在OCaml中是否有一种惯用的方式来实现隐式本地状态？

Question

我想编写一些代码来构建一些使用本地状态的东西。例如，考虑使用本地状态产生连续整数下面的代码：

type state = int ref 

let uniqueId : (state -> int) = 
fun s -> incr s; !s 

let makeThings : ((state -> 'a) -> 'a) = 
fun body -> body (ref 0) 

let() = 

    let x1 = makeThings(fun s -> 
    let i = uniqueId s in  (* 1 *) 
    i 
) in 
    print_int x1; print_newline(); (* Prints 1 *) 

    (* Each makeThings callback gets its own local state. 
    The ids start being generated from 1 again *) 
    let x2 = makeThings(fun s -> 
    let i = uniqueId s in  (* 1 *) 
    let j = uniqueId s in  (* 2 *) 
    i + j 
) in 
    print_int x2; print_newline(); (* Prints 3 *) 

() 

我很好奇，如果有一种方法，使该makeThings内s状态参数回调隐式的，所以我就不说了需要反复输入，因此保证所有uniqueId调用都通过相同的状态参数。例如，在哈斯克尔你可以使用单子做，符号与沿

makeThings $ do 
    i <- uniqueId 
    j <- uniqueId 
    return (i + j) 

线OCaml中，浮现在我的脑海里的唯一的东西代码落得正在s一个全局变量（万劫）或者试图模仿Haskell的monadic接口，我担心这会导致很多工作，并且由于缺少标识符而导致代码编写慢也很难看。有没有我没有想到的替代方案？

Answer 1

你已经拥有的细微差异。而不是使用一个延续，只是提供了一个函数生成一个新的状态：

module State : sig 

    type t 

    val fresh : unit -> t 

    val uniqueId : t -> int 

end = struct 

    type t = int ref 

    let fresh() = ref 0 

    let uniqueId s = incr s; !s 

end 

let() = 
    let x1 = 
    let s = State.fresh() in 
    let i = State.uniqueId s in 
     i 
    in 
    print_int x1; 
    print_newline() (* Prints 1 *) 

let() = 
    let x2 = 
    let s = State.fresh() in 
    let i = State.uniqueId s in  (* 1 *) 
    let j = State.uniqueId s in  (* 2 *) 
     i + j 
    in 
    print_int x2; 
    print_newline() (* Prints 3 *) 

这是为了处理环境中的编译器，它看起来很像你正在尝试做的常用方法。它不会隐式地通过状态线程，因为OCaml不支持隐式参数。但是，如果您只需要一个这样的“环境”参数，那么将其添加到所有适当的功能并不太繁重。

Answer 2

Monads也在OCaml工作。由于pa_monad_custom语法扩展，您甚至可以有一个符号。虽然在大多数情况下只有一个中缀运算符，即>>=就足以编写一个奇特的代码。

Answer 3

你的代码看起来像一元的风格+参考奇怪的混合体。如果你想限制你的本地状态只能通过特定的方式发生变化，你应该把他们藏在当地的具体情况：

let make_unique_id init = 
    let s = ref (init - 1) (* :-) *) in 
    fun() -> 
    incr s; 
    !s 

s是现在隐藏在关闭中。因此，你可以创建柜相互独立：

let() = 
    let x1 = 
    let unique_id = make_unique_id 1 in 
    let i = unique_id() in 
    i 
    in 
    print_int x1; print_newline(); (* Prints 1 *) 

    let x2 = 
    let unique_id = make_unique_id 1 in 
    let i = unique_id() in  (* 1 *) 
    let j = unique_id() in  (* 2 *) 
    i + j 
    in 
    print_int x2; print_newline() (* Prints 3 *) 

Answer 4

这听起来像你想有一个全局变量

let currentId = ref 0 

let uniqueId() = 
    incr currentId; 
    !currentId 

你认为一个全局变量是不可取的，但您指定的行为（“所有来电uniqueId通过相同的状态参数“）恰恰是全局变量的行为。

如果您担心访问全局变量的其他代码，则不要在模块的签名（.mli文件）中公开currentId。

如果您在同一模块访问currentId那么你可以通过将其放置的uniqueId定义范围内限制其范围关注其他代码：

let uniqueId = 
    let currentId = ref 0 in 
    fun() -> 
     incr currentId; 
     !currentId 

或创建一个子模块，不公开currentId在签名：

module M : sig 

    val uniqueId : unit -> int 

end = struct 

    let currentId = ref 0 

    let uniqueId() = 
    incr currentId; 
    !currentId 

end 

include M 

就个人而言，我会去的第一个解决方案（由.mli文件隐藏的全局变量）。确保同一模块中的其他代码不会滥用currentId并且模块系统可以保护您免受其他代码的攻击。

Answer 5

我想你想达到的目的是什么：

1. 函数f（make_things），其具有state。
2. 每次你打电话f，国家越来越重
3. 但是，f内一个通话过程中，该状态可自动改变

如果我是正确的，那么我们就需要Monald，相反，我们可以使用备忘录。

let memo_incr_state() = 
    let s = ref 0 in 
    fun() -> s := !s + 1; !s 

let make_things f = 
    let ms = memo_incr_state() in 
    f ms 

let f1 ms = 
    let i = ms() in 
    let j = ms() in 
    i+j 

let x1 = make_things f1 (* x1 should be 3 *) 

基本思想是我们用thunk来记住状态。

约背诵更多的知识可以从https://realworldocaml.org/v1/en/html/imperative-programming-1.html#memoization-and-dynamic-programming