如何有效地使用Alex的启动代码功能？

Question

我开始学习亚历克斯并相信我已经达到了有状态的环境会有所帮助,但我不完全确定如何去做.我试图lex有限的erlang二进制子集.使用以下词法分析器:

{
module Main (main, Token(..), AlexPosn(..), alexScanTokens, token_posn) where
}

%wrapper "posn"

$digit = 0-9      -- digits                                                                            
$alpha = [a-zA-Z] -- alphabetic characters                                                             
$dbl_quote = \"

tokens :-

  $white+                        ;
  ","                            { tok (\p s -> Comma p) }
  "<<"                           { tok (\p s -> BinaryOpen p) }
  ">>"                           { tok (\p s -> BinaryClose p) }
  $dbl_quote [^$dbl_quote]* $dbl_quote { tok (\p s -> ErlStr p (init (tail s))) }
  $digit+                        { tok (\p s -> ErlInt p (read s)) }

{
-- action helpers:                                                                                     
tok :: (AlexPosn -> String -> Token) -> AlexPosn -> String -> Token
tok f p s = f p s

data Token =
  Comma       AlexPosn |
  BinaryOpen  AlexPosn |
  BinaryClose AlexPosn |
  ErlInt   AlexPosn Integer |
  ErlStr   AlexPosn String
  deriving (Eq, Show)

token_posn :: Token -> AlexPosn
token_posn (Comma    p) = p
token_posn (BinaryOpen  p) = p
token_posn (BinaryClose p) = p
token_posn (ErlInt   p _) = p
token_posn (ErlStr   p _) = p

main :: IO ()
main = do
  s <- getContents
  print (alexScanTokens s)
}

我做得很好.例如,

> alex so_erlang_lexer.x  && ghc --make -o erlexer so_erlang_lexer.hs && echo '<<"100", 1>>' | ./erlexer 
[1 of 1] Compiling Main             ( so_erlang_lexer.hs, so_erlang_lexer.o )
Linking erlexer ...
[BinaryOpen (AlexPn 0 1 1),ErlStr (AlexPn 2 1 3) "100",Comma (AlexPn 7 1 8),ErlInt (AlexPn 9 1 10) 1,BinaryClose (AlexPn 10 1 11)]

我宁愿让lexed返回相当于Binary [ErlStr "100", ErlInt 1],但我找不到一个词法分析器,它使用了点击我脑袋的开始代码.

• 这里引用的 GHC词法分析器不使用任何Alex包装器.
• 亚历克斯的自己对其单子和monadUserState包装文档在这里留下我不确定我应该选择哪个,我怎么可能会使用两种.
• 亚历克斯的老虎榜样是最有希望的,但它太大了,我无法消除我的无知.
• 这个问题使用monad解析器,但似乎没有使用它的状态特征.

有人会如此善良地指导我一点吗？

Answer 1

我不太确定你想用词法分析器做什么，并且知识足够指导你（但如果你需要的只是过滤无用的标记，那么 alex 的单子接口似乎有点矫枉过正），无论如何，这里有一个用于累积的示例AlexUserState代码使用“monadUserState”包装器选择的令牌。

{
module Main (main) where
}

%wrapper "monadUserState"

$digit = 0-9      -- digits                                                                            
$alpha = [a-zA-Z] -- alphabetic characters                                                             
$dbl_quote = \"

tokens :-

  $white+                              ;
  ","                                  { ignoreToken  }
  ">"                                 { ignoreToken }
  $dbl_quote [^$dbl_quote]* $dbl_quote { pushToken  $ ErlStr . init . tail  }
  $digit+                              { pushToken  $ ErlInt . read }

{

alexEOF :: Alex ()
alexEOF = return ()

-- some useful interaces to the Alex monad (which is naturally an instance of state monad)
modifyUserState :: (AlexUserState -> AlexUserState) -> Alex ()
modifyUserState f = Alex (\s -> let st = alex_ust s in Right (s {alex_ust = f st},()))

getUserState ::  Alex AlexUserState
getUserState = Alex (\s -> Right (s,alex_ust s))

-- Token definition minus position information for simplicity
data Token =
  Comma        |
  BinaryOpen   |
  BinaryClose  |
  ErlInt    Integer |
  ErlStr    String
  deriving (Eq, Show)

newtype AlexUserState = Binary [Token]
  deriving (Eq, Show)

alexInitUserState :: AlexUserState
alexInitUserState = Binary []


-- action helpers:                                                                                     
pushToken :: (String -> Token) -> AlexAction ()
pushToken tokenizer = 
  \(posn,prevChar,pending,s) len -> modifyUserState (push $ take len s) >> alexMonadScan
    where
       -- Here tokens are accumulated in reverse order for efficiency.
       -- You need a more powerful data structure like Data.Sequence to preserve the order.
       push :: String -> AlexUserState -> AlexUserState
       push s (Binary ts) = Binary (tokenizer s : ts) 

ignoreToken :: AlexAction ()
ignoreToken _ _   = alexMonadScan


runAlexScan :: String -> Either String AlexUserState
runAlexScan s = runAlex s $ alexMonadScan >> getUserState


main :: IO ()
main = getContents >>= print . runAlexScan

}

但我想主要的问题是你似乎还没有足够熟悉 Haskell 中 monad 的概念和用法。Alex 的单子接口实际上非常自然，并且是状态单子的典型，一旦您有了一些编码经验，您只需浏览生成的代码就可以轻松猜到。（如果您猜错了，类型检查器很可能会发现相关错误。）

为此，由于这里似乎有很多关于 monad 的好问题和答案，我只参考Real World Haskell（其中关于分析的章节对我特别有帮助。）

但是，如果您碰巧已经对范畴论有所了解，那么学习单子的最快方法可能是直接深入研究一些相关论文（请记住，范畴论中的单子是动作的概括，就像群的动作一样，自然适合编程环境。）为此，请参阅 有关 monad 和 arrow 的论文列表，其中包括针对具有一定技术背景的人员的介绍性论文和教程。

顺便说一句，我刚刚开始学习 Erlang。您能指导一下吗？静态类型的缺乏没有让你感到困扰吗？您是否尝试过 cloud-haskell 并将其与 Erlang 进行比较？在分布式编程环境中，您觉得哪种语言最有生产力？