F# 对象表达式中的可变状态

Question

我希望 F# 对象表达式具有可变状态。 第一种方法是使用引用单元格，如下所示：

type PP =
    abstract member A : int

let foo =
    let a = ref 0
    { new PP with
        member x.A = 
            let ret = !a
            a := !a + 1
            ret 
    }

printfn "%A" foo.A
printfn "%A" foo.A
printfn "%A" foo.A
printfn "%A" foo.A

另一种方法如下：

type State(s : int) =
    let mutable intState = s
    member x.state 
        with get () = intState
        and set v = intState <- v 

[<AbstractClass>]         
type PPP(state : State) =
    abstract member A : int
    member x.state 
        with get () = state.state
        and set v = state.state <- v 

let bar n =
    { new PPP(State(n)) with
        member x.A = 
            let ret = x.state
            x.state <- ret + 1
            ret  
    }

let barA1 = bar 0
printfn "%A" barA1.A
printfn "%A" barA1.A
printfn "%A" barA1.A
printfn "%A" barA1.A

哪个版本可能性能更好（我需要状态更新 x.state <- ret + 1 在性能关键部分）？我的猜测是 State 对象也分配在堆上，因此没有理由第二个版本应该更快。然而，它使用起来稍微更有吸引力。

感谢您的任何反馈和建议

Answer 1

正如 Daniel 所说，最后一种方法本质上等同于使用内置的 ref 。

使用 ref 时，您将分配两个对象 - 您要返回的对象和引用单元格本身。您可以通过使用具体实现将其减少为单个分配的对象（但我认为这在实践中并不重要）：

type Stateful(initial:int) = 
  let mutable state = initial
  interface PP with
    member x.A =
      let ret = state
      state <- state + 1
      ret

let foo = 
   Statefull(0) :> PP // Creates a single object that keeps the state as mutable field

此外，您正在使用只读属性来修改对象的内部状态并返回新状态每次。这是一种危险的模式，可能会非常令人困惑 - 带 getter 的属性不应修改状态，因此您可能应该使用方法 (unit -> int)。

Answer 2

您的 State 类与 ref 相同。它们都是引用类型（您无法从对象表达式捕获可变值类型）。如果可能的话，我更喜欢内置类型。 ref 是表示堆分配的可变值的惯用方式。

如果对性能有疑问，请对其进行基准测试。