생성 매개 변수 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, [])) 

지금 나는 그것을 일반화 할를, 그래서 대신 유형의 I "애완 동물 "속성 및"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)) 

, 제 1 및 제 2 표현의 차이는 첫 번째 경우에 최상위 NewDelegate 표현식은 PropertyGet을 포함하고, 두 번째 표현식은 PropertyGet을 Application/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 

이제는 표현식을 1에서 2로 변환 할 수 있습니다. 그러나 표현 트리를 가로 지르지 않고 간단한 방법으로 달성 할 수 있는지 알아 보는 데 관심이 있습니다.

Answer 1

이렇게 할 수 없을 것이라고 생각합니다. 두 번째 경우에는 Lambda 노드를 사용하여 표현 된 표현식 <@ (fun (x : Pet) -> x.Name) @>을 다른 표현식의 구멍에 연결합니다. 컴파일러는이 연결 프로세스 중에 표현식을 단순화하지 않으므로 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입니다! 그러나, 컴파일러에 의해 생성 된 표현 양식의 제한된 범위를 감안할 때 깨진 버전은 실제로 문제가되지 않을 수도 있습니다. 당신의 후속 질문에 대해서는

편집

, 내가 제대로 이해한다면 당신이 원하는 것을 달성하지 못할 수 있습니다. x => x + 1이 Func<int,int> 또는 Expression<Func<int,int>> 유형으로 해석 될 수있는 C#과 달리 F # fun x -> x + 1은 항상 int->int입니다.Expr<int->int> 유형의 값을 가져 오려면 일반적으로 (<@ @>)이라는 인용 연산자를 사용해야합니다.

그러나 사용할 수있는 대안이 하나 있습니다. 레터 바운드 기능에 [<ReflectedDefinition>] 속성을 사용하여 따옴표를 사용할 수도 있습니다. 다음은 그 예입니다.

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) @>