Data.Tickle.Get

Get data type

data Get e a

Instances

Bifunctor Get

Map on the error and result of a Get decoder.

>>> runGet (bimap (const True) (\x -> x + x) word8) (BLC.pack "")
RunGetFail 0 True

>>> runGet (bimap (const True) (\x -> x + x) word8) (BLC.pack "abc")
RunGet 194

Monad (Get e)

Sequence an action through the Get decoder.

>>> runGet (return 7 :: Get () Int) (BLC.pack "abc")
RunGet 7

runGet (return x :: Get () Int) (BLC.pack "abc") == _RunGet # x

>>> runGet (word8 >>= \c1 -> word8 >>= \c2 -> return (c1 + c2)) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (word8 >>= \c1 -> word8 >>= \c2 -> return (c1 + c2)) (BLC.pack "a")
RunGetFail 1 ()

>>> runGet (word8 >>= \c1 -> word8 >>= \c2 -> return (c1 + c2)) (BLC.pack "ab")
RunGet 195

>>> runGet (word8 >>= \c1 -> word8 >>= \c2 -> return (c1 + c2)) (BLC.pack "abc")
RunGet 195

Functor (Get e)

Map on the result of a Get decoder.

>>> runGet (fmap (\x -> x + x) word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (fmap (\x -> x + x) word8) (BLC.pack "abc")
RunGet 194

Applicative (Get e)

Apply a function on the Get decoder result.

>>> runGet (fmap (+) word8 <*> word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (fmap (+) word8 <*> word8) (BLC.pack "a")
RunGetFail 1 ()

>>> runGet (fmap (+) word8 <*> word8) (BLC.pack "ab")
RunGet 195

>>> runGet (fmap (+) word8 <*> word8) (BLC.pack "abc")
RunGet 195

>>> runGet (pure 7 :: Get () Int) (BLC.pack "abc")
RunGet 7

runGet (pure x :: Get () Int) (BLC.pack "abc") == _RunGet # x

Alt (Get e)

Pick between two Get decoders, finding the first to not fail.

>>> runGet ((+1) <$> word8 <!> subtract 1 <$> word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet ((+1) <$> word8 <!> subtract 1 <$> word8) (BLC.pack "abc")
RunGet 98

>>> runGet (word8 <!> failGet ()) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (word8 <!> failGet ()) (BLC.pack "abc")
RunGet 97

>>> runGet (Al.some word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (Al.some word8) (BLC.pack "a")
RunGet [97]

>>> runGet (Al.some word8) (BLC.pack "abc")
RunGet [97,98,99]

>>> runGet (Al.many word8) (BLC.pack "")
RunGet []

>>> runGet (Al.many word8) (BLC.pack "a")
RunGet [97]

>>> runGet (Al.many word8) (BLC.pack "abc")
RunGet [97,98,99]

Apply (Get e)

Apply a function on the Get decoder result.

>>> runGet (fmap (+) word8 <.> word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (fmap (+) word8 <.> word8) (BLC.pack "a")
RunGetFail 1 ()

>>> runGet (fmap (+) word8 <.> word8) (BLC.pack "ab")
RunGet 195

>>> runGet (fmap (+) word8 <.> word8) (BLC.pack "abc")
RunGet 195

Bind (Get e)

Sequence an action through the Get decoder.

>>> runGet (word8 >>- \c1 -> fmap (\c2 -> c1 + c2) word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (word8 >>- \c1 -> fmap (\c2 -> c1 + c2) word8) (BLC.pack "a")
RunGetFail 1 ()

>>> runGet (word8 >>- \c1 -> fmap (\c2 -> c1 + c2) word8) (BLC.pack "ab")
RunGet 195

>>> runGet (word8 >>- \c1 -> fmap (\c2 -> c1 + c2) word8) (BLC.pack "abc")
RunGet 195

Semigroup (Get e a)

Pick between two Get decoders, finding the first to not fail.

>>> runGet (((+1) <$> word8) <> (subtract 1 <$> word8)) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (((+1) <$> word8) <> (subtract 1 <$> word8)) (BLC.pack "abc")
RunGet 98

>>> runGet (word8 <> failGet ()) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (word8 <> failGet ()) (BLC.pack "abc")
RunGet 97

Primitive parsers

lazyByteString :: Int64 -> Get () ByteString

>>> runGet (lazyByteString 5) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (lazyByteString 5) (BLC.pack "abc")
RunGetFail 3 ()

>>> runGet (lazyByteString 5) (BLC.pack "abcdefg")
RunGet "abcde"

lazyByteStringNul :: Get () ByteString

>>> runGet lazyByteStringNul (BLC.pack "")
RunGetFail 0 ()

>>> runGet lazyByteStringNul (BLC.pack "abc")
RunGetFail 3 ()

>>> runGet lazyByteStringNul (BLC.pack "abc\0")
RunGet "abc"

>>> runGet lazyByteStringNul (BLC.pack "abc\0def")
RunGet "abc"

remainingLazyByteString :: Get e ByteString

>>> runGet remainingLazyByteString  (BLC.pack "")
RunGet ""

>>> runGet remainingLazyByteString  (BLC.pack "abc")
RunGet "abc"

ptr :: Storable a => Int -> Get () a

word8 :: Get () Word8

>>> runGet word8 (BLC.pack "abc")
RunGet 97

>>> runGet word8 (BLC.pack "123")
RunGet 49

word16be :: Get () Word16

>>> runGet word16be (BLC.pack "abc")
RunGet 24930

>>> runGet word16be (BLC.pack "123")
RunGet 12594

word16le :: Get () Word16

>>> runGet word16le (BLC.pack "abc")
RunGet 25185

>>> runGet word16le (BLC.pack "123")
RunGet 12849

word32be :: Get () Word32

>>> runGet word32be (BLC.pack "abcdef")
RunGet 1633837924

>>> runGet word32be (BLC.pack "123456")
RunGet 825373492

word32le :: Get () Word32

• - >>> runGet word32le (BLC.pack "abcdef") RunGet 1684234849

>>> runGet word32le (BLC.pack "123456")
RunGet 875770417

word64be :: Get () Word64

>>> runGet word64be (BLC.pack "abcdefghi")
RunGet 7017280452245743464

>>> runGet word64be (BLC.pack "123456789")
RunGet 3544952156018063160

word64le :: Get () Word64

>>> runGet word64le (BLC.pack "abcdefghi")
RunGet 7523094288207667809

>>> runGet word64le (BLC.pack "123456789")
RunGet 4050765991979987505

wordhost :: Get () Word

>>> runGet wordhost (BLC.pack "abcdefghi")
RunGet 7523094288207667809

>>> runGet wordhost (BLC.pack "123456789")
RunGet 4050765991979987505

word16host :: Get () Word16

>>> runGet word16host (BLC.pack "abcde")
RunGet 25185

>>> runGet word16host (BLC.pack "12345")
RunGet 12849

word32host :: Get () Word32

>>> runGet word32host (BLC.pack "abcde")
RunGet 1684234849

>>> runGet word32host (BLC.pack "12345")
RunGet 875770417

word64host :: Get () Word64

>>> runGet word64host (BLC.pack "abcdeghi")
RunGet 7595434456733934177

>>> runGet word64host (BLC.pack "123456789")
RunGet 4050765991979987505

failGet :: e -> Get e a

A Get decoder that always fails with the given value.

runGet (failGet x :: Get Int ()) (BLC.pack s) == _RunGetFail # (0, x)

>>> runGet (failGet "abc" :: Get String ()) (BLC.pack "def")
RunGetFail 0 "abc"

constant :: (forall r. XDecoder e r) -> Get e a

bytesRead :: Get e Int64

>>> runGet (bytesRead :: Get () Int64) (BLC.pack "")
RunGet 0

>>> runGet (bytesRead :: Get () Int64) (BLC.pack "abc")
RunGet 0

>>> runGet (word8 >> word16be >> word32le >> bytesRead) (BLC.pack "abcdefghijk")
RunGet 7

demandInput :: Get () ()

>>> runGet demandInput (BLC.pack "")
RunGetFail 0 ()

>>> runGet demandInput (BLC.pack "a")
RunGet ()

>>> runGet demandInput (BLC.pack "abc")
RunGet ()

skip :: Int -> Get () ()

>>> runGet (word8 >>= \c -> skip 2 >> word8 >>= \d -> return (c,d)) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (word8 >>= \c -> skip 2 >> word8 >>= \d -> return (c,d)) (BLC.pack "abcdefghi")
RunGet (97,100)

>>> runGet (word8 >>= \c -> skip 2 >> word8 >>= \d -> return (c,d)) (BLC.pack "abc")
RunGetFail 3 ()

isNotEmpty :: Get e Bool

>>> runGet isNotEmpty (BLC.pack "")
RunGet False

>>> runGet isNotEmpty (BLC.pack "abc")
RunGet True

>>> runGet (isNotEmpty >>= \p -> word8 >>= \w -> return (w, p)) (BLC.pack "abc")
RunGet (97,True)

>>> runGet (isNotEmpty >>= \p -> word8 >>= \w -> return (w, p)) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (isNotEmpty >>= \p -> word8 >>= \w -> return (w, p)) (BLC.pack "a")
RunGet (97,True)

isEmpty :: Get e Bool

>>> runGet isEmpty (BLC.pack "")
RunGet True

>>> runGet isEmpty (BLC.pack "abc")
RunGet False

>>> runGet (isEmpty >>= \p -> word8 >>= \w -> return (w, p)) (BLC.pack "abc")
RunGet (97,False)

>>> runGet (isEmpty >>= \p -> word8 >>= \w -> return (w, p)) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (isEmpty >>= \p -> word8 >>= \w -> return (w, p)) (BLC.pack "a")
RunGet (97,False)

getByteString :: Int -> Get () ByteString

>>> runGet (getByteString (-3)) (BLC.pack "")
RunGet ""

>>> runGet (getByteString 3) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (getByteString 3) (BLC.pack "abc")
RunGet "abc"

>>> runGet (getByteString 3) (BLC.pack "abcdef")
RunGet "abc"

modify :: (ByteString -> ByteString) -> Get e ()

readN :: Int -> (ByteString -> a) -> Get () a

>>> runGet (readN 3 id) (BLC.pack "abc")
RunGet "abc"

>>> runGet (readN 3 id) (BLC.pack "ab")
RunGetFail 0 ()

>>> runGet (readN 3 id) (BLC.pack "abcdef")
RunGet "abcdef"

>>> runGet (readN (-3) id) (BLC.pack "abcdef")
RunGet ""

ensureN :: Int -> Get () ()

>>> runGet (ensureN 3) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (ensureN 3) (BLC.pack "abc")
RunGet ()

>>> runGet (ensureN 3) (BLC.pack "abcdef")
RunGet ()

Higher-level parsers

IEEE754 parsers

toFloat :: (Storable w, Storable f) => w -> f

toFloat16 :: Word16 -> Float

float16be :: Get () Float

float16le :: Get () Float

float32be :: Get () Float

float32le :: Get () Float

float64be :: Get () Double

float64le :: Get () Double

Integer parsers

int8 :: Get () Int8

int16be :: Get () Int16

int16le :: Get () Int16

int32be :: Get () Int32

int32le :: Get () Int32

int64be :: Get () Int64

int64le :: Get () Int64

data IntegerError

Instances

Eq IntegerError

Ord IntegerError

Show IntegerError

integerError :: a -> (Word8 -> a) -> a -> (ListError -> a) -> IntegerError -> a

_IntegerTagUnexpectedEof :: Prism' IntegerError ()

_Integer0TagUnexpectedEof :: Prism' IntegerError Word8

_Integer1TagUnexpectedEof :: Prism' IntegerError ()

_IntegerListError :: Prism' IntegerError ListError

integer :: Get IntegerError Integer

List parsers

data ListError

Instances

Eq ListError

Ord ListError

Show ListError

listError :: a -> a -> ListError -> a

listErrorIso :: Iso' Bool ListError

list :: Get e a -> Get ListError [a]

many :: Get e a -> Int64 -> Get e [a]

Higher-level combinators

runAndKeepTrack :: Get e a -> Get x (CompletedXDecoder e a, [ByteString])

Run a Get decoder, but keep a track of the input that ran it to completion.

>>> runGet (runAndKeepTrack word8 :: Get () (CompletedXDecoder () Word8, [BC.ByteString])) (BLC.pack "")
RunGet (CompletedFail "" (),[])

>>> runGet (runAndKeepTrack word8 :: Get () (CompletedXDecoder () Word8, [BC.ByteString])) (BLC.pack "abc")
RunGet (CompletedDone "bc" 97,["abc"])

pushBack :: [ByteString] -> Get e ()

>>> runGet (pushBack [] :: Get () ()) (BLC.pack "")
RunGet ()

>>> runGet (pushBack [] :: Get () ()) (BLC.pack "abc")
RunGet ()

>>> runGet (pushBack [BC.pack "def"] :: Get () ()) (BLC.pack "")
RunGet ()

>>> runGet (pushBack [BC.pack "def"] :: Get () ()) (BLC.pack "abc")
RunGet ()

pushFront :: ByteString -> Get e ()

>>> runGet (pushFront (BC.pack "def") :: Get () ()) (BLC.pack "")
RunGet ()

>>> runGet (pushFront (BC.pack "def") :: Get () ()) (BLC.pack "abc")
RunGet ()

xrunGetIncremental :: Get e a -> XDecoder e a

noMeansNo :: XDecoder e a -> XDecoder e a

prompt :: ByteString -> XDecoder e a -> (ByteString -> XDecoder e a) -> XDecoder e a

isolate :: Int -> Get e a -> Get (IsolateError e) a

>>> runGet (isolate 1 word8) (BLC.pack "ab")
RunGet 97

>>> runGet (isolate 1 word8) (BLC.pack "abcde")
RunGet 97

>>> runGet (isolate 2 word16le) (BLC.pack "abcde")
RunGet 25185

>>> runGet (isolate 1 word16le) (BLC.pack "abcde")
RunGetFail 0 (IsolateXFail ())

>>> runGet (isolate (-3) word16le) (BLC.pack "abcde")
RunGetFail 0 NegativeSize

>>> runGet (isolate 3 word16le) (BLC.pack "abcde")
RunGetFail 2 (UnexpectedConsumed 2 3)

lookAhead :: Get e a -> Get e a

>>> runGet (lookAhead word8) (BLC.pack "")
RunGetFail 0 ()

>>> runGet (lookAhead word8) (BLC.pack "abc")
RunGet 97

>>> runGet (lookAhead word8) (BLC.pack "a")
RunGet 97

lookAheadM :: Get e (Maybe a) -> Get e (Maybe a)

>>> runGet (lookAheadM (word8 >>= \w -> return (if even w then Just (w + 5) else Nothing))) (BLC.pack "abc")
RunGet Nothing

>>> runGet (lookAheadM (word8 >>= \w -> return (if even w then Just (w + 5) else Nothing))) (BLC.pack "bc")
RunGet (Just 103)

>>> runGet (lookAheadM (word8 >>= \w -> return (if even w then Just (w + 5) else Nothing))) (BLC.pack "")
RunGetFail 0 ()

lookAheadE :: Get e (Either a b) -> Get e (Either a b)

>>> runGet (lookAheadE (word8 >>= \w -> return (if even w then Left (w + 5) else Right (w - 4)))) (BLC.pack "abc")
RunGet (Right 93)

>>> runGet (lookAheadE (word8 >>= \w -> return (if even w then Left (w + 5) else Right (w - 4)))) (BLC.pack "bc")
RunGet (Left 103)

>>> runGet (lookAheadE (word8 >>= \w -> return (if even w then Left (w + 5) else Right (w - 4)))) (BLC.pack "")
RunGetFail 0 ()

readNWith :: Int -> (Ptr a -> IO a) -> Get () a

calculateOffset :: XDecoder e a -> Decoder e a

pushChunk :: Decoder e a -> ByteString -> Decoder e a

pushChunks :: Decoder e a -> ByteString -> Decoder e a

pushEndOfInput :: Decoder e a -> Decoder e a

Error label

(!+) :: Semigroup e => e -> Get e a -> Get e a infixl 3

>>> runGet ([(), ()] !+ (setLabel [] word8)) (BLC.pack "")
RunGetFail 0 [(),()]

>>> runGet ([(), ()] !+ (setLabel [] word8)) (BLC.pack "abc")
RunGet 97

addLabel :: Semigroup e => e -> Get e a -> Get e a

>>> runGet ([(), ()] `addLabel` (setLabel [] word8)) (BLC.pack "")
RunGetFail 0 [(),()]

>>> runGet ([(), ()] `addLabel` (setLabel [] word8)) (BLC.pack "abc")
RunGet 97

(!-) :: e -> Get d a -> Get e a infixl 3

>>> runGet ("error" !- word8) (BLC.pack "")
RunGetFail 0 "error"

>>> runGet ("error" !- word8) (BLC.pack "abc")
RunGet 97

setLabel :: e -> Get d a -> Get e a

>>> runGet ("error" `setLabel` word8) (BLC.pack "")
RunGetFail 0 "error"

>>> runGet ("error" `setLabel` word8) (BLC.pack "abc")
RunGet 97

(!!-) :: (d -> e) -> Get d a -> Get e a infixl 3

>>> runGet (reverse !!- setLabel "error" word8) (BLC.pack "")
RunGetFail 0 "rorre"

>>> runGet (reverse !!- setLabel "error" word8) (BLC.pack "abc")
RunGet 97

modifyLabel :: (d -> e) -> Get d a -> Get e a

>>> runGet (reverse `modifyLabel` setLabel "error" word8) (BLC.pack "")
RunGetFail 0 "rorre"

>>> runGet (reverse `modifyLabel` setLabel "error" word8) (BLC.pack "abc")
RunGet 97

Decoder

data Decoder e a

Instances

Bifunctor Decoder

>>> (bimap (+10) (*20) (_Fail # (BC.pack "abc", 19, 31))) ^? _Fail
Just ("abc",19,41)

>>> (bimap (+10) (*20) (_Done # (BC.pack "abc", 19, 31))) ^? _Done
Just ("abc",19,620)

Functor (Decoder e)

>>> (fmap (+10) (_Fail # (BC.pack "abc", 19, 31))) ^? _Fail
Just ("abc",19,31)

>>> (fmap (+10) (_Done # (BC.pack "abc", 19, 31))) ^? _Done
Just ("abc",19,41)

decoder :: (ByteString -> Int64 -> e -> x) -> ((Maybe ByteString -> Decoder e a) -> x) -> (ByteString -> Int64 -> a -> x) -> Decoder e a -> x

>>> decoder (\b i n -> B.length b + fromIntegral i + n) (\_ -> 99) (\b n a -> B.length b + fromIntegral n + a) (_Fail # (BC.pack "abc", 12, 19))
34

>>> decoder (\b i n -> B.length b + fromIntegral i + n) (\_ -> 99) (\b n a -> B.length b + fromIntegral n + a) (_Partial # (\b -> _Fail # (fromMaybe (BC.pack "abc") b, 12, 19)))
99

>>> decoder (\b i n -> B.length b + fromIntegral i + n) (\_ -> 99) (\b n a -> B.length b + fromIntegral n + a) (_Done # (BC.pack "abc", 12, 19))
34

_Fail :: Prism' (Decoder e a) (ByteString, Int64, e)

>>> (_Fail # (BC.pack "abc", 19, 31)) ^? _Fail
Just ("abc",19,31)

>>> isNothing ((_Fail # (BC.pack "abc", 19, 31)) ^? _Partial)
True

>>> (_Fail # (BC.pack "abc", 19, 31)) ^? _Done
Nothing

_Partial :: Prism' (Decoder e a) (Maybe ByteString -> Decoder e a)

>>> (_Partial # (\b -> _Fail # (fromMaybe (BC.pack "abc") b, 12, 19))) ^? _Fail
Nothing

>>> isJust ((_Partial # (\b -> _Fail # (fromMaybe (BC.pack "abc") b, 12, 19))) ^? _Partial)
True

>>> (_Partial # (\b -> _Fail # (fromMaybe (BC.pack "abc") b, 12, 19))) ^? _Done
Nothing

_Done :: Prism' (Decoder e a) (ByteString, Int64, a)

>>> (_Done # (BC.pack "abc", 19, 31)) ^? _Fail
Nothing

>>> isNothing ((_Done # (BC.pack "abc", 19, 31)) ^? _Partial)
True

>>> (_Done # (BC.pack "abc", 19, 31)) ^? _Done
Just ("abc",19,31)

Run Get parser

runGet :: Get e a -> ByteString -> RunGetResult e a

runGetFile :: Get e a -> FilePath -> IO (RunGetResult e a)

(.>>) :: Get e a -> ByteString -> RunGetResult e a infixl 2

An alias for runGet.

>>> (word8 >>= \c1 -> word8 >>= \c2 -> return (c1 + c2)) .>> BLC.pack "abc"
RunGet 195

(<<.) :: ByteString -> Get e a -> RunGetResult e a infixl 2

An alias for runGet with the arguments flipped.

>>> BLC.pack "abc" <<. (word8 >>= \c1 -> word8 >>= \c2 -> return (c1 + c2))
RunGet 195

runGetIncremental :: Get e a -> Decoder e a

XDecoder data type

data XDecoder e a

Instances

Bifunctor XDecoder

Bifoldable XDecoder

Functor (XDecoder e)

Foldable (XDecoder e)

Reduction

xdecoder :: (ByteString -> e -> x) -> ((Maybe ByteString -> XDecoder e a) -> x) -> (ByteString -> a -> x) -> (Int64 -> (Int64 -> XDecoder e a) -> x) -> XDecoder e a -> x

Prisms

_XFail :: Prism' (XDecoder e a) (ByteString, e)

_XPartial :: Prism' (XDecoder e a) (Maybe ByteString -> XDecoder e a)

_XDone :: Prism' (XDecoder e a) (ByteString, a)

_XBytesRead :: Prism' (XDecoder e a) (Int64, Int64 -> XDecoder e a)

CompletedXDecoder data type

data CompletedXDecoder e a

Instances

Bifunctor CompletedXDecoder

Bitraversable CompletedXDecoder

Bifoldable CompletedXDecoder

Functor (CompletedXDecoder e)

Foldable (CompletedXDecoder e)

Traversable (CompletedXDecoder e)

(Eq e, Eq a) => Eq (CompletedXDecoder e a)

(Ord e, Ord a) => Ord (CompletedXDecoder e a)

(Show e, Show a) => Show (CompletedXDecoder e a)

Reduction

completedXDecoder :: (ByteString -> e -> x) -> (ByteString -> a -> x) -> CompletedXDecoder e a -> x

Prism

_CompletedFail :: Prism' (CompletedXDecoder e a) (ByteString, e)

_CompletedDone :: Prism' (CompletedXDecoder e a) (ByteString, a)

Isomorphism

completedIso :: Iso (CompletedXDecoder e a) (CompletedXDecoder f b) (Either e a, ByteString) (Either f b, ByteString)

Lens

completedByteString :: Lens' (CompletedXDecoder e a) ByteString

completedValue :: Lens' (CompletedXDecoder e a) (Either e a)

Prism

uncomplete :: Prism' (XDecoder e a) (CompletedXDecoder e a)

Traversal

uncompletedByteString :: Traversal' (XDecoder e a) ByteString

uncompletedValue :: Traversal' (XDecoder e a) (Either e a)