Abstract:
A serrated kneading disk including a body having a perimeter that is an ellipse having truncated ends, the curved elliptical portions forming flanks and the truncated ends forming crests. The crests are curved to form the arc of a circle having a radius substantially the same as the radius of the bore of the extruder barrel with which the disk is to be used. The disk body has a cylindrical passageway extending through the middle thereof, the passageway having a configuration adapted to allow the kneading disks to be lockingly engaged on the shaft of an extruder screw. A plurality of grooves are formed in the flanks and crests. A serrated kneading block can be formed from a plurality of the serrated kneading disks, or formed as a single body having a plurality of lobes, each lobe being substantially identical to the serrated kneading disk.
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:
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. Additionally, language(s) that do not support variance can treat generic type(s) as non-variant.
Abstract:
Methods are disclosed of producing and purifying at least one amide. In accordance with one of the methods disclosed herein, the at least one amide is produced by providing an organic liquid comprising at least one oxime, providing at least one catalyst, adding the at least one catalyst to the organic liquid to form a rearrangement mass, wherein the rearrangement mass comprises at least one amide, at least one impurity, and the at least one catalyst, and heating the rearrangement mass to a temperature of at least about 115° C. for a period of time in order to sulfonate, break down and/or reduce the concentration of some of the at least one impurity in the rearrangement mass.
Abstract:
Methods are disclosed of producing and purifying at least one amide. In accordance with one of the methods disclosed herein, the at least one amide is produced by providing an organic liquid comprising at least one oxime, providing at least one catalyst, adding the at least one catalyst to the organic liquid to form a rearrangement mass, wherein the rearrangement mass comprises at least one amide, at least one impurity, and the at least one catalyst, and heating the rearrangement mass to a temperature of at least about 115° C. for a period of time in order to sulfonate, break down and/or reduce the concentration of some of the at least one impurity in the rearrangement mass.
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:
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:
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.
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. In another aspect, code inferencing is disclosed whereby given a type, the corresponding code can be inferred by the compiler and inserted for compiling by a compiler.
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.