斯卡拉兹州的monad例子

Question

我没见过很多scalaz state monad的例子.有这个例子,但很难理解,似乎只有一个关于堆栈溢出的问题.

我将发布一些我玩过的例子,但我会欢迎其他的例子.此外,如果有人可以提供上的例子,为什么init,modify,put和gets用于将是巨大的.

编辑:这是一个关于州monad的令人敬畏的2小时演讲.

Answer 1

我假设,scalaz 7.0.x和以下导入(查看scalaz 6.x的答案历史记录):

import scalaz._
import Scalaz._

状态类型被定义为State[S, A]其中S是状态的类型和A是被装饰的值的类型.创建状态值的基本语法使用State[S, A]函数:

// Create a state computation incrementing the state and returning the "str" value
val s = State[Int, String](i => (i + 1, "str")) 

要在初始值上运行状态计算:

// start with state of 1, pass it to s
s.eval(1)
// returns result value "str"

// same but only retrieve the state
s.exec(1)
// 2

// get both state and value
s(1) // or s.run(1)
// (2, "str")

状态可以通过函数调用进行.要做到这一点而不是Function[A, B],定义Function[A, State[S, B]]].使用State功能......

import java.util.Random
def dice() = State[Random, Int](r => (r, r.nextInt(6) + 1))

然后for/yield语法可用于组合函数:

def TwoDice() = for {
  r1 <- dice()
  r2 <- dice()
} yield (r1, r2)

// start with a known seed 
TwoDice().eval(new Random(1L))
// resulting value is (Int, Int) = (4,5)

这是另一个例子.使用TwoDice()状态计算填充列表.

val list = List.fill(10)(TwoDice())
// List[scalaz.IndexedStateT[scalaz.Id.Id,Random,Random,(Int, Int)]]

使用序列得到一个State[Random, List[(Int,Int)]].我们可以提供类型别名.

type StateRandom[x] = State[Random,x]
val list2 = list.sequence[StateRandom, (Int,Int)]
// list2: StateRandom[List[(Int, Int)]] = ...
// run this computation starting with state new Random(1L)
val tenDoubleThrows2 = list2.eval(new Random(1L))
// tenDoubleThrows2  : scalaz.Id.Id[List[(Int, Int)]] =
//   List((4,5), (2,4), (3,5), (3,5), (5,5), (2,2), (2,4), (1,5), (3,1), (1,6))

或者我们可以使用sequenceU哪个会推断出类型:

val list3 = list.sequenceU
val tenDoubleThrows3 = list3.eval(new Random(1L))
// tenDoubleThrows3  : scalaz.Id.Id[List[(Int, Int)]] = 
//   List((4,5), (2,4), (3,5), (3,5), (5,5), (2,2), (2,4), (1,5), (3,1), (1,6))

另一个State[Map[Int, Int], Int]用于计算上面列表中的和的频率的示例.freqSum计算投掷的总和并计算频率.

def freqSum(dice: (Int, Int)) = State[Map[Int,Int], Int]{ freq =>
  val s = dice._1 + dice._2
  val tuple = s -> (freq.getOrElse(s, 0) + 1)
  (freq + tuple, s)
}

现在使用遍历申请freqSum过tenDoubleThrows.traverse相当于map(freqSum).sequence.

type StateFreq[x] = State[Map[Int,Int],x]
// only get the state
tenDoubleThrows2.copoint.traverse[StateFreq, Int](freqSum).exec(Map[Int,Int]())
// Map(10 -> 1, 6 -> 3, 9 -> 1, 7 -> 1, 8 -> 2, 4 -> 2) : scalaz.Id.Id[Map[Int,Int]]

或者通过使用traverseU推断类型更简洁:

tenDoubleThrows2.copoint.traverseU(freqSum).exec(Map[Int,Int]())
// Map(10 -> 1, 6 -> 3, 9 -> 1, 7 -> 1, 8 -> 2, 4 -> 2) : scalaz.Id.Id[Map[Int,Int]]

请注意,因为State[S, A]是类型别名StateT[Id, S, A],tenDoubleThrows2最终被输入为Id.我用copoint它把它变回一种List类型.

简而言之,使用状态的关键似乎是让函数返回一个函数来修改状态和所需的实际结果值... 免责声明:我从未state在生产代码中使用过,只是试图感受它.

有关@ziggystar评论的其他信息

我放弃了尝试使用stateT可能被别人才能证明StateFreq或StateRandom可增强执行合并计算.我找到的是两个状态变换器的组成可以像这样组合:

def stateBicompose[S, T, A, B](
      f: State[S, A],
      g: (A) => State[T, B]) = State[(S,T), B]{ case (s, t) =>
  val (newS, a) = f(s)
  val (newT, b) = g(a) apply t
  (newS, newT) -> b
}

它是以g一个参数函数为基础的,它取第一个状态变换器的结果并返回一个状态变换器.然后以下工作:

def diceAndFreqSum = stateBicompose(TwoDice, freqSum)
type St2[x] = State[(Random, Map[Int,Int]), x]
List.fill(10)(diceAndFreqSum).sequence[St2, Int].exec((new Random(1L), Map[Int,Int]()))

Answer 2

我偶然发现了一个有趣的博客文章来自sigfp的Grok Haskell Monad变形金刚,它有一个通过monad变换器应用两个状态monad的例子.这是一个scalaz翻译.

第一个例子显示了一个State[Int, _]monad:

val test1 = for {
  a <- init[Int] 
  _ <- modify[Int](_ + 1)
  b <- init[Int]
} yield (a, b)

val go1 = test1 ! 0
// (Int, Int) = (0,1)

所以我在这里有一个使用init和的例子modify.在玩了一下之后,init[S]结果是生成一个State[S,S]值非常方便,但它允许的另一件事就是访问for comprehension中的状态.modify[S]是一种方便的方法来改变理解中的状态.所以上面的例子可以解读为:

• a <- init[Int]:从Int状态开始,将其设置为State[Int, _]monad 包装的值并将其绑定到a
• _ <- modify[Int](_ + 1):增加Int状态
• b <- init[Int]:获取Int状态并将其绑定到b(与a现在相同但现在状态增加)
• State[Int, (Int, Int)]使用a和产生一个值b.

for comprehension语法已经使得在A一边工作变得微不足道State[S, A].init,modify,put并gets提供一些工具,在工作S中边State[S, A].

博客文章中的第二个示例转换为:

val test2 = for {
  a <- init[String]
  _ <- modify[String](_ + "1")
  b <- init[String]
} yield (a, b)

val go2 = test2 ! "0"
// (String, String) = ("0","01")

非常相同的解释test1.

在第三个例子是比较棘手的,我希望有更简单的东西,我还没有发现.

type StateString[x] = State[String, x]

val test3 = {
  val stTrans = stateT[StateString, Int, String]{ i => 
    for {
      _ <- init[String]
      _ <- modify[String](_ + "1")
      s <- init[String]
    } yield (i+1, s)
  }
  val initT = stateT[StateString, Int, Int]{ s => (s,s).pure[StateString] }
  for {
    b <- stTrans
    a <- initT
  } yield (a, b)
}

val go3 = test3 ! 0 ! "0"
// (Int, String) = (1,"01")

在该代码中,stTrans负责两个状态的转换(增量和后缀"1")以及拉出String状态.stateT允许我们在任意monad上添加状态转换M.在这种情况下,状态Int是递增的.如果我们打电话,stTrans ! 0我们最终会M[String].在我们的例子中,M是StateString,所以我们最终会得到StateString[String]它State[String, String].

这里棘手的部分是我们想从中取出Int状态值stTrans.这initT是为了什么.它只是创建一个对象,以一种我们可以使用flatMap的方式访问状态stTrans.

编辑:如果我们真正重用test1并且test2方便地将所需状态存储在_2其返回元组的元素中,则可以避免所有这些尴尬:

// same as test3:
val test31 = stateT[StateString, Int, (Int, String)]{ i => 
  val (_, a) = test1 ! i
  for (t <- test2) yield (a, (a, t._2))
}

Answer 3

这是一个关于如何State使用的非常小的例子:

让我们定义一个小"游戏",其中一些游戏单位正在与老板(也是游戏单位)作战.

case class GameUnit(health: Int)
case class Game(score: Int, boss: GameUnit, party: List[GameUnit])


object Game {
  val init = Game(0, GameUnit(100), List(GameUnit(20), GameUnit(10)))
}

当游戏开启时我们想要跟踪游戏状态,所以让我们用状态monad来定义我们的"动作":

让我们努力击中老板让他从他那里失去10 health:

def strike : State[Game, Unit] = modify[Game] { s =>
  s.copy(
    boss = s.boss.copy(health = s.boss.health - 10)
  )
}

老板可以反击!当他做党派中的每个人失去5 health.

def fireBreath : State[Game, Unit] = modify[Game] { s =>
  val us = s.party
    .map(u => u.copy(health = u.health - 5))
    .filter(_.health > 0)

  s.copy(party = us)
}

现在我们可以将这些行为组合成play:

def play = for {
  _ <- strike
  _ <- fireBreath
  _ <- fireBreath
  _ <- strike
} yield ()

当然,在现实生活中,这个剧本会更有活力,但对于我的小例子来说,它就足够了:)

我们现在可以运行它来查看游戏的最终状态:

val res = play.exec(Game.init)
println(res)

>> Game(0,GameUnit(80),List(GameUnit(10)))

因此,我们几乎没有击中老板,其中一个单位已经死亡,RIP.

这里的重点是构图. State(这只是一个函数S => (A, S))允许您定义产生结果的操作,并且在不了解状态来源的情况下操纵某些状态.该Monad部分为您提供合成,以便您的行动可以组成:

 A => State[S, B] 
 B => State[S, C]
------------------
 A => State[S, C]

等等.

PS至于之间的差异get,put和modify:

modify可以看作是get和put在一起:

def modify[S](f: S => S) : State[S, Unit] = for {
  s <- get
  _ <- put(f(s))
} yield ()

或者干脆

def modify[S](f: S => S) : State[S, Unit] = get[S].flatMap(s => put(f(s)))

因此,当您使用modify概念时使用get和put,或者您可以单独使用它们.