Parsley与根据状态改变行为的动态解析器

在这篇博客里我们会重构一下上次的缩进解析器，特别是把可恶的???给去掉。在改的过程中我们会遇到一些困难，但是我们会战胜他，奥力给！

先糊一点

先复习一下上次写了啥，有啥问题：

// 和上次有那么一点不太一样，不过无所谓
val scope: Parsley[Scope] = many(
    state.update((
        many(' ').map(_.length) <~> stmt <~ '\n'
    ).map { res => (s: State) =>
        val sc = s.scope
        val (i, sm) = res
        if i == s.level then
            s.push(sm)
        else if i == s.level + 4 then
            s.newScope(sm)
        else if i == s.level - 4 then
            s.prevScope(sm)
        else
            ??? // 寄
        s
    }
)) ~> state.get.map { s => s.scope.last }

从寄字也看得出来如果输入不合规，进了最后一种情况，我们的解析器不会返回一个Failure而是会直接爆。所以我们真正想要的应该大约是：

def spaces(x: Int) = string(" ".repeat(x))
val scope: Parsley[Scope] = many(
    state.update((
        (spaces(???) <|> spaces(??? + 4) <|> spaces(??? - 4))
        <~> stmt <~ '\n'
    ).map { res => (s: State) =>
        val sc = s.scope
        val (i, sm) = res
        if i == s.level then
            s.push(sm)
        else if i == s.level + 4 then
            s.newScope(sm)
        else if i == s.level - 4 then
            s.prevScope(sm)
        else
            ??? // 这是安全的，不可能进这种情况
        s
    }
)) ~> state.get.map { s => s.scope.last }

???基于现在的缩进，很自然会想到用state.gets来取值：

val scope: Parsley[Scope] = many(
    state.update((
        state.gets { s =>
            spaces(s.level) <|> spaces(s.level + 4) <|> spaces(s.level - 4)
        }
        <~> stmt <~ '\n'
    ).map { ... } // omitted
)) ~> ... // omitted

啧，但这样类型不对。 def gets[B](f: State => B): Parsley[B]，但我们返回的是 Parsley[String]，而Parsley[Parsley[String]] 啥也不是

那么是不是.map和spaces都得在gets那个块里呢？

val scope: Parsley[Scope] = many(
    state.update((
        state.gets { s =>
            (spaces(s.level) <|> spaces(s.level + 4) <|> spaces(s.level - 4))
            <~> stmt <~ '\n'
        ).map { ... }
    }
)) ~> ...

不行，state.update 要一个 State，但我们给的是Parsley[State]。

还有一些别的选择，比如把update塞gets里，你会发现类型也对不上（如果那样update又返回Parsley[State]了）。

quote

The reason monads are not supported is because of the Staging: Parsley parsers are compiled ahead of time to produce fast code, but this means the entirely of the parser must be known before any input is provided, ruling out dynamic monadic operations.

好吧，上面那段是parsley haskell里讲的，所以不一定对，所以说不定update+gets还是有搞头的。\_ ツ _/

但是这样搞肯定不是库作者想看到的，而且大概率没法优化。我个人是相信Parsley类型会防止你这么写动态解析器。

但这个逻辑命令式是很好写的，直接全局变量一糊就完事了，函数式就干不了吗？

解决方法

其实内置就有个forP组合子完美契合这个需求。

val scope: Parsley[Scope] = many(
    state.update((
        ((atomic(
            forP[Int](state.gets(_.level + 4), pure(_ > 0), pure(_ - 1))
        ) <|>
        atomic(
          forP[Int](state.gets(_.level), pure(_ > 0), pure(_ - 1))
        ) <|>
        atmoic(
         forP[Int](state.gets(_.level - 4), pure(_ > 0), pure(_ - 1))
        ))
        <~> stmt <~ '\n'
        ).map { ... }
    }
)) ~> ...

那他是怎么实现的？是我太菜了吗？

// forP => forP_
def forP_[A](...)(body: Parsley[A] => Parsley[_]): Parsley[Unit] = {
    init.fillRef { ref =>
      lazy val _cond = ref.gets(cond)
      lazy val _step = ref.update(step)
      whenS(_cond, whileS(body(ref.get) *> _step *> _cond))
    }
}
// whenS
def whenS(condP: Parsley[Boolean], thenP: =>Parsley[Unit]): Parsley[Unit] = ifS(condP, thenP, unit)
// ifS
def ifS[A](condP: Parsley[Boolean], thenP: =>Parsley[A], elseP: =>Parsley[A]): Parsley[A] = {
    new Parsley(new frontend.If(condP.internal, thenP.internal, elseP.internal))
}

所以是直接注入了个内部指令，作弊了 😃

这章有点短啊。

感想

我写这篇博客的目的不是为了和上一篇一样教你做XXX，有可能这forP其实是可以直接内置组合子组合出来的，这篇的结论也有点简单：直接用另一个API。

我觉得Parsley的类型系统防止我糊逻辑是很有意思的。我们都知道理论上类型=>限制=>发现bug=>好，但是这件事是给我上了一课（希望也给你上了一课）好的API设计是如何引导你的。

如果我的问题没解决我就不会这么说了

下次再见！