Haskell Bytestrings: Как сопоставить шаблон?
Я новичок в 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 из некоторого текста. Если есть чистый способ сделать это, я хотел бы услышать это, но эта ошибка сопоставления с образцом кажется чем-то, что новичок должен по-настоящему понять.
5 ответов
Вы можете использовать шаблоны просмотра для таких вещей
{-# 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)
В последней версии 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))
Вы можете увидеть больше на моем посте по шаблону синонимов.
Шаблоны используют конструкторы данных. 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)
Для этого я бы сопоставил образец с результатом uncons :: ByteString -> Maybe (Word8, ByteString),
Сопоставление с образцом в Haskell работает только для конструкторов, объявленных с "data" или "newtype". Тип ByteString не экспортирует свои конструкторы, которые вы не можете сопоставить с шаблоном.
Просто обратитесь к сообщению об ошибке, которое вы получили, и что это значит:
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).