Question

我是一名正在学习使用F＃的功能反应范式的学生。这对我来说是一个全新的观点。昨天我学会了使用这个范例创建一个简单的乒乓球比赛。我到目前为止所掌握的想法是：我们认为价值观是时间的函数。纯粹的形式，它是无国籍的。但是，我需要记住球（或状态）的位置。所以我总是将球的当前位置作为全局函数的参数传递。

如果我们谈论轻微的更复杂的游戏，比如太空入侵者，我们有很多州（外星人的位置，外星人目前的HP，剩余炸弹的数量等）

是否有优雅/最好的方法来解决这个问题？我们总是将州存储在最高层吗？是否应将所有当前状态作为全局函数的附加输入参数？

有人可以在F＃上使用简单的样本解释这个吗？非常感谢。

Answer 1

FRP的方法不止一种，而且它是一个活跃的研究领域。什么是最好的可以很大程度上取决于事物如何相互作用的细节，未来可能会出现新的和更好的技术。

从广义上讲，这个想法是让时间函数的行为代替普通价值（如你所说）。行为可以根据其他行为来定义，并且可以定义为在特定事件发生时在其他行为之间进行交换。

在你的例子中，你通常不需要通过参数记住球的位置（但是你可能会做某些类型的FRP）。相反，你可以有一个行为：
ballPos : time -> (float * float)
这可能具有全局范围，或者对于更大的程序而言，在该范围内使用本地范围并使用它可能更好。

随着事情变得越来越复杂，您将以越来越复杂的方式定义行为，依赖于其他行为和事件 - 包括在不同FRP框架中以不同方式处理的递归依赖。在F＃中，对于递归依赖，我希望你需要一个包含所有相关行为的let rec。这些仍然可以组织成结构 - 在顶级你可能有：

type alienInfo =  { pos : float*float; hp : float }
type playerInfo = { pos : float*float; bombs : int } 
let rec aliens : time -> alienInfo array =             // You might want laziness here.
    let behaviours = [| for n in 1..numAliens -> 
                        (alienPos player n, alienHP player n) |]
    fun t -> [| for (posBeh, hpBeh) in behaviours -> 
                {pos=posBeh t; hp=hpBeh t} |]          // You might want laziness here.
and player : time -> playerInfo  = fun t ->
    { pos=playerPos aliens t; bombs=playerBombs aliens t}

然后可以定义alienPos，alienHP的行为，依赖于玩家，玩家动物，玩家炸弹可以依赖外星人来定义。

无论如何，如果您可以提供有关您正在使用何种FRP的更多详细信息，那么提供更具体的建议会更容易。（如果你想要什么样的建议 - 我个人建议阅读：http://conal.net/papers/push-pull-frp/push-pull-frp.pdf）

Answer 2

我对F＃下的反应式编程没有任何经验，但纯功能系统中的全局状态问题非常普遍，并且有一个非常优雅的解决方案： Monads 。

虽然monads本身主要用于Haskell，但基础概念将其作为computation expressions进入F＃。

这个想法是你实际上并没有改变状态，只是描述了状态的转变，即如何产生新的状态。状态本身可以完全隐藏在程序中。通过使用特殊的monadic语法，您几乎可以编写纯粹但有状态的程序。

从this source采取（修改）实施，State monad可能看起来像这样

let (>>=) x f =
   (fun s0 ->
      let a,s = x s0    
      f a s)       
let returnS a = (fun s -> a, s)

type StateBuilder() =
  member m.Delay(f) = f()
  member m.Bind(x, f) = x >>= f
  member m.Return a = returnS a
  member m.ReturnFrom(f) = f

let state = new StateBuilder()     

let getState = (fun s -> s, s)
let setState s = (fun _ -> (),s) 

let runState m s = m s |> fst

让我们举个例子：我们想要编写一个可以在继续执行时将值写入日志（只是一个列表）的函数。因此我们定义

let writeLog x = state {
  let! oldLog = getState // Notice the ! for monadic computations (i.e. where the state is involved)
  do! setState (oldLog @ [x]) // Set new state
  return () // Just return (), we only update the state
}

在state内，我们现在可以在命令式语法中使用它，而无需手动处理日志列表。

let test = state {
   let k = 42
   do! writeLog k // It's just that - no log list we had to handle explicitly
   let b = 2 * k
   do! writeLog b
   return "Blub"
}

let (result, finalState) = test [] // Run the stateful computation (starting with an empty list)
printfn "Result: %A\nState: %A" result finalState

但是，这里的一切都是纯粹的功能;）

Answer 3

Tomas在F＃中提供了nice talk反应式编程。许多概念应该适用于您的情况。

Answer 4

也许你想看看FsReactive。

Answer 5

Elm是一个现代的FRP实施。对于在诸如Space Invaders等游戏中无处不在的动态集合的建模，它包含基于箭头化FRP概念的Automaton library。你一定要看一下。

功能反应F＃ - 在游戏中存储状态

5 个答案: