F# 中的累加器生成器

Question

为了了解更多 F#，我尝试实现 Paul Graham 此处。到目前为止，我最好的解决方案是完全动态类型：

open System

let acc (init:obj) : obj->obj=
  let state = ref init
  fun (x:obj) ->
    if (!state).GetType() = typeof<Int32>
       && x.GetType() = typeof<Int32> then
      state := (Convert.ToInt32(!state) + Convert.ToInt32(x)) :> obj
    else
      state := (Convert.ToDouble(!state) + Convert.ToDouble(x)) :> obj
    !state

do
  let x : obj -> obj = acc 1  // the type annotation is necessary here
  (x 5) |> ignore
  printfn "%A" (x 2)   // prints "8"
  printfn "%A" (x 2.3) // prints "10.3"

我有三个问题：

• 如果我删除 x 的类型注释，代码将无法编译，因为编译器推断类型 int ->; obj for x - 尽管 acc 被注释为返回 obj->obj。这是为什么？我可以避免吗？
• 有什么想法可以改进这个动态类型版本吗？
• 是否可以使用适当的静态类型来实现它？也许有成员限制？ （在 Haskell 中是可能的，但在 OCaml 中不行，AFAIK）

Answer 1

为了了解更多 F#，我尝试实现一个“累加器生成器”，如 Paul Graham 此处所述。

这个问题需要存在一个未指定的数字塔。 Lisp 恰好有一个，而且它恰好足以满足 Paul Graham 的例子，因为这个问题是专门设计来让 Lisp 看起来人为的好。

您可以在 F# 中使用联合类型（例如 type number = Int of int | Float of float）或通过装箱所有内容来实现数字塔。以下解决方案使用后一种方法：

let add (x: obj) (y: obj) =
  match x, y with
  | (:? int as m), (:? int as n) -> box(m+n)
  | (:? int as n), (:? float as x)
  | (:? float as x), (:? int as n) -> box(x + float n)
  | (:? float as x), (:? float as y) -> box(x + y)
  | _ -> failwith "Run-time type error"

let acc x =
  let x = ref x
  fun (y: obj) ->
    x := add !x y
    !x

let x : obj -> _ = acc(box 1)
do x(box 5)
do acc(box 3)
do printfn "%A" (x(box 2.3))

然而，数字塔在现实世界中几乎没有用处。除非你非常小心，否则试图从这些无聊的挑战中学习只会弊大于利。您应该问自己为什么我们不想要数字塔，不想要装箱并且不想要运行时类型提升？

为什么我们不直接写：

let x = 1
let x = x + 5
ignore(3)
let x = float x + 2.3

我们在每一步都知道x的类型。每个号码均未装箱存储。我们知道这段代码永远不会产生运行时类型错误......

Answer 2

我同意 Jon 的观点，即这是一个相当人为的示例，它不是学习 F# 的良好起点。但是，您可以使用静态成员约束来相当接近，而无需动态转换和反射。如果将其标记为 inline 并使用 float 添加转换两个参数：

let inline acc x = 
  let x = ref (float x)
  fun y ->
    x := (float y) + !x
    !x

您将得到一个具有以下类型的函数：

val inline acc :
   ^a -> ( ^b -> float)
    when  ^a : (static member op_Explicit :  ^a -> float) and
          ^b : (static member op_Explicit :  ^b -> float)

该函数采用任意两个可以是的参数显式转换为浮点数。与 LISP 版本相比（我猜）的唯一限制是它始终返回 float（作为最通用的可用数字类型）。你可以这样写：

> acc 1 2;;            // For two integers, it returns float
val it : float = 3.0
> acc 1 2.1;;          // integer + float
val it : float = 3.1
> acc 1 "31";;         // It even works with strings!
val it : float = 32.0

Answer 3

使用正确的静态类型绝对不可能实现这一点。你说你可以用 Haskell，但我不相信你。

Answer 4

尝试使用静态类型来做到这一点的问题在于添加两个可能不同类型的不同数量，同时保留左侧的类型。正如 Jon Harrop 所说，这对于联合类型是可能的。一旦定义了联合类型和相应的加法运算（如前面提到的那样工作），实际的累加器就非常简单。我的实现：

module MyTest

type Numeric =
  | NInt of int
  | NFloat of float

  member this.Add(other : Numeric) : Numeric =
    match this with
      | NInt x ->
        match other with
          | NInt y -> NInt (x + y)
          | NFloat y -> NInt (x + (int y))
      | NFloat x ->
        match other with
          | NInt y -> NFloat (x + (float y))
          | NFloat y -> NFloat (x + y)

  override this.ToString() =
    match this with
      | NInt x -> x.ToString()
      | NFloat x -> x.ToString()

let foo (n : Numeric) =
  let acc = ref n
  fun i ->
    acc := (!acc).Add(i)
    !acc

let f = foo (NFloat 1.1)
(2 |> NInt |> f).ToString() |> printfn "%s"