有没有办法让这种延续传递与 codata 示例在 F# 中工作？

Question

type Interpreter<'a> =
| RegularInterpreter of (int -> 'a)
| StringInterpreter of (string -> 'a)

let add<'a> (x: 'a) (y: 'a) (in_: Interpreter<'a>): 'a = 
    match in_ with
    | RegularInterpreter r -> 
        x+y |> r
    | StringInterpreter r -> 
        sprintf "(%s + %s)" x y |> r

在编译时无法解析 'a 的错误消息对我来说非常清楚。我猜测是否可以使上述工作的问题的答案是否定的，没有直接将函数添加到数据类型中。但是我还不如使用接口，或者完全摆脱泛型参数。

编辑：马克的回复确实符合我的要求，但让我扩展这个问题，因为我没有充分解释它。我想要做的是用上面的技术来模仿post 中所做的事情。这样做的动机是避免内联函数，因为它们的可组合性很差 - 如果没有专门的泛型参数，它们就不能作为 lambdas 传递。

我希望我可以通过将带有泛型参数的联合类型传递给闭包来解决它，但是...

type Interpreter<'a> =
| RegularInterpreter of (int -> 'a)
| StringInterpreter of (string -> 'a)

let val_ x in_ =
    match in_ with
    | RegularInterpreter r -> r x
    | StringInterpreter r -> r (string x)

let inline add x y in_ = 
    match in_ with
    | RegularInterpreter r -> 
        x in_ + y in_ |> r
    | StringInterpreter r -> 
        sprintf "(%A + %A)" (x in_) (y in_) |> r

let inline mult x y in_ = 
    match in_ with
    | RegularInterpreter r -> 
        x in_ * y in_ |> r
    | StringInterpreter r -> 
        sprintf "(%A * %A)" (x in_) (y in_) |> r

let inline r2 in_ = add (val_ 1) (val_ 3) in_

r2 (RegularInterpreter id)
r2 (StringInterpreter id) // Type error.

最后一行给出了类型错误。有没有解决的办法？尽管由于它们对可组合性的限制，我更希望函数不要被内联。

Answer 1

移除类型注解：

let inline add x y in_ = 
    match in_ with
    | RegularInterpreter r -> 
        x + y |> r
    | StringInterpreter r -> 
        sprintf "(%A + %A)" x y |> r

您还需要进行一些其他更改，我在上面也合并了这些更改：

• 将sprintf 使用的格式说明符更改为更通用的内容。当您使用%s 时，您是说该占位符的参数必须是字符串，因此编译器会推断出x 和y 为string 值。
• 添加 inline 关键字。

通过这些更改，add 的推断类型现在是：

x: ^a -> y: ^b -> in_:Interpreter<'c> -> 'c
    when ( ^a or  ^b) : (static member ( + ) :  ^a *  ^b -> int)

您会注意到它适用于任何将+ 定义为将输入参数转换为int 的类型。在实践中，这可能仅意味着 int 本身，除非您定义自定义运算符。

FSI 烟雾测试：

> add 3 2 (RegularInterpreter id);;
val it : int = 5
> add 2 3 (StringInterpreter (fun _ -> 42));;
val it : int = 42

Answer 2

编译器最终默认为 int，而您想要的多态性在 F# 中很难实现。这个article 阐明了这一点。

也许，您可以使用 FSharp.Interop.Dynamic 来处理黑暗艺术，但您会浪费编译时间来检查哪种方式不符合要点。

Answer 3

我得出的结论是，我正在尝试做的事情是不可能的。我有一种预感，它已经是，但证据如下：

let vale (x,_,_) = x
let adde (_,x,_) = x
let multe (_,_,x) = x

let val_ x d =
    let f = vale d
    f x

let add x y d =
    let f = adde d
    f (x d) (y d)

let mult x y d =
    let f = multe d
    f (x d) (y d)

let in_1 =
    let val_ (x: int) = x
    let add x y = x+y
    let mult x y = x*y
    val_,add,mult

let in_2 =
    let val_ (x: int) = string x
    let add x y = sprintf "(%s + %s)" x y
    let mult x y = sprintf "(%s * %s)" x y
    val_,add,mult

let r2 d = add (val_ 1) (val_ 3) d

//let test x = x in_1, x in_2 // Type error.

let a2 = r2 in_1 // Works
let b2 = r2 in_2 // Works

推理是，如果不能使用作为参数传递的普通函数来完成，那么使用接口、记录、可区分联合或任何其他方案肯定是不可能的。标准函数比上述任何函数都更通用，如果他们做不到，那么这是语言的基本限制。

导致代码不通用的不是缺少 HKT，而是像这样简单。事实上，通过 Reddit 帖子中链接到的 Final Tagless 论文，Haskell 也存在同样的问题，即需要复制解释器而不使用谓词类型扩展——尽管我环顾四周，似乎将来会删除谓词类型因为扩展很难维护。

不过，我确实希望这只是 F# 的当前限制。如果语言是动态的，上面的代码段实际上会正确运行。

Answer 4

很遗憾，我并不完全清楚您要做什么。但是，似乎可以通过使用泛型方法创建接口来实现。例如，您可以通过以下方式获取来自your answer 的代码来工作：

type I = abstract Apply : ((int -> 'a) * ('a -> 'a -> 'a) * ('a -> 'a -> 'a)) -> 'a

//let test x = x in_1, x in_2 // Type error.
let test (i:I) = i.Apply in_1, i.Apply in_2

let r2' = { new I with member __.Apply d = add (val_ 1) (val_ 3) d }
test r2' // no problem

如果您想通用地使用一个值（例如函数输入），那么在大多数情况下，最简洁的方法是使用其签名表达所需多态性的通用方法创建一个接口。