F# 中的随机/状态工作流

Question

我正试图围绕 F# 中的 mon-、err、工作流，虽然我认为我对基本的“可能”工作流有相当扎实的理解，但尝试实现一个状态工作流来生成随机数已经真的把我难住了。

我的未完成尝试可以在这里看到：

let randomInt state =
    let random = System.Random(state)
    // Generate random number and a new state as well
    random.Next(0,1000), random.Next() 

type RandomWF (initState) =
    member this.Bind(rnd,rest) =
        let value, newState = rnd initState
        // How to feed "newState" into "rest"??
        value |> rest
    member this.Return a = a // Should I maybe feed "initState" into the computation here?

RandomWF(0) {
    let! a = randomInt
    let! b = randomInt
    let! c = randomInt
    return [a; b; c]
} |> printfn "%A"

编辑：实际上让它工作了！虽然不完全确定它是如何工作的，所以如果有人想把它放在一个好的答案中，它仍然可以争夺。这是我的工作代码：

type RandomWF (initState) =
    member this.Bind(rnd,rest) =
        fun state ->
            let value, nextState = rnd state
            rest value nextState

    member this.Return a = fun _ -> a 

    member this.Run x = x initState

Answer 1

有两件事让您更难了解您的工作流程正在做什么：

1. 您正在使用函数类型作为 monad 的类型，
2. 您的工作流不仅建立计算，还运行它。

我认为，一旦您看到没有这两个障碍的情况后，它会更清晰。下面是使用 DU 包装器类型定义的工作流：

type Random<'a> = 
    Comp of (int -> 'a * int)

let run init (Comp f) = f init

type Random<'a> with 
    member this.Run(state) = fst <| run state this 

type RandomBuilder() =
    member this.Bind(Comp m, f: 'a -> Random<_>) =
        Comp <| fun state ->
            let value, nextState = m state
            let comp = f value
            run nextState comp             

    member this.Return(a) = Comp (fun s -> a, s)

let random = RandomBuilder()

这是你如何使用它的：

let randomInt =
    Comp <| fun state ->
        let rnd = System.Random(state)
        rnd.Next(0,1000), rnd.Next()

let rand =
    random {
        let! a = randomInt
        let! b = randomInt
        let! c = randomInt
        return [a; b; c ]
    }

rand.Run(0)
|> printfn "%A"

在此版本中，您单独构建计算（并将其存储在 Random 类型中），然后以初始状态运行它。查看构建器方法上的类型是如何推断的，并将它们与MSDN documentation 描述的内容进行比较。

编辑：构造一个构建器对象并使用绑定作为各种别名大多是惯例，但它的合理性在于构建器无状态是有意义的。我可以理解为什么具有参数化构建器似乎是一个有用的功能，但老实说，我无法想象一个令人信服的用例。

monad 的主要卖点是计算的定义和执行的分离。

在您的情况下 - 您想要做的是获取计算的表示并能够以某种状态运行它 - 也许是 0，也许是 42。您不需要知道初始状态定义将使用它的计算。通过将状态传递给构建器，您最终会模糊定义和执行之间的界限，这只会使工作流变得不那么有用。

将其与async 工作流进行比较 - 当您编写异步块时，您不会使代码异步运行。您只需创建一个 Async<'a> 对象，该对象代表一个计算，当您运行它时将生成一个 'a 对象 - 但如何操作取决于您。建造者不需要知道。