częściowe zastosowanie F # Notowań

Question

Powiedzmy mam ten cytat typu Quotations.Expr<(int -> int -> int)>

<@ fun x y -> x + y @> 

Chcę utworzyć funkcję fun reduce x expr że kiedy nazywa się reduce 1 expr będzie zasadniczo otrzymując

<@ fun y -> 1 + y @> 

tj chcę częściowo zastosuj wycenę, aby wyprodukować inną ofertę.

Jestem pewien, że jest to wykonalne, czy ktoś ma jakieś myśli? Czy próbowano już wcześniej? Nie mogę niczego znaleźć.

Również nie jestem bardzo zaznajomiony z LISP-em, ale czy jest to zasadniczo podobne do tego, co mogę osiągnąć za pomocą makr LISP?

AKTUALIZACJA: Obniżając cytat, chciałbym ocenić części, które można ocenić w wynikowym drzewie wyrażeń.

Na przykład: reduce true <@ fun b x y -> if b then x + y else x - y@> powinien spowodować <@ fun x y -> x + y @>.

Answer 1

Jeśli wiesz, że Twój cytat jest postaci fun x ... to proste:

let subst (v:'a) (Patterns.Lambda(x,b) : Expr<'a->'b>) = 
    b.Substitute(fun x' -> if x = x' then Some (Expr.Value v) else None) 
    |> Expr.Cast<'b> 

subst 1 <@ fun x y -> x + y @> 

Jeśli dodatkowo chcemy uprościć wyrażenia, a następnie istnieje kilka nieco podchwytliwe pytania trzeba odpowiedzieć:

• Czy interesują Cię efekty uboczne? Jeśli zacznę od <@ fun x y -> printfn "%i" x @> i zastępuję w 1 dla x, jaka jest uproszczona wersja <@ fun y -> printfn "%i" 1 @>? To powinno wydrukować 1 za każdym razem, gdy zostanie wywołany, ale jeśli nie wiesz z wyprzedzeniem, które wyrażenia mogą powodować efekty uboczne, prawie nigdy nie uprościsz niczego. Jeśli to zignorujesz (zakładając, że żadna ekspresja nie spowoduje efektów ubocznych), wtedy rzeczy stają się znacznie prostsze kosztem wierności.
• Co naprawdę oznacza uproszczenie? Powiedzmy, że dostaję <@ fun y -> y + 1 @> po zamianie. Czy to jest dobre czy złe, aby uprościć to do odpowiednika let f y = y+1 in <@ f @>? Jest to zdecydowanie "prostsze", ponieważ jest to trywialne wyrażenie zawierające tylko wartość, ale wartość jest teraz funkcją nieprzezroczystą. Co jeśli mam <@ fun y -> 1 + (fun z -> z) y @>? Czy można w prosty sposób uprościć funkcję wewnętrzną do wartości lub zła?

Jeśli możemy ignorować skutków ubocznych i nie zawsze chcą zastąpić funkcję o wartości, a następnie można zdefiniować funkcję uproszczenia tak:

let reduce (e:Expr<'a>) : Expr<'a> = 
    let rec helper : Expr -> Expr = function 
    | e when e.GetFreeVars() |> Seq.isEmpty && not (Reflection.FSharpType.IsFunction e.Type) -> // no free variables, and won't produce a function value 
     Expr.Value(Linq.RuntimeHelpers.LeafExpressionConverter.EvaluateQuotation e, e.Type) 
    | ExprShape.ShapeLambda(v, e) -> Expr.Lambda(v, helper e) // simplify body 
    | ExprShape.ShapeCombination(o, es) -> // simplify each subexpression 
     ExprShape.RebuildShapeCombination(o, es |> List.map helper) 
    | ExprShape.ShapeVar v -> Expr.Var v 

    helper e |> Expr.Cast 

pamiętać, że ta wciąż nie może uprość rzecz tak, jak chcesz; na przykład <@ (fun x (y:int) -> x) 1 @> nie zostanie uproszczony, chociaż będzie to <@ (fun x -> x) 1 @>.

Answer 2

Łączenie jest wygodnym sposobem osadzania cytaty w cudzysłowie:

let reduce x expr = 
    <@ (%expr) x @> 

reduce ma typ 'a -> Expr<('a -> 'b)> -> Expr<'b>

Zastosowanie:

let q = <@ fun x y -> x + y @> 
let r = reduce 1 q // Expr<int -> int> 
let s = reduce 2 <| reduce 3 q // Expr<int> 
let t = reduce "world" <@ sprintf "Hello %s" @> // Expr<string>