Patent application number | Description | Published |
20080243764 | GROUP JOINS TO NAVIGATE DATA RELATIONSHIPS - A group join query facilitates navigation of relationships (e.g., one-to-many or many-to-one) across a plurality of data collections. Such a query operator produces nested or hierarchical results that capture the arguments passed thereto. If desired, the nested results can be flattened to simulate conventional relational database results. | 10-02-2008 |
20080262992 | TYPE INFERENCE FOR OBJECT-ORIENTED LANGUAGES - Systems and methods facilitate type inference in a computer-programming environment. Type inference can be applied to generic method or function invocation in object-oriented languages to determine a type argument list left implicit by a programmer. One or more type arguments can be identified as a parameter type to which all other types in a set of associated parameter types can be converted. | 10-23-2008 |
20080320440 | FULLY CAPTURING OUTER VARIABLES AS DATA OBJECTS - Providing for read/write access to captured free variables expressed as environment data objects is disclosed herein. By way of example, free variables can be rewritten as a field of a private class, and accessed via an instance of the private class captured within the environment data object. In such a manner, no need of a placeholder or proxy function is required to access the free variable. Consequently, the subject innovation provides a simplified method for capturing free variables within expression trees and providing read/write access to such variables. | 12-25-2008 |
20090328016 | GENERALIZED EXPRESSION TREES - Expression tree versatility and applicability are enhanced to facilitate programming across various program languages and execution contexts. An expression tree can represent programmatic code as data in a representation common to multiple process mechanisms. As a result, entire programs or portions thereof can be captured and processed by a numerous common language components. Further, language specific concepts can be reduced to the common representation to enable language independent employment. | 12-31-2009 |
20100299658 | COMPILE-TIME CONTEXT FOR DYNAMICALLY BOUND OPERATIONS - Compile-time context information is captured and provided to a runtime binder for dynamic features in programming languages. For example, a C# run-time binder uses the information to perform a run-time bind with semantics matching the compiler's binding behavior. Dynamic programming language features supported relate to compound operations, events, delegates, member accessibility, dynamic-typed objects, structs passed by ref, arguments passed by name rather than position, extension methods, conditionally compiled methods, literal arguments, overflow checking, dynamic indexed properties, dynamic method groups, and static method groups. | 11-25-2010 |
20100299660 | DYNAMIC BINDING DIRECTED BY STATIC TYPES - A static type, called “dynamic”, is introduced into a statically bound programming language. An expression or subexpression that is defined as a static type called “dynamic” in the source code of a program written in the statically bound programming language, is bound based on its runtime type instead of on its compile time type. Binding can be performed based on a mixture of compile time and runtime types that are based on the specification of types of expressions in source code. This type of binding is called hybrid binding. Operations are bound using the runtime type of constituent expressions (i.e., the runtime type of a receiver, an argument, or an operand) typed as dynamic and the compile time type of static constituents. If any constituent expression of an operation is dynamic, binding occurs at runtime instead of at compile time. | 11-25-2010 |
20110154295 | Design Time Debugging - A design time debugging tool provides debugging information available from the compiler during design time, as if a user were debugging code that provided the debugging information, by exposing information available from the compiler without initiation of a debugging session and without executing the program being debugged. | 06-23-2011 |
20110167088 | EFFICIENT IMMUTABLE SYNTAX REPRESENTATION WITH INCREMENTAL CHANGE - Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared. | 07-07-2011 |
20110167248 | EFFICIENT RESUMPTION OF CO-ROUTINES ON A LINEAR STACK - Unsuspended co-routines are handled by the machine call stack mechanism in which the stack grows and shrinks as recursive calls are made and returned from. When a co-routine is suspended, however, additional call stack processing is performed. A suspension message is issued, and the entire resume-able part of the call stack is removed, and is copied to the heap. A frame that returns control to a driver method (a resumer) is copied to the call stack so that resumption of the co-routine does not recursively reactivate the whole call stack. Instead the resumer reactivates only the topmost or most current frame called the leaf frame. When a co-routine is suspended, it does not return to its caller, but instead returns to the resumer that has reactivated it. | 07-07-2011 |
20110265070 | RESUMABLE METHODS - APIs are provided, that are external to a programming language but that provide functionality that can be plugged into a language compiler. The provided APIs tailor functionality associated with asynchronous programming, iterators or writing symmetric co-routines using a generalized pattern-based approach. Several types of resumable methods are provided in the APIs which can be applied to method bodies written in traditional program code. Syntactically distinguishable control points in method bodies written in traditional program code invoke transformation of the code by the compiler using the external APIs. The transformed code enables the pausing and resumption of the code sandwiched between control points in the transformed code. The source code contained within a method having control points in it is transformed so that code within the method can be executed in discrete parts, each part starting and ending at a control point in the transformed code. | 10-27-2011 |
20120324431 | PATTERN-BASED COMPILATION OF ASYNCHRONOUS CONSUMPTION - The present invention extends to methods, systems, and computer program products for transforming source code to await execution of asynchronous operations. Embodiments of the invention simplify authoring and use of asynchronous methods, by generating statements that use well-defined awaitable objects to await completion of asynchronous operations. For example, a computer system can transform a statement that requests to await the completion of an asynchronous operation into a plurality of statements that use a predefined pattern of members of an awaitable object corresponding the asynchronous operation. The pattern can include one or more members configured to return a completion status of the asynchronous operation, one or more members configured to resume execution of the asynchronous method at a resumption point when the asynchronous operation completes, and one or more members configured to retrieve completion results. Accordingly, the plurality of statements can use these members to await execution of the asynchronous operation. | 12-20-2012 |
20120324457 | USING COMPILER-GENERATED TASKS TO REPRESENT PROGRAMMING ELEMENTS - The present invention extends to methods, systems, and computer program products for representing various programming elements with compiler-generated tasks. Embodiments of the invention enable access to the future state of a method through a handle to a single and composable task object. For example, an asynchronous method is rewritten to generate and return a handle to an instance of a builder object, which represents one or more future states of the asynchronous method. Information about operation of the asynchronous method is then passed through the handle. Accordingly, state of the asynchronous method is trackable prior to and after completing. | 12-20-2012 |
20130104148 | AMBIENT STATE FOR ASYNCHRONOUS METHODS - A method of providing asynchronous programming support at run time for scope-based ambient state at a method call is disclosed. In response to the method call, an asynchronous method stack frame is created along with ambient state for the asynchronous method call. In one example of the method, a current frame of a method stack is captured. A new frame is instantiated by setting a previous reference of the new frame to the current frame and moving data from the previous frame into the current frame. One example of instantiating the new frame includes pushing the current frame onto the stack. In another example, the new frame is lazily created when changes have been made. A state machine used to transform the synchronously-created method into an asynchronous method is moved from a current state to a next state. The captured frame is restored. | 04-25-2013 |
20140282441 | STATIC TYPE CHECKING ACROSS MODULE UNIVERSES - Static type checking can be performed on types and values defined in modules in a system that dynamically composes programs from modules. The types and values do not share a global namespace. Each module defines its own module universe, disjoint from other modules. A language mechanism can establish a local name binding to one module within the content of another module. When type checking at compile time an environment can be established that corresponds to a runtime instance of the program. The static type system can be arranged to align with the runtime values, such that the names used to refer to objects at runtime are the same as the names used to refer to the types of those objects in the static type system. Aliases of a particular type are resolved to a known compile time description of the type. | 09-18-2014 |
20140282442 | STATICALLY EXTENSIBLE TYPES - Statically extensible types allow a static type system to model the behavior of dynamic object model extension in dynamic runtime systems. Static types that model dynamically extended types can be extended using additional declarations in the same compilation. Declarations for a particular type can come from multiple independent sources which can have been defined at multiple points in time. Extension declarations can use the same syntax as the initial type declaration. Hence presence of one or more declarations for the same type in a compilation can indicate that the type has been extended. These features allow static type checking of dynamic plug-ins to be supported using statically extensible types. Declarations and extension declarations for a type can be merged together to create an extended type that enables different processing paths and dependencies. | 09-18-2014 |
20140282443 | CONTEXTUAL TYPING - Type inference is used to provide the benefits of static type checking without explicitly declaring type in the source code. Type inference that proceeds in a bottom up direction is augmented by contextual typing that proceeds in a top down direction. Contextual typing types enclosed expressions by associating the type of a directly enclosing expression with the enclosed expression. Object literals, function literals and array literals enclosed in assignment and call expressions, can be contextually typed. | 09-18-2014 |
20140372993 | OVERLOADING ON CONSTANTS - A function in a type system can be overloaded using specified constants. The constant can be can be the result of evaluating an expression to: a string, a number, a Boolean, a pattern or any type of constant. The return type of the function can depend on the specified constant that is passed into the function. The return type of the function can depend on the type of the specified constant that is passed into the function. The type of the parameter that is passed into the function can depend on the value of the constant. The function overloads can be validated to ensure that the constant-based overload is a subtype of a more general overload. A constant can be an expression used at compile time during type checking. | 12-18-2014 |