Lazify状态机

Question

我是Haskell的初学者，我正在尝试写一台懒惰的Lexer状态机。

我有这个代码，确定不是懒惰的代码。因此，我应该用什么样的库或模式来懒惰的此代码？

module Main where

import           Control.Monad.State.Lazy
import           Data.Sequence (Seq (..))
import qualified Data.Sequence as Seq

data Suppe = A | B Integer

data StateBase = StateBase String (Seq Suppe)

newtype StateFn = StateFn (StateBase -> (Maybe StateFn, StateBase))

type StateMachine = (Maybe StateFn, StateBase)

next :: StateMachine -> StateMachine
next (Just (StateFn f), x) = f x
next (Nothing, x) = (Nothing, x)

run :: String -> Seq Lexeme
run input = evalState go (Just startStateFn, startState) 
  where
    startState = StateBase input Seq.empty
    startStateFn = FnA

    go :: State StateMachine (Seq Lexeme)
    go = get >>= \stateMachine -> let newStateMachine = next stateMachine
      in
      case fst newStateMachine of
        (Just _) -> put newStateMachine >> go
        Nothing -> return $ getSeq $ snd newStateMachine
    getSeq :: StateBase -> Seq Suppe
    getSeq (StateBase _ seq) = seq

fnA :: StateFn
fnA = undefined

fnB :: StateFn
fnB = undefined

main = undefined

我正在使用容器 ^＆gt; = 0.6.0.1，mtl ^＆gt; = 2.2

Answer 1

对我来说，看来您周围有太多的机器，这只是使事情混乱，使它难以看到懒惰在哪里丢失。您是否尝试过仅使用Direct Style编程？这样的事情：

import Data.Char

data Lexeme = A | B Integer

stateAOrB :: String -> [Lexeme]
stateAOrB ('A':rest) = stateA rest
stateAOrB ('B':rest) = stateB 0 rest
stateAOrB (_:rest) = error "lex error" -- or, could return [Maybe Lexeme] or [Either PositionInformation Lexeme] or whatever
stateAOrB [] = []

stateA :: String -> [Lexeme]
stateA cs = A : stateAOrB cs

stateB :: Integer -> String -> [Lexeme]
stateB n (c:cs) | isDigit c = stateB (10*n + toInteger (digitToInt c)) cs
stateB n other = B n : stateAOrB other

我猜想这比fna和fnb在您的设置中的实现要短（或仅可忽略的），同时清晰且非常明显地懒惰。