Header menu logo FSharp.Core

Expr Type

Quoted expressions annotated with System.Type values.

Instance members

Instance member Description

this.CustomAttributes

Full Usage: this.CustomAttributes

Returns: Expr list

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
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val sampleQuotation: Expr<int>
property Expr.CustomAttributes: Expr list with get
Evaluates to a list of expressions containing one custom attribute for the source location of the quotation literal.

this.GetFreeVars

Full Usage: this.GetFreeVars

Returns: Var seq A sequence of the free variables in the expression.

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

Returns: Var seq

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()
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val sampleQuotation: Expr<(int -> int)>
val v: int
val v: Var
val body: Expr
active recognizer Lambda: Expr -> (Var * Expr) option
val failwith: message: string -> 'T
member Expr.GetFreeVars: unit -> Var seq
Evaluates to a set containing the single variable for v

this.Substitute

Full Usage: this.Substitute

Parameters:
    substitution : Var -> Expr option - The function to map variables into expressions.

Returns: Expr The expression with the given substitutions.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val sampleQuotation: Expr<(int -> int)>
val v: int
val v: Var
val body: Expr
active recognizer Lambda: Expr -> (Var * Expr) option
val failwith: message: string -> 'T
member Expr.Substitute: substitution: (Var -> Expr option) -> Expr
val v2: Var
union case Option.Some: Value: 'T -> Option<'T>
union case Option.None: Option<'T>
Evaluates to <@ (1 + 1) * (1 + 1)>.

this.ToString

Full Usage: this.ToString

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

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val expr1: Expr<int>
System.Object.ToString() : string
member Expr.ToString: full: bool -> string
Evaluates "Call (None, Int32 op_Addition[Int32,Int32,Int32](Int32, Int32),[Value (1), Value (1)])".

this.Type

Full Usage: this.Type

Returns: Type

Returns type of an expression.

Returns: Type
Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns

 let sampleQuotation =  <@ 1 + 1 @>

 sampleQuotation.Type
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val sampleQuotation: Expr<int>
property Expr.Type: System.Type with get
Evaluates to typeof<int>.

Static members

Static member Description

Expr.AddressOf(target)

Full Usage: Expr.AddressOf(target)

Parameters:
    target : Expr - The target expression.

Returns: Expr The resulting expression.

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] @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
val array: int array

--------------------
type 'T array = 'T array
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.AddressOf: target: Expr -> Expr
Evaluates to AddressOf (Call (None, GetArray, [PropertyGet (None, array, []), Value (1)])).

Expr.AddressSet(target, value)

Full Usage: Expr.AddressSet(target, value)

Parameters:
    target : Expr - The target expression.
    value : Expr - The value to set at the address.

Returns: Expr The resulting expression.

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 @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
val array: int array

--------------------
type 'T array = 'T array
val addrExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.AddressOf: target: Expr -> Expr
static member Expr.AddressSet: target: Expr * value: Expr -> Expr
Evaluates to AddressSet (AddressOf (Call (None, GetArray, [PropertyGet (None, array, []), Value (1)])), Value (4)).

Expr.Application(functionExpr, argument)

Full Usage: Expr.Application(functionExpr, argument)

Parameters:
    functionExpr : Expr - The function to apply.
    argument : Expr - The argument to the function.

Returns: Expr The resulting expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val funcExpr: Expr<(int -> int)>
val x: int
val argExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Application: functionExpr: Expr * argument: Expr -> Expr
Evaluates to a quotation with the same structure as <@ (fun x -> x + 1) 3 @>.

Expr.Applications(functionExpr, arguments)

Full Usage: Expr.Applications(functionExpr, arguments)

Parameters:
    functionExpr : Expr - The function to apply.
    arguments : Expr list list - The list of lists of arguments to the function.

Returns: Expr The resulting expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val funcExpr: Expr<(int * int -> int -> int)>
val x: int
val y: int
val z: int
val curriedArgExprs: Expr<int> list list
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Applications: functionExpr: Expr * arguments: Expr list list -> Expr
Evaluates to a quotation with the same structure as <@ (fun (x, y) z -> x + y + z) (1,2) 3 @>.

Expr.Call(obj, methodInfo, arguments)

Full Usage: Expr.Call(obj, methodInfo, arguments)

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

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])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val objExpr: Expr
val methInfo: Reflection.MethodInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
property Console.Out: IO.TextWriter with get
IO.TextWriter.WriteLine() : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: uint64) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: uint32) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: Text.StringBuilder) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: string) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: float32) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(buffer: ReadOnlySpan<char>) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: obj) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: int64) : unit
   (+0 other overloads)
IO.TextWriter.WriteLine(value: int) : unit
   (+0 other overloads)
active recognizer Call: Expr -> (Expr option * Reflection.MethodInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
Multiple items
val obj: Expr

--------------------
type obj = Object
val mi: Reflection.MethodInfo
val failwith: message: string -> 'T
val argExpr: Expr<string>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Call: methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
static member Expr.Call: obj: Expr * methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ Console.Out.WriteLine("Hello World") @>.

Expr.Call(methodInfo, arguments)

Full Usage: Expr.Call(methodInfo, arguments)

Parameters:
    methodInfo : MethodInfo - The MethodInfo describing the method to call.
    arguments : Expr list - The list of arguments to the method.

Returns: Expr The resulting expression.

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])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val methInfo: Reflection.MethodInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
Console.WriteLine() : unit
   (+0 other overloads)
Console.WriteLine(value: uint64) : unit
   (+0 other overloads)
Console.WriteLine(value: uint32) : unit
   (+0 other overloads)
Console.WriteLine(value: string) : unit
   (+0 other overloads)
Console.WriteLine(value: float32) : unit
   (+0 other overloads)
Console.WriteLine(value: obj) : unit
   (+0 other overloads)
Console.WriteLine(value: int64) : unit
   (+0 other overloads)
Console.WriteLine(value: int) : unit
   (+0 other overloads)
Console.WriteLine(value: float) : unit
   (+0 other overloads)
Console.WriteLine(value: decimal) : unit
   (+0 other overloads)
active recognizer Call: Expr -> (Expr option * Reflection.MethodInfo * Expr list) option
val mi: Reflection.MethodInfo
val failwith: message: string -> 'T
val argExpr: Expr<string>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Call: methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
static member Expr.Call: obj: Expr * methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ Console.WriteLine("Hello World") @>.

Expr.CallWithWitnesses(obj, methodInfo, methodInfoWithWitnesses, witnesses, arguments)

Full Usage: Expr.CallWithWitnesses(obj, methodInfo, methodInfoWithWitnesses, witnesses, arguments)

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

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

Expr.CallWithWitnesses(methodInfo, methodInfoWithWitnesses, witnesses, arguments)

Full Usage: Expr.CallWithWitnesses(methodInfo, methodInfoWithWitnesses, witnesses, arguments)

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

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 construct 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])
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val addMethInfoG: System.Reflection.MethodInfo
val addMethInfoGW: System.Reflection.MethodInfo
active recognizer CallWithWitnesses: Expr -> (Expr option * System.Reflection.MethodInfo * System.Reflection.MethodInfo * Expr list * Expr list) option
union case Option.None: Option<'T>
val mi: System.Reflection.MethodInfo
val miW: System.Reflection.MethodInfo
System.Reflection.MethodInfo.GetGenericMethodDefinition() : System.Reflection.MethodInfo
val failwith: message: string -> 'T
type C = new: value: int -> C member Value: int
val value: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val x: C
val witnessExpr: Expr<(C -> C -> C)>
val y: C
new: value: int -> C
property C.Value: int with get
val argExpr1: Expr<C>
val argExpr2: Expr<C>
val addMethInfo: System.Reflection.MethodInfo
System.Reflection.MethodInfo.MakeGenericMethod([<System.ParamArray>] typeArguments: System.Type array) : System.Reflection.MethodInfo
val typeof<'T> : System.Type
val addMethInfoW: System.Reflection.MethodInfo
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.CallWithWitnesses: methodInfo: System.Reflection.MethodInfo * methodInfoWithWitnesses: System.Reflection.MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr
static member Expr.CallWithWitnesses: obj: Expr * methodInfo: System.Reflection.MethodInfo * methodInfoWithWitnesses: System.Reflection.MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ Call (None, op_Addition, [NewObject (C, Value (4)), NewObject (C, Value (5))]) @>.

Expr.Cast(source)

Full Usage: Expr.Cast(source)

Parameters:
    source : Expr - The expression to cast.

Returns: Expr<'T> The resulting typed expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val rawExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Cast: source: Expr -> Expr<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates with type Expr<int>.

Expr.Coerce(source, target)

Full Usage: Expr.Coerce(source, target)

Parameters:
    source : Expr - The expression to coerce.
    target : Type - The target type.

Returns: Expr The resulting expression.

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>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val expr: Expr<obj>
val box: value: 'T -> obj
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Coerce: source: Expr * target: System.Type -> Expr
val typeof<'T> : System.Type
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
Evaluates to a quotation with the same structure as <@ (fun x -> x + 1) 3 @>.

Expr.DefaultValue(expressionType)

Full Usage: Expr.DefaultValue(expressionType)

Parameters:
    expressionType : Type - The type on which the constructor is invoked.

Returns: Expr The resulting expression.

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>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.DefaultValue: expressionType: System.Type -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to the quotation DefaultValue (Int32).

Expr.Deserialize(qualifyingType, spliceTypes, spliceExprs, bytes)

Full Usage: Expr.Deserialize(qualifyingType, spliceTypes, spliceExprs, bytes)

Parameters:
    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 array - 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.

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 array

The serialized form of the quoted expression.

Returns: Expr

The resulting expression.

Expr.Deserialize40(qualifyingType, referencedTypes, spliceTypes, spliceExprs, bytes)

Full Usage: Expr.Deserialize40(qualifyingType, referencedTypes, spliceTypes, spliceExprs, bytes)

Parameters:
    qualifyingType : Type - A type in the assembly where the quotation occurs.
    referencedTypes : Type array - The type definitions referenced.
    spliceTypes : Type array - The spliced types, to replace references to type variables.
    spliceExprs : Expr array - The spliced expressions to replace references to spliced expressions.
    bytes : byte array - 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 array

The type definitions referenced.

spliceTypes : Type array

The spliced types, to replace references to type variables.

spliceExprs : Expr array

The spliced expressions to replace references to spliced expressions.

bytes : byte array

The serialized form of the quoted expression.

Returns: Expr

The resulting expression.

Expr.FieldGet(obj, fieldInfo)

Full Usage: Expr.FieldGet(obj, fieldInfo)

Parameters:
    obj : Expr - The input object.
    fieldInfo : FieldInfo - The description of the field to access.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fieldInfo: System.Reflection.FieldInfo
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Multiple items
val ref: value: 'T -> 'T ref

--------------------
type 'T ref = Ref<'T>
val refValue: int ref
val refExpr: Expr<int ref>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.FieldGet: fieldInfo: System.Reflection.FieldInfo -> Expr
static member Expr.FieldGet: obj: Expr * fieldInfo: System.Reflection.FieldInfo -> Expr
Evaluates to FieldGet (Some (PropertyGet (None, refValue, [])), contents@). Note that for technical reasons the quotation <@ refValue.contents @> evaluates to a different quotation accessing the contents field via a property.

Expr.FieldGet(fieldInfo)

Full Usage: Expr.FieldGet(fieldInfo)

Parameters:
    fieldInfo : FieldInfo - The description of the field to access.

Returns: Expr The resulting expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fieldInfo: System.Reflection.FieldInfo
val typeof<'T> : System.Type
namespace System
[<Struct>] type DayOfWeek = | Sunday = 0 | Monday = 1 | Tuesday = 2 | Wednesday = 3 | Thursday = 4 | Friday = 5 | Saturday = 6
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.FieldGet: fieldInfo: System.Reflection.FieldInfo -> Expr
static member Expr.FieldGet: obj: Expr * fieldInfo: System.Reflection.FieldInfo -> Expr
Evaluates to FieldGet (None, Monday). Note that for technical reasons the quotation <@ System.DayOfWeek.Monday @> evaluates to a different quotation containing a constant enum value Value (Monday).

Expr.FieldSet(obj, fieldInfo, value)

Full Usage: Expr.FieldSet(obj, fieldInfo, value)

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

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fieldInfo: System.Reflection.FieldInfo
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Multiple items
val ref: value: 'T -> 'T ref

--------------------
type 'T ref = Ref<'T>
val refValue: int ref
val refExpr: Expr<int ref>
val valueExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.FieldSet: fieldInfo: System.Reflection.FieldInfo * value: Expr -> Expr
static member Expr.FieldSet: obj: Expr * fieldInfo: System.Reflection.FieldInfo * value: Expr -> Expr
Evaluates to FieldSet (Some (PropertyGet (None, refValue, [])), contents@, Value (6)). Note that for technical reasons the quotation <@ refValue.contents <- 6 @> evaluates to a slightly different quotation accessing the contents field via a property.

Expr.FieldSet(fieldInfo, value)

Full Usage: Expr.FieldSet(fieldInfo, value)

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

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

Full Usage: Expr.ForIntegerRangeLoop(loopVariable, start, endExpr, body)

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

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val loopVariable: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val startExpr: Expr<int>
val endExpr: Expr<int>
val body: Expr<unit>
namespace System
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
System.Console.WriteLine() : unit
   (+0 other overloads)
System.Console.WriteLine(value: uint64) : unit
   (+0 other overloads)
System.Console.WriteLine(value: uint32) : unit
   (+0 other overloads)
System.Console.WriteLine(value: string) : unit
   (+0 other overloads)
System.Console.WriteLine(value: float32) : unit
   (+0 other overloads)
System.Console.WriteLine(value: obj) : unit
   (+0 other overloads)
System.Console.WriteLine(value: int64) : unit
   (+0 other overloads)
System.Console.WriteLine(value: int) : unit
   (+0 other overloads)
System.Console.WriteLine(value: float) : unit
   (+0 other overloads)
System.Console.WriteLine(value: decimal) : unit
   (+0 other overloads)
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.ForIntegerRangeLoop: loopVariable: Var * start: Expr * endExpr: Expr * body: Expr -> Expr
Evaluates to a quotation with the same structure as <@ for x in 6..7 do System.Console.WriteLine("hello") @>.

Expr.GlobalVar(name)

Full Usage: Expr.GlobalVar(name)

Parameters:
    name : string - The variable name.

Returns: Expr<'T> The created of fetched typed global variable.

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")
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val expr1: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.GlobalVar: name: string -> Expr<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val expr2: Expr<int>
Evaluates expr1 and expr2 to identical quotations.

Expr.IfThenElse(guard, thenExpr, elseExpr)

Full Usage: Expr.IfThenElse(guard, thenExpr, elseExpr)

Parameters:
    guard : Expr - The condition expression.
    thenExpr : Expr - The then sub-expression.
    elseExpr : Expr - The else sub-expression.

Returns: Expr The resulting expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val guardExpr: Expr<bool>
val thenExpr: Expr<int>
val elseExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.IfThenElse: guard: Expr * thenExpr: Expr * elseExpr: Expr -> Expr
Evaluates to a quotation with the same structure as <@ if 1 > 3 then 6 else 7 @>.

Expr.Lambda(parameter, body)

Full Usage: Expr.Lambda(parameter, body)

Parameters:
    parameter : Var - The parameter to the function.
    body : Expr - The body of the function.

Returns: Expr The resulting expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
active recognizer Var: Expr -> Var option

--------------------
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val vExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
static member Expr.Lambda: parameter: Var * body: Expr -> Expr
Evaluates to Lambda (v, v).

Expr.Let(letVariable, letExpr, body)

Full Usage: Expr.Let(letVariable, letExpr, body)

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

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val rhsExpr: Expr<int>
val vExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
static member Expr.Let: letVariable: Var * letExpr: Expr * body: Expr -> Expr
Evaluates to a quotation with the same structure as <@ let v = 6 in v @>.

Expr.LetRecursive(bindings, body)

Full Usage: Expr.LetRecursive(bindings, body)

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

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fVar: Var
Multiple items
active recognizer Var: Expr -> Var option

--------------------
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val gVar: Var
val fExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
val gExpr: Expr
val fImplExpr: Expr<(int -> int)>
val x: int
val gImplExpr: Expr<(int -> int)>
val bodyExpr: Expr<int>
static member Expr.LetRecursive: bindings: (Var * Expr) list * body: Expr -> Expr
Evaluates to a quotation with the same structure as <@ let rec f x = g (x-1) + 1 and g x = if x > 0 then f (x - 1) else 0 in g 10 @>.

Expr.NewArray(elementType, elements)

Full Usage: Expr.NewArray(elementType, elements)

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

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 @> ])
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewArray: elementType: System.Type * elements: Expr list -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as <@ [| 1; 2 |] @>.

Expr.NewDelegate(delegateType, parameters, body)

Full Usage: Expr.NewDelegate(delegateType, parameters, body)

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

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)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: Type * ?isMutable: bool -> Var
val typeof<'T> : Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
val vExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
static member Expr.NewDelegate: delegateType: Type * parameters: Var list * body: Expr -> Expr
Multiple items
type Func<'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: unit -> 'TResult

--------------------
type Func<'T,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg: 'T * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg: 'T -> 'TResult

--------------------
type Func<'T1,'T2,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 -> 'TResult

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'T16,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * arg16: 'T16 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * arg16: 'T16 -> 'TResult
Evaluates to a quotation with the same structure as <@ new System.Func<int, int>(fun v -> v) @>.

Expr.NewObject(constructorInfo, arguments)

Full Usage: Expr.NewObject(constructorInfo, arguments)

Parameters:
    constructorInfo : ConstructorInfo - The description of the constructor.
    arguments : Expr list - The list of arguments to the constructor.

Returns: Expr The resulting expression.

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])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val ctorInfo: Reflection.ConstructorInfo
Multiple items
[<Struct>] type DateTime = new: date: DateOnly * time: TimeOnly -> unit + 16 overloads member Add: value: TimeSpan -> DateTime member AddDays: value: float -> DateTime member AddHours: value: float -> DateTime member AddMicroseconds: value: float -> DateTime member AddMilliseconds: value: float -> DateTime member AddMinutes: value: float -> DateTime member AddMonths: months: int -> DateTime member AddSeconds: value: float -> DateTime member AddTicks: value: int64 -> DateTime ...

--------------------
DateTime ()
   (+0 other overloads)
DateTime(ticks: int64) : DateTime
   (+0 other overloads)
DateTime(date: DateOnly, time: TimeOnly) : DateTime
   (+0 other overloads)
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(date: DateOnly, time: TimeOnly, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
   (+0 other overloads)
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
   (+0 other overloads)
active recognizer NewObject: Expr -> (Reflection.ConstructorInfo * Expr list) option
val ci: Reflection.ConstructorInfo
val failwith: message: string -> 'T
val argExpr: Expr<int64>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewObject: constructorInfo: Reflection.ConstructorInfo * arguments: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ NewObject (DateTime, Value (100000L)) @>.

Expr.NewRecord(recordType, elements)

Full Usage: Expr.NewRecord(recordType, elements)

Parameters:
    recordType : Type - The type of record.
    elements : Expr list - The list of elements of the record.

Returns: Expr The resulting expression.

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" @> ])
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
type R = { Y: int X: string }
R.Y: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
R.X: string
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewRecord: recordType: System.Type * elements: Expr list -> Expr
val typeof<'T> : System.Type
Evaluates to a quotation with the same structure as <@ { Y = 1; X = "a" } @>.

Expr.NewStructTuple(elements)

Full Usage: Expr.NewStructTuple(elements)

Parameters:
    elements : Expr list - The list of elements of the tuple.

Returns: Expr The resulting expression.

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" @> ])
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewStructTuple: elements: Expr list -> Expr
static member Expr.NewStructTuple: asm: System.Reflection.Assembly * elements: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ struct (1, "a") @>.

Expr.NewStructTuple(asm, elements)

Full Usage: Expr.NewStructTuple(asm, elements)

Parameters:
    asm : Assembly - Runtime assembly containing System.ValueTuple definitions.
    elements : Expr list - The list of elements of the tuple.

Returns: Expr The resulting expression.

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" @> ])
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewStructTuple: elements: Expr list -> Expr
static member Expr.NewStructTuple: asm: System.Reflection.Assembly * elements: Expr list -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as <@ struct (1, "a") @>.

Expr.NewTuple(elements)

Full Usage: Expr.NewTuple(elements)

Parameters:
    elements : Expr list - The list of elements of the tuple.

Returns: Expr The resulting expression.

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" @> ])
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewTuple: elements: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ (1, "a") @>.

Expr.NewUnionCase(unionCase, arguments)

Full Usage: Expr.NewUnionCase(unionCase, arguments)

Parameters:
    unionCase : UnionCaseInfo - The description of the union case.
    arguments : Expr list - The list of arguments for the case.

Returns: Expr The resulting expression.

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] @> ])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp.Reflection
val ucCons: UnionCaseInfo
type FSharpType = static member GetExceptionFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetFunctionElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] functionType: Type -> Type * Type static member GetRecordFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] recordType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetTupleElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] tupleType: Type -> Type array static member GetUnionCases: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: BindingFlags -> UnionCaseInfo array static member IsExceptionRepresentation: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> bool static member IsFunction: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsModule: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsRecord: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type * ?bindingFlags: BindingFlags -> bool static member IsTuple: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool ...
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?allowAccessToPrivateRepresentation: bool -> UnionCaseInfo array
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: Reflection.BindingFlags -> UnionCaseInfo array
val typeof<'T> : Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
type 'T list = List<'T>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewUnionCase: unionCase: UnionCaseInfo * arguments: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ 10 :: [11] @>.

Expr.PropertyGet(property, ?indexerArgs)

Full Usage: Expr.PropertyGet(property, ?indexerArgs)

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

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)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
property Console.Out: IO.TextWriter with get
active recognizer PropertyGet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list) option
union case Option.None: Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertyGet: property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
static member Expr.PropertyGet: obj: Expr * property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ Console.Out @>.

Expr.PropertyGet(obj, property, ?indexerArgs)

Full Usage: Expr.PropertyGet(obj, property, ?indexerArgs)

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

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)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
active recognizer PropertyGet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
val objExpr: Expr<string>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertyGet: property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
static member Expr.PropertyGet: obj: Expr * property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ "bb".Length @>.

Expr.PropertySet(property, value, ?indexerArgs)

Full Usage: Expr.PropertySet(property, value, ?indexerArgs)

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

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 @>)
namespace System
namespace System.Collections
namespace System.Collections.Generic
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
property Console.BackgroundColor: ConsoleColor with get, set
[<Struct>] type ConsoleColor = | Black = 0 | DarkBlue = 1 | DarkGreen = 2 | DarkCyan = 3 | DarkRed = 4 | DarkMagenta = 5 | DarkYellow = 6 | Gray = 7 | DarkGray = 8 | Blue = 9 ...
field ConsoleColor.Red: ConsoleColor = 12
active recognizer PropertySet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list * Expr) option
union case Option.None: Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertySet: property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr
static member Expr.PropertySet: obj: Expr * property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr
field ConsoleColor.Blue: ConsoleColor = 9
Evaluates to a quotation with the same structure as <@ Console.BackgroundColor <- ConsoleColor.Blue @>.

Expr.PropertySet(obj, property, value, ?indexerArgs)

Full Usage: Expr.PropertySet(obj, property, value, ?indexerArgs)

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

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 @>)
namespace System
namespace System.Collections
namespace System.Collections.Generic
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
Multiple items
type List<'T> = interface ICollection<'T> interface IEnumerable<'T> interface IEnumerable interface IList<'T> interface IReadOnlyCollection<'T> interface IReadOnlyList<'T> interface ICollection interface IList new: unit -> unit + 2 overloads member Add: item: 'T -> unit ...

--------------------
List() : List<'T>
List(collection: IEnumerable<'T>) : List<'T>
List(capacity: int) : List<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
active recognizer PropertyGet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
val objExpr: Expr<List<int>>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertySet: property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr
static member Expr.PropertySet: obj: Expr * property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr
Evaluates to a quotation with the same structure as <@ (new List<int>()).Capacity <- 6 @>.

Expr.QuoteRaw(inner)

Full Usage: Expr.QuoteRaw(inner)

Parameters:
    inner : Expr - The expression being quoted.

Returns: Expr The resulting expression.

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 @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.QuoteRaw: inner: Expr -> Expr
Evaluates to a quotation with the same structure as <@ <@ 1 @> @>.

Expr.QuoteTyped(inner)

Full Usage: Expr.QuoteTyped(inner)

Parameters:
    inner : Expr - The expression being quoted.

Returns: Expr The resulting expression.

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 @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.QuoteTyped: inner: Expr -> Expr
Evaluates to a quotation with the same structure as <@ <@ 1 @> @>.

Expr.RegisterReflectedDefinitions(assembly, resource, serializedValue, referencedTypes)

Full Usage: Expr.RegisterReflectedDefinitions(assembly, resource, serializedValue, referencedTypes)

Parameters:
    assembly : Assembly - The assembly associated with the resource.
    resource : string - The unique name for the resources being added.
    serializedValue : byte array - The serialized resource to register with the environment.
    referencedTypes : Type array - 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 array

The serialized resource to register with the environment.

referencedTypes : Type array

The type definitions referenced.

Expr.RegisterReflectedDefinitions(assembly, resource, serializedValue)

Full Usage: Expr.RegisterReflectedDefinitions(assembly, resource, serializedValue)

Parameters:
    assembly : Assembly - The assembly associated with the resource.
    resource : string - The unique name for the resources being added.
    serializedValue : byte array - The serialized resource to register with the environment.

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 array

The serialized resource to register with the environment.

Expr.Sequential(first, second)

Full Usage: Expr.Sequential(first, second)

Parameters:
    first : Expr - The first expression.
    second : Expr - The second expression.

Returns: Expr The resulting expression.

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") @>)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Sequential: first: Expr * second: Expr -> Expr
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
Console.WriteLine() : unit
   (+0 other overloads)
Console.WriteLine(value: uint64) : unit
   (+0 other overloads)
Console.WriteLine(value: uint32) : unit
   (+0 other overloads)
Console.WriteLine(value: string) : unit
   (+0 other overloads)
Console.WriteLine(value: float32) : unit
   (+0 other overloads)
Console.WriteLine(value: obj) : unit
   (+0 other overloads)
Console.WriteLine(value: int64) : unit
   (+0 other overloads)
Console.WriteLine(value: int) : unit
   (+0 other overloads)
Console.WriteLine(value: float) : unit
   (+0 other overloads)
Console.WriteLine(value: decimal) : unit
   (+0 other overloads)
Evaluates to a quotation with the same structure as <@ Console.WriteLine("a"); Console.WriteLine("b") @>.

Expr.TryFinally(body, compensation)

Full Usage: Expr.TryFinally(body, compensation)

Parameters:
    body : Expr - The body of the try expression.
    compensation : Expr - The final part of the expression to be evaluated.

Returns: Expr The resulting expression.

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") @>)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryFinally: body: Expr * compensation: Expr -> Expr
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
Console.WriteLine() : unit
   (+0 other overloads)
Console.WriteLine(value: uint64) : unit
   (+0 other overloads)
Console.WriteLine(value: uint32) : unit
   (+0 other overloads)
Console.WriteLine(value: string) : unit
   (+0 other overloads)
Console.WriteLine(value: float32) : unit
   (+0 other overloads)
Console.WriteLine(value: obj) : unit
   (+0 other overloads)
Console.WriteLine(value: int64) : unit
   (+0 other overloads)
Console.WriteLine(value: int) : unit
   (+0 other overloads)
Console.WriteLine(value: float) : unit
   (+0 other overloads)
Console.WriteLine(value: decimal) : unit
   (+0 other overloads)
Evaluates to a quotation with the same structure as <@ try 1+1 finally Console.WriteLine("finally") @>.

Expr.TryGetReflectedDefinition(methodBase)

Full Usage: Expr.TryGetReflectedDefinition(methodBase)

Parameters:
    methodBase : MethodBase - The description of the method to find.

Returns: Expr option The reflection definition or None if a match could not be found.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
Multiple items
type ReflectedDefinitionAttribute = inherit Attribute new: unit -> ReflectedDefinitionAttribute + 1 overload member IncludeValue: bool

--------------------
new: unit -> ReflectedDefinitionAttribute
new: includeValue: bool -> ReflectedDefinitionAttribute
val f: x: int -> int
val x: int
val methInfo: System.Reflection.MethodInfo
active recognizer Call: Expr -> (Expr option * System.Reflection.MethodInfo * Expr list) option
val mi: System.Reflection.MethodInfo
val failwith: message: string -> 'T
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryGetReflectedDefinition: methodBase: System.Reflection.MethodBase -> Expr option
Evaluates to a quotation with the same structure as <@ fun x -> x + 1 @>, which is the implementation of the method f.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
Multiple items
type ReflectedDefinitionAttribute = inherit Attribute new: unit -> ReflectedDefinitionAttribute + 1 overload member IncludeValue: bool

--------------------
new: unit -> ReflectedDefinitionAttribute
new: includeValue: bool -> ReflectedDefinitionAttribute
val f: x: 'a -> 'a * 'a
val x: 'a
val methInfoGeneric: System.Reflection.MethodInfo
module Methods from document
active recognizer Call: Expr -> (Expr option * System.Reflection.MethodInfo * Expr list) option
val mi: System.Reflection.MethodInfo
System.Reflection.MethodInfo.GetGenericMethodDefinition() : System.Reflection.MethodInfo
val failwith: message: string -> 'T
val methInfoAtString: System.Reflection.MethodInfo
System.Reflection.MethodInfo.MakeGenericMethod([<System.ParamArray>] typeArguments: System.Type array) : System.Reflection.MethodInfo
val typeof<'T> : System.Type
Multiple items
val string: value: 'T -> string

--------------------
type string = System.String
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryGetReflectedDefinition: methodBase: System.Reflection.MethodBase -> Expr option
Evaluates to a quotation with the same structure as <@ fun (x: string) -> (x, x) @>, which is the implementation of the generic method f instantiated at type string.

Expr.TryWith(body, filterVar, filterBody, catchVar, catchBody)

Full Usage: Expr.TryWith(body, filterVar, filterBody, catchVar, catchBody)

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

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 @>)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
val exnVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: Type * ?isMutable: bool -> Var
val typeof<'T> : Type
type exn = Exception
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryWith: body: Expr * filterVar: Var * filterBody: Expr * catchVar: Var * catchBody: Expr -> Expr
Evaluates to a quotation with the same structure as <@ try 1+1 with exn -> 2+2 @>.

Expr.TupleGet(tuple, index)

Full Usage: Expr.TupleGet(tuple, index)

Parameters:
    tuple : Expr - The input tuple.
    index : int - The index of the tuple element to get.

Returns: Expr The resulting expression.

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)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val tupExpr: Expr<int * int * int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TupleGet: tuple: Expr * index: int -> Expr
Evaluates to quotation that displays as TupleGet (NewTuple (Value (1), Value (2), Value (3)), 1).

Expr.TypeTest(source, target)

Full Usage: Expr.TypeTest(source, target)

Parameters:
    source : Expr - The expression to test.
    target : Type - The target type.

Returns: Expr The resulting expression.

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>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
val obj: obj

--------------------
type obj = System.Object
val box: value: 'T -> obj
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TypeTest: source: Expr * target: System.Type -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to quotation that displays as TypeTest (Int32, PropertyGet (None, obj, [])).

Expr.UnionCaseTest(source, unionCase)

Full Usage: Expr.UnionCaseTest(source, unionCase)

Parameters:
    source : Expr - The expression to test.
    unionCase : UnionCaseInfo - The description of the union case.

Returns: Expr The resulting expression.

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)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp.Reflection
val ucCons: UnionCaseInfo
type FSharpType = static member GetExceptionFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetFunctionElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] functionType: Type -> Type * Type static member GetRecordFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] recordType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetTupleElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] tupleType: Type -> Type array static member GetUnionCases: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: BindingFlags -> UnionCaseInfo array static member IsExceptionRepresentation: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> bool static member IsFunction: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsModule: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsRecord: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type * ?bindingFlags: BindingFlags -> bool static member IsTuple: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool ...
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?allowAccessToPrivateRepresentation: bool -> UnionCaseInfo array
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: Reflection.BindingFlags -> UnionCaseInfo array
val typeof<'T> : Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
type 'T list = List<'T>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.UnionCaseTest: source: Expr * unionCase: UnionCaseInfo -> Expr
Evaluates to a quotation that displays as UnionCaseTest (NewUnionCase (Cons, Value (11), NewUnionCase (Empty)), Cons).

Expr.Value(value)

Full Usage: Expr.Value(value)

Parameters:
    value : 'T - The typed value.

Returns: Expr

Builds an expression that represents a constant value

value : 'T

The typed value.

Returns: Expr
Example

 open FSharp.Quotations

 Expr.Value(1)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Value: value: 'T -> Expr
static member Expr.Value: value: obj * expressionType: System.Type -> Expr
Evaluates to a quotation with the same structure as <@ 1 @>.

Expr.Value(value, expressionType)

Full Usage: Expr.Value(value, expressionType)

Parameters:
    value : objnull - The untyped object.
    expressionType : Type - The type of the object.

Returns: Expr The resulting expression.

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

value : objnull

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>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Value: value: 'T -> Expr
static member Expr.Value: value: obj * expressionType: System.Type -> Expr
val box: value: 'T -> obj
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as <@ 1 @>.

Expr.ValueWithName(value, expressionType, name)

Full Usage: Expr.ValueWithName(value, expressionType, name)

Parameters:
    value : objnull - The untyped object.
    expressionType : Type - The type of the object.
    name : string - The name of the variable.

Returns: Expr The resulting expression.

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

value : objnull

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")
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.ValueWithName: value: 'T * name: string -> Expr
static member Expr.ValueWithName: value: obj * expressionType: System.Type * name: string -> Expr
val box: value: 'T -> obj
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as <@ 1 @> and associated information that the name of the value is "name".

Expr.ValueWithName(value, name)

Full Usage: Expr.ValueWithName(value, name)

Parameters:
    value : 'T - The typed value.
    name : string - The name of the variable.

Returns: Expr The resulting expression.

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

value : 'T

The typed value.

name : string

The name of the variable.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.ValueWithName(1, "name")
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.ValueWithName: value: 'T * name: string -> Expr
static member Expr.ValueWithName: value: obj * expressionType: System.Type * name: string -> Expr
Evaluates to a quotation with the same structure as <@ 1 @> and associated information that the name of the value is "name".

Expr.Var(variable)

Full Usage: Expr.Var(variable)

Parameters:
    variable : Var - The input variable.

Returns: Expr The resulting expression.

Builds an expression that represents a variable

variable : Var

The input variable.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

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

 Expr.Var(vVar)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
Evaluates to a quotation displayed as v.

Expr.VarSet(variable, value)

Full Usage: Expr.VarSet(variable, value)

Parameters:
    variable : Var - The input variable.
    value : Expr - The value to set.

Returns: Expr The resulting expression.

Builds an expression that represents setting a mutable variable

variable : Var

The input variable.

value : Expr

The value to set.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let vVar = Var("v", typeof<int>, isMutable=true)

 Expr.VarSet(vVar, <@ 5 @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type

--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.VarSet: variable: Var * value: Expr -> Expr
Evaluates to a quotation displayed as VarSet (v, Value (5)).

Expr.WhileLoop(guard, body)

Full Usage: Expr.WhileLoop(guard, body)

Parameters:
    guard : Expr - The predicate to control the loop iteration.
    body : Expr - The body of the while loop.

Returns: Expr The resulting expression.

Builds an expression that represents a while loop

guard : Expr

The predicate to control the loop iteration.

body : Expr

The body of the while loop.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 let guardExpr = <@ true @>
 let bodyExpr = <@ () @>

 Expr.WhileLoop(guardExpr, bodyExpr)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val guardExpr: Expr<bool>
val bodyExpr: Expr<unit>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.WhileLoop: guard: Expr * body: Expr -> Expr
Evaluates to a quotation with the same structure as <@ while true do () @>.

Expr.WithValue(value, expressionType, definition)

Full Usage: Expr.WithValue(value, expressionType, definition)

Parameters:
    value : objnull - The untyped object.
    expressionType : Type - The type of the object.
    definition : Expr - The definition of the value being quoted.

Returns: Expr The resulting expression.

Builds an expression that represents a value and its associated reflected definition as a quotation

value : objnull

The untyped object.

expressionType : Type

The type of the object.

definition : Expr

The definition of the value being quoted.

Returns: Expr

The resulting expression.

Example

 open FSharp.Quotations

 Expr.WithValue(box 1, typeof<int>, <@ 2 - 1 @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.WithValue: value: 'T * definition: Expr<'T> -> Expr<'T>
static member Expr.WithValue: value: obj * expressionType: System.Type * definition: Expr -> Expr
val box: value: 'T -> obj
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

--------------------
type int = int32

--------------------
type int<'Measure> = int
Evaluates to a quotation that displays as WithValue (1, Call (None, op_Subtraction, [Value (2), Value (1)])).

Expr.WithValue(value, definition)

Full Usage: Expr.WithValue(value, definition)

Parameters:
    value : 'T - The value being quoted.
    definition : Expr<'T> - The definition of the value being quoted.

Returns: Expr<'T> The resulting expression.

Builds an expression that represents a value and its associated reflected definition as a quotation

value : 'T

The value being quoted.

definition : Expr<'T>

The definition of the value being quoted.

Returns: Expr<'T>

The resulting expression.

Example

 open FSharp.Quotations

 Expr.WithValue(1, <@ 2 - 1 @>)
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...

--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.WithValue: value: 'T * definition: Expr<'T> -> Expr<'T>
static member Expr.WithValue: value: obj * expressionType: System.Type * definition: Expr -> Expr
Evaluates to a quotation that displays as WithValue (1, Call (None, op_Subtraction, [Value (2), Value (1)])).

Type something to start searching.