Returns the custom attributes of an expression. For quotations deriving from quotation literals this may include the source location of the literal.

Returns: Expr list

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let sampleQuotation =  <@ 1 + 1 @>

 sampleQuotation.CustomAttributes

Gets the free expression variables of an expression as a list.

Returns: seq<Var>

A sequence of the free variables in the expression.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let sampleQuotation =  <@ fun v -> v * v @>

 let v, body =
     match sampleQuotation with
     | Lambda(v, body) -> (v, body)
     | _ -> failwith "unreachable"

 body.GetFreeVars()

Substitutes 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.

substitution : Var -> Expr option

The function to map variables into expressions.

Returns: Expr

The expression with the given substitutions.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let sampleQuotation =  <@ fun v -> v * v @>

 let v, body =
     match sampleQuotation with
     | Lambda(v, body) -> (v, body)
     | _ -> failwith "unreachable"

 body.Substitute(function v2 when v = v2 -> Some <@ 1 + 1 @> | _ -> None)

Format the expression as a string

full : bool

Indicates if method, property, constructor and type objects should be printed in detail. If false, these are abbreviated to their name.

Returns: string

The formatted string.

Example

 open FSharp.Quotations

 let expr1 = <@ 1 + 1 @>

 expr1.ToString(true)

Returns type of an expression.

Returns: Type

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let sampleQuotation =  <@ 1 + 1 @>

 sampleQuotation.Type

Builds an expression that represents getting the address of a value.

target : Expr

The target expression.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let array = [| 1; 2; 3 |]

 Expr.AddressOf(<@ array.[1] @>)

Builds an expression that represents setting the value held at a particular address.

target : Expr

The target expression.

value : Expr

The value to set at the address.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let array = [| 1; 2; 3 |]

 let addrExpr = Expr.AddressOf(<@ array.[1] @>)

 Expr.AddressSet(addrExpr, <@ 4 @>)

Builds an expression that represents the application of a first class function value to a single argument.

functionExpr : Expr

The function to apply.

argument : Expr

The argument to the function.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let funcExpr = <@ (fun x -> x + 1) @>
 let argExpr = <@ 3 @>

 Expr.Application(funcExpr, argExpr)

Builds an expression that represents the application of a first class function value to multiple arguments

functionExpr : Expr

The function to apply.

arguments : Expr list list

The list of lists of arguments to the function.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let funcExpr = <@ (fun (x, y) z -> x + y + z) @>
 let curriedArgExprs = [[ <@ 1 @>; <@ 2 @> ]; [ <@ 3 @> ]]

 Expr.Applications(funcExpr, curriedArgExprs)

Builds an expression that represents a call to an instance method associated with an object

obj : Expr

The input object.

methodInfo : MethodInfo

The description of the method to call.

arguments : Expr list

The list of arguments to the method.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let objExpr, methInfo =
     match <@ Console.Out.WriteLine("1") @> with
     | Call(Some obj, mi, _) -> obj, mi
     | _ -> failwith "call expected"

 let argExpr = <@ "Hello World" @>

 Expr.Call(objExpr, methInfo, [argExpr])

Builds an expression that represents a call to an static method or module-bound function

methodInfo : MethodInfo

The MethodInfo describing the method to call.

arguments : Expr list

The list of arguments to the method.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let methInfo =
     match <@ Console.WriteLine("1") @> with
     | Call(_, mi, _) -> mi
     | _ -> failwith "call expected"

 let argExpr = <@ "Hello World" @>

 Expr.Call(methInfo, [argExpr])

Builds an expression that represents a call to an instance method associated with an object, potentially passing additional witness arguments

obj : Expr

The input object.

methodInfo : MethodInfo

The description of the method to call.

methodInfoWithWitnesses : MethodInfo

The additional MethodInfo describing the method to call, accepting witnesses.

witnesses : Expr list

The list of witnesses to the method.

arguments : Expr list

The list of arguments to the method.

Returns: Expr

The resulting expression.

Example

See examples for Call and CallWithWitnesses

Builds an expression that represents a call to an static method or module-bound function, potentially passing additional witness arguments

methodInfo : MethodInfo

The MethodInfo describing the method to call.

methodInfoWithWitnesses : MethodInfo

The additional MethodInfo describing the method to call, accepting witnesses.

witnesses : Expr list

The list of witnesses to the method.

arguments : Expr list

The list of arguments to the method.

Returns: Expr

The resulting expression.

Example

In this example, we show how to use a witness to cosntruct an `op_Addition` call for a type that doesn't support addition directly:

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 // Get the entrypoint for inline addition that takes an explicit witness
 let addMethInfoG, addMethInfoGW =
     match <@ 1+1 @> with
     | CallWithWitnesses(None, mi, miW, _, _) ->
         mi.GetGenericMethodDefinition(), miW.GetGenericMethodDefinition()
     | _ ->
         failwith "call expected"

 // Make a non-standard witness for addition for a type C

 type C(value: int) =
     member x.Value = value

 let witnessExpr = <@ (fun (x: C) (y: C) -> C(x.Value + y.Value)) @>
 let argExpr1 = <@ C(4) @>
 let argExpr2 = <@ C(5) @>

 // Instantiate the generic method at the right type

 let addMethInfo = addMethInfoG.MakeGenericMethod(typeof<C>, typeof<C>, typeof<C>)
 let addMethInfoW = addMethInfoGW.MakeGenericMethod(typeof<C>, typeof<C>, typeof<C>)

 Expr.CallWithWitnesses(addMethInfo, addMethInfoW, [witnessExpr], [argExpr1; argExpr2])

Returns a new typed expression given an underlying runtime-typed expression. A type annotation is usually required to use this function, and using an incorrect type annotation may result in a later runtime exception.

source : Expr

The expression to cast.

Returns: Expr<'T>

The resulting typed expression.

Example

 open FSharp.Quotations

 let rawExpr = <@ 1 @>

 Expr.Cast<int>(rawExpr)

Builds an expression that represents the coercion of an expression to a type

source : Expr

The expression to coerce.

target : Type

The target type.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let expr = <@ box "3" @>

 Expr.Coerce(expr, typeof<string>)

Builds an expression that represents the invocation of a default object constructor

expressionType : Type

The type on which the constructor is invoked.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.DefaultValue(typeof<int>)

This function is called automatically when quotation syntax (<@ @>) and other sources of quotations are used.

qualifyingType : Type

A type in the assembly where the quotation occurs.

spliceTypes : Type list

The spliced types, to replace references to type variables.

spliceExprs : Expr list

The spliced expressions to replace references to spliced expressions.

bytes : byte[]

The serialized form of the quoted expression.

Returns: Expr

The resulting expression.

This function is called automatically when quotation syntax (<@ @>) and other sources of quotations are used.

qualifyingType : Type

A type in the assembly where the quotation occurs.

referencedTypes : Type[]

The type definitions referenced.

spliceTypes : Type[]

The spliced types, to replace references to type variables.

spliceExprs : Expr[]

The spliced expressions to replace references to spliced expressions.

bytes : byte[]

The serialized form of the quoted expression.

Returns: Expr

The resulting expression.

Builds an expression that represents the access of a field of an object

obj : Expr

The input object.

fieldInfo : FieldInfo

The description of the field to access.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let fieldInfo = typeof<int ref>.GetField("contents@")
 let refValue = ref 3
 let refExpr = <@ refValue @>

 Expr.FieldGet(refExpr, fieldInfo)

Builds an expression that represents the access of a static field

fieldInfo : FieldInfo

The description of the field to access.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let fieldInfo = typeof<System.DayOfWeek>.GetField("Monday")

 Expr.FieldGet(fieldInfo)

Builds an expression that represents writing to a field of an object

obj : Expr

The input object.

fieldInfo : FieldInfo

The description of the field to write to.

value : Expr

The value to set to the field.

Returns: Expr

The resulting expression.

Example

Create an expression setting a reference cell via the public backing field:

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let fieldInfo = typeof<int ref>.GetField("contents@")
 let refValue = ref 3
 let refExpr = <@ refValue @>
 let valueExpr = <@ 6 @>

 Expr.FieldSet(refExpr, fieldInfo, valueExpr)

Builds an expression that represents writing to a static field

Settable public static fields are rare in F# and .NET libraries, so examples of using this method are uncommon.

fieldInfo : FieldInfo

The description of the field to write to.

value : Expr

The value to the set to the field.

Returns: Expr

The resulting expression.

Builds a 'for i = ... to ... do ...' expression that represent loops over integer ranges

loopVariable : Var

The sub-expression declaring the loop variable.

start : Expr

The sub-expression setting the initial value of the loop variable.

endExpr : Expr

The sub-expression declaring the final value of the loop variable.

body : Expr

The sub-expression representing the body of the loop.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let loopVariable = Var("x", typeof<int>)
 let startExpr = <@ 6 @>
 let endExpr = <@ 7 @>
 let body = <@ System.Console.WriteLine("hello") @>

 Expr.ForIntegerRangeLoop(loopVariable, startExpr, endExpr, body)

Fetches or creates a new variable with the given name and type from a global pool of shared variables indexed by name and type. The type is given by the explicit or inferred type parameter

name : string

The variable name.

Returns: Expr<'T>

The created of fetched typed global variable.

Example

 open FSharp.Quotations

 let expr1 = Expr.GlobalVar<int>("x")
 let expr2 = Expr.GlobalVar<int>("x")

Builds 'if ... then ... else' expressions.

guard : Expr

The condition expression.

thenExpr : Expr

The then sub-expression.

elseExpr : Expr

The else sub-expression.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let guardExpr = <@ 1 > 3 @>
 let thenExpr = <@ 6 @>
 let elseExpr = <@ 7 @>

 Expr.IfThenElse(guardExpr, thenExpr, elseExpr)

Builds an expression that represents the construction of an F# function value

parameter : Var

The parameter to the function.

body : Expr

The body of the function.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let vVar = Var("v", typeof<int>)
 let vExpr = Expr.Var(vVar)

 Expr.Lambda(vVar, vExpr)

Builds expressions associated with 'let' constructs

letVariable : Var

The variable in the let expression.

letExpr : Expr

The expression bound to the variable.

body : Expr

The sub-expression where the binding is in scope.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let vVar = Var("v", typeof<int>)
 let rhsExpr = <@ 6 @>
 let vExpr = Expr.Var(vVar)

 Expr.Let(vVar, rhsExpr, vExpr)

Builds recursive expressions associated with 'let rec' constructs

bindings : (Var * Expr) list

The list of bindings for the let expression.

body : Expr

The sub-expression where the bindings are in scope.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let fVar = Var("f", typeof<int -> int>)
 let gVar = Var("v", typeof<int -> int>)
 let fExpr = Expr.Var(fVar)
 let gExpr = Expr.Var(gVar)
 let fImplExpr = <@ fun x -> (%%gExpr : int -> int) (x - 1) + 1 @>
 let gImplExpr = <@ fun x -> if x > 0 then (%%fExpr : int -> int) (x - 1) else 0 @>
 let bodyExpr = <@ (%%gExpr : int -> int) 10 @>

 Expr.LetRecursive([(fVar, fImplExpr); (gVar, gImplExpr)], bodyExpr)

Builds an expression that represents the creation of an array value initialized with the given elements

elementType : Type

The type for the elements of the array.

elements : Expr list

The list of elements of the array.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.NewArray(typeof<int>, [ <@ 1 @>; <@ 2 @> ])

Builds an expression that represents the creation of a delegate value for the given type

delegateType : Type

The type of delegate.

parameters : Var list

The parameters for the delegate.

body : Expr

The body of the function.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations

 let vVar = Var("v", typeof<int>)
 let vExpr = Expr.Var(vVar)

 Expr.NewDelegate(typeof<Func<int,int>>, [vVar], vExpr)

Builds an expression that represents the invocation of an object constructor

constructorInfo : ConstructorInfo

The description of the constructor.

arguments : Expr list

The list of arguments to the constructor.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let ctorInfo =
     match <@ new System.DateTime(100L) @> with
     | NewObject(ci, _) -> ci
     | _ -> failwith "call expected"

 let argExpr = <@ 100000L @>

 Expr.NewObject(ctorInfo, [argExpr])

Builds record-construction expressions

recordType : Type

The type of record.

elements : Expr list

The list of elements of the record.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 type R = { Y: int; X: string }

 Expr.NewRecord(typeof<R>, [ <@ 1 @>; <@ "a" @> ])

Builds an expression that represents the creation of an F# tuple value

elements : Expr list

The list of elements of the tuple.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.NewStructTuple( [ <@ 1 @>; <@ "a" @> ])

Builds an expression that represents the creation of an F# tuple value

asm : Assembly

Runtime assembly containing System.ValueTuple definitions.

elements : Expr list

The list of elements of the tuple.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.NewStructTuple(typeof<struct (int * int)>.Assembly, [ <@ 1 @>; <@ "a" @> ])

Builds an expression that represents the creation of an F# tuple value

elements : Expr list

The list of elements of the tuple.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.NewTuple([ <@ 1 @>; <@ "a" @> ])

Builds an expression that represents the creation of a union case value

unionCase : UnionCaseInfo

The description of the union case.

arguments : Expr list

The list of arguments for the case.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Reflection

 let ucCons = FSharpType.GetUnionCases(typeof<int list>)[1]

 Expr.NewUnionCase(ucCons, [ <@ 10 @>; <@ [11] @> ])

Builds an expression that represents reading a static property

property : PropertyInfo

The description of the property.

?indexerArgs : Expr list

List of indices for the property if it is an indexed property.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let propInfo =
     match <@ Console.Out @> with
     | PropertyGet(None, pi, _) -> pi
     | _ -> failwith "property get expected"

 Expr.PropertyGet(propInfo)

Builds an expression that represents reading a property of an object

obj : Expr

The input object.

property : PropertyInfo

The description of the property.

?indexerArgs : Expr list

List of indices for the property if it is an indexed property.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let propInfo =
     match <@ "a".Length @> with
     | PropertyGet(Some _, pi, _) -> pi
     | _ -> failwith "property get expected"

 let objExpr = <@ "bb" @>

 Expr.PropertyGet(objExpr, propInfo)

Builds an expression that represents writing to a static property

property : PropertyInfo

The description of the property.

value : Expr

The value to set.

?indexerArgs : Expr list

List of indices for the property if it is an indexed property.

Returns: Expr

The resulting expression.

Example

 open System
 open System.Collections.Generic
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let propInfo =
     match <@ Console.BackgroundColor <- ConsoleColor.Red  @> with
     | PropertySet(None, pi, _, _) -> pi
     | _ -> failwith "property get expected"

 Expr.PropertySet(propInfo, <@ ConsoleColor.Blue @>)

Builds an expression that represents writing to a property of an object

obj : Expr

The input object.

property : PropertyInfo

The description of the property.

value : Expr

The value to set.

?indexerArgs : Expr list

List of indices for the property if it is an indexed property.

Returns: Expr

The resulting expression.

Example

 open System
 open System.Collections.Generic
 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let propInfo =
     match <@ (new List<int>()).Capacity @> with
     | PropertyGet(Some _, pi, _) -> pi
     | _ -> failwith "property get expected"

 let objExpr = <@ (new List<int>()) @>

 Expr.PropertySet(objExpr, propInfo, <@ 6 @>)

Builds an expression that represents a nested raw quotation literal

inner : Expr

The expression being quoted.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.QuoteRaw(<@ 1 @>)

Builds an expression that represents a nested typed quotation literal

inner : Expr

The expression being quoted.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.QuoteTyped(<@ 1 @>)

Permits interactive environments such as F# Interactive to explicitly register new pickled resources that represent persisted top level definitions.

assembly : Assembly

The assembly associated with the resource.

resource : string

The unique name for the resources being added.

serializedValue : byte[]

The serialized resource to register with the environment.

referencedTypes : Type[]

The type definitions referenced.

Permits interactive environments such as F# Interactive to explicitly register new pickled resources that represent persisted top level definitions.

assembly : Assembly

The assembly associated with the resource.

resource : string

The unique name for the resources being added.

serializedValue : byte[]

The serialized resource to register with the environment.

Builds an expression that represents the sequential execution of one expression followed by another

first : Expr

The first expression.

second : Expr

The second expression.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations

 Expr.Sequential(<@ Console.WriteLine("a") @>, <@ Console.WriteLine("b") @>)

Builds an expression that represents a try/finally construct

body : Expr

The body of the try expression.

compensation : Expr

The final part of the expression to be evaluated.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations

 Expr.TryFinally(<@ 1+1 @>, <@ Console.WriteLine("finally") @>)

Try and find a stored reflection definition for the given method. Stored reflection definitions are added to an F# assembly through the use of the [] attribute.

methodBase : MethodBase

The description of the method to find.

Returns: Expr option

The reflection definition or None if a match could not be found.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 [<ReflectedDefinition>]
 let f x = x + 1

 let methInfo =
     match <@ f 1 @> with
     | Call(_, mi, _) -> mi
     | _ -> failwith "call expected"

 Expr.TryGetReflectedDefinition(methInfo)

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 [<ReflectedDefinition>]
 module Methods =
    let f x = (x, x)

 let methInfoGeneric =
     match <@ Methods.f (1, 2) @> with
     | Call(_, mi, _) -> mi.GetGenericMethodDefinition()
     | _ -> failwith "call expected"

 let methInfoAtString = methInfoGeneric.MakeGenericMethod(typeof<string>)

 Expr.TryGetReflectedDefinition(methInfoAtString)

Builds an expression that represents a try/with construct for exception filtering and catching.

body : Expr

The body of the try expression.

filterVar : Var

filterBody : Expr

catchVar : Var

The variable to bind to a caught exception.

catchBody : Expr

The expression evaluated when an exception is caught.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations

 let exnVar = Var("exn", typeof<exn>)

 Expr.TryWith(<@ 1+1 @>, exnVar, <@ 1 @>, exnVar, <@ 2+2 @>)

Builds an expression that represents getting a field of a tuple

tuple : Expr

The input tuple.

index : int

The index of the tuple element to get.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let tupExpr = <@ (1, 2, 3) @>

 Expr.TupleGet(tupExpr, 1)

Builds an expression that represents a type test.

source : Expr

The expression to test.

target : Type

The target type.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let obj = box 1

 Expr.TypeTest( <@ obj @>, typeof<int>)

Builds an expression that represents a test of a value is of a particular union case

source : Expr

The expression to test.

unionCase : UnionCaseInfo

The description of the union case.

Returns: Expr

The resulting expression.

Example

 open System
 open FSharp.Quotations
 open FSharp.Reflection

 let ucCons = FSharpType.GetUnionCases(typeof<int list>)[1]

 Expr.UnionCaseTest(<@ [11] @>, ucCons)

Builds an expression that represents a constant value

value : 'T

The typed value.

Returns: Expr

Example

 open FSharp.Quotations

 Expr.Value(1)

Builds an expression that represents a constant value of a particular type

value : obj

The untyped object.

expressionType : Type

The type of the object.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.Value(box 1, typeof<int>)

Builds an expression that represents a constant value of a particular type, arising from a variable of the given name

value : obj

The untyped object.

expressionType : Type

The type of the object.

name : string

The name of the variable.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.ValueWithName(box 1, typeof<int>, "name")