open System.Linq.Expressions

open System

open System.Collections.Generic

​

let be = Expression.Power(Expression.Constant(2.0), Expression.Constant(3.0))

let le = Expression.Lambda(be)

​

let lecomp = le.Compile() :?> Func<double>

//printf "%A" lecomp

​

let res= lecomp.Invoke()

​

​

printfn "%f" res

​

type BExpr = Bool of bool

                | EVar of string

              //  | SVar of string * BExpr

                | And of BExpr * BExpr

                | Or of BExpr * BExpr

                | Not of BExpr

​

​

let bexp = And (Bool true, Or(Bool false, Bool false))

let bexp2 = And (EVar "b", Or(EVar "a", EVar "c"))// (a,b,c) => b && (a || c)) => (a)=> (b) => (c)=> 

let rec beval = function 

            | Bool b -> b

            | EVar (name) -> beval(Bool true) //always extract true for evey var, cause context is currently missing

           // | SVar (name, value) -> beval(Bool true) //always set true for evey var, cause context is currently missing

            | And (a,b) -> beval a && beval b

            | Or (a,b) -> beval a || beval b

            | Not a -> not (beval a)

​

printfn "%A" (beval bexp)

​

let rec bevaltranspileJS = function 

            | Bool b -> sprintf "%b" b

            | EVar (name) -> sprintf "%s" name 

          //  | SVar (name, value) -> sprintf "var %s=%s" name (bevaltranspile value) //always set true for evey var, cause context is currently missing

            | And (a,b) -> sprintf "(%s && %s)" (bevaltranspileJS a) (bevaltranspileJS b)

            | Or (a,b) -> sprintf "(%s || %s)" (bevaltranspileJS a) (bevaltranspileJS b)

            | Not a -> sprintf "!%s" (bevaltranspileJS a)

printfn "%A" (bevaltranspileJS bexp)

printfn "%A" (bevaltranspileJS bexp2)

​

let bevalToExpT exp =

    let dict = new Dictionary<string,ParameterExpression>()

    let rec bevalToExpression:BExpr -> Expression = function 

                | Bool b -> Expression.Constant(b) :> Expression

                | EVar (name) -> let param = Expression.Parameter(typedefof<bool>,name)

                                 if dict.ContainsKey(name) then

                                     dict.Item(name) :> Expression 

                                 else

                                     dict.Add(name, param)

                                     param :> Expression 

               //| SVar (name, value) -> Expression. //sprintf "var %s=%s" name (bevaltranspile value) //always set true for evey var, cause context is currently missing

                | And (a,b) -> Expression.And(bevalToExpression(a), bevalToExpression(b)) :> Expression //sprintf "(%s && %s)" (bevaltranspile a) (bevaltranspile b)

                | Or (a,b) -> Expression.Or(bevalToExpression(a), bevalToExpression(b)) :> Expression //sprintf "(%s || %s)" (bevaltranspile a) (bevaltranspile b)

                | Not a -> Expression.Not(bevalToExpression(a)) :> Expression //sprintf "!%s" (bevaltranspile a)

    Expression.Lambda(bevalToExpression exp, new List<ParameterExpression>(dict.Values)).Compile() 

let resExp = bevalToExpT bexp2

printfn "type: %A" resExp

printfn "evaluation result:%b" ((resExp :?> Func<bool,bool,bool,bool>).Invoke(true, false, true)) 

​

​

​

​

​

​