FSharp.Compiler.CodeDom

The total number of elements in the set

Remove the given element from the set

Apply the given function to each binding in the hash table

Apply the given function to the set threading the accumulating parameter through the sequence of function applications

Create a new empty mutable hash set with key hash/equality based on the F# structural "hash" and (=) functions

Create a new empty mutable hash set with an internal bucket array of the given approximate size and with key hash/equality based on the F# structural "hash" and (=) functions

Create a new empty mutable hash set with an internal bucket array of the given approximate size and with the given key hash/equality functions

Create a new mutable hash set containing elements drawn from the given sequence

Make a shallow copy of the set

Test if the set contains the given element

Clear all elements from the set

Add an element to the collection

Create a new empty mutable hash set with key hash/equality based on the F# structural "hash" and (=) functions

Create a new empty mutable hash set with an internal bucket array of the given approximate size and with key hash/equality based on the F# structural "hash" and (=) functions

Create a new empty mutable hash set with an internal bucket array of the given approximate size and with the given key hash/equality functions

Create a new mutable hash set containing elements drawn from the given sequence

Mutable hash sets based by default on F# structural "hash" and (=) functions. Implemented via a hash table and/or Dictionary.

The default location of FSharp.Core.dll and fsc.exe based on the version of fsc.exe that is running

Implementation of the CodeDomProvider for the F# language. This is specialized version that can be used with ASP.NET.

Implementation of the CodeDomProvider for the F# language. If you intend to use CodeDom with ASP.NET you should use FSharpAspNetCodeProvider instead.

Where are we generating member?

Generates code for binary operator using function for left and right operand

Process collection - keeps context through the whole processing calls 'f' for every element in sequence and 'fs' between every two elements as a separator

Call specified function only on elements of specified type. (performs dynamic type test using x.GetType())

Process collection - keeps context through the whole processing calls 'f' for every element in sequence and 'fs' between every two elements as a separator. This is a variant that works on typed collections.

Returns F# conversion function for the specified type (or empty string)

Create context using specified text writer and options

Create closure to do the counting (this is usend when we need indexing during collection processing)

Call function, but give it context as an argument

Generate array initializer. Checks generator options for ASP.NET workaround.

Generates expression which is casted to the inferred type using "(unbox (box e))" this is useful if the environment where it is used specifies the type explicitly for example in array initializers

Generates method code, adds OverloadID attribute when index isn't "-1" Generates comments and than calls 'generatMethod'

Generate code for compile unit (file)

Generate expression - with unkonw type

Generates expression, but generates "this" if the expression is null (used in field reference etc. because some CodeDOM generators do this though I believe it is a mistake)

fields

Abstract method in the interface

Abstract property in the interface

Generates a main method.

By default all CodeDOM generated methods are 'virtual' which means that we have to generate "abstract and default" (unless we're in struct or we're implementing an interface, or the method is overriden) (NOTE: the same logic isn't properly implemented for properties)

Generate code for namespace without compilation unit

Generates namespace code - takes output from 'preprocessNamespace'

Generate value of primitive expression

Generate type arguments using context

Generate code for type declaration (not included in namespace)

Generate type reference using context (this is most commonly used method)

Get type reference, but don't rename .NET types to F# types (this is only needed when calling static methods on the type)

Generates type reference (not for arrays)

Generate type reference with empty context

Get full type reference using information from context

Get full type reference string using empty context

Identity function

Are both types numerical types where numeric conversion function can be applied?

Perform map and filter operations in one

Output string as a valid F# identifier

Append specified string without line-break

Function composition operator

Break-line and append specified string

Returns CodeNamespace, list of classes with scope (which includes class names of containing classes and sequence of class renames)

Preprocess collection with type parameters Returns array to be used with usingTyParams and function to be called to generate < ... > code

Print object converted to string

Tries to resolve type of a variable and adds it to the Context dictionary

Tries to resolve type of an expression using a few tricks: * Fields of current type may have known type * Properties of current type as well * We can also try to resolve other properties (sometimes it helps) * Resolve type for local variables or argument reference

Get System.Type of know type (either standard type or resolved)

Tries to resolve if type is an array, so we can generate appropriate code (it can be either indexer or array, but we need to generate .Item call for indexers (no overloading is supported by .[]). Returns: "None" - can't resolve, "Some" resovled (true/false - is it an array?)

Print unique id using: "+> uniqid"

Record specified type parameters in the context, call generating function and then restore the original type parameters (this works if someone uses nested type parameters with the same name)

Matches array or indexer expression and corrects it if the generated CodeDOM is incorrect

Tries to find .NET type for specified type name This is used when we need to know type in order to generate something correctly, but it's just a fallback case

Walks through the CodeDom tree and keeps current "scope" and the result. The result is collected through entire tree, but the modified scope is passed only to sub-nodes of the current node. First argument is a function that is called for nodes and has a function as a first argument, scope and result as a second and current node as a third. The function argument can be used to walk deeper in the tree if wanted.

Search for members and return flat list of selected members Function given as an argument returns tuple - first item specifies if the current element should be included in the result, the second specifies if we should walk through child members of the current object