2

我开始学习 Haskell 并希望为 execrsice 解析 PPM 图像。PPM 格式的结构相当简单，但也很棘手。它在这里描述。首先，我为 PPM Image 定义了一个类型：

data Pixel = Pixel { red :: Int, green :: Int, blue :: Int} deriving(Show)
data BitmapFormat = TextualBitmap | BinaryBitmap deriving(Show)
data Header = Header { format :: BitmapFormat
                     , width :: Int
                     , height :: Int
                     , colorDepth :: Int} deriving(Show)
data PPM = PPM { header :: Header
               , bitmap :: [Pixel]
               }

bitmap应该包含整个图像。这是第一个挑战出现的地方 - 在 PPM 中包含实际图像数据的部分可以是文本或二进制（在标题中描述）。对于文本位图，我编写了以下函数：

parseTextualBitmap :: String -> [Pixel]
parseTextualBitmap = map textualPixel . chunksOf 3 . wordsBy isSpace
                     where textualPixel (r:g:b:[]) = Pixel (read r) (read g) (read b)

不过，我不确定如何处理二进制位图。Usingread将数字的字符串表示形式转换为数字。我想将“\x01”转换为 Int 类型的 1。

第二个挑战是解析标题。我写了以下函数：

parseHeader :: String -> Header
parseHeader = constructHeader . wordsBy isSpace . filterComments
              where
                filterComments = unlines . map (takeWhile (/= '#')) . lines
                formatFromText s
                  | s == "P6" = BinaryBitmap
                  | s == "P3" = TextualBitmap
                constructHeader (format:width:height:colorDepth:_) =
                  Header (formatFromText format) (read width) (read height) (read colorDepth)

效果很好。现在我应该编写模块导出函数（我们称之为parsePPM），它获取整个文件内容（String）然后返回PPM。该函数应该调用parseHeader，确定位图格式，调用适当的parse(Textual|Binary)Bitmap，然后用结果构造一个 PPM。一旦 parseHeader 返回，我应该从 parseHeader 停止的点开始解码位图。但是，我不知道字符串 parseHeader 停止的点。我能想到的唯一解决方案是，当元组的第二个元素是由constructHeader（当前命名为_）检索到的余数时Header，parseHeader 将返回，而不是返回。(Header,String)但我不确定这是做事的“Haskell方式”。

总结一下我的问题： 1.如何将二进制格式解码成一个列表Pixel 2.我怎么知道标头在哪一点结束

因为我自己学习 Haskell，所以没有人真正审查我的代码，所以除了回答我的问题之外，我还会对我的编码方式（编码风格、错误、做事的替代方式等）提出任何评论。 .)。

4

1 回答 1

3

让我们从问题 2 开始，因为它更容易回答。您的方法是正确的：当您解析内容时，您从输入字符串中删除这些字符，并返回一个包含解析结果和剩余字符串的元组。但是，没有理由从头开始编写所有这些内容（可能作为学术练习除外） - 有很多解析器会为您解决这个问题。我将使用的是Parsec. 如果您不熟悉 monadic 解析，您应该首先阅读RWH中的部分Parsec。

至于问题 1，如果你使用ByteString而不是String，那么解析单个字节很容易，因为单个字节是ByteStrings 的原子元素！

还有Char/ByteString接口的问题。使用Parsec，这不是问题，因为您可以将 aByteString视为Byte或的序列Char- 我们稍后会看到。

我决定只编写完整的解析器 - 这是一种非常简单的语言，因此在Parsec库中为您定义了所有原语，它非常简单且非常简洁。

文件头：

import Text.Parsec.Combinator
import Text.Parsec.Char
import Text.Parsec.ByteString
import Text.Parsec 
import Text.Parsec.Pos

import Data.ByteString (ByteString, pack)
import qualified Data.ByteString.Char8 as C8

import Control.Monad (replicateM)
import Data.Monoid

首先，我们编写“原始”解析器——即解析字节、解析文本数字和解析空格（PPM 格式用作分隔符）：

parseIntegral :: (Read a, Integral a) => Parser a
parseIntegral = fmap read (many1 digit)

digit解析单个数字 - 您会注意到许多函数名称解释了解析器的作用 -many1并将应用给定的解析器 1 次或更多次。然后我们读取结果字符串以返回一个实际数字（而不是字符串）。在这种情况下，输入ByteString被视为文本。

parseByte :: Integral a => Parser a
parseByte = fmap (fromIntegral . fromEnum) $ tokenPrim show (\pos tok _ -> updatePosChar pos tok) Just

对于这个解析器，我们解析一个Char- 它实际上只是一个字节。它只是作为Char. 我们可以安全地创建返回类型Parser Word8，因为可以返回的值的范围是[0..255]

whitespace1 :: Parser ()
whitespace1 = many1 (oneOf "\n ") >> return ()

oneOf获取Char并按给定顺序解析任何一个字符的列表 - 再次ByteString被视为Text.

现在我们可以编写头部的解析器了。

parseHeader :: Parser Header 
parseHeader = do
  f <- choice $ map try $ 
         [string "P3" >> return TextualBitmap
         ,string "P6" >> return BinaryBitmap]
  w <- whitespace1 >> parseIntegral
  h <- whitespace1 >> parseIntegral
  d <- whitespace1 >> parseIntegral
  return $ Header f w h d

一些笔记。choice获取解析器列表并按顺序尝试它们。try p获取解析器 p，并在p开始解析之前“记住”状态。如果 p 成功，则try p == p. 如果 p 失败，则恢复 p 开始之前的状态，并且您假装从未尝试过p。由于choice行为方式，这是必要的。

对于像素，我们目前有两种选择：

parseTextual :: Header -> Parser [Pixel]
parseTextual h = do
  xs <- replicateM (3 * width h * height h) (whitespace1 >> parseIntegral)
  return $ map (\[a,b,c] -> Pixel a b c) $ chunksOf 3 xs

我们可以使用many1 (whitespace 1 >> parseIntegral)- 但这不会强制执行我们知道长度应该是多少的事实。然后，将数字列表转换为像素列表是微不足道的。

对于二进制数据：

parseBinary :: Header -> Parser [Pixel]
parseBinary h = do
  whitespace1
  xs <- replicateM (3 * width h * height h) parseByte
  return $ map (\[a,b,c] -> Pixel a b c) $ chunksOf 3 xs

请注意两者几乎相同。您可能可以概括此功能（如果您决定解析其他类型的像素数据 - 单色和灰度，这将特别有用）。

现在把它们放在一起：

parsePPM :: Parser PPM
parsePPM = do
  h <- parseHeader
  fmap (PPM h) $ 
       case format h of
         TextualBitmap -> parseTextual h
         BinaryBitmap  -> parseBinary  h

这应该是不言自明的。解析头部，然后根据格式解析正文。这里有一些例子可以试一试。它们是规范页面中的那些。

example0 :: ByteString
example0 = C8.pack $ unlines 
  ["P3"
  , "4 4"
  , "15"
  , " 0  0  0    0  0  0    0  0  0   15  0 15"
  , " 0  0  0    0 15  7    0  0  0    0  0  0"
  , " 0  0  0    0  0  0    0 15  7    0  0  0"
  , "15  0 15    0  0  0    0  0  0    0  0  0" ]

example1 :: ByteString
example1 = C8.pack ("P6 4 4 15 ") <> 
  pack [0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 15, 0, 0, 0, 0, 15, 7, 
        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 7, 0, 0, 0, 15,
        0, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]

几个注意事项：这不处理注释，这是规范的一部分。错误消息不是很有用；您可以使用该<?>功能创建自己的错误消息。规范还指出“行不应超过 70 个字符。” - 这也没有强制执行。

编辑：

仅仅因为您看到 do-notation，并不一定意味着您正在使用不纯的代码。一些单子（比如这个解析器）仍然是纯粹的——它们只是为了方便而使用。例如，您可以使用 type 编写解析器parser :: String -> (a, String)，或者，我们在这里所做的是使用新类型：data Parser a = Parser (String -> (a, String))并且 have parser :: Parser a; 然后我们编写一个 monad 实例Parser来获得有用的 do-notation。需要明确的是，Parsec它支持单子解析，但我们的解析器不是单子 - 或者更确切地说，使用Identity单子，这只是newtype Identity a = Identity { runIdentity :: a }，而且只是必要的，因为如果我们使用type Identity a = a，我们会到处都有“重叠实例”错误，这不好。

>:i Parser
type Parser = Parsec ByteString ()
        -- Defined in `Text.Parsec.ByteString'
>:i Parsec
type Parsec s u = ParsecT s u Data.Functor.Identity.Identity
        -- Defined in `Text.Parsec.Prim'

那么，类型Parser是真的ParsecT ByteString () Identity。也就是说，解析器输入是ByteString，用户状态是()- 这只是意味着我们没有使用用户状态，而我们正在解析的 monad 是Identity。ParsecT本身只是一种新类型：

forall b.
    State s u
    -> (a -> State s u -> ParseError -> m b)
    -> (ParseError -> m b)
    -> (a -> State s u -> ParseError -> m b)
    -> (ParseError -> m b)
    -> m b

中间的所有这些函数都只是用来漂亮地打印错误。如果您正在解析 10 的数千个字符并发生错误，您将无法仅查看它并查看发生的位置 - 但Parsec会告诉您行和列。如果我们将所有类型专门化为我们的Parser，并假装它Identity是 just type Identity a = a，那么所有的单子都消失了，你可以看到解析器不是不纯的。正如你所看到的，Parsec它比这个问题所需的要强大得多——我只是因为熟悉而使用它，但如果你愿意编写自己的原始函数，比如manyand digit，那么你可以不用使用newtype Parser a = Parser (ByteString -> (a, ByteString)).

于 2013-12-28T16:50:01.593 回答