generics - F# 编译器在 currying 时从首次使用泛型函数推断具体类型

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

一切都很好。然后我决定 curry 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

自动泛化不适用于值绑定(bind)，就像它应用于函数绑定(bind)一样。这意味着如果绑定(bind)不是语法上函数，即没有参数，它可能会导致问题。试试这个:

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 字段。旧版本必须省略名称。 使用这些，我可以在 MyClass 中编写一个通用的 checkAll 函数。如果您想坚持使用旧类型，那不会改变函数的形状。

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)

(我假设问题中方法 AllFits 的参数 services 是一个重构工件；它隐藏了同名的私有(private)值。)

---

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

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

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

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

无论如何，IService 都在发生巨大的变化，它可以与异步一起工作。可以使用 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 }

我想象中的编码尝试到此结束。 不保证其中任何一个是健全的、可行的或适用的。但希望它有助于获得想法。