生成参数化 F# 引用

Question

假设我们有一个简单的 F# 引用：

type Pet = {  Name : string }
let exprNonGeneric = <@@ System.Func(fun (x : Pet) -> x.Name) @@>

生成的引用如下：

val exprNonGeneri : Expr =
  NewDelegate (System.Func`2[[FSI_0152+Pet, FSI-ASSEMBLY, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]],
             x, PropertyGet (Some (x), System.String Name, []))

现在我想概括它，因此我可以使用在其上定义的任意类型和方法/属性，而不是类型“Pet”和属性“Name”。这就是我想要做的：

let exprGeneric<'T, 'R> f = <@@ System.Func<'T, 'R>( %f ) @@>
let exprSpecialized = exprGeneric<Pet, string> <@ (fun (x : Pet) -> x.Name) @>

结果表达式现在不同了：

val exprSpecialized : Expr =
  NewDelegate (System.Func`2[[FSI_0152+Pet, FSI-ASSEMBLY, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null],[System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]],
             delegateArg,
             Application (Lambda (x,
                                  PropertyGet (Some (x), System.String Name, [])),
                          delegateArg))

如您所见，第一个和第二个表达式之间的区别在于，在第一种情况下，顶级 NewDelegate 表达式包含 PropertyGet，而第二个表达式将 PropertyGet 包装在应用程序/Lambda 表达式。当我将此表达式传递给外部代码时，它不期望这样的表达式结构并失败。

因此，我需要某种方法来构建引用的通用版本，因此当它变得专业化时，生成的引用与 <@@ System.Func(fun (x : Pet) -> x.Name) @@ 完全匹配>。这可能吗？或者只能选择手动将模式匹配应用于生成的报价并将其转换为我需要的内容？

更新。作为解决方法，我实现了以下适配器：

let convertExpr (expr : Expr) =
    match expr with
    | NewDelegate(t, darg, appl) ->
        match (darg, appl) with
        | (delegateArg, appl) ->
            match appl with 
            | Application(l, ldarg) ->
                match (l, ldarg) with
                | (Lambda(x, f), delegateArg) ->
                    Expr.NewDelegate(t, [x], f)
                | _ -> expr
            | _ -> expr
    | _ -> expr

它完成了工作 - 我现在可以将表达式从第一种形式转换为第二种形式。但我有兴趣了解是否可以通过简单的方式实现这一点，而无需遍历表达式树。

Answer 1

我认为这是不可能的；在第二种情况下，您插入表达式 <@ (fun (x : Pet) -> x.Name) @>，它使用 Lambda 表示code> 节点，插入其他表达式的洞中。在此插入过程中，编译器不会简化表达式，因此无论您做什么，Lambda 节点都不会被删除。

但是，您的模式匹配解决方法可以大大简化：

let convertExpr = function
| NewDelegate(t, [darg], Application(Lambda(x,f), Var(arg))) 
    when darg = arg -> Expr.NewDelegate(t, [x], f)
| expr -> expr

事实上，您更复杂的版本是不正确的。这是因为最里面模式中的 delegateArg 与外部模式中之前绑定的 delegateArg 标识符的值不匹配；它是一个新绑定的新标识符，也称为 delegateArg。事实上，外部 delegateArg 标识符的类型为 Var list，而内部标识符的类型为 Expr！然而，考虑到编译器生成的表达式形式的范围有限，您的损坏版本在实践中可能不会有问题。

编辑

关于你的后续问题，如果我理解正确的话，可能无法实现你想要的。与 C# 不同，其中 x =>在 F# 中，x + 1 可以解释为具有 Func 或 Expression> 类型有趣的x-> x + 1 始终为 int->int 类型。如果要获取 Exprint> 类型的值，那么通常需要使用引号运算符 (<@ @>)。

然而，有一种替代方案可能有用。您可以在 let 绑定函数上使用 [] 属性来使其引用也可用。这是一个例子：

open Microsoft.FSharp.Quotations
open Microsoft.FSharp.Quotations.ExprShape
open Microsoft.FSharp.Quotations.Patterns
open Microsoft.FSharp.Quotations.DerivedPatterns

let rec exprMap (|P|_|) = function
| P(e) -> e
| ShapeVar(v) -> Expr.Var v
| ShapeLambda(v,e) -> Expr.Lambda(v, exprMap (|P|_|) e)
| ShapeCombination(o,l) -> RebuildShapeCombination(o, l |> List.map (exprMap (|P|_|)))


let replaceDefn = function
| Call(None,MethodWithReflectedDefinition(e),args) 
    -> Some(Expr.Applications(e, [args]))
| _ -> None


(* plugs all definitions into an expression *)
let plugDefs e = exprMap replaceDefn e

[<ReflectedDefinition>]
let f x = x + 1

(* inlines f into the quotation since it uses the [<ReflectedDefinition>] attribute *)
let example = plugDefs <@ fun y z -> (f y) - (f 2) @>