2 people like it.

F# lambda as C# expression

Expression<Func<'a, 'b>> as expr builder

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18: 
19: 
20: 
21: 
22: 
23: 
24: 
25: 
26: 
27: 
28: 
29: 
30: 
31: 
32: 
33: 
34: 
35: 
36: 
37: 
38: 
39: 
open System
open System.Linq.Expressions

type ExprBuilder() =
    member __.ReturnFrom(f: Expression<Func<'a,'b>>) = f
    member __.Return(x) = __.ReturnFrom(fun _ -> x)
let expr = ExprBuilder()

let (|Value|Null|) (x: Nullable<_>) =
    if x.HasValue then Value x.Value else Null

module Nullable =
    let map f =
        Option.ofNullable >> Option.map f >> Option.toNullable

let getDateRangePredicate startDate endDate =
        let (<!>) = Nullable.map
        let dateOf (x: DateTimeOffset) = DateTimeOffset x.Date
        let dayAfter (x: DateTimeOffset) = x.AddDays(1.)
        let startDate = dateOf <!> startDate
        let endDate = dayAfter << dateOf <!> endDate
        expr {
            match startDate, endDate with
            | Value startDate, Value endDate ->
                return! fun date -> date >= startDate && date < endDate
            | Value startDate, Null ->
                return! fun date -> date >= startDate
            | Null, Value endDate ->
                return! fun date -> date < endDate
            | Null, Null -> 
                return true
        }

let date1 = Nullable ()
let date2 = Nullable DateTimeOffset.Now
getDateRangePredicate date1 date1
getDateRangePredicate date1 date2
getDateRangePredicate date2 date1
getDateRangePredicate date2 date2
namespace System
namespace System.Linq
namespace System.Linq.Expressions
Multiple items
type ExprBuilder =
  new : unit -> ExprBuilder
  member Return : x:'a -> Expression<Func<'b,'a>>
  member ReturnFrom : f:Expression<Func<'a,'b>> -> Expression<Func<'a,'b>>

Full name: Script.ExprBuilder

--------------------
new : unit -> ExprBuilder
member ExprBuilder.ReturnFrom : f:Expression<Func<'a,'b>> -> Expression<Func<'a,'b>>

Full name: Script.ExprBuilder.ReturnFrom
val f : Expression<Func<'a,'b>>
Multiple items
type Expression =
  member CanReduce : bool
  member NodeType : ExpressionType
  member Reduce : unit -> Expression
  member ReduceAndCheck : unit -> Expression
  member ReduceExtensions : unit -> Expression
  member ToString : unit -> string
  member Type : Type
  static member Add : left:Expression * right:Expression -> BinaryExpression + 1 overload
  static member AddAssign : left:Expression * right:Expression -> BinaryExpression + 2 overloads
  static member AddAssignChecked : left:Expression * right:Expression -> BinaryExpression + 2 overloads
  ...

Full name: System.Linq.Expressions.Expression

--------------------
type Expression<'TDelegate> =
  inherit LambdaExpression
  member Compile : unit -> 'TDelegate + 1 overload
  member Update : body:Expression * parameters:IEnumerable<ParameterExpression> -> Expression<'TDelegate>

Full name: System.Linq.Expressions.Expression<_>
Multiple items
type Func<'TResult> =
  delegate of unit -> 'TResult

Full name: System.Func<_>

--------------------
type Func<'T,'TResult> =
  delegate of 'T -> 'TResult

Full name: System.Func<_,_>

--------------------
type Func<'T1,'T2,'TResult> =
  delegate of 'T1 * 'T2 -> 'TResult

Full name: System.Func<_,_,_>

--------------------
type Func<'T1,'T2,'T3,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 -> 'TResult

Full name: System.Func<_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 -> 'TResult

Full name: System.Func<_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 -> 'TResult

Full name: System.Func<_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>

--------------------
type Func<'T1,'T2,'T3,'T4,'T5,'T6,'T7,'T8,'T9,'T10,'T11,'T12,'T13,'T14,'T15,'T16,'TResult> =
  delegate of 'T1 * 'T2 * 'T3 * 'T4 * 'T5 * 'T6 * 'T7 * 'T8 * 'T9 * 'T10 * 'T11 * 'T12 * 'T13 * 'T14 * 'T15 * 'T16 -> 'TResult

Full name: System.Func<_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_>
val __ : ExprBuilder
member ExprBuilder.Return : x:'a -> Expression<Func<'b,'a>>

Full name: Script.ExprBuilder.Return
val x : 'a
member ExprBuilder.ReturnFrom : f:Expression<Func<'a,'b>> -> Expression<Func<'a,'b>>
val expr : ExprBuilder

Full name: Script.expr
val x : Nullable<'a> (requires default constructor and value type and 'a :> ValueType)
Multiple items
type Nullable =
  static member Compare<'T> : n1:Nullable<'T> * n2:Nullable<'T> -> int
  static member Equals<'T> : n1:Nullable<'T> * n2:Nullable<'T> -> bool
  static member GetUnderlyingType : nullableType:Type -> Type

Full name: System.Nullable

--------------------
type Nullable<'T (requires default constructor and value type and 'T :> ValueType)> =
  struct
    new : value:'T -> Nullable<'T>
    member Equals : other:obj -> bool
    member GetHashCode : unit -> int
    member GetValueOrDefault : unit -> 'T + 1 overload
    member HasValue : bool
    member ToString : unit -> string
    member Value : 'T
  end

Full name: System.Nullable<_>

--------------------
Nullable()
Nullable(value: 'T) : unit
property Nullable.HasValue: bool
property Nullable.Value: 'a
val map : f:('a -> 'b) -> (Nullable<'a> -> Nullable<'b>) (requires default constructor and value type and 'a :> ValueType and default constructor and value type and 'b :> ValueType)

Full name: Script.Nullable.map
val f : ('a -> 'b) (requires default constructor and value type and 'a :> ValueType and default constructor and value type and 'b :> ValueType)
module Option

from Microsoft.FSharp.Core
val ofNullable : value:Nullable<'T> -> 'T option (requires default constructor and value type and 'T :> ValueType)

Full name: Microsoft.FSharp.Core.Option.ofNullable
val map : mapping:('T -> 'U) -> option:'T option -> 'U option

Full name: Microsoft.FSharp.Core.Option.map
val toNullable : option:'T option -> Nullable<'T> (requires default constructor and value type and 'T :> ValueType)

Full name: Microsoft.FSharp.Core.Option.toNullable
val getDateRangePredicate : startDate:Nullable<DateTimeOffset> -> endDate:Nullable<DateTimeOffset> -> Expression<Func<DateTimeOffset,bool>>

Full name: Script.getDateRangePredicate
val startDate : Nullable<DateTimeOffset>
val endDate : Nullable<DateTimeOffset>
val dateOf : (DateTimeOffset -> DateTimeOffset)
val x : DateTimeOffset
Multiple items
type DateTimeOffset =
  struct
    new : dateTime:DateTime -> DateTimeOffset + 5 overloads
    member Add : timeSpan:TimeSpan -> DateTimeOffset
    member AddDays : days:float -> DateTimeOffset
    member AddHours : hours:float -> DateTimeOffset
    member AddMilliseconds : milliseconds:float -> DateTimeOffset
    member AddMinutes : minutes:float -> DateTimeOffset
    member AddMonths : months:int -> DateTimeOffset
    member AddSeconds : seconds:float -> DateTimeOffset
    member AddTicks : ticks:int64 -> DateTimeOffset
    member AddYears : years:int -> DateTimeOffset
    ...
  end

Full name: System.DateTimeOffset

--------------------
DateTimeOffset()
DateTimeOffset(dateTime: DateTime) : unit
DateTimeOffset(ticks: int64, offset: TimeSpan) : unit
DateTimeOffset(dateTime: DateTime, offset: TimeSpan) : unit
DateTimeOffset(year: int, month: int, day: int, hour: int, minute: int, second: int, offset: TimeSpan) : unit
DateTimeOffset(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, offset: TimeSpan) : unit
DateTimeOffset(year: int, month: int, day: int, hour: int, minute: int, second: int, millisecond: int, calendar: Globalization.Calendar, offset: TimeSpan) : unit
property DateTimeOffset.Date: DateTime
val dayAfter : (DateTimeOffset -> DateTimeOffset)
DateTimeOffset.AddDays(days: float) : DateTimeOffset
active recognizer Value: Nullable<'a> -> Choice<'a,unit>

Full name: Script.( |Value|Null| )
val startDate : DateTimeOffset
val endDate : DateTimeOffset
val date : DateTimeOffset
active recognizer Null: Nullable<'a> -> Choice<'a,unit>

Full name: Script.( |Value|Null| )
val date1 : Nullable<'a> (requires default constructor and value type and 'a :> ValueType)

Full name: Script.date1
val date2 : Nullable<DateTimeOffset>

Full name: Script.date2
property DateTimeOffset.Now: DateTimeOffset

More information

Link:http://fssnip.net/7Wx
Posted:5 years ago
Author:habib sadullaev
Tags: computation expression , expression , linq , quotation