strongly type expression splices

typedQuotation.fsx

open FSharp.Quotations
open FSharp.Linq.RuntimeHelpers
open System.Linq
open System

type AST =
    | StartsWith of string
    | Contains of string
    | EndsWith of string

    | And of AST * AST
    | Or of AST * AST

let (<||>) l r = Or(l, r)
let (<&&>) l r = And(l, r)

let convert ast =
    let param = Var("x", typeof<string>)
    let var = Expr.Var param |> Expr.Cast<string>

    let rec visit expr =
        match expr with
        | StartsWith x ->
            <@ (%var).StartsWith x @>

        | Contains x ->
            <@ (%var).Contains x @>

        | EndsWith x ->
            <@ (%var).EndsWith x @>

        | And (a, b) ->
            let left = visit a
            let right = visit b
            <@ %left && %right @>

        | Or (a, b) ->
            let left = visit a
            let right = visit b
            <@ %left || %right @>

    Expr.Lambda(param, visit ast)
    |> Expr.Cast<string -> bool>


let toLambdaExpression ast =
    match convert ast with
    | ExprShape.ShapeLambda(var, body) ->
        Expr.NewDelegate(typeof<Func<string, bool>>, [var], body)
        |> Expr.Cast<Func<string, bool>>
        |> LeafExpressionConverter.QuotationToLambdaExpression

    | _ -> failwithf "must be lambda"

let predicate =
    Contains "abc" <||> (StartsWith "a" <&&> EndsWith "B")
    |> toLambdaExpression

[ "aaaaBBBB"; "xxxabcxxx"; "xxx" ]
    .AsQueryable()
    .Where(predicate)
    .ToList()