Safe Haskell	None
Language	Haskell2010

Data.Packed.Reader

Description

It is recommended to import this module like so:

import qualified Data.Packed.Reader as R

Synopsis

newtype PackedReader (p :: [Type]) (r :: [Type]) v = PackedReader {
- runPackedReader :: ReaderPtr (p :++: r) -> Int -> IO (v, ReaderPtr r, Int)
}
mkPackedReader :: forall (p :: [Type]) (r :: [Type]) v. (ReaderPtr (p :++: r) -> Int -> IO (v, ReaderPtr r, Int)) -> PackedReader p r v
runReader :: forall (p :: [Type]) (r :: [Type]) v. PackedReader p r v -> Packed (p :++: r) -> IO (v, Packed r)
(>>=) :: forall (p :: [Type]) (r1 :: [Type]) (r2 :: [Type]) v v'. PackedReader p (r1 :++: r2) v -> (v -> PackedReader r1 r2 v') -> PackedReader (p :++: r1) r2 v'
(>>) :: forall (p :: [Type]) (r1 :: [Type]) (r2 :: [Type]) v v'. PackedReader p (r1 :++: r2) v -> PackedReader r1 r2 v' -> PackedReader (p :++: r1) r2 v'
lift :: forall (a :: [Type]) (b :: [Type]) v (r :: [Type]). PackedReader a b v -> Packed (a :++: b) -> PackedReader ('[] :: [Type]) r v
fail :: forall (r :: [Type]) v. String -> PackedReader ('[] :: [Type]) r v
return :: forall v (r :: [Type]). v -> PackedReader ('[] :: [Type]) r v
type ReaderPtr (r :: k) = Ptr Word8
finishReader :: forall (p :: [Type]) (r :: [Type]) (a :: [Type]). PackedReader p r (Needs ('[] :: [Type]) a) -> PackedReader p r (Packed a)

Documentation

newtype PackedReader (p :: [Type]) (r :: [Type]) v Source #

Basically a function that reads/desrialises a value from a Packed

p the types of the packed values to read

r the packed type after the encoded values to read

v the type of the value to unpack

Note: It is an indexed monad.

Constructors

PackedReader
Fields runPackedReader :: ReaderPtr (p :++: r) -> Int -> IO (v, ReaderPtr r, Int)

Instances

Instances details

Functor (PackedReader p r) Source #
Instance details Defined in Data.Packed.Reader Methods fmap :: (a -> b) -> PackedReader p r a -> PackedReader p r b # (<$) :: a -> PackedReader p r b -> PackedReader p r a #

mkPackedReader :: forall (p :: [Type]) (r :: [Type]) v. (ReaderPtr (p :++: r) -> Int -> IO (v, ReaderPtr r, Int)) -> PackedReader p r v Source #

Builds a PackedReader

runReader :: forall (p :: [Type]) (r :: [Type]) v. PackedReader p r v -> Packed (p :++: r) -> IO (v, Packed r) Source #

Run the reading function using a ByteString.

(>>=) :: forall (p :: [Type]) (r1 :: [Type]) (r2 :: [Type]) v v'. PackedReader p (r1 :++: r2) v -> (v -> PackedReader r1 r2 v') -> PackedReader (p :++: r1) r2 v' Source #

Allows bindings PackedReader together, in a monad-like manner.

Similar to >>=

(>>) :: forall (p :: [Type]) (r1 :: [Type]) (r2 :: [Type]) v v'. PackedReader p (r1 :++: r2) v -> PackedReader r1 r2 v' -> PackedReader (p :++: r1) r2 v' Source #

Similar to >>

lift :: forall (a :: [Type]) (b :: [Type]) v (r :: [Type]). PackedReader a b v -> Packed (a :++: b) -> PackedReader ('[] :: [Type]) r v Source #

Allows reading another packed value in a do-notation.

The reading of the second stream does not consume anything from the first.

Example:

import qualified Data.Packed.Reader as R
data Tree a = Leaf | Node (Tree a) a (Tree a)

packedTreeToList :: PackedReader '[Tree Int] '[] [Int]
packedTreeToList = go []
    where
        go l =
            caseTree
                (R.return l)
                ( R.do
                    packedLeft <- isolate
                    n <- readerWithFieldSize
                    packedRight <- isolate
                    -- Using lift allows consuming the packedRight value
                    rightList <- R.lift (go l) packedRight
                    R.lift (go $ n : rightList) packedLeft
                )

fail :: forall (r :: [Type]) v. String -> PackedReader ('[] :: [Type]) r v Source #

return :: forall v (r :: [Type]). v -> PackedReader ('[] :: [Type]) r v Source #

Like return, wraps a value in a PackedReader that will not consume its input.

type ReaderPtr (r :: k) = Ptr Word8 Source #

finishReader :: forall (p :: [Type]) (r :: [Type]) (a :: [Type]). PackedReader p r (Needs ('[] :: [Type]) a) -> PackedReader p r (Packed a) Source #

Util function that calls finish on the value produced by the input PackedReader