在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