Builds an expression that represents getting the address of a value.
Expr
The target expression.
Expr
The resulting expression.
open FSharp.Quotations
let array = [| 1; 2; 3 |]
Expr.AddressOf(<@ array.[1] @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
val array: int array
--------------------
type 'T array = 'T array
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.AddressOf: target: Expr -> Expr
Evaluates toAddressOf (Call (None, GetArray, [PropertyGet (None, array, []), Value (1)])).
Builds an expression that represents setting the value held at a particular address.
Expr
The target expression.
Expr
The value to set at the address.
Expr
The resulting expression.
open FSharp.Quotations
let array = [| 1; 2; 3 |]
let addrExpr = Expr.AddressOf(<@ array.[1] @>)
Expr.AddressSet(addrExpr, <@ 4 @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
val array: int array
--------------------
type 'T array = 'T array
val addrExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.AddressOf: target: Expr -> Expr
static member Expr.AddressSet: target: Expr * value: Expr -> Expr
Evaluates toAddressSet (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.
Expr
The function to apply.
Expr
The argument to the function.
Expr
The resulting expression.
open FSharp.Quotations
let funcExpr = <@ (fun x -> x + 1) @>
let argExpr = <@ 3 @>
Expr.Application(funcExpr, argExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val funcExpr: Expr<(int -> int)>
val x: int
val argExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Application: functionExpr: Expr * argument: Expr -> Expr
Evaluates to a quotation with the same structure as<@ (fun x -> x + 1) 3 @>.
Builds an expression that represents the application of a first class function value to multiple arguments
Expr
The function to apply.
Expr list list
The list of lists of arguments to the function.
Expr
The resulting expression.
open FSharp.Quotations
let funcExpr = <@ (fun (x, y) z -> x + y + z) @>
let curriedArgExprs = [[ <@ 1 @>; <@ 2 @> ]; [ <@ 3 @> ]]
Expr.Applications(funcExpr, curriedArgExprs)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val funcExpr: Expr<(int * int -> int -> int)>
val x: int
val y: int
val z: int
val curriedArgExprs: Expr<int> list list
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Applications: functionExpr: Expr * arguments: Expr list list -> Expr
Evaluates to a quotation with the same structure as<@ (fun (x, y) z -> x + y + z) (1,2) 3 @>.
Builds an expression that represents a call to an instance method associated with an object
Expr
The input object.
MethodInfo
The description of the method to call.
Expr list
The list of arguments to the method.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Quotations.Patterns
let objExpr, methInfo =
match <@ Console.Out.WriteLine("1") @> with
| Call(Some obj, mi, _) -> obj, mi
| _ -> failwith "call expected"
let argExpr = <@ "Hello World" @>
Expr.Call(objExpr, methInfo, [argExpr])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val objExpr: Expr
val methInfo: Reflection.MethodInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
property Console.Out: IO.TextWriter with get
<summary>Gets the standard output stream.</summary>
<returns>A <see cref="T:System.IO.TextWriter" /> that represents the standard output stream.</returns>
IO.TextWriter.WriteLine() : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: uint64) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: uint32) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: Text.StringBuilder) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: string) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: float32) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(buffer: ReadOnlySpan<char>) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: obj) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: int64) : unit
(+0 other overloads)
IO.TextWriter.WriteLine(value: int) : unit
(+0 other overloads)
active recognizer Call: Expr -> (Expr option * Reflection.MethodInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
Multiple items
val obj: Expr
--------------------
type obj = Object
val mi: Reflection.MethodInfo
val failwith: message: string -> 'T
val argExpr: Expr<string>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Call: methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
static member Expr.Call: obj: Expr * methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
<@ Console.Out.WriteLine("Hello World") @>.
Builds an expression that represents a call to an static method or module-bound function
MethodInfo
The MethodInfo describing the method to call.
Expr list
The list of arguments to the method.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Quotations.Patterns
let methInfo =
match <@ Console.WriteLine("1") @> with
| Call(_, mi, _) -> mi
| _ -> failwith "call expected"
let argExpr = <@ "Hello World" @>
Expr.Call(methInfo, [argExpr])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val methInfo: Reflection.MethodInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
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: ReadOnlySpan<char>) : 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)
active recognizer Call: Expr -> (Expr option * Reflection.MethodInfo * Expr list) option
val mi: Reflection.MethodInfo
val failwith: message: string -> 'T
val argExpr: Expr<string>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Call: methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
static member Expr.Call: obj: Expr * methodInfo: Reflection.MethodInfo * arguments: Expr list -> Expr
<@ Console.WriteLine("Hello World") @>.
Builds an expression that represents a call to an instance method associated with an object, potentially passing additional witness arguments
Expr
The input object.
MethodInfo
The description of the method to call.
MethodInfo
The additional MethodInfo describing the method to call, accepting witnesses.
Expr list
The list of witnesses to the method.
Expr list
The list of arguments to the method.
Expr
The resulting expression.
See examples for Call and CallWithWitnesses
Builds an expression that represents a call to an static method or module-bound function, potentially passing additional witness arguments
MethodInfo
The MethodInfo describing the method to call.
MethodInfo
The additional MethodInfo describing the method to call, accepting witnesses.
Expr list
The list of witnesses to the method.
Expr list
The list of arguments to the method.
Expr
The resulting expression.
In this example, we show how to use a witness to construct an `op_Addition` call for a type that doesn't support addition directly:
open FSharp.Quotations
open FSharp.Quotations.Patterns
// Get the entrypoint for inline addition that takes an explicit witness
let addMethInfoG, addMethInfoGW =
match <@ 1+1 @> with
| CallWithWitnesses(None, mi, miW, _, _) ->
mi.GetGenericMethodDefinition(), miW.GetGenericMethodDefinition()
| _ ->
failwith "call expected"
// Make a non-standard witness for addition for a type C
type C(value: int) =
member x.Value = value
let witnessExpr = <@ (fun (x: C) (y: C) -> C(x.Value + y.Value)) @>
let argExpr1 = <@ C(4) @>
let argExpr2 = <@ C(5) @>
// Instantiate the generic method at the right type
let addMethInfo = addMethInfoG.MakeGenericMethod(typeof<C>, typeof<C>, typeof<C>)
let addMethInfoW = addMethInfoGW.MakeGenericMethod(typeof<C>, typeof<C>, typeof<C>)
Expr.CallWithWitnesses(addMethInfo, addMethInfoW, [witnessExpr], [argExpr1; argExpr2])
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val addMethInfoG: System.Reflection.MethodInfo
val addMethInfoGW: System.Reflection.MethodInfo
active recognizer CallWithWitnesses: Expr -> (Expr option * System.Reflection.MethodInfo * System.Reflection.MethodInfo * Expr list * Expr list) option
union case Option.None: Option<'T>
val mi: System.Reflection.MethodInfo
val miW: System.Reflection.MethodInfo
System.Reflection.MethodInfo.GetGenericMethodDefinition() : System.Reflection.MethodInfo
val failwith: message: string -> 'T
type C = new: value: int -> C member Value: int
val value: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val x: C
val witnessExpr: Expr<(C -> C -> C)>
val y: C
new: value: int -> C
property C.Value: int with get
val argExpr1: Expr<C>
val argExpr2: Expr<C>
val addMethInfo: System.Reflection.MethodInfo
System.Reflection.MethodInfo.MakeGenericMethod([<System.ParamArray>] typeArguments: System.Type array) : System.Reflection.MethodInfo
val typeof<'T> : System.Type
val addMethInfoW: System.Reflection.MethodInfo
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.CallWithWitnesses: methodInfo: System.Reflection.MethodInfo * methodInfoWithWitnesses: System.Reflection.MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr
static member Expr.CallWithWitnesses: obj: Expr * methodInfo: System.Reflection.MethodInfo * methodInfoWithWitnesses: System.Reflection.MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr
<@ 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.
Expr
The expression to cast.
Expr<'T>
The resulting typed expression.
open FSharp.Quotations
let rawExpr = <@ 1 @>
Expr.Cast<int>(rawExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val rawExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Cast: source: Expr -> Expr<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates with typeExpr<int>.
Builds an expression that represents the coercion of an expression to a type
Expr
The expression to coerce.
Type
The target type.
Expr
The resulting expression.
open FSharp.Quotations
let expr = <@ box "3" @>
Expr.Coerce(expr, typeof<string>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val expr: Expr<obj>
val box: value: 'T -> obj
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Coerce: source: Expr * target: System.Type -> Expr
val typeof<'T> : System.Type
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
Evaluates to a quotation with the same structure as<@ (fun x -> x + 1) 3 @>.
Builds an expression that represents the invocation of a default object constructor
Type
The type on which the constructor is invoked.
Expr
The resulting expression.
open FSharp.Quotations
Expr.DefaultValue(typeof<int>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.DefaultValue: expressionType: System.Type -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to the quotationDefaultValue (Int32).
This function is called automatically when quotation syntax (<@ @>) and other sources of quotations are used.
Type
A type in the assembly where the quotation occurs.
Type list
The spliced types, to replace references to type variables.
Expr list
The spliced expressions to replace references to spliced expressions.
byte array
The serialized form of the quoted expression.
Expr
The resulting expression.
This function is called automatically when quotation syntax (<@ @>) and other sources of quotations are used.
Type
A type in the assembly where the quotation occurs.
Type array
The type definitions referenced.
Type array
The spliced types, to replace references to type variables.
Expr array
The spliced expressions to replace references to spliced expressions.
byte array
The serialized form of the quoted expression.
Expr
The resulting expression.
Builds an expression that represents the access of a field of an object
Expr
The input object.
FieldInfo
The description of the field to access.
Expr
The resulting expression.
open FSharp.Quotations
open FSharp.Quotations.Patterns
let fieldInfo = typeof<int ref>.GetField("contents@")
let refValue = ref 3
let refExpr = <@ refValue @>
Expr.FieldGet(refExpr, fieldInfo)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fieldInfo: System.Reflection.FieldInfo
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Multiple items
val ref: value: 'T -> 'T ref
--------------------
type 'T ref = Ref<'T>
val refValue: int ref
val refExpr: Expr<int ref>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.FieldGet: fieldInfo: System.Reflection.FieldInfo -> Expr
static member Expr.FieldGet: obj: Expr * fieldInfo: System.Reflection.FieldInfo -> Expr
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
FieldInfo
The description of the field to access.
Expr
The resulting expression.
open FSharp.Quotations
open FSharp.Quotations.Patterns
let fieldInfo = typeof<System.DayOfWeek>.GetField("Monday")
Expr.FieldGet(fieldInfo)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fieldInfo: System.Reflection.FieldInfo
val typeof<'T> : System.Type
namespace System
[<Struct>] type DayOfWeek = | Sunday = 0 | Monday = 1 | Tuesday = 2 | Wednesday = 3 | Thursday = 4 | Friday = 5 | Saturday = 6
<summary>Specifies the day of the week.</summary>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.FieldGet: fieldInfo: System.Reflection.FieldInfo -> Expr
static member Expr.FieldGet: obj: Expr * fieldInfo: System.Reflection.FieldInfo -> Expr
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
Expr
The input object.
FieldInfo
The description of the field to write to.
Expr
The value to set to the field.
Expr
The resulting expression.
Create an expression setting a reference cell via the public backing field:
open FSharp.Quotations
open FSharp.Quotations.Patterns
let fieldInfo = typeof<int ref>.GetField("contents@")
let refValue = ref 3
let refExpr = <@ refValue @>
let valueExpr = <@ 6 @>
Expr.FieldSet(refExpr, fieldInfo, valueExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fieldInfo: System.Reflection.FieldInfo
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Multiple items
val ref: value: 'T -> 'T ref
--------------------
type 'T ref = Ref<'T>
val refValue: int ref
val refExpr: Expr<int ref>
val valueExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.FieldSet: fieldInfo: System.Reflection.FieldInfo * value: Expr -> Expr
static member Expr.FieldSet: obj: Expr * fieldInfo: System.Reflection.FieldInfo * value: Expr -> Expr
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
FieldInfo
The description of the field to write to.
Expr
The value to the set to the field.
Expr
The resulting expression.
Builds a 'for i = ... to ... do ...' expression that represent loops over integer ranges
Var
The sub-expression declaring the loop variable.
Expr
The sub-expression setting the initial value of the loop variable.
Expr
The sub-expression declaring the final value of the loop variable.
Expr
The sub-expression representing the body of the loop.
Expr
The resulting expression.
open FSharp.Quotations
let loopVariable = Var("x", typeof<int>)
let startExpr = <@ 6 @>
let endExpr = <@ 7 @>
let body = <@ System.Console.WriteLine("hello") @>
Expr.ForIntegerRangeLoop(loopVariable, startExpr, endExpr, body)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val loopVariable: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val startExpr: Expr<int>
val endExpr: Expr<int>
val body: Expr<unit>
namespace System
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
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: System.ReadOnlySpan<char>) : 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)
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
string
The variable name.
Expr<'T>
The created of fetched typed global variable.
open FSharp.Quotations
let expr1 = Expr.GlobalVar<int>("x")
let expr2 = Expr.GlobalVar<int>("x")
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val expr1: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.GlobalVar: name: string -> Expr<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val expr2: Expr<int>
Evaluatesexpr1 and expr2 to identical quotations.
Builds 'if ... then ... else' expressions.
Expr
The condition expression.
Expr
The then sub-expression.
Expr
The else sub-expression.
Expr
The resulting expression.
open FSharp.Quotations
let guardExpr = <@ 1 > 3 @>
let thenExpr = <@ 6 @>
let elseExpr = <@ 7 @>
Expr.IfThenElse(guardExpr, thenExpr, elseExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val guardExpr: Expr<bool>
val thenExpr: Expr<int>
val elseExpr: Expr<int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.IfThenElse: guard: Expr * thenExpr: Expr * elseExpr: Expr -> Expr
Evaluates to a quotation with the same structure as<@ if 1 > 3 then 6 else 7 @>.
Builds an expression that represents the construction of an F# function value
Var
The parameter to the function.
Expr
The body of the function.
Expr
The resulting expression.
open FSharp.Quotations
open FSharp.Quotations.Patterns
let vVar = Var("v", typeof<int>)
let vExpr = Expr.Var(vVar)
Expr.Lambda(vVar, vExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
active recognizer Var: Expr -> Var option
--------------------
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val vExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
static member Expr.Lambda: parameter: Var * body: Expr -> Expr
Evaluates toLambda (v, v).
Builds expressions associated with 'let' constructs
Var
The variable in the let expression.
Expr
The expression bound to the variable.
Expr
The sub-expression where the binding is in scope.
Expr
The resulting expression.
open FSharp.Quotations
let vVar = Var("v", typeof<int>)
let rhsExpr = <@ 6 @>
let vExpr = Expr.Var(vVar)
Expr.Let(vVar, rhsExpr, vExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val rhsExpr: Expr<int>
val vExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
static member Expr.Let: letVariable: Var * letExpr: Expr * body: Expr -> Expr
Evaluates to a quotation with the same structure as<@ let v = 6 in v @>.
Builds recursive expressions associated with 'let rec' constructs
(Var * Expr) list
The list of bindings for the let expression.
Expr
The sub-expression where the bindings are in scope.
Expr
The resulting expression.
open FSharp.Quotations
open FSharp.Quotations.Patterns
let fVar = Var("f", typeof<int -> int>)
let gVar = Var("v", typeof<int -> int>)
let fExpr = Expr.Var(fVar)
let gExpr = Expr.Var(gVar)
let fImplExpr = <@ fun x -> (%%gExpr : int -> int) (x - 1) + 1 @>
let gImplExpr = <@ fun x -> if x > 0 then (%%fExpr : int -> int) (x - 1) else 0 @>
let bodyExpr = <@ (%%gExpr : int -> int) 10 @>
Expr.LetRecursive([(fVar, fImplExpr); (gVar, gImplExpr)], bodyExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
val fVar: Var
Multiple items
active recognizer Var: Expr -> Var option
--------------------
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val gVar: Var
val fExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
val gExpr: Expr
val fImplExpr: Expr<(int -> int)>
val x: int
val gImplExpr: Expr<(int -> int)>
val bodyExpr: Expr<int>
static member Expr.LetRecursive: bindings: (Var * Expr) list * body: Expr -> Expr
Evaluates to a quotation with the same structure as<@ let rec f x = g (x-1) + 1 and g x = if x > 0 then f (x - 1) else 0 in g 10 @>.
Builds an expression that represents the creation of an array value initialized with the given elements
Type
The type for the elements of the array.
Expr list
The list of elements of the array.
Expr
The resulting expression.
open FSharp.Quotations
Expr.NewArray(typeof<int>, [ <@ 1 @>; <@ 2 @> ])
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewArray: elementType: System.Type * elements: Expr list -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as<@ [| 1; 2 |] @>.
Builds an expression that represents the creation of a delegate value for the given type
Type
The type of delegate.
Var list
The parameters for the delegate.
Expr
The body of the function.
Expr
The resulting expression.
open System
open FSharp.Quotations
let vVar = Var("v", typeof<int>)
let vExpr = Expr.Var(vVar)
Expr.NewDelegate(typeof<Func<int,int>>, [vVar], vExpr)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: Type * ?isMutable: bool -> Var
val typeof<'T> : Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
val vExpr: Expr
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
static member Expr.NewDelegate: delegateType: Type * parameters: Var list * body: Expr -> Expr
Multiple items
type Func<'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: unit -> 'TResult
--------------------
type Func<'T,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg: 'T * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg: 'T -> 'TResult
--------------------
type Func<'T1,'T2,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 -> 'TResult
--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'T16,'TResult> = new: object: obj * method: nativeint -> unit member BeginInvoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * arg16: 'T16 * callback: AsyncCallback * object: obj -> IAsyncResult member EndInvoke: result: IAsyncResult -> 'TResult member Invoke: arg1: 'T1 * arg2: 'T2 * arg3: 'T3 * arg4: 'T4 * arg5: 'T5 * arg6: 'T6 * arg7: 'T7 * arg8: 'T8 * arg9: 'T9 * arg10: 'T10 * arg11: 'T11 * arg12: 'T12 * arg13: 'T13 * arg14: 'T14 * arg15: 'T15 * arg16: 'T16 -> 'TResult
<@ new System.Func<int, int>(fun v -> v) @>.
Builds an expression that represents the invocation of an object constructor
ConstructorInfo
The description of the constructor.
Expr list
The list of arguments to the constructor.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Quotations.Patterns
let ctorInfo =
match <@ new System.DateTime(100L) @> with
| NewObject(ci, _) -> ci
| _ -> failwith "call expected"
let argExpr = <@ 100000L @>
Expr.NewObject(ctorInfo, [argExpr])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val ctorInfo: Reflection.ConstructorInfo
Multiple items
[<Struct>] type DateTime = new: date: DateOnly * time: TimeOnly -> unit + 16 overloads member Add: value: TimeSpan -> DateTime member AddDays: value: float -> DateTime member AddHours: value: float -> DateTime member AddMicroseconds: value: float -> DateTime member AddMilliseconds: value: float -> DateTime member AddMinutes: value: float -> DateTime member AddMonths: months: int -> DateTime member AddSeconds: value: float -> DateTime member AddTicks: value: int64 -> DateTime ...
--------------------
DateTime ()
DateTime(ticks: int64) : DateTime
DateTime(date: DateOnly, time: TimeOnly) : DateTime
DateTime(ticks: int64, kind: DateTimeKind) : DateTime
DateTime(date: DateOnly, time: TimeOnly, kind: DateTimeKind) : DateTime
DateTime(year: int, month: int, day: int) : DateTime
DateTime(year: int, month: int, day: int, calendar: Globalization.Calendar) : DateTime
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int) : DateTime
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, kind: DateTimeKind) : DateTime
DateTime(year: int, month: int, day: int, hour: int, minute: int, second: int, calendar: Globalization.Calendar) : DateTime
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
Type
The type of record.
Expr list
The list of elements of the record.
Expr
The resulting expression.
open FSharp.Quotations
type R = { Y: int; X: string }
Expr.NewRecord(typeof<R>, [ <@ 1 @>; <@ "a" @> ])
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
type R = { Y: int X: string }
R.Y: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
R.X: string
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewRecord: recordType: System.Type * elements: Expr list -> Expr
val typeof<'T> : System.Type
Evaluates to a quotation with the same structure as<@ { Y = 1; X = "a" } @>.
Builds an expression that represents the creation of an F# tuple value
Expr list
The list of elements of the tuple.
Expr
The resulting expression.
open FSharp.Quotations
Expr.NewStructTuple( [ <@ 1 @>; <@ "a" @> ])
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewStructTuple: elements: Expr list -> Expr
static member Expr.NewStructTuple: asm: System.Reflection.Assembly * elements: Expr list -> Expr
<@ struct (1, "a") @>.
Builds an expression that represents the creation of an F# tuple value
Assembly
Runtime assembly containing System.ValueTuple definitions.
Expr list
The list of elements of the tuple.
Expr
The resulting expression.
open FSharp.Quotations
Expr.NewStructTuple(typeof<struct (int * int)>.Assembly, [ <@ 1 @>; <@ "a" @> ])
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewStructTuple: elements: Expr list -> Expr
static member Expr.NewStructTuple: asm: System.Reflection.Assembly * elements: Expr list -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as<@ struct (1, "a") @>.
Builds an expression that represents the creation of an F# tuple value
Expr list
The list of elements of the tuple.
Expr
The resulting expression.
open FSharp.Quotations
Expr.NewTuple([ <@ 1 @>; <@ "a" @> ])
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewTuple: elements: Expr list -> Expr
Evaluates to a quotation with the same structure as<@ (1, "a") @>.
Builds an expression that represents the creation of a union case value
UnionCaseInfo
The description of the union case.
Expr list
The list of arguments for the case.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Reflection
let ucCons = FSharpType.GetUnionCases(typeof<int list>)[1]
Expr.NewUnionCase(ucCons, [ <@ 10 @>; <@ [11] @> ])
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp.Reflection
val ucCons: UnionCaseInfo
type FSharpType = static member GetExceptionFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetFunctionElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] functionType: Type -> Type * Type static member GetRecordFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] recordType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetTupleElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] tupleType: Type -> Type array static member GetUnionCases: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: BindingFlags -> UnionCaseInfo array static member IsExceptionRepresentation: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> bool static member IsFunction: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsModule: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsRecord: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type * ?bindingFlags: BindingFlags -> bool static member IsTuple: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool ...
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?allowAccessToPrivateRepresentation: bool -> UnionCaseInfo array
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: Reflection.BindingFlags -> UnionCaseInfo array
val typeof<'T> : Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
type 'T list = List<'T>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.NewUnionCase: unionCase: UnionCaseInfo * arguments: Expr list -> Expr
Evaluates to a quotation with the same structure as<@ 10 :: [11] @>.
Builds an expression that represents reading a static property
PropertyInfo
The description of the property.
Expr list
List of indices for the property if it is an indexed property.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Quotations.Patterns
let propInfo =
match <@ Console.Out @> with
| PropertyGet(None, pi, _) -> pi
| _ -> failwith "property get expected"
Expr.PropertyGet(propInfo)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
property Console.Out: IO.TextWriter with get
<summary>Gets the standard output stream.</summary>
<returns>A <see cref="T:System.IO.TextWriter" /> that represents the standard output stream.</returns>
active recognizer PropertyGet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list) option
union case Option.None: Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertyGet: property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
static member Expr.PropertyGet: obj: Expr * property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
<@ Console.Out @>.
Builds an expression that represents reading a property of an object
Expr
The input object.
PropertyInfo
The description of the property.
Expr list
List of indices for the property if it is an indexed property.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Quotations.Patterns
let propInfo =
match <@ "a".Length @> with
| PropertyGet(Some _, pi, _) -> pi
| _ -> failwith "property get expected"
let objExpr = <@ "bb" @>
Expr.PropertyGet(objExpr, propInfo)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
active recognizer PropertyGet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
val objExpr: Expr<string>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertyGet: property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
static member Expr.PropertyGet: obj: Expr * property: Reflection.PropertyInfo * ?indexerArgs: Expr list -> Expr
<@ "bb".Length @>.
Builds an expression that represents writing to a static property
PropertyInfo
The description of the property.
Expr
The value to set.
Expr list
List of indices for the property if it is an indexed property.
Expr
The resulting expression.
open System
open System.Collections.Generic
open FSharp.Quotations
open FSharp.Quotations.Patterns
let propInfo =
match <@ Console.BackgroundColor <- ConsoleColor.Red @> with
| PropertySet(None, pi, _, _) -> pi
| _ -> failwith "property get expected"
Expr.PropertySet(propInfo, <@ ConsoleColor.Blue @>)
namespace System
namespace System.Collections
namespace System.Collections.Generic
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
property Console.BackgroundColor: ConsoleColor with get, set
<summary>Gets or sets the background color of the console.</summary>
<exception cref="T:System.ArgumentException">The color specified in a set operation is not a valid member of <see cref="T:System.ConsoleColor" />.</exception>
<exception cref="T:System.Security.SecurityException">The user does not have permission to perform this action.</exception>
<exception cref="T:System.IO.IOException">An I/O error occurred.</exception>
<returns>A value that specifies the background color of the console; that is, the color that appears behind each character. The default is black.</returns>
[<Struct>] type ConsoleColor = | Black = 0 | DarkBlue = 1 | DarkGreen = 2 | DarkCyan = 3 | DarkRed = 4 | DarkMagenta = 5 | DarkYellow = 6 | Gray = 7 | DarkGray = 8 | Blue = 9 ...
<summary>Specifies constants that define foreground and background colors for the console.</summary>
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 @>.
Builds an expression that represents writing to a property of an object
Expr
The input object.
PropertyInfo
The description of the property.
Expr
The value to set.
Expr list
List of indices for the property if it is an indexed property.
Expr
The resulting expression.
open System
open System.Collections.Generic
open FSharp.Quotations
open FSharp.Quotations.Patterns
let propInfo =
match <@ (new List<int>()).Capacity @> with
| PropertyGet(Some _, pi, _) -> pi
| _ -> failwith "property get expected"
let objExpr = <@ (new List<int>()) @>
Expr.PropertySet(objExpr, propInfo, <@ 6 @>)
namespace System
namespace System.Collections
namespace System.Collections.Generic
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
val propInfo: Reflection.PropertyInfo
Multiple items
type List<'T> = interface ICollection<'T> interface IEnumerable<'T> interface IEnumerable interface IList<'T> interface IReadOnlyCollection<'T> interface IReadOnlyList<'T> interface ICollection interface IList new: unit -> unit + 2 overloads member Add: item: 'T -> unit ...
--------------------
List() : List<'T>
List(collection: IEnumerable<'T>) : List<'T>
List(capacity: int) : List<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
active recognizer PropertyGet: Expr -> (Expr option * Reflection.PropertyInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
val pi: Reflection.PropertyInfo
val failwith: message: string -> 'T
val objExpr: Expr<List<int>>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.PropertySet: property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr
static member Expr.PropertySet: obj: Expr * property: Reflection.PropertyInfo * value: Expr * ?indexerArgs: Expr list -> Expr
<@ (new List<int>()).Capacity <- 6 @>.
Builds an expression that represents a nested raw quotation literal
Expr
The expression being quoted.
Expr
The resulting expression.
open FSharp.Quotations
Expr.QuoteRaw(<@ 1 @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.QuoteRaw: inner: Expr -> Expr
Evaluates to a quotation with the same structure as<@ <@ 1 @> @>.
Builds an expression that represents a nested typed quotation literal
Expr
The expression being quoted.
Expr
The resulting expression.
open FSharp.Quotations
Expr.QuoteTyped(<@ 1 @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.QuoteTyped: inner: Expr -> Expr
Evaluates to a quotation with the same structure as<@ <@ 1 @> @>.
Permits interactive environments such as F# Interactive to explicitly register new pickled resources that represent persisted top level definitions.
Assembly
The assembly associated with the resource.
string
The unique name for the resources being added.
byte array
The serialized resource to register with the environment.
Type array
The type definitions referenced.
Permits interactive environments such as F# Interactive to explicitly register new pickled resources that represent persisted top level definitions.
Assembly
The assembly associated with the resource.
string
The unique name for the resources being added.
byte array
The serialized resource to register with the environment.
Builds an expression that represents the sequential execution of one expression followed by another
Expr
The first expression.
Expr
The second expression.
Expr
The resulting expression.
open System
open FSharp.Quotations
Expr.Sequential(<@ Console.WriteLine("a") @>, <@ Console.WriteLine("b") @>)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Sequential: first: Expr * second: Expr -> Expr
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
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: ReadOnlySpan<char>) : 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("a"); Console.WriteLine("b") @>.
Builds an expression that represents a try/finally construct
Expr
The body of the try expression.
Expr
The final part of the expression to be evaluated.
Expr
The resulting expression.
open System
open FSharp.Quotations
Expr.TryFinally(<@ 1+1 @>, <@ Console.WriteLine("finally") @>)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryFinally: body: Expr * compensation: Expr -> Expr
type Console = static member Beep: unit -> unit + 1 overload static member Clear: unit -> unit static member GetCursorPosition: unit -> struct (int * int) static member MoveBufferArea: sourceLeft: int * sourceTop: int * sourceWidth: int * sourceHeight: int * targetLeft: int * targetTop: int -> unit + 1 overload static member OpenStandardError: unit -> Stream + 1 overload static member OpenStandardInput: unit -> Stream + 1 overload static member OpenStandardOutput: unit -> Stream + 1 overload static member Read: unit -> int static member ReadKey: unit -> ConsoleKeyInfo + 1 overload static member ReadLine: unit -> string ...
<summary>Represents the standard input, output, and error streams for console applications. This class cannot be inherited.</summary>
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: ReadOnlySpan<char>) : 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)
<@ try 1+1 finally Console.WriteLine("finally") @>.
Try and find a stored reflection definition for the given method. Stored reflection definitions are added to an F# assembly through the use of the [ ] attribute.
MethodBase
The description of the method to find.
Expr option
The reflection definition or None if a match could not be found.
open FSharp.Quotations
open FSharp.Quotations.Patterns
[<ReflectedDefinition>]
let f x = x + 1
let methInfo =
match <@ f 1 @> with
| Call(_, mi, _) -> mi
| _ -> failwith "call expected"
Expr.TryGetReflectedDefinition(methInfo)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
Multiple items
type ReflectedDefinitionAttribute = inherit Attribute new: unit -> ReflectedDefinitionAttribute + 1 overload member IncludeValue: bool
--------------------
new: unit -> ReflectedDefinitionAttribute
new: includeValue: bool -> ReflectedDefinitionAttribute
val f: x: int -> int
val x: int
val methInfo: System.Reflection.MethodInfo
active recognizer Call: Expr -> (Expr option * System.Reflection.MethodInfo * Expr list) option
val mi: System.Reflection.MethodInfo
val failwith: message: string -> 'T
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryGetReflectedDefinition: methodBase: System.Reflection.MethodBase -> Expr option
Evaluates to a quotation with the same structure as<@ fun x -> x + 1 @>, which is the implementation of the method f.
open FSharp.Quotations
open FSharp.Quotations.Patterns
[<ReflectedDefinition>]
module Methods =
let f x = (x, x)
let methInfoGeneric =
match <@ Methods.f (1, 2) @> with
| Call(_, mi, _) -> mi.GetGenericMethodDefinition()
| _ -> failwith "call expected"
let methInfoAtString = methInfoGeneric.MakeGenericMethod(typeof<string>)
Expr.TryGetReflectedDefinition(methInfoAtString)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
Multiple items
type ReflectedDefinitionAttribute = inherit Attribute new: unit -> ReflectedDefinitionAttribute + 1 overload member IncludeValue: bool
--------------------
new: unit -> ReflectedDefinitionAttribute
new: includeValue: bool -> ReflectedDefinitionAttribute
val f: x: 'a -> 'a * 'a
val x: 'a
val methInfoGeneric: System.Reflection.MethodInfo
module Methods from document
active recognizer Call: Expr -> (Expr option * System.Reflection.MethodInfo * Expr list) option
val mi: System.Reflection.MethodInfo
System.Reflection.MethodInfo.GetGenericMethodDefinition() : System.Reflection.MethodInfo
val failwith: message: string -> 'T
val methInfoAtString: System.Reflection.MethodInfo
System.Reflection.MethodInfo.MakeGenericMethod([<System.ParamArray>] typeArguments: System.Type array) : System.Reflection.MethodInfo
val typeof<'T> : System.Type
Multiple items
val string: value: 'T -> string
--------------------
type string = System.String
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryGetReflectedDefinition: methodBase: System.Reflection.MethodBase -> Expr option
Evaluates to a quotation with the same structure as<@ fun (x: string) -> (x, x) @>, which is the implementation of the generic method f instantiated at type string.
Builds an expression that represents a try/with construct for exception filtering and catching.
Expr
The body of the try expression.
Var
Expr
Var
The variable to bind to a caught exception.
Expr
The expression evaluated when an exception is caught.
Expr
The resulting expression.
open System
open FSharp.Quotations
let exnVar = Var("exn", typeof<exn>)
Expr.TryWith(<@ 1+1 @>, exnVar, <@ 1 @>, exnVar, <@ 2+2 @>)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
val exnVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: Type * ?isMutable: bool -> Var
val typeof<'T> : Type
type exn = Exception
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TryWith: body: Expr * filterVar: Var * filterBody: Expr * catchVar: Var * catchBody: Expr -> Expr
Evaluates to a quotation with the same structure as<@ try 1+1 with exn -> 2+2 @>.
Builds an expression that represents getting a field of a tuple
Expr
The input tuple.
int
The index of the tuple element to get.
Expr
The resulting expression.
open FSharp.Quotations
let tupExpr = <@ (1, 2, 3) @>
Expr.TupleGet(tupExpr, 1)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val tupExpr: Expr<int * int * int>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TupleGet: tuple: Expr * index: int -> Expr
Evaluates to quotation that displays asTupleGet (NewTuple (Value (1), Value (2), Value (3)), 1).
Builds an expression that represents a type test.
Expr
The expression to test.
Type
The target type.
Expr
The resulting expression.
open FSharp.Quotations
let obj = box 1
Expr.TypeTest( <@ obj @>, typeof<int>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
val obj: obj
--------------------
type obj = System.Object
val box: value: 'T -> obj
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.TypeTest: source: Expr * target: System.Type -> Expr
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to quotation that displays asTypeTest (Int32, PropertyGet (None, obj, [])).
Builds an expression that represents a test of a value is of a particular union case
Expr
The expression to test.
UnionCaseInfo
The description of the union case.
Expr
The resulting expression.
open System
open FSharp.Quotations
open FSharp.Reflection
let ucCons = FSharpType.GetUnionCases(typeof<int list>)[1]
Expr.UnionCaseTest(<@ [11] @>, ucCons)
namespace System
namespace Microsoft.FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp.Reflection
val ucCons: UnionCaseInfo
type FSharpType = static member GetExceptionFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetFunctionElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] functionType: Type -> Type * Type static member GetRecordFields: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] recordType: Type * ?bindingFlags: BindingFlags -> PropertyInfo array static member GetTupleElements: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] tupleType: Type -> Type array static member GetUnionCases: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: BindingFlags -> UnionCaseInfo array static member IsExceptionRepresentation: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] exceptionType: Type * ?bindingFlags: BindingFlags -> bool static member IsFunction: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsModule: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool static member IsRecord: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type * ?bindingFlags: BindingFlags -> bool static member IsTuple: [<DynamicallyAccessedMembers (enum<DynamicallyAccessedMemberTypes> (-1))>] typ: Type -> bool ...
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?allowAccessToPrivateRepresentation: bool -> UnionCaseInfo array
static member FSharpType.GetUnionCases: [<Diagnostics.CodeAnalysis.DynamicallyAccessedMembers (enum<Diagnostics.CodeAnalysis.DynamicallyAccessedMemberTypes> (-1))>] unionType: Type * ?bindingFlags: Reflection.BindingFlags -> UnionCaseInfo array
val typeof<'T> : Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
type 'T list = List<'T>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.UnionCaseTest: source: Expr * unionCase: UnionCaseInfo -> Expr
Evaluates to a quotation that displays asUnionCaseTest (NewUnionCase (Cons, Value (11), NewUnionCase (Empty)), Cons).
Builds an expression that represents a constant value
'T
The typed value.
Expr
open FSharp.Quotations
Expr.Value(1)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Value: value: 'T -> Expr
static member Expr.Value: value: obj * expressionType: System.Type -> Expr
<@ 1 @>.
Builds an expression that represents a constant value of a particular type
objnull
The untyped object.
Type
The type of the object.
Expr
The resulting expression.
open FSharp.Quotations
Expr.Value(box 1, typeof<int>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Value: value: 'T -> Expr
static member Expr.Value: value: obj * expressionType: System.Type -> Expr
val box: value: 'T -> obj
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as<@ 1 @>.
Builds an expression that represents a constant value of a particular type, arising from a variable of the given name
objnull
The untyped object.
Type
The type of the object.
string
The name of the variable.
Expr
The resulting expression.
open FSharp.Quotations
Expr.ValueWithName(box 1, typeof<int>, "name")
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.ValueWithName: value: 'T * name: string -> Expr
static member Expr.ValueWithName: value: obj * expressionType: System.Type * name: string -> Expr
val box: value: 'T -> obj
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to a quotation with the same structure as<@ 1 @> and associated information that the name of the value is "name".
Builds an expression that represents a constant value, arising from a variable of the given name
'T
The typed value.
string
The name of the variable.
Expr
The resulting expression.
open FSharp.Quotations
Expr.ValueWithName(1, "name")
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.ValueWithName: value: 'T * name: string -> Expr
static member Expr.ValueWithName: value: obj * expressionType: System.Type * name: string -> Expr
<@ 1 @> and associated information that the name of the value is "name".
Builds an expression that represents a variable
Var
The input variable.
Expr
The resulting expression.
open FSharp.Quotations
let vVar = Var("v", typeof<int>)
Expr.Var(vVar)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.Var: variable: Var -> Expr
Evaluates to a quotation displayed asv.
Builds an expression that represents setting a mutable variable
Var
The input variable.
Expr
The value to set.
Expr
The resulting expression.
open FSharp.Quotations
let vVar = Var("v", typeof<int>, isMutable=true)
Expr.VarSet(vVar, <@ 5 @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val vVar: Var
Multiple items
type Var = interface IComparable new: name: string * typ: Type * ?isMutable: bool -> Var static member Global: name: string * typ: Type -> Var member IsMutable: bool member Name: string member Type: Type
--------------------
new: name: string * typ: System.Type * ?isMutable: bool -> Var
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.VarSet: variable: Var * value: Expr -> Expr
Evaluates to a quotation displayed asVarSet (v, Value (5)).
Builds an expression that represents a while loop
Expr
The predicate to control the loop iteration.
Expr
The body of the while loop.
Expr
The resulting expression.
open FSharp.Quotations
let guardExpr = <@ true @>
let bodyExpr = <@ () @>
Expr.WhileLoop(guardExpr, bodyExpr)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
val guardExpr: Expr<bool>
val bodyExpr: Expr<unit>
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.WhileLoop: guard: Expr * body: Expr -> Expr
Evaluates to a quotation with the same structure as<@ while true do () @>.
Builds an expression that represents a value and its associated reflected definition as a quotation
objnull
The untyped object.
Type
The type of the object.
Expr
The definition of the value being quoted.
Expr
The resulting expression.
open FSharp.Quotations
Expr.WithValue(box 1, typeof<int>, <@ 2 - 1 @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.WithValue: value: 'T * definition: Expr<'T> -> Expr<'T>
static member Expr.WithValue: value: obj * expressionType: System.Type * definition: Expr -> Expr
val box: value: 'T -> obj
val typeof<'T> : System.Type
Multiple items
val int: value: 'T -> int (requires member op_Explicit)
--------------------
type int = int32
--------------------
type int<'Measure> = int
Evaluates to a quotation that displays asWithValue (1, Call (None, op_Subtraction, [Value (2), Value (1)])).
Builds an expression that represents a value and its associated reflected definition as a quotation
'T
The value being quoted.
Expr<'T>
The definition of the value being quoted.
Expr<'T>
The resulting expression.
open FSharp.Quotations
Expr.WithValue(1, <@ 2 - 1 @>)
Multiple items
namespace Microsoft.FSharp
--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
Multiple items
type Expr = override Equals: obj: obj -> bool member GetFreeVars: unit -> Var seq member Substitute: substitution: (Var -> Expr option) -> Expr member ToString: full: bool -> string static member AddressOf: target: Expr -> Expr static member AddressSet: target: Expr * value: Expr -> Expr static member Application: functionExpr: Expr * argument: Expr -> Expr static member Applications: functionExpr: Expr * arguments: Expr list list -> Expr static member Call: methodInfo: MethodInfo * arguments: Expr list -> Expr + 1 overload static member CallWithWitnesses: methodInfo: MethodInfo * methodInfoWithWitnesses: MethodInfo * witnesses: Expr list * arguments: Expr list -> Expr + 1 overload ...
--------------------
type Expr<'T> = inherit Expr member Raw: Expr
static member Expr.WithValue: value: 'T * definition: Expr<'T> -> Expr<'T>
static member Expr.WithValue: value: obj * expressionType: System.Type * definition: Expr -> Expr
WithValue (1, Call (None, op_Subtraction, [Value (2), Value (1)])).
RetroSearch is an open source project built by @garambo | Open a GitHub Issue
Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo
HTML:
3.2
| Encoding:
UTF-8
| Version:
0.7.4