Haskell 哈斯克尔莫纳德州德苏加

为了研究国家单子的细节，我试图去研究：

我正在粘贴在论坛成员帮助下创建的版本

我想确保我的思路是正确的：

newtype State s a = State { runState :: s -> (a, s) }

state :: (s -> (a, s)) -> State s a

---

foo=do
a>=\a->
put（a+1）
2.foo=get>>=\a->put（a+1）
2.1 get=状态（\s->（s，s））
2.2放置a=状态（\\\->（（），a+1）
3.foo=State（\s->（s，s））>=\a->State（\\ u->（（），a+1）
4.foo=State（\s0->let（a，s1）=runState（State（\s->（s，s））s0
处于运行状态（（\a->State（\\u->（（），a+1）a）s1
5.foo=状态（\s0->let（a，s1）=（\s->（s，s））s0
处于运行状态（（\a->State（\\u->（（），a+1）a）s1
6.foo=State（\s0->let（a，s1）=（s0，s0）--a=s0 i s1=s0
处于运行状态（（\a->State（\\u->（（），a+1）a）s1
7.foo=State（\s0->runState（\a->State（\\ u->（（），a+1）s0）s1
8.foo=State（\s0->runState（（State（\\u->（（），s0+1））s1
9.foo=状态（\s0->（\ \u0->（（），s0+1）
10.foo=状态（\s0->（（），s0+1）
11.运行状态foo 0
12.运行状态（状态（\s0->（（），s0+1）0
13.（\s0->（（），s0+1）0

---

是正确的吗？：）

我写了一篇博客文章，几乎完全是这样一个例子：

如果我们将

（>>=）

定义为

  (>>=) (State sa) fn =
    State (\s0 -> let (a, s1)  = sa s0
                      State sb = fn a
                  in sb s1)

那么，脱糖就开始了

    do i <- get; put (i+1)
 == get >>= \i -> put (i+1)
 == State (\s -> (s, s)) >>= \i -> State (\_ -> ((), i+1))

最后，我们有

    exec (State (\i -> ((), i+1))) 0
 == snd $ runState (State (\i -> ((), i+1))) 0
 == snd $ (\i -> ((), i+1)) 0
 == snd $ ((), 1)
 == 1

---

你真的应该编辑你的原始问题，而不是删除它并发布这个问题。当我们看到“新”问题时，通常会让其他用户感到困惑，这些问题看起来很像我们记得见过的那些问题。也许观察一下

state=state

，会有帮助，因此

runState（state f）=runState（state f）=f

.和

运行状态（state$\st->（st，st））s

=

（\st->（st，st））s

=

（s，s）

所以

x=s

和

s'=s

-现在您可以在下一个

运行状态（state…

表达式中替换它，并观察

运行状态（state（\s->）s'

只是

（\s->）再次请注意，当您使用desugar
foo
时，您没有替换您的
a
-请仔细看
a
确实是
st
！我很高兴：）。如果您能接受这个答案，我将不胜感激。
    (>>=) (State (\s -> (s,s))) (\i -> State (\_ -> ((), i+1))) =
      State (\s0 -> let (a, s1)  = (\s -> (s,s)) s0
                     -- (a, s1)  = (s0, s0)
                        State sb = (\i -> State (\_ -> ((), i+1))) a
                     --       sb = (\_ -> ((), s0+1))
                    in sb s1)
                     -- ((), s0+1)
 == State (\s0 -> ((), s0+1))
 == State (\i  -> ((), i+1))

    exec (State (\i -> ((), i+1))) 0
 == snd $ runState (State (\i -> ((), i+1))) 0
 == snd $ (\i -> ((), i+1)) 0
 == snd $ ((), 1)
 == 1