使用 Cont 从未来和过去获取值

Question

我正在用 Haskell 编写一个脑残的解释器，我想出了一个我认为非常有趣的程序描述：

data Program m = Instruction (m ()) (Program m)
               | Control (m (Program m))
               | Halt

但是，将脑残程序的文本表示解析为这种数据类型是很棘手的。尝试正确解析方括号时会出现问题，因为需要打结，以便循环内的最终Instruction 再次链接到循环的Control。

更多初步信息。详情请见this version on the github repo。

type TapeM = StateT Tape IO
type TapeP = Program TapeM
type TapeC = Cont TapeP

branch :: Monad m => m Bool -> Program m -> Program m -> Program m
branch cond trueBranch falseBranch =
  Control ((\b -> if b then trueBranch else falseBranch) `liftM` cond)

loopControl :: TapeP -> TapeP -> TapeP
loopControl = branch (not <$> is0)

这是我尝试过的：

toProgram :: String -> TapeP
toProgram = (`runCont` id) . toProgramStep

liftI :: TapeM () -> String -> TapeC TapeP
liftI i cs = Instruction i <$> toProgramStep cs

toProgramStep :: String -> TapeC TapeP
toProgramStep ('>':cs) = liftI right cs
-- similarly for other instructions
toProgramStep ('[':cs) = push (toProgramStep cs)
toProgramStep (']':cs) = pop (toProgramStep cs)

push :: TapeC TapeP -> TapeC TapeP
push mcontinue = do
  continue <- mcontinue
  cont (\breakMake -> loopControl continue (breakMake continue))

pop :: TapeC TapeP -> TapeC TapeP
pop mbreak = do
  break <- mbreak
  cont (\continueMake -> loopControl (continueMake break) break)

我想我可以以某种方式使用延续将信息从 '[' 案例传递到 ']' 案例，反之亦然，但我对 Cont 没有足够的把握，除了收集疯狂的猜测之外，我还没有真正做任何事情一些看起来可能有效的东西，如上面push 和pop 所示。这编译并运行，但结果是垃圾。

Cont 可以在这种情况下适当地打结吗？如果不是，那我应该使用什么技术来实现toProgram？

---

注意 1：我之前遇到了一个微妙的逻辑错误：loopControl = branch is0 的布尔值颠倒了。

注意 2：我设法使用 MonadFix（如 jberryman 建议）和 State 来提出解决方案（请参阅 the current state of the github repository）。我仍然想知道如何使用Cont 来代替。

注 3：我的 Racketeer 导师为我整理了 a similar Racket program（查看所有修订）。可以使用Cont 将他的管道/管道输出技术翻译成 Haskell 吗？

---

tl;dr 我设法使用 MonadFix 做到了这一点，而其他人设法使用 Racket 的延续组合器做到了这一点。我很确定这可以通过 Haskell 中的Cont 来完成。你能告诉我怎么做吗？

Answer 1

带有 continuation monad 的前进状态如下所示：

Cont (fw -> r) a

那么cont的参数类型是

(a -> fw -> r) -> fw -> r

所以你得到一个从过去传入的fw，你必须将它传递给延续。

倒车状态如下：

Cont (bw, r) a

那么cont的参数类型是

(a -> (bw, r)) -> (bw, r)

即你从你必须传递给过去的延续中得到一个bw。

这些可以组合成一个延续单子：

Cont (fw -> (bw, r)) a

将它应用到解析器时有一个问题，因为toProgramStep 反向构建程序，所以']' 点列表是前向状态，而'[' 点列表是后向状态。另外，我很懒，跳过了 Maybe 部分，它应该会捕获 openBrace 和 closeBrace 中的模式匹配错误。

type ParseState = Cont ([TapeP] -> ([TapeP], TapeP))

toProgram :: String -> TapeP
toProgram = snd . ($ []) . (`runCont` (\a _ -> ([], a))) . toProgramStep


openBrace :: ParseState TapeP -> ParseState TapeP
openBrace mcontinue = do
  continue <- mcontinue
  cont $ \k (break:bs) -> let (cs, r) = k (loopControl continue break) bs in (continue:cs, r)

closeBrace :: ParseState TapeP -> ParseState TapeP
closeBrace mbreak = do
  break <- mbreak
  cont $ \k bs -> let (continue:cs, r) = k (loopControl continue break) (break:bs) in (cs, r)

Answer 2

由于我对Cont 不满意，因此对这个答案非常懒惰，但是MonadFix 可能是您要找的吗？ State 是一个实例，虽然不是Cont，它可以让你做一些看起来像的事情（使用"recursive do" notation）：

{-# LANGUAGE DoRec #-}
parseInst str = do
    rec ctl <- parseInstructionsLinkingTo ctl str

这是我为我的演员库发现的解决方案：我们想要一个返回生成演员邮箱的spawn 操作，但是我们如何启动相互通信的演员？还是可以访问自己邮箱的演员？

使用合适的MonadFix 实例我们可以做到：

fork3 = do
    rec mb1 <- spawn $ actorSpamming mb2 mb3
        mb2 <- spawn $ actorSpamming mb1 mb2
        mb3 <- spawn $ actorSpamming mb2 mb3
    send "go" mb1

以上希望能给你一些想法。