| Value | Description |
|---|
val bindMethod :
(Type list -> 'a -> Type) -> Type -> string * int * 'a list * 'a -> MethodInfo |
General method binder helper to hide some of the detail of
using System.Reflection to bind method specications to generic methods
|
val deepMacroExpandUntil : (expr -> bool) -> expr -> expr |
Perform macro expansion (deep call-by-value reduction)
on an expression. Lambda applications are beta-reduced
after reducing the function term and the argument term.
Top-level definitions are expanded according to their definitions.
Top-level definitions that are not functions are expanded once per use.
The interior bodies of lambda expressions are reduced. Reduction rules
for unions, records, arithmetic etc. are not applied.
A cutoff that halts the rewriting for expressions
that pass the given test (usually a test for inclusion within a particular
'target' langauge).
|
val efAnd : (expr * expr) exprFamily |
The expression family corresponding to "a && b " expressions
|
val efAnyTopDefn : (topDefData * dtype list) exprFamily |
The family of expressions that are constants referring to top-level public definitions,
where the constants may generic and applied to a number of type arguments.
|
val efApp : (expr * expr) exprFamily |
The family of expression applications
|
val efApps : expr list exprFamilyLLinear |
An expression family corresponding to a series of applications f(g(...(x))
|
val efArrayMk : exprFamily1N |
The family of array construction expressions
|
val efBool : bool exprFamily |
The family of constant boolean expressions
|
val efByte : byte exprFamily | |
val efChar : char exprFamily |
The family of constant unicode character expressions
|
val efCoerce : exprFamily21 |
The family of coercion expressions, resulting from implicit coercions at object-model calls and explicit coercions elsewhere.
|
val efCond : exprFamily13 |
The family of 'if ... then ... else' expressions
|
val efConst : (exprConstr * dtype list) exprFamily |
The family of expression constructors and constant expressions
|
val efCtorCall : ctorSpec exprFamilyGNN |
The family of new-object calls to constructors in the .NET obejct model
|
val efDefn : expr -> dtype list exprFamily |
Build a family of expressions corresponding to uses of a particular known top level definition
The input expression must be an efAnyTopDefn. Often used to name a particular definition,
e.g. efDefn (<@ List.map @>)
|
val efDelegateMk : exprFamily11 |
The family of calls to construct delegate values in the .NET obejct model
|
val efDouble : float exprFamily |
The family of constant 64-bit floating point number expressions
|
val efEquality : exprFamily12 |
The family of equality tests, resulting from the compilation of pattern matching
|
val efFalse : unit exprFamily |
The expression family corresponding to the constant 'false'. A refinement of efBool.
|
val efForLoop : exprFamilyE3 |
The family of for-loop expressions, where the body of the for-loop is encoded as a lambda.
The signature of this expression family is likely to change in a future release.
|
val efGetAddr : expr exprFamily |
The family of address-access expressions. Under revision.
|
val efHole : dtype exprFamily |
The family of expressions representing holes in quotations
|
val efInt16 : int16 exprFamily | |
val efInt32 : int32 exprFamily | |
val efInt64 : int64 exprFamily | |
val efLambda : (exprVar * expr) exprFamily |
The family of lambda (abstraction) expressions
|
val efLambdas : exprVar list exprFamilyRLinear |
An expression family corresponding to a series of lambdas.
|
val efLet : ((exprVar * expr) * expr) exprFamily |
The family of expressions associated with 'let' constructs
|
val efLetRec : ((exprVar * expr) list * expr) exprFamily |
The family of recursives expressions associated with 'let rec' constructs
|
val efLiftedValue : obj exprFamily |
The family of expressions made up of reified (lifted) values
generated via the 'lift' function
|
val efMethodCall : methSpec exprFamilyGNN |
The family of calls to the .NET obejct model, excluding property accesses etc.
|
val efOr : (expr * expr) exprFamily |
The expression family corresponding to "a || b " expressions
|
val efPropGetCall : propGetOpData exprFamilyGN1 |
The family of calls to property accessors in the .NET obejct model
|
val efQuote : expr exprFamily |
The family of quoted expressions (for inner quotations)
|
val efRecdGet : recdGetOpData exprFamilyGN1 |
The family of record-access expressions
|
val efRecdMk : recdMkOpData exprFamilyGNN |
The family of record-construction expressions
|
val efSByte : sbyte exprFamily |
The family of constant signed 8-bit integers
|
val efSeq : exprFamilyE2 |
The family of sequence expressions "a;b"
|
val efSingle : float32 exprFamily |
The family of constant 32-bit floating point number expressions
|
val efString : string exprFamily |
The family of constant string expressions
|
val efTemplate : ('rawqty,'rawfty) template -> 'rawqty exprFamily | |
val efTrue : unit exprFamily |
The expression family corresponding to the constant 'true'. A refinement of efBool.
|
val efTupleGet : tupleGetOpData exprFamilyGN1 |
The family of tuple access expressions
|
val efTupleMk : exprFamilyNN |
The family of tuple-expressions
|
val efUInt16 : uint16 exprFamily | |
val efUInt32 : uint32 exprFamily | |
val efUInt64 : uint64 exprFamily | |
val efUnionGet : unionGetOpData exprFamilyGN1 |
The family of discriminated-union access expressions, resulting from the compilation of pattern matches
|
val efUnionMk : unionMkOpData exprFamilyGNN |
The family of discriminated-union construction expressions
|
val efUnionTest : unionTestOpData exprFamilyGN1 |
The family of discriminated-union discrimination test expressions, resulting from the compilation of pattern matches
|
val efUnit : unit exprFamily |
The unary family of 'unit' constant expressions
|
val efVar : exprVarName exprFamily |
The family of variable expressions
|
val efWhileLoop : exprFamilyE2 |
The family of while-loop expressions, where the body of the loop is encoded as a lambda.
The signature of this expression family is likely to change in a future release.
|
val explicitlyRegisterTopDefs : #Assembly -> string -> byte [] -> unit |
Permit top-level environments to explicitly register new pickled resources that represent persisted
top level definitions.
|
val fill : ('b,'rawfty) template -> 'rawfty |
Match an existing raw expression against the given expression template
|
val freeInExpr : expr -> exprVarName list |
Get the free expression variables of an expression as a list
|
val freshExprVarName : (string -> exprVarName) |
Generate a new variable name, using the given name as a basis
|
val op_LessAtAt AtAtGreater : ('b,'rawfty) template -> 'rawfty |
ASCII syntax for raw expression quotation. If there are holes
in the expression then a function is produced to generate new terms
via the function 'fill'.
|
val op_LessAtAtBar BarAtAtGreater :
('rawqty,'b) template -> expr -> 'rawqty option |
ASCII syntax for raw expression querying via matching
|
val op_LessAtAtDot DotAtAtGreater : ('a,'b) template -> ('a,'b) template |
ASCII syntax for raw expression template quotation.
|
val pickledDefinitionsResourceNameBase : string |
Files compiled with --quotation-data persist definitions to
the emitted assembly ('cross stage persistence of level 0 definitions').
They are saved as a resource in the emitted module. This is the base name
for the resources.
|
val query : ('rawqty,'b) template -> expr -> 'rawqty option |
Match an existing raw expression against the given raw expression template
|
val resolveTopDef : topDefData * dtype list -> expr option |
Resolve a top level definition to an implementation. If the definition is
polymorphic then appropriate type arguments must also be specified.
|
val substitute :
(dtypeVarIdx -> dtype option) -> (exprVarName -> expr option) -> expr -> expr |
Substitute through the given expression using the given functions
to map variables to new values. The functions must give consistent results
at each application. Variable renaming may occur on the target expression
if variable capture occurs.
|
val unpickle : Type -> byte [] -> ('a,'b) template |
This function is called automatically when quotation syntax (<@@ @@>) and related raw-expression
quotations are used. The bytes are a pickled binary representation of an unlinke form of the qutoed expression,
and the System.Type argument is any type in the assembly where the quoted
expression occurs, i.e. it helps scope the interpretation of the cross-assembly
references in the bytes.
|