Abstract: A computer-implemented system for representing data comprises a position indicator that indicates a position of a datum within a group, a name indicator that optionally names the datum, and a value of the datum. A type to be assigned to the datum is derived from at least one of a name of the datum and the position of the datum within the group. Methods of using the system are also provided.

Abstract: A computer-implemented system for accessing data stored in a computer-readable format comprises a data source indicator that identifies least one datum of a data source to be typed. The system also includes a type definition component that defines a strongly typed view of the at least one datum. Methods of using the system are also provided.

Abstract: A query language system is provided that includes a query component that specifies operations for one or more items in a data set. An aggregator component identifies one or more keys associated with the data set, the keys are supplied to one or more aggregators that perform direct computations from the keys in order to determine at least one aggregated value for the data set.

Abstract: The subject disclosure pertains to interaction with one or more collections of data. Queries and domains are presented as separate entities. A number of compositional operators are provided to manipulate a generic collection of data at a low level. Query comprehensions can specify interactions with one or more collections at a higher or more intuitive level. The query comprehensions can be translated or mapped to operators that can be employed to interact with one or more data collections and return results where applicable.

Abstract: Systems and methods that enhance a programming language by introducing null unification on a type level in addition to a value level, for static types of both reference and value types T. An operator that adds a level of nullability (and removes such nullability) is introduced without a mention of the actual type, to steer overloading in a precise manner.

Abstract: A batch compiler is employed to enable compilation of code provided at runtime. A managed application receives code during execution and invokes the compiler to transform the code to enable it to execute within the context of the receiving application. Among other things, employment of a batch compiler preserves investments made to such compilers while also opening up new scenarios in application scripting and/or hosting that are otherwise unavailable.

Abstract: Compiler functionality is componentized to enable use across different contexts. Conventionally tightly coupled functionality is decoupled and an interface afforded to facilitate interaction with compiler components/subcomponents in various scenarios. In one instance, compiler components can be employed across compile time and runtime. Compile time functionality can be employed at runtime and runtime functionality utilized at compile time thereby blurring the line between time dimensions.

Abstract: An object-oriented interface for providing access to stored data comprises a data enumeration module that provides an object-oriented view to at least one stored first datum that is not an object created by the interface. The interface also includes a scanning module that cooperates with the data enumeration module to change the view from the stored first datum to another datum. Methods for using the interface are also provided.

Abstract: Techniques are disclosed to support the resolution of an operator which has been called with inconsistent typing and at least one operand of a user-defined type. In order to allow the compilation of such an operation, first all possible widening conversions for each operand are examined to determine if any widening conversions of any operands would result in types over which the operator is defined. If not, both the narrowing and the widening conversions of each operand are considered, to determine if any conversions of either or both operands would result in types for which the operator is defined. If only widening conversions are used, the most encompassed possible result type is selected as the target type. If a narrowing conversion is used, the most encompassing possible result type is selected as the target type. In order to use the target type, each operand is converted to the target type. The operation is then performed using the converted operands.

Abstract: Standard group operators afford expressive grouping across collections of various types for employment by a number of programming languages. The operators can leverage positional information to facilitate grouping of sequential/ordered input data. Groups can also include more than one input element. Additionally or alternatively, the operators can enable multi-level grouping such as nested or hierarchical grouping. In accordance with one aspect, the group operators can be employed in conjunction with language-integrated queries.

Abstract: Systems and methods are described that enhance a programming language by introducing support for declarative object identity in both class declarations and object literals. An exemplary system includes a memory that stores code associated with a computer program and a component coupled to the memory. The component is configured to access the code, to identify a variable in the code and a modifier associated with the variable and, responsive to identifying the variable, to use the variable to determine the identity of an object associated with the variable and to determine whether the object is equal to another object based on value semantics.

Abstract: Systems and methods that optimize query translations at compile time in LINQ languages. An optimization component optimizes algebraic trees and rewrites an expression composed from sequence operators into a more efficient expression(s). A compiler associated with the optimization component can receive syntax (e.g., query comprehensions, query expressions) to turn into standard sequence operators that can operate on arbitrary collections. The compiler can then perform transformations on the algebraic trees, such as push filter conditions upwards or downwards and/or to combine filter conditions.

Abstract: Programmatic assistance is provided for dynamic typing within an integrated development environment (IDE). Types associated with late bound constructs can be inferred from static information and/or determined from design time execution. Assistance can then be provided as a function of a precise and/or speculative type. Furthermore, dynamic type assistance can be employed in conjunction with static type assistance to facilitate development of a program that supports both late and early binding, for example.

Abstract: A type inference option is available for a computer programming language. The option acts as a switch to specify whether or not type inference is applicable (e.g., on or off). Type inference can be employed in conjunction with late binding or options therefor. In this manner, a computer program can be developed with the convenience of type inference and the flexibility of late binding while still maintaining at a degree of type safety.

Abstract: Systems and methods are provided with respect to computer programming. Program behavior can be tuned to provide a seamless mixture of semantic behavior across a single program language syntax. Semantic behavior can be explicitly specified at arbitrary levels of syntactic granularity (e.g. expressions, members, types, compilation units . . . ), wherein semantic scope is commensurate with the specified level of granularity.

Abstract: Binding can automatically take place between controls and information sources at runtime. This minimizes an amount of code that is to be generated by a user and thus can lower errors from the code. In addition, some wizards that allow binding without code writing can become problematic since some information is not available at runtime (e.g., when the wizard operates prior to runtime.) Relevant information is received and at least one binding is created based off received information.

Abstract: There is alteration of a late-bound expression produced by a compiler into an early-bound structure. Alteration of the late-bound expression can occur at runtime and a visitor pattern can be used to create the alteration. In one instance, a conversion from late-bound to early-bound takes place through replacing a late-bound property with a statically typed call. The early-bound structure can translate into an expression tree to enable an implementation of a store specific query operated upon storage.

Abstract: 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.

Abstract: Systems and methods facilitate variable capture with respect to closures in object oriented programming languages. In particular, multiple copies of closure variables are generated such that lifetime of variables is defined by variable scope. However, if a previous version of a variable exists, a newly created variable is initialized with the value of the previous version.

Abstract: The claimed subject matter relates to a formalization of operator patterns that can facilitate type flow of element types between an operator in a first clause of an expression to an operator in a next clause of the expression. The type that flows to, and the operator extant in, the next clause can be combined to infer the element type of the next clause. As such, type-checking, autocompletion and other advantageous features can be accomplished incrementally without the need for a prior full translation of the expression.