Header menu logo FSharp.Core

DerivedPatterns Module

Namespace: FSharp.Quotations
Assembly: FSharp.Core.dll

Contains a set of derived F# active patterns to analyze F# expression objects

Active patterns

Active patternDescription

(|AndAlso|_|) input

Full Usage: (|AndAlso|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: (Expr * Expr) option When successful, the pattern binds the left and right parts of the input expression

An active pattern to recognize expressions of the form a && b

input : Expr

The input expression to match against.

Returns: (Expr * Expr) option

When successful, the pattern binds the left and right parts of the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ true && false @> with
 | AndAlso (a, b) -> (a, b)
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer AndAlso: Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
val a: Quotations.Expr
val b: Quotations.Expr
val failwith: message: string -> 'T
Evaluates to <@ true @>, <@ false @>.

(|Applications|_|) input

Full Usage: (|Applications|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: (Expr * Expr list list) option When successful, the pattern binds the function and curried arguments of the input expression

An active pattern to recognize expressions that represent the application of a (possibly curried or tupled) first class function value

input : Expr

The input expression to match against.

Returns: (Expr * Expr list list) option

When successful, the pattern binds the function and curried arguments of the input expression

Example

 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

 match <@ (fun f -> f (1, 2) 3) @> with
 | Lambda(_, Applications (f, curriedArgs)) ->
     curriedArgs |> List.map (fun args -> args.Length)
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module DerivedPatterns from Microsoft.FSharp.Quotations
val f: (int * int -> int -> obj)
active recognizer Lambda: Quotations.Expr -> (Quotations.Var * Quotations.Expr) option
active recognizer Applications: Quotations.Expr -> (Quotations.Expr * Quotations.Expr list list) option
val f: Quotations.Expr
val curriedArgs: Quotations.Expr list list
Multiple items
module List from Microsoft.FSharp.Collections

--------------------
type List<'T> = | op_Nil | op_ColonColon of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex: rank: int * offset: int -> int member GetSlice: startIndex: int option * endIndex: int option -> 'T list static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...
val map: mapping: ('T -> 'U) -> list: 'T list -> 'U list
val args: Quotations.Expr list
property List.Length: int with get
val failwith: message: string -> 'T
Evaluates to [2; 1].

(|Bool|_|) input

Full Usage: (|Bool|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: bool option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant boolean expressions

input : Expr

The input expression to match against.

Returns: bool option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ true @> with
 | Bool v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Bool: Quotations.Expr -> bool option
val v: bool
val failwith: message: string -> 'T
Evaluates to true.

(|Byte|_|) input

Full Usage: (|Byte|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: byte option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant byte expressions

input : Expr

The input expression to match against.

Returns: byte option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8uy @> with
 | Byte v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Byte: Quotations.Expr -> byte option
val v: byte
val failwith: message: string -> 'T
Evaluates to 8uy.

(|Char|_|) input

Full Usage: (|Char|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: char option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant unicode character expressions

input : Expr

The input expression to match against.

Returns: char option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 'a' @> with
 | Char v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Char: Quotations.Expr -> char option
val v: char
val failwith: message: string -> 'T
Evaluates to 'a'.

(|Decimal|_|) input

Full Usage: (|Decimal|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: decimal option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant decimal expressions

input : Expr

The input expression to match against.

Returns: decimal option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8.0M @> with
 | Decimal v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Decimal: Quotations.Expr -> decimal option
val v: decimal
val failwith: message: string -> 'T
Evaluates to 8.0M.

(|Double|_|) input

Full Usage: (|Double|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: float option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant 64-bit floating point number expressions

input : Expr

The input expression to match against.

Returns: float option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 1.0 @> with
 | Double v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Double: Quotations.Expr -> float option
val v: float
val failwith: message: string -> 'T
Evaluates to 1.0.

(|Int16|_|) input

Full Usage: (|Int16|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: int16 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant int16 expressions

input : Expr

The input expression to match against.

Returns: int16 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8s @> with
 | Int16 v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Int16: Quotations.Expr -> int16 option
val v: int16
val failwith: message: string -> 'T
Evaluates to 8s.

(|Int32|_|) input

Full Usage: (|Int32|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: int32 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant int32 expressions

input : Expr

The input expression to match against.

Returns: int32 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8 @> with
 | Int32 v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Int32: Quotations.Expr -> int32 option
val v: int32
val failwith: message: string -> 'T
Evaluates to 8.

(|Int64|_|) input

Full Usage: (|Int64|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: int64 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant int64 expressions

input : Expr

The input expression to match against.

Returns: int64 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8L @> with
 | Int64 v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Int64: Quotations.Expr -> int64 option
val v: int64
val failwith: message: string -> 'T
Evaluates to 8L.

(|Lambdas|_|) input

Full Usage: (|Lambdas|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: (Var list list * Expr) option When successful, the pattern binds the curried variables and body of the input expression

An active pattern to recognize expressions that represent a (possibly curried or tupled) first class function value

input : Expr

The input expression to match against.

Returns: (Var list list * Expr) option

When successful, the pattern binds the curried variables and body of the input expression

Example

 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

 match <@ (fun (a1, a2) b -> ()) @> with
 | Lambdas(curriedVars, _) ->
     curriedVars |> List.map (List.map (fun arg -> arg.Name))
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module Patterns from Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module DerivedPatterns from Microsoft.FSharp.Quotations
val a1: obj
val a2: obj
val b: obj
active recognizer Lambdas: Quotations.Expr -> (Quotations.Var list list * Quotations.Expr) option
val curriedVars: Quotations.Var list list
Multiple items
module List from Microsoft.FSharp.Collections

--------------------
type List<'T> = | op_Nil | op_ColonColon of Head: 'T * Tail: 'T list interface IReadOnlyList<'T> interface IReadOnlyCollection<'T> interface IEnumerable interface IEnumerable<'T> member GetReverseIndex: rank: int * offset: int -> int member GetSlice: startIndex: int option * endIndex: int option -> 'T list static member Cons: head: 'T * tail: 'T list -> 'T list member Head: 'T member IsEmpty: bool member Item: index: int -> 'T with get ...
val map: mapping: ('T -> 'U) -> list: 'T list -> 'U list
val arg: Quotations.Var
property Quotations.Var.Name: string with get
val failwith: message: string -> 'T
Evaluates to [["a1"; "a2"]; ["b"]].

(|MethodWithReflectedDefinition|_|) methodBase

Full Usage: (|MethodWithReflectedDefinition|_|) methodBase

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

Returns: Expr option The expression of the method definition if found, or None.

An active pattern to recognize methods that have an associated ReflectedDefinition

methodBase : MethodBase

The description of the method.

Returns: Expr option

The expression of the method definition if found, or None.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

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

 let inpExpr = <@ f 4 @>

 let implExpr =
     match inpExpr with
     | Call(None, MethodWithReflectedDefinition implExpr, [ _argExpr ]) -> implExpr
     | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
module DerivedPatterns 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 inpExpr: Expr<int * int>
val implExpr: Expr
active recognizer Call: Expr -> (Expr option * System.Reflection.MethodInfo * Expr list) option
union case Option.None: Option<'T>
active recognizer MethodWithReflectedDefinition: System.Reflection.MethodBase -> Expr option
val _argExpr: Expr
val failwith: message: string -> 'T
Evaluates implExpr to a quotation with the same structure as <@ fun (x: int) -> (x, x) @>, which is the implementation of the method f. Note that the correct generic instantiation has been applied to the implementation to reflect the type at the callsite.

(|OrElse|_|) input

Full Usage: (|OrElse|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: (Expr * Expr) option When successful, the pattern binds the left and right parts of the input expression

An active pattern to recognize expressions of the form a || b

input : Expr

The input expression to match against.

Returns: (Expr * Expr) option

When successful, the pattern binds the left and right parts of the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ true || false @> with
 | OrElse (a, b) -> (a, b)
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer OrElse: Quotations.Expr -> (Quotations.Expr * Quotations.Expr) option
val a: Quotations.Expr
val b: Quotations.Expr
val failwith: message: string -> 'T
Evaluates to <@ true @>, <@ false @>.

(|PropertyGetterWithReflectedDefinition|_|) propertyInfo

Full Usage: (|PropertyGetterWithReflectedDefinition|_|) propertyInfo

Parameters:
    propertyInfo : PropertyInfo - The description of the property.

Returns: Expr option The expression of the method definition if found, or None.

An active pattern to recognize property getters or values in modules that have an associated ReflectedDefinition

propertyInfo : PropertyInfo

The description of the property.

Returns: Expr option

The expression of the method definition if found, or None.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

 [<ReflectedDefinition>]
 type C<'T>() =
    member x.Identity = x

 let inpExpr = <@ C<int>().Identity @>

 let implExpr =
     match inpExpr with
     | PropertyGet(Some _, PropertyGetterWithReflectedDefinition implExpr, [ ]) -> implExpr
     | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
module DerivedPatterns 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
type C<'T> = new: unit -> C<'T> member Identity: C<'T>
'T
val x: C<'T>
val inpExpr: Expr<C<int>>
new: unit -> C<'T>
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

--------------------
type int<'Measure> = int
val implExpr: Expr
active recognizer PropertyGet: Expr -> (Expr option * System.Reflection.PropertyInfo * Expr list) option
union case Option.Some: Value: 'T -> Option<'T>
active recognizer PropertyGetterWithReflectedDefinition: System.Reflection.PropertyInfo -> Expr option
val failwith: message: string -> 'T
Evaluates implExpr to a quotation with the same structure as <@ fun (x: C<int>) () -> x @>, which is the implementation of the property Identity. Note that the correct generic instantiation has been applied to the implementation to reflect the type at the callsite.

(|PropertySetterWithReflectedDefinition|_|) propertyInfo

Full Usage: (|PropertySetterWithReflectedDefinition|_|) propertyInfo

Parameters:
    propertyInfo : PropertyInfo - The description of the property.

Returns: Expr option The expression of the method definition if found, or None.

An active pattern to recognize property setters that have an associated ReflectedDefinition

propertyInfo : PropertyInfo

The description of the property.

Returns: Expr option

The expression of the method definition if found, or None.

Example

 open FSharp.Quotations
 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

 [<ReflectedDefinition>]
 type C<'T>() =
    member x.Count with set (v: int) = ()

 let inpExpr = <@ C<int>().Count <- 3 @>

 let implExpr =
     match inpExpr with
     | PropertySet(Some _, PropertySetterWithReflectedDefinition implExpr, [], _valueExpr) -> implExpr
     | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
module DerivedPatterns 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
type C<'T> = new: unit -> C<'T> member Count: int with set
'T
val x: C<'T>
val set: elements: 'T seq -> Set<'T> (requires comparison)
val v: int
Multiple items
val int: value: 'T -> int (requires member op_Explicit)

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

--------------------
type int<'Measure> = int
val inpExpr: Expr<unit>
new: unit -> C<'T>
val implExpr: Expr
active recognizer PropertySet: Expr -> (Expr option * System.Reflection.PropertyInfo * Expr list * Expr) option
union case Option.Some: Value: 'T -> Option<'T>
active recognizer PropertySetterWithReflectedDefinition: System.Reflection.PropertyInfo -> Expr option
val _valueExpr: Expr
val failwith: message: string -> 'T
Evaluates implExpr to a quotation with the same structure as <@ fun (x: C<int>) (v: int) -> () @>, which is the implementation of the setter for the property Count. Note that the correct generic instantiation has been applied to the implementation to reflect the type at the callsite.

(|SByte|_|) input

Full Usage: (|SByte|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: sbyte option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant signed byte expressions

input : Expr

The input expression to match against.

Returns: sbyte option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8y @> with
 | SByte v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer SByte: Quotations.Expr -> sbyte option
val v: sbyte
val failwith: message: string -> 'T
Evaluates to 8y.

(|Single|_|) input

Full Usage: (|Single|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: float32 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant 32-bit floating point number expressions

input : Expr

The input expression to match against.

Returns: float32 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 1.0f @> with
 | Single v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Single: Quotations.Expr -> float32 option
val v: float32
val failwith: message: string -> 'T
Evaluates to 1.0f.

(|SpecificCall|_|) templateParameter

Full Usage: (|SpecificCall|_|) templateParameter

Parameters:
    templateParameter : Expr - The input template expression to specify the method to call.

Returns: Expr -> (Expr option * Type list * Expr list) option The optional target object (present if the target is an instance method), the generic type instantiation (non-empty if the target is a generic instantiation), and the arguments to the function or method.

A parameterized active pattern to recognize calls to a specified function or method. The returned elements are the optional target object (present if the target is an instance method), the generic type instantiation (non-empty if the target is a generic instantiation), and the arguments to the function or method.

templateParameter : Expr

The input template expression to specify the method to call.

Returns: Expr -> (Expr option * Type list * Expr list) option

The optional target object (present if the target is an instance method), the generic type instantiation (non-empty if the target is a generic instantiation), and the arguments to the function or method.

Example

Match a specific call to Console.WriteLine taking one string argument:

 open FSharp.Quotations
 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

 let inpExpr = <@ Console.WriteLine("hello") @>

 match inpExpr with
 | SpecificCall <@ Console.WriteLine("1") @> (None, [], [ argExpr ]) -> argExpr
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
val inpExpr: Expr<obj>
active recognizer SpecificCall: Expr -> Expr -> (Expr option * System.Type list * Expr list) option
union case Option.None: Option<'T>
val argExpr: Expr
val failwith: message: string -> 'T
Evaluates to a quotation with the same structure as <@ "hello" @>.

Example

Calls to this active pattern can be partially applied to pre-evaluate some aspects of the matching. For example:

 open FSharp.Quotations
 open FSharp.Quotations.Patterns
 open FSharp.Quotations.DerivedPatterns

 let (|ConsoleWriteLineOneArg|_|) = (|SpecificCall|_|) <@ Console.WriteLine("1") @>

 let inpExpr = <@ Console.WriteLine("hello") @>

 match inpExpr with
 | ConsoleWriteLineOneArg (None, [], [ argExpr ]) -> argExpr
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
namespace Microsoft.FSharp
module Patterns from Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer SpecificCall: Expr -> Expr -> (Expr option * System.Type list * Expr list) option
val inpExpr: Expr<obj>
active recognizer ConsoleWriteLineOneArg: Expr<obj> -> (Expr option * System.Type list * Expr list) option
union case Option.None: Option<'T>
val argExpr: Expr
val failwith: message: string -> 'T
Evaluates to a quotation with the same structure as <@ "hello" @>.

(|String|_|) input

Full Usage: (|String|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: string option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant string expressions

input : Expr

The input expression to match against.

Returns: string option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ "a" @> with
 | String v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
Multiple items
active recognizer String: Quotations.Expr -> string option

--------------------
module String from Microsoft.FSharp.Core
val v: string
val failwith: message: string -> 'T
Evaluates to "a".

(|UInt16|_|) input

Full Usage: (|UInt16|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: uint16 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant unsigned int16 expressions

input : Expr

The input expression to match against.

Returns: uint16 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8us @> with
 | UInt16 v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer UInt16: Quotations.Expr -> uint16 option
val v: uint16
val failwith: message: string -> 'T
Evaluates to 8us.

(|UInt32|_|) input

Full Usage: (|UInt32|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: uint32 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant unsigned int32 expressions

input : Expr

The input expression to match against.

Returns: uint32 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8u @> with
 | UInt32 v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer UInt32: Quotations.Expr -> uint32 option
val v: uint32
val failwith: message: string -> 'T
Evaluates to 8u.

(|UInt64|_|) input

Full Usage: (|UInt64|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: uint64 option When successful, the pattern binds the constant value from the input expression

An active pattern to recognize constant unsigned int64 expressions

input : Expr

The input expression to match against.

Returns: uint64 option

When successful, the pattern binds the constant value from the input expression

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ 8UL @> with
 | UInt64 v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer UInt64: Quotations.Expr -> uint64 option
val v: uint64
val failwith: message: string -> 'T
Evaluates to 8UL.

(|Unit|_|) input

Full Usage: (|Unit|_|) input

Parameters:
    input : Expr - The input expression to match against.

Returns: unit option When successful, the pattern does not bind any results

An active pattern to recognize () constant expressions

input : Expr

The input expression to match against.

Returns: unit option

When successful, the pattern does not bind any results

Example

 open FSharp.Quotations.DerivedPatterns

 match <@ () @> with
 | Unit v -> v
 | _ -> failwith "unexpected"
Multiple items
namespace Microsoft.FSharp

--------------------
namespace FSharp
namespace Microsoft.FSharp.Quotations
module DerivedPatterns from Microsoft.FSharp.Quotations
active recognizer Unit: Quotations.Expr -> unit option
val v: unit
val failwith: message: string -> 'T
Evaluates to true.

Type something to start searching.