Expr Type
Quoted expressions annotated with System.Type values.
Instance members
Instance member |
Description
|
|
Returns the custom attributes of an expression. For quotations deriving from quotation literals this may include the source location of the literal. Example
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.
|
|
Gets the free expression variables of an expression as a list. Example
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
|
|
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.
Example
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)> .
|
|
Format the expression as a string
Example
Multiple items
namespace Microsoft.FSharp -------------------- namespace FSharp namespace Microsoft.FSharp.Quotations
val expr1: Expr<int>
System.Object.ToString() : string
Evaluates member Expr.ToString: full: bool -> string "Call (None, Int32 op_Addition[Int32,Int32,Int32](Int32, Int32),[Value (1), Value (1)])" .
|
Returns type of an expression.
Example
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
|
|
Builds an expression that represents getting the address of a value.
Example
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)])) .
|
|
Builds an expression that represents setting the value held at a particular address.
Example
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)) .
|
|
Builds an expression that represents the application of a first class function value to a single argument.
Example
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 @> .
|
Builds an expression that represents the application of a first class function value to multiple arguments
Example
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 @> .
|
|
Full Usage:
Expr.Call(obj, methodInfo, arguments)
Parameters:
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
Example
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
Evaluates to a quotation with the same structure as static member Expr.Call: obj: Expr * methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr <@ Console.Out.WriteLine("Hello World") @> .
|
Full Usage:
Expr.Call(methodInfo, arguments)
Parameters:
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
Example
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
Evaluates to a quotation with the same structure as static member Expr.Call: obj: Expr * methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr <@ Console.WriteLine("Hello World") @> .
|
Full Usage:
Expr.CallWithWitnesses(obj, methodInfo, methodInfoWithWitnesses, witnesses, arguments)
Parameters:
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
ExampleSee examples for Call and CallWithWitnesses |
Full Usage:
Expr.CallWithWitnesses(methodInfo, methodInfoWithWitnesses, witnesses, arguments)
Parameters:
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
ExampleIn this example, we show how to use a witness to construct an `op_Addition` call for a type that doesn't support addition directly:
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
Evaluates to a quotation with the same structure as static member Expr.CallWithWitnesses: obj: Expr * methodInfo: System.Reflection.MethodInfo * methodInfoWithWitnesses: System.Reflection.MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr <@ Call (None, op_Addition, [NewObject (C, Value (4)), NewObject (C, Value (5))]) @> .
|
|
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.
Example
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
Evaluates with type val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int Expr<int> .
|
|
Builds an expression that represents the coercion of an expression to a type
Example
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
Evaluates to a quotation with the same structure as val string: value: 'T -> string -------------------- type string = System.String <@ (fun x -> x + 1) 3 @> .
|
|
Builds an expression that represents the invocation of a default object constructor
Example
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
Evaluates to the quotation val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int DefaultValue (Int32) .
|
Full Usage:
Expr.Deserialize(qualifyingType, spliceTypes, spliceExprs, bytes)
Parameters:
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.
|
Full Usage:
Expr.Deserialize40(qualifyingType, referencedTypes, spliceTypes, spliceExprs, bytes)
Parameters:
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.
|
|
Builds an expression that represents the access of a field of an object
Example
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
Evaluates to static member Expr.FieldGet: obj: Expr * fieldInfo: System.Reflection.FieldInfo -> Expr 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.
|
|
Builds an expression that represents the access of a static field
Example
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
Evaluates to static member Expr.FieldGet: obj: Expr * fieldInfo: System.Reflection.FieldInfo -> Expr 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) .
|
|
Builds an expression that represents writing to a field of an object
ExampleCreate an expression setting a reference cell via the public backing field:
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
Evaluates to static member Expr.FieldSet: obj: Expr * fieldInfo: System.Reflection.FieldInfo * value: Expr -> Expr 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.
|
|
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.
|
Full Usage:
Expr.ForIntegerRangeLoop(loopVariable, start, endExpr, body)
Parameters:
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
Example
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") @> .
|
|
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
Example
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.
|
|
Builds 'if ... then ... else' expressions.
Example
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 @> .
|
|
Builds an expression that represents the construction of an F# function value
Example
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) .
|
|
Builds expressions associated with 'let' constructs
Example
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 @> .
|
Builds recursive expressions associated with 'let rec' constructs
Example
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 @> .
|
|
|
Builds an expression that represents the creation of an array value initialized with the given elements
Example
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
Evaluates to a quotation with the same structure as val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int <@ [| 1; 2 |] @> .
|
|
Builds an expression that represents the creation of a delegate value for the given type
Example
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
Evaluates to a quotation with the same structure as 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 <@ new System.Func<int, int>(fun v -> v) @> .
|
Full Usage:
Expr.NewObject(constructorInfo, arguments)
Parameters:
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
Example
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)) @> .
|
|
Builds record-construction expressions
Example
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" } @> .
|
|
Builds an expression that represents the creation of an F# tuple value
Example
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
Evaluates to a quotation with the same structure as static member Expr.NewStructTuple: asm: System.Reflection.Assembly * elements: Expr list -> Expr <@ struct (1, "a") @> .
|
|
Builds an expression that represents the creation of an F# tuple value
Example
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
Evaluates to a quotation with the same structure as val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int <@ struct (1, "a") @> .
|
|
Builds an expression that represents the creation of an F# tuple value
Example
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") @> .
|
Full Usage:
Expr.NewUnionCase(unionCase, arguments)
Parameters:
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
Example
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] @> .
|
Full Usage:
Expr.PropertyGet(property, ?indexerArgs)
Parameters:
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
Example
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
Evaluates to a quotation with the same structure as static member Expr.PropertyGet: obj: Expr * property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr <@ Console.Out @> .
|
Full Usage:
Expr.PropertyGet(obj, property, ?indexerArgs)
Parameters:
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
Example
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
Evaluates to a quotation with the same structure as static member Expr.PropertyGet: obj: Expr * property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr <@ "bb".Length @> .
|
Full Usage:
Expr.PropertySet(property, value, ?indexerArgs)
Parameters:
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
Example
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 @> .
|
Full Usage:
Expr.PropertySet(obj, property, value, ?indexerArgs)
Parameters:
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
Example
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
Evaluates to a quotation with the same structure as static member Expr.PropertySet: obj: Expr * property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr <@ (new List<int>()).Capacity <- 6 @> .
|
|
Builds an expression that represents a nested raw quotation literal
Example
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 @> @> .
|
|
Builds an expression that represents a nested typed quotation literal
Example
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 @> @> .
|
Full Usage:
Expr.RegisterReflectedDefinitions(assembly, resource, serializedValue, referencedTypes)
Parameters:
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. |
Full Usage:
Expr.RegisterReflectedDefinitions(assembly, resource, serializedValue)
Parameters:
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. |
|
Builds an expression that represents the sequential execution of one expression followed by another
Example
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
Evaluates to a quotation with the same structure as (+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) <@ Console.WriteLine("a"); Console.WriteLine("b") @> .
|
|
Builds an expression that represents a try/finally construct
Example
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
Evaluates to a quotation with the same structure as (+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) <@ try 1+1 finally Console.WriteLine("finally") @> .
|
Full Usage:
Expr.TryGetReflectedDefinition(methodBase)
Parameters:
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 [
Example
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
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 .
|
Full Usage:
Expr.TryWith(body, filterVar, filterBody, catchVar, catchBody)
Parameters:
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.
Example
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 @> .
|
|
Builds an expression that represents getting a field of a tuple
Example
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) .
|
|
Builds an expression that represents a type test.
Example
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
Evaluates to quotation that displays as val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int TypeTest (Int32, PropertyGet (None, obj, [])) .
|
Full Usage:
Expr.UnionCaseTest(source, unionCase)
Parameters:
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
Example
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) .
|
|
Builds an expression that represents a constant value
Example
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
Evaluates to a quotation with the same structure as static member Expr.Value: value: obj * expressionType: System.Type -> Expr <@ 1 @> .
|
|
Builds an expression that represents a constant value of a particular type
Example
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
Evaluates to a quotation with the same structure as val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int <@ 1 @> .
|
|
Builds an expression that represents a constant value of a particular type, arising from a variable of the given name
Example
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
Evaluates to a quotation with the same structure as val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int <@ 1 @> and associated information that the name of the value is "name" .
|
|
Builds an expression that represents a constant value, arising from a variable of the given name
Example
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
Evaluates to a quotation with the same structure as static member Expr.ValueWithName: value: obj * expressionType: System.Type * name: string -> Expr <@ 1 @> and associated information that the name of the value is "name" .
|
|
Builds an expression that represents a variable
Example
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 .
|
|
Builds an expression that represents setting a mutable variable
Example
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)) .
|
|
Builds an expression that represents a while loop
Example
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 () @> .
|
|
Builds an expression that represents a value and its associated reflected definition as a quotation
Example
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
Evaluates to a quotation that displays as val int: value: 'T -> int (requires member op_Explicit) -------------------- type int = int32 -------------------- type int<'Measure> = int WithValue (1, Call (None, op_Subtraction, [Value (2), Value (1)])) .
|
|
Builds an expression that represents a value and its associated reflected definition as a quotation
Example
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>
Evaluates to a quotation that displays as static member Expr.WithValue: value: obj * expressionType: System.Type * definition: Expr -> Expr WithValue (1, Call (None, op_Subtraction, [Value (2), Value (1)])) .
|