调试 Haskell 应用程序

Question

学习了一些基础知识后，我想尝试 Haskell 中的“现实世界应用程序”，从 Bittorrent 客户端开始。遵循此blog post的解释，我没有使用 Attoparsec parser combinator图书馆。相反，请遵循 Huttons book ，我开始编写解析器组合器。这是我到目前为止的代码(仍处于解析阶段，还有很长的路要走):

module Main where

import System.Environment (getArgs)
import qualified Data.Map as Map
import Control.Monad (liftM, ap)
import Data.Char (isDigit, isAlpha, isAlphaNum, ord)
import Data.List(foldl')

main :: IO ()
main = do
    [fileName] <- getArgs
    contents <- readFile fileName
    download . parse $ contents

parse :: String -> Maybe BenValue
parse s = case runParser value s of
    []       -> Nothing
    [(p, _)] -> Just p

download :: Maybe BenValue -> IO ()
download (Just p) = print p
download _        = print "Oh!! Man!!"

data BenValue = BenString String
    | BenNumber Integer
    | BenList [BenValue]
    | BenDict (Map.Map String BenValue)
    deriving(Show, Eq)

-- From Hutton, this follows: a Parser is a function 
-- that takes a string and returns a list of results
-- each containing a pair : a result of type a and 
-- an output string. (the string is the unconsumed part of the input).
newtype Parser a = Parser (String -> [(a, String)])

-- Unit takes a value and returns a Parser (a function)
unit :: a -> Parser a
unit v = Parser (\inp -> [(v, inp)])

failure :: Parser a
failure = Parser (\inp -> [])

one :: Parser Char
one = Parser $ \inp -> case inp of
        []      -> []
        (x: xs) -> [(x, xs)]

runParser :: Parser a -> String -> [(a, String)]
runParser (Parser p) inp = p inp

bind :: Parser a -> (a -> Parser b) -> Parser b
bind (Parser p) f = Parser $ \inp -> case p inp of
    []         -> []
    [(v, out)] -> runParser (f v) out

instance Monad Parser where
    return  = unit
    p >>= f = bind p f

instance Applicative Parser where
    pure  = unit
    (<*>) = ap

instance Functor Parser where
    fmap = liftM

choice :: Parser a -> Parser a -> Parser a
choice p q = Parser $ \inp -> case runParser p inp of
    [] -> runParser q inp
    x  -> x

satisfies :: (Char -> Bool) -> Parser Char
satisfies p = do
    x <- one
    if p x 
    then unit x
    else failure

digit :: Parser Char
digit = satisfies isDigit

letter :: Parser Char
letter = satisfies isAlpha

alphanum :: Parser Char
alphanum = satisfies isAlphaNum

char :: Char -> Parser Char
char x = satisfies (== x)

many :: Parser a -> Parser [a]
many p = choice (many1 p) (unit [])

many1 :: Parser a -> Parser [a]
many1 p = do
    v <- p
    vs <- many p
    unit (v:vs)

peek :: Parser Char
peek = Parser $ \inp -> case inp of
    []       -> []
    v@(x:xs) -> [(x, v)]    

taken :: Int -> Parser [Char]
taken n = do
    if n > 0
    then do
        v <- one
        vs <- taken (n-1)
        unit (v:vs)
    else unit []

takeWhile1 :: (Char -> Bool) -> Parser [Char]
takeWhile1 pred = do
    v <- peek
    if pred v
    then do
        one
        vs <- takeWhile1 pred
        unit (v:vs)
    else unit []

decimal :: Integral a => Parser a
decimal = foldl' step 0 `fmap` takeWhile1 isDigit
    where step a c = a * 10 + fromIntegral (ord c - 48)

string :: Parser BenValue
string = do
    n <- decimal
    char ':'
    BenString <$> taken n

signed :: Num a => Parser a -> Parser a
signed p = (negate <$> (char '-' *> p) )
    `choice` (char '+' *> p)
    `choice` p

number :: Parser BenValue
number = BenNumber <$> (char 'i' *> (signed decimal) <* char 'e')

list :: Parser BenValue
list = BenList <$> (char 'l' *> (many value) <* char 'e')

dict :: Parser BenValue
dict = do
    char 'd'
    pair <- many ((,) <$> string <*> value)
    char 'e'
    let pair' = (\(BenString s, v) -> (s,v)) <$> pair
    let map' = Map.fromList pair'
    unit $ BenDict map'

value = string `choice` number `choice` list `choice` dict

以上是从三个来源的源码中读取/理解的代码混合the blog , the library ，和the book 。 download 函数只是打印从解析器获得的“解析树”，一旦解析器工作，将填充 download 函数并对其进行测试。

1. 解析器无法处理少数 torrent 文件。 :( 我绝对有可能错误地使用了引用文献中的代码。并且想知道是否有任何明显的事情。
2. 它适用于“玩具”示例，也适用于从 combinatorrent 中选取的测试文件。
3. 当我选择像 Debian/Ubuntu 等现实世界的 torrent 时，就会失败。
4. 我想调试并看看发生了什么，使用 GHCI 调试似乎并不直接，我尝试过中提到的 :trace/:history 风格调试这个document ，但看起来很原始:-)。
5. 我向专家提出的问题是:“如何调试!!” :-)
6. 非常感谢有关如何调试此问题的任何提示。

谢谢。

Answer 1

因为 Haskell 代码是纯粹的，所以“单步执行”它不像其他语言那么重要。当我单步执行一些 Java 代码时，我经常试图查看某个变量在哪里发生了变化。鉴于事物是不可变的，这显然在 Haskell 中不是问题。

这意味着我们还可以在 GHCi 中运行代码片段来调试正在发生的情况，而不必担心我们运行的代码会改变某些全局状态，或者我们运行的代码的工作方式与在我们的内部调用时的工作方式有任何不同。程序。这种工作模式受益于慢慢地迭代您的设计，将其构建为能够处理所有预期输入。

解析总是有点不愉快——即使在命令式语言中也是如此。没有人愿意运行解析器只是为了返回 Nothing - 你想知道为什么你什么也没得到。为此，大多数解析器库都有助于为您提供一些有关问题所在的信息。这就是使用像 attoparsec 这样的解析器的要点。 。另外，attoparsec与 ByteString 一起工作默认情况下 - 非常适合二进制数据。如果您想推出自己的解析器实现，则还必须对其进行调试。

最后，根据您的评论，您似乎遇到了字符编码问题。这正是我们拥有 ByteString 的原因- 它表示压缩的字节序列 - 无编码。分机 OverloadedStrings 甚至使它变得非常容易制作ByteString看起来就像常规字符串的文字。