Haskell 字节串：如何模式匹配？

Question

我是 Haskell 新手，在弄清楚如何模式匹配 ByteString 时遇到了一些麻烦。我的函数的 [Char] 版本如下所示：

dropAB :: String -> String
dropAB []       = []
dropAB (x:[])   = x:[]
dropAB (x:y:xs) = if x=='a' && y=='b'
                  then dropAB xs
                  else x:(dropAB $ y:xs) 

正如预期的那样，这会从字符串中过滤掉所有出现的“ab”。但是，我在尝试将其应用于 ByteString 时遇到问题。

天真的版本

dropR :: BS.ByteString -> BS.ByteString
dropR []         = []
dropR (x:[])     = [x]
<...>

产生

Couldn't match expected type `BS.ByteString'
       against inferred type `[a]'
In the pattern: []
In the definition of `dropR': dropR [] = []

[] 显然是罪魁祸首，因为它是针对常规 String 而不是 ByteString。在 BS.empty 中进行替换似乎是正确的事情，但给出了“绑定位置的限定名称：BS.empty”。让我们尝试一下，

dropR :: BS.ByteString -> BS.ByteString
dropR empty              = empty        
dropR (x cons empty)     = x cons empty
<...>

这会导致 (x cons empty) 出现“模式解析错误”。我真的不知道我还能在这里做什么。

附带说明一下，我尝试使用此函数执行的操作是从某些文本中过滤掉特定的 UTF16 字符。如果有一种干净的方法来实现这一点，我很想听听，但这种模式匹配错误似乎是新手 Haskeller 应该真正理解的东西。

Answer 1

您可以使用 查看模式 来实现此类操作

{-# LANGUAGE ViewPatterns #-}    
import Data.ByteString (ByteString, cons, uncons, singleton, empty)
import Data.ByteString.Internal (c2w) 

dropR :: ByteString -> ByteString
dropR (uncons -> Nothing) = empty
dropR (uncons -> Just (x,uncons -> Nothing)) = singleton x
dropR (uncons -> Just (x,uncons -> Just(y,xs))) =
    if x == c2w 'a' && y == c2w 'b'
    then dropR xs
    else cons x (dropR $ cons y xs)

Answer 2

最新版本的 GHC (7.8) 有一个称为模式同义词的功能，可以将其添加到 gawi 的示例中：

{-# LANGUAGE ViewPatterns, PatternSynonyms #-}

import Data.ByteString (ByteString, cons, uncons, singleton, empty)
import Data.ByteString.Internal (c2w)

infixr 5 :<

pattern b :< bs <- (uncons -> Just (b, bs))
pattern Empty   <- (uncons -> Nothing)

dropR :: ByteString -> ByteString
dropR Empty          = empty
dropR (x :< Empty)   = singleton x
dropR (x :< y :< xs)
  | x == c2w 'a' && y == c2w 'b' = dropR xs
  | otherwise                    = cons x (dropR (cons y xs))

进一步，您可以将其抽象为在任何类型类上工作（当/如果我们得到 关联模式同义词）。模式定义保持不变：

{-# LANGUAGE ViewPatterns, PatternSynonyms, TypeFamilies #-}

import qualified Data.ByteString as BS
import Data.ByteString (ByteString, singleton)
import Data.ByteString.Internal (c2w)
import Data.Word

class ListLike l where
  type Elem l

  empty  :: l
  uncons :: l -> Maybe (Elem l, l)
  cons   :: Elem l -> l -> l

instance ListLike ByteString where
  type Elem ByteString = Word8

  empty  = BS.empty
  uncons = BS.uncons
  cons   = BS.cons

instance ListLike [a] where
  type Elem [a] = a

  empty         = []
  uncons []     = Nothing
  uncons (x:xs) = Just (x, xs)
  cons          = (:)

在这种情况下，dropR 可以在 [Word8] 和 ByteString 上工作：

-- dropR :: [Word8]    -> [Word8]
-- dropR :: ByteString -> ByteString
dropR :: (ListLike l, Elem l ~ Word8) => l -> l
dropR Empty          = empty
dropR (x :< Empty)   = cons x empty
dropR (x :< y :< xs)
  | x == c2w 'a' && y == c2w 'b' = dropR xs
  | otherwise                    = cons x (dropR (cons y xs))

而且最重要的是：

import Data.ByteString.Internal (w2c)

infixr 5 :•    
pattern b :• bs <- (w2c -> b) :< bs

dropR :: (ListLike l, Elem l ~ Word8) => l -> l
dropR Empty              = empty
dropR (x   :< Empty)     = cons x empty
dropR ('a' :• 'b' :• xs) = dropR xs
dropR (x   :< y   :< xs) = cons x (dropR (cons y xs))

您可以在我关于模式同义词的帖子中查看更多信息。

Answer 3

模式使用数据构造函数。 http://book.realworldhaskell.org/read/defining-types-streamlined -functions.html

你的empty只是第一个参数的绑定，它可能是x并且它不会改变任何东西。

您无法在模式中引用普通函数，因此 (x cons empty) 不合法。注意：我猜 (cons xempty) 确实是您的意思，但这也是非法的。

ByteString 与String 有很大不同。 String 是 [Char] 的别名，因此它是一个真实的列表，并且 : 运算符可以在模式中使用。

ByteString 是 Data.ByteString.Internal.PS !(GHC.ForeignPtr.ForeignPtr GHC.Word.Word8) !Int !Int （即指向本机 char* + 偏移量 + 长度的指针）。由于 ByteString 的数据构造函数是隐藏的，因此您必须使用函数而不是模式来访问数据。

---

这是使用 text 包解决 UTF-16 过滤器问题的解决方案（当然不是最好的解决方案）：

module Test where

import Data.ByteString as BS
import Data.Text as T
import Data.Text.IO as TIO
import Data.Text.Encoding

removeAll :: Char -> Text -> Text
removeAll c t =  T.filter (/= c) t

main = do
  bytes <- BS.readFile "test.txt"
  TIO.putStr $ removeAll 'c' (decodeUtf16LE bytes)

Answer 4

为此，我将对 uncons :: ByteString -> 的结果进行模式匹配。也许（Word8，ByteString）。

Haskell 中的模式匹配仅适用于使用“data”或“newtype”声明的构造函数。 ByteString 类型不会导出其无法进行模式匹配的构造函数。

Answer 5

只是为了解决您收到的错误消息及其含义：

Couldn't match expected type `BS.ByteString'
       against inferred type `[a]'
In the pattern: []
In the definition of `dropR': dropR [] = []

因此编译器期望您的函数类型为：BS.ByteString -> BS.ByteString 因为您在签名中指定了该类型。然而它推断（通过查看函数的主体）该函数实际上是 [a] -> 类型。 [a]。那里存在不匹配，因此编译器会抱怨。

问题是您将 (:) 和 [] 视为语法糖，而实际上它们只是列表类型的构造函数（与 ByteString 非常不同）。