Copyright | (c) Audrey Tang 2004-2011 |
---|---|
License | PublicDomain |
Maintainer | audreyt@audreyt.org |
Stability | experimental |
Portability | non-portable (GHC-only) |
Safe Haskell | None |
Language | Haskell98 |
This module handles pre-parsed "chunks" in AFP files.
- type NStr = Buffer0
- type AStr = NStr
- type ChunkWriter c = WriterT (ChunkQueue c)
- type WriterStateIO v a = forall c m. (Chunk c, MonadReader v m) => ChunkWriter c m a
- nullForeignPtr :: ForeignPtr a
- _NStr :: NStr
- packAStr :: AStr -> ByteString
- fromAStr :: AStr -> String
- toAStr :: String -> AStr
- packNStr :: NStr -> ByteString
- fromNStr :: NStr -> [N1]
- toNStr :: [N1] -> NStr
- newtype ChunkType = MkChunkType TypeRep
- mkChunkType :: TypeRep -> ChunkType
- typeInt :: TypeRep -> Int
- chunkTypeOf :: Typeable a => a -> ChunkType
- class (Show c, Typeable c, Buf (BufOf c), Enum (N c), Num (N c)) => Chunk c where
- class (Rec r, Chunk (ChunkOf r)) => RecChunk r where
- type ChunkOf r
- class (Rec a, Rec b) => RecData a b where
- (~~) :: (Chunk c, Typeable t) => c -> t -> Bool
- (<~~) :: (Monad m, Chunk c, Typeable t, Rec r) => t -> [c] -> m r
- (~~>) :: (Monad m, Chunk c, Typeable t, Rec r) => [c] -> t -> m r
- (==>) :: (Chunk c, Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m [c]
- (<==) :: (Chunk c, Monad m) => [(ChunkType, c -> m [c])] -> [c] -> m [c]
- (..>) :: (Chunk c, Monad m) => [c] -> [(ChunkType, c -> m [c])] -> m ()
- (<..) :: (Chunk c, Monad m) => [(ChunkType, c -> m [c])] -> [c] -> m ()
- (===) :: (Chunk c, Rec r, Monad m) => r -> (r -> ChunkWriter c m a) -> (ChunkType, c -> m [c])
- processChunk :: (Monad m, Rec r, Chunk c) => r -> (r -> ChunkWriter c m a) -> c -> m [c]
- (...) :: (Chunk c, Rec a, Monad m) => a -> (a -> m t) -> (ChunkType, c -> m [c])
- (....) :: (Monad (t m), Monad m, MonadTrans t, Chunk c, Rec a) => a -> (a -> m t1) -> (ChunkType, c -> t m [c])
- (.....) :: (Monad (t m), Monad (t1 (t m)), Monad m, MonadTrans t, MonadTrans t1, Chunk c, Rec a) => a -> (a -> m t2) -> (ChunkType, c -> t1 (t m) [c])
- inspectChunk :: (Monad m, Rec a, Chunk c) => a -> (a -> m t) -> c -> m [c]
- push :: (Chunk c, Monad m, Rec a) => a -> ChunkWriter c m ()
- filterChunks :: (Monad m, RecChunk r, Chunk c) => r -> [(ChunkType, ChunkOf r -> ChunkWriter c m [ChunkOf r])] -> ChunkWriter c m ()
- data ChunkQueue a
- = ChunkQueue [a]
- | ChunkItem a
Documentation
type ChunkWriter c = WriterT (ChunkQueue c) Source #
type WriterStateIO v a = forall c m. (Chunk c, MonadReader v m) => ChunkWriter c m a Source #
nullForeignPtr :: ForeignPtr a Source #
packAStr :: AStr -> ByteString Source #
packNStr :: NStr -> ByteString Source #
mkChunkType :: TypeRep -> ChunkType Source #
chunkTypeOf :: Typeable a => a -> ChunkType Source #
class (Show c, Typeable c, Buf (BufOf c), Enum (N c), Num (N c)) => Chunk c where Source #
The Chunk class represents non-parsed chunks, constructed from a (ChunkType, Buffer) tuple.
chunkApply :: N c -> c -> (forall a. Rec a => a -> x) -> x Source #
mkChunk :: N c -> BufOf c -> c Source #
chunkCon :: (N c, BufOf c) -> c Source #
chunkDecon :: c -> (N c, BufOf c) Source #
chunkType :: c -> ChunkType Source #
chunkTypeLookup :: c -> N c -> ChunkType Source #
packChunk :: c -> PStringLen Source #
chunkMapFiltersM_ :: Monad m => c -> [(ChunkType, c -> m [c])] -> m () Source #
chunkMapFiltersM :: Monad m => c -> [(ChunkType, c -> m [c])] -> m [c] Source #
chunksMapFiltersM :: Monad m => [c] -> [(ChunkType, c -> m [c])] -> m [c] Source #
chunksMapFiltersM_ :: Monad m => [c] -> [(ChunkType, c -> m [c])] -> m () Source #
decodeChunk :: Binary (Record r) => c -> r Source #
encodeChunk :: (Binary r, Storable r, Rec r) => r -> c Source #
class (Rec r, Chunk (ChunkOf r)) => RecChunk r where Source #
The RecChunk class unifies a Rec (parent) with its contained chunk types (children).
readChunks :: r -> [ChunkOf r] Source #
writeChunks :: Monad m => r -> m [ChunkOf r] -> m r Source #
class (Rec a, Rec b) => RecData a b where Source #
The RecData class unifies a Rec (parent) with its contained Rec data type (children).
(===) :: (Chunk c, Rec r, Monad m) => r -> (r -> ChunkWriter c m a) -> (ChunkType, c -> m [c]) infixr 4 Source #
processChunk :: (Monad m, Rec r, Chunk c) => r -> (r -> ChunkWriter c m a) -> c -> m [c] Source #
(....) :: (Monad (t m), Monad m, MonadTrans t, Chunk c, Rec a) => a -> (a -> m t1) -> (ChunkType, c -> t m [c]) infixr 4 Source #
(.....) :: (Monad (t m), Monad (t1 (t m)), Monad m, MonadTrans t, MonadTrans t1, Chunk c, Rec a) => a -> (a -> m t2) -> (ChunkType, c -> t1 (t m) [c]) infixr 4 Source #
filterChunks :: (Monad m, RecChunk r, Chunk c) => r -> [(ChunkType, ChunkOf r -> ChunkWriter c m [ChunkOf r])] -> ChunkWriter c m () Source #
data ChunkQueue a Source #
ChunkQueue [a] | |
ChunkItem a |
Show a => Show (ChunkQueue a) Source # | |
Monoid (ChunkQueue a) Source # | |