Haskell Bytestrings: Как сопоставить шаблон?

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. Subbing в BS.empty кажется правильным, но дает «Квалифицированное имя в позиции привязки: BS.empty». Оставляя нас, чтобы попробовать

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

это дает "ошибку разбора в шаблоне" для (x cons empty). Я действительно не знаю, что еще я могу сделать здесь.

В качестве дополнительного примечания я пытаюсь отфильтровать определенный символ UTF16 из некоторого текста. Если есть чистый способ сделать это, я хотел бы услышать это, но эта ошибка сопоставления с образцом кажется чем-то, что новичок должен действительно понимать.

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-streamlining-functions.html

Ваш empty является просто привязкой к первому параметру, он мог бы быть x и ничего не изменит.

Вы не можете ссылаться на обычную функцию в вашем шаблоне, поэтому (x cons empty) недопустимо. Примечание: я думаю, (cons x empty) действительно то, что вы имели в виду, но это также незаконно.

ByteString сильно отличается от String. String - это псевдоним [Char], так что это реальный список, и оператор : можно использовать в шаблонах.

ByteString равен Data.ByteString.Internal.PS !(GHC.ForeignPtr.ForeignPtr GHC.Word.Word8) !Int !Int (то есть указатель на собственный символ * + смещение + длина). Поскольку конструктор данных ByteString скрыт, для доступа к данным необходимо использовать функции, а не шаблоны.

---

Вот решение (конечно, не лучшее) вашей проблемы с фильтром UTF-16 с использованием пакета text:

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 -> Maybe (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].Там есть несоответствие, поэтому компилятор жалуется.

Проблема в том, что вы думаете о (:) и [] как о синтаксическом сахаре, когда они на самом деле просто конструкторы для типа списка (который ОЧЕНЬ отличается отбайтовой строки).