Data.Columbia.Types

Documentation

type Pointer = Word32

data SeekableStream m c

Constructors

SeekableStream

Fields

• __consumeToken :: !(m (Maybe c))
• __consumeIntegralToken :: !(m (Maybe Word32))
• __seek :: !(Pointer -> m ())
• __getPosition :: !(m Pointer)
• __seekAtEnd :: !(m ())
• __isLockLive :: !(m Bool)

Instances

Functor m => Functor (SeekableStream m)

Methods

fmap :: (a -> b) -> SeekableStream m a -> SeekableStream m b

(<$) :: a -> SeekableStream m b -> SeekableStream m a

data SeekableWriter m c

Constructors

SeekableWriter

Fields

• _putToken :: !(c -> m ())
• _putIntegralToken :: !(Word32 -> m ())
• stream :: !(SeekableStream m c)

class Typeable t => RW t where

The RW class describes operations that can locate entities in a stream by seeking, and also read and write primitive types.

Methods

readData :: Monad m => ReaderT (SeekableStream m Word8) m t

writeData :: Monad m => t -> ReaderT (SeekableWriter m Word8) m ()

Instances

(Typeable * k, Typeable * v) => RW (Pair k v)

Methods

readData :: Monad m => ReaderT * (SeekableStream m Word8) m (Pair k v)

writeData :: Monad m => Pair k v -> ReaderT * (SeekableWriter m Word8) m ()

data RWCtx a

Constructors

RW a => RWCtx

type PolyTraversal ctx m d = Proxy ctx -> (forall a. Data ctx a => ReaderT (SeekableStream m Word8) m a) -> ReaderT (SeekableStream m Word8) m d

A PolyTraversal is a reader method over a data type, parameterized over a method to read components. It can be seen as a curried form of the gmapM operator from Data.Data, in like manner as the Traversal is a curried form of traverse.

type PolyTraversalW ctx m d = Proxy ctx -> (forall a. Data ctx a => a -> ReaderT (SeekableWriter m Word8) m ()) -> d -> ReaderT (SeekableWriter m Word8) m ()

This is a variant of PolyTraversal purposed for writing. By convention, strategies with this type require the stream to be seeked at an *address*, which the strategy will then dereference to access the corresponding data.

data LazyFix f

The standard Fix constructor is too strict for some things this library has to do, hence the alias.

Constructors

LazyFix (Rep f (LazyFix f))

data LazyMap k v

This type alias exposes an alternate view of the data constructors of a dictionary type. Why break abstraction????because I need the structure sharing.

Constructors

BinPrime

Fields

• lazy_map_size :: Int
• lazy_map_key :: k
• lazy_map_value :: v
• lazy_map_bin1 :: WithAddress (LazyMap k v)
• lazy_map_bin2 :: WithAddress (LazyMap k v)

TipPrime

Instances

(Eq v, Eq k) => Eq (LazyMap k v)

Methods

(==) :: LazyMap k v -> LazyMap k v -> Bool

(/=) :: LazyMap k v -> LazyMap k v -> Bool

(Ord v, Ord k) => Ord (LazyMap k v)

Methods

compare :: LazyMap k v -> LazyMap k v -> Ordering

(<) :: LazyMap k v -> LazyMap k v -> Bool

(<=) :: LazyMap k v -> LazyMap k v -> Bool

(>) :: LazyMap k v -> LazyMap k v -> Bool

(>=) :: LazyMap k v -> LazyMap k v -> Bool

max :: LazyMap k v -> LazyMap k v -> LazyMap k v

min :: LazyMap k v -> LazyMap k v -> LazyMap k v

(Show v, Show k) => Show (LazyMap k v)

Methods

showsPrec :: Int -> LazyMap k v -> ShowS

show :: LazyMap k v -> String

showList :: [LazyMap k v] -> ShowS

class KeyComparable t where

isKeyed may always return false, but if it returns true ever, keyCompare must be well-defined and a valid equivalence relation on values for which isKeyed returns true (i.e. where all values concerned have isKeyed x=true). The default is to have isKeyed return false on all values.

Methods

isKeyed :: t -> Bool

keyCompare :: t -> t -> Ordering

Instances

Ord k => KeyComparable (Pair k v)

Methods

isKeyed :: Pair k v -> Bool

keyCompare :: Pair k v -> Pair k v -> Ordering

data KeyCtx t

Constructors

KeyComparable t => KeyCtx

data WithAddress t

Data type for a piece of data that may or may not have an explicit address associated with it. This is nice because I can play with these in pure code to manipulate data, while still remembering all of the explicit term structure.

Constructors

WithAddress Pointer t

Instances

Eq t => Eq (WithAddress t)

Methods

(==) :: WithAddress t -> WithAddress t -> Bool

(/=) :: WithAddress t -> WithAddress t -> Bool

Ord t => Ord (WithAddress t)

Methods

compare :: WithAddress t -> WithAddress t -> Ordering

(<) :: WithAddress t -> WithAddress t -> Bool

(<=) :: WithAddress t -> WithAddress t -> Bool

(>) :: WithAddress t -> WithAddress t -> Bool

(>=) :: WithAddress t -> WithAddress t -> Bool

max :: WithAddress t -> WithAddress t -> WithAddress t

min :: WithAddress t -> WithAddress t -> WithAddress t

Show t => Show (WithAddress t)

Methods

showsPrec :: Int -> WithAddress t -> ShowS

show :: WithAddress t -> String

showList :: [WithAddress t] -> ShowS

data Header

Constructors

Header !Word8 !ConIndex !Int

isUArray :: Header -> Bool

isArray :: Header -> Bool

isPrimtype :: Header -> Bool

isAlgtype :: Header -> Bool

getConIndex :: Header -> ConIndex

getNFields :: Header -> Int