Abstract: The subject disclosure pertains to lambda expressions and the employment of such expressions in imperative and/or object-oriented computer programming languages. Lambda expressions can be employed in conjunction with methods (e.g., arguments, assignment . . . ) to provide a more concise and functional manner of code specification. Further, lambda expressions can participate in type inference and checking as well as overload resolution, among other things.

Abstract: Anonymous types for a programming language. Non-denotable anonymous types are types that a compiler generates on behalf of a programmer and can then be used as nominal types. Insofar as anonymous types do not have a name, they can be used only inside a method in which they are created. Additionally, an anonymous type cannot be exposed in any way outside of the method. Syntax to create an anonymous type is useful when employed with a Select operator to generate a result with a particular shape, without the need of having a regular type for it. Anonymous types are expressible such that an expression of that type can be written. Translation of an anonymous type by a compiler generates a nominal class that implements Equals and GetHashCode methods. There is equivalence of anonymous types within the same method, and conversion of an unrealized structural type into structurally compatible nominal type.

Abstract: This disclosure concerns various manners and mechanisms to capture and interact with free/outer variables or parameters. The capture of such variables, among other things, enables the code to become mobile to facilitate transmission to and execution by various systems or sub-systems. Transmission can be accomplished, for instance, by generation of code objects or data packets that include substituted values of the free variables and/or references to the location of the values.

Abstract: A general-purpose programming language having language extensions for strongly typed, compile-time checked query and set operations that can be applied to arbitrary data structures, be they object-relational (O-R) mappings or just regular objects. As is appropriate for a general purpose programming language, the extensions do not mandate a particular object-relational layer; rather, they are introduced as abstractions that can be implemented in multiple environments. Accordingly, there is provided a system that facilitates data querying in accordance with an innovative aspect. The system include a program component that provides embedded query and set operations in a programming language, and an application component that facilitates application of the query and set operations over a data structure of data. The data can be any kind of data such as that found in a database, a document (e.g., XML), and data sources in a programming language (e.g., C#), for example.

Abstract: Syntax for creating object instances utilizing expressions instead of statements. A syntax component facilitates extension of conventional object-creation-expression syntax. An initializer component provides for initialization of a newly-created entity via object and collection initializers. The initializer component provides initialization of the newly-created entity utilizing an object initializer where the object initializer specifies values for one or more fields or properties of the newly-created entity which is an object, and consists of a sequence of member initializers enclosed by tokens and separated by commas. The initializer component can also provides initialization of the newly-created entity utilizing a collection initializer when the underlying object implements a certain interface or implements a certain pattern. An overloading constructor can be called as part of the initialization process.

Abstract: A program execution engine that facilitates generic type variance verification is provided. The execution engine receives a program executable in the form of intermediate language (IL). The program executable can be based on code that includes expression(s) with generic type(s) which have been identified as requiring variance verification (e.g., covariance and/or contra-variance). The execution engine includes a variance verification component that dynamically determines whether value(s) associated with the generic type(s) identified as requiring variance verification comply with the particular variance verification requirement. The variance verification component can provide error information (e.g., throw an exception), if the specified variance is not safely compliant Variance verification can be based on static checking which places the burden on a source language compiler to emit the run-time checks in intermediate language (IL), if run-time checked variance is required.

Abstract: Architecture that extends existing types including constructed and sealed types using extension methods. Extension methods are static methods that can be invoked using instance method syntax. Extension methods are declared by specifying the keyword “this” as a modifier on the first parameter of the methods. Extension methods have all the capabilities of regular static methods. In addition, once imported, extension methods can be invoked using instance method syntax. Also disclosed are rules for importing extension methods, and extension method invocations. Extension methods are imported through using-namespace-directives. In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods.

Abstract: A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion.

Abstract: The subject invention relates to systems and methods that provide null capabilities within the context of programming languages. In one aspect, a system is provided that facilitates null-support in various programming languages. The system includes one or more types associated with at least one programming language. A type modifier is provided to signal that the type is nullable. The type modifier enables a multi-element structure to be automatically created in association with the type wherein, the multi-element structure includes the type and a Boolean element indicating whether or not the variable is null.

Abstract: The subject disclosure pertains to systems and methods for supporting null capabilities for general purpose programming languages. Low level, runtime support for a nullable type is provided to ensure consistency and coherency. An execution component restricts support of the nullable type to programming language types that lack a null capability. The execution component may also provide support for conversion between the nullable type and a reference type.

Abstract: The present invention discloses an improved system and method for specifying and compiling computer programs. Type aliases are introduced whose binding is inferred by a type inference component during compilation. Once declared, type aliases can be utilized just like regular types thereby providing added efficiency in coding, among other things. Additionally, a mechanism for specifying the introduction of a new variable whose type is to be inferred is disclosed. This mechanism clears up an ambiguity during type inference concerning whether to infer a new variable type or utilize a variable in scope. Further yet, an efficient type inference system and method is disclosed to effectively deal with overloading among other things.