Question

我遇到类型推断和currying的问题。

我有一个这样的辅助方法：

requestToGroup :
    group:'T array ->
      operation:('T -> System.Threading.Tasks.Task<'B>) ->
        predicate:('B -> bool) -> timeout:int -> Async<int>

基本上，这种方法允许我并行地在几个服务中启动相同的操作，当它们全部完成或超时到期时，返回有多少成功使用谓词对它们进行评估。

考虑这些简单的定义：

  type RequestA(name:string) =
    member val Name=name with get,set

  type ResultA(has:bool)=
    member x.Has()=has

  type RequestB(id:int) =
    member val Id=id with get,set

  type ResultB(fits:bool)=
    member x.Fits()=fits

  type IService =
    abstract member Has: RequestA -> Task<ResultA>
    abstract member Fits: RequestB -> Task<ResultB>

我可以像这样使用这个助手：

  type MyClass<'T>(services:IService array) =

    member x.AllHas(value:string) =
      let positive = Async.RunSynchronously <| requestToGroup services (fun(s)->s.Has(RequestA(value))) (fun(r)->r.Has()) 1000
      positive=services.Length
    member x.AllFits(value:int, services:IService array) =
      let positive = Async.RunSynchronously <| requestToGroup services (fun(s)->s.Fits(RequestB(value))) (fun(r)->r.Fits()) 1000
      positive=services.Length

这一切都很好。然后，我决定通过执行以下操作来讨论requestToGroup函数：

  type MyClass<'T>(services:IService array) =

    let groupOp = requestToGroup services

    member x.AllHas(value:string) =
      let positive = Async.RunSynchronously <| groupOp (fun(s)->s.Has(RequestA(value))) (fun(r)->r.Has()) 1000
      positive=services.Length
    member x.AllFits(value:int, services:IService array) =
      let positive = Async.RunSynchronously <| groupOp (fun(s)->s.Fits(RequestB(value))) (fun(r)->r.Fits()) 1000
      positive=services.Length

但是现在，groupOp推断出具体类型而不是泛型，并且编译在s.Fits(RequestB(value))处失败，表示期待Task<RequestA>，但我提供Task<RequestB>。

如何阻止编译器推断具体类型？

奖励：如何使用MyClass方法使代码更好，更清晰？

Answer 1

自动泛化不适用于以应用于函数绑定的方式进行的值绑定。这意味着如果绑定不是语法一个函数，它可能会导致问题，即没有参数。试试这个：

let groupOp a = requestToGroup services a

（在静态分辨率的情况下，可能还需要inline，但这在这里似乎并不重要。）

编辑：代码建议（可能完全没有标记）

在重构时，我会发布一些疯狂的想法，并留给你，看它们是否有用。如果它不适用，请不要介意。将会有一个小的提案和一个有很大变化的提案。

作为轻量级重构，我建议使请求和结果类型不可变。它们可以这样定义：

type RequestA = RequestA of name : string
type ResultA = ResultA of has : bool

type RequestB = RequestB of ident : int
type ResultB = ResultB of fits : bool

这是使用F＃3.1中引入的命名DU字段。旧版本必须省略名称。使用这些，我可以在checkAll中编写一般的MyClass函数。如果你想坚持旧的类型，那就不会改变函数的形状。

type MyClass<'T>(services:IService array) =
    let checkAll operation predicate =
        let op = requestToGroup services operation predicate 1000
        Async.RunSynchronously op = Array.length services

    member x.AllHas value =
        checkAll (fun s -> s.Has(RequestA(value))) (fun (ResultA a) -> a)
    member x.AllFits value =
        checkAll (fun s -> s.Fits(RequestB(value))) (fun (ResultB b) -> b)

（我假设问题中方法services的参数AllFits是重构工件;它会隐藏同名的私有值。）

更重的重构我不知道这是否过分，但可以更改签名并完全删除请求/响应类型。

requestToGroup正在做两件不一定相关的事情：并行执行任务，同时注意超时并使用谓词计算结果。如何使第一部分成为一个单独的功能：

let tryRunAll (group : 'T array) (getJob : 'T -> Async<'B>) (timeout : int) =
    // ... result typed Async<'B option []>

它将返回结果数组，其中None表示超时。如果您想直接处理结果，此功能本身可能很有用。

无论如何都要彻底改变一切，IService可以与asyncs一起使用。可以使用Async.StartAsTask将其转换为任务。

type IService =
    abstract member HasName: string -> Async<bool>
    abstract member FitsId: int -> Async<bool>

然后，MyClass的实现将如下所示：

type MyClass<'T> (services : IService array) =
    let checkAll getter =
        Async.RunSynchronously (tryRunAll services getter 1000)
        |> Array.forall ((=) (Some true))

    member x.AllHas value = checkAll (fun s -> s.HasName value)
    member x.AllFits value = checkAll (fun s -> s.FitsId value)

如果您仍然需要requestToGroup，可以按照以下方式实施：

let requestToGroup group operation predicate timeout = async {
    let! res = tryRunAll group operation timeout
    return res |> Array.choose id |> Array.filter predicate |> Array.length }

这就是我想象中的编码尝试。 不保证任何此类内容都是合理的，可行的或适用的。但希望它有助于获得想法。

F＃编译器在currying时首次使用泛型函数来推断具体类型

1 个答案:

编辑：代码建议（可能完全没有标记）