Capnp.Untyped

The types and functions in this module know about things like structs and lists, but are not schema aware.

Each of the data types exported by this module is parametrized over the mutability of the message it contains (see Capnp.Message).

Type-level descriptions of wire representations.

data Repr

A Repr describes a wire representation for a value. This is mostly used at the type level (using DataKinds); types are parametrized over representations.

Constructors

Ptr (Maybe PtrRepr)

Pointer type. Nothing indicates an AnyPointer, Just describes a more specific pointer type.

Data DataSz

Non-pointer type.

Instances

Show Repr

Defined in Capnp.Untyped

Methods

showsPrec :: Int -> Repr -> ShowS

show :: Repr -> String

showList :: [Repr] -> ShowS

data PtrRepr

Information about the representation of a pointer type

Constructors

Cap

Capability pointer.

List (Maybe ListRepr)

List pointer. Nothing describes an AnyList, Just describes more specific list types.

Struct

A struct (or group).

Instances

Show PtrRepr

Defined in Capnp.Untyped

Methods

showsPrec :: Int -> PtrRepr -> ShowS

show :: PtrRepr -> String

showList :: [PtrRepr] -> ShowS

Element ('Ptr ('Just 'Cap))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Cap)))) mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Cap)))) mut)

IsPtrRepr ('Just ('List a)) => Element ('Ptr ('Just ('List a)))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just ('List a))))) mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List a))) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List a))) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just ('List a))))) mut)

Element ('Ptr ('Just 'Struct))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Struct)))) mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Struct)))) mut)

Element ('Ptr ('Nothing :: Maybe PtrRepr))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr 'Nothing))) mut) -> m (Unwrapped (Untyped ('Ptr 'Nothing) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr 'Nothing) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr 'Nothing))) mut)

HasMessage (ListOf ('Ptr ('Just 'Struct)))

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (ListOf ('Ptr ('Just 'Struct)) mut) -> Message mut

IsPtrRepr ('Nothing :: Maybe PtrRepr)

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr 'Nothing) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr 'Nothing) mut))

ListItem ('Ptr ('Just 'Struct))

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Ptr ('Just 'Struct)) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Ptr ('Just 'Struct)) mut -> m (Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Ptr ('Just 'Struct)) ('Mut s))) => a -> Int -> ListOf ('Ptr ('Just 'Struct)) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Ptr ('Just 'Struct)) mut -> ListOf ('Ptr ('Just 'Struct)) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Ptr ('Just 'Struct)) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Ptr ('Just 'Struct)) ('Mut s) -> ListOf ('Ptr ('Just 'Struct)) ('Mut s) -> m ()

ListItem ('Ptr ('Nothing :: Maybe PtrRepr))

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Ptr 'Nothing) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Ptr 'Nothing) mut -> m (Unwrapped (Untyped ('Ptr 'Nothing) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Ptr 'Nothing) ('Mut s))) => a -> Int -> ListOf ('Ptr 'Nothing) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Ptr 'Nothing) mut -> ListOf ('Ptr 'Nothing) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Ptr 'Nothing) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Ptr 'Nothing) ('Mut s) -> ListOf ('Ptr 'Nothing) ('Mut s) -> m ()

MessageDefault (ListOf ('Ptr ('Just 'Struct)))

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (ListOf ('Ptr ('Just 'Struct)) mut))

IsPtrRepr ('Just 'Cap)

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut))

IsListPtrRepr r => IsPtrRepr ('Just ('List ('Just r)))

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List ('Just r)))) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List ('Just r)))) mut))

IsPtrRepr ('Just ('List ('Nothing :: Maybe ListRepr)))

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List 'Nothing))) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List 'Nothing))) mut))

IsPtrRepr ('Just 'Struct)

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut))

data ListRepr where

Information about the representation of a list type.

Constructors

ListNormal :: NormalListRepr -> ListRepr

A "normal" list

ListComposite :: ListRepr

A composite (struct) list

Instances

Show ListRepr

Defined in Capnp.Untyped

Methods

showsPrec :: Int -> ListRepr -> ShowS

show :: ListRepr -> String

showList :: [ListRepr] -> ShowS

Allocate ('List ('Just 'ListComposite))

Defined in Capnp.Untyped

Associated Types

type AllocHint ('List ('Just 'ListComposite))

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint ('List ('Just 'ListComposite)) -> m (Unwrapped (UntypedSomePtr ('List ('Just 'ListComposite)) ('Mut s)))

AllocateNormalList r => Allocate ('List ('Just ('ListNormal r)))

Defined in Capnp.Untyped

Associated Types

type AllocHint ('List ('Just ('ListNormal r)))

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint ('List ('Just ('ListNormal r))) -> m (Unwrapped (UntypedSomePtr ('List ('Just ('ListNormal r))) ('Mut s)))

IsListPtrRepr r => IsPtrRepr ('Just ('List ('Just r)))

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List ('Just r)))) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List ('Just r)))) mut))

IsPtrRepr ('Just ('List ('Nothing :: Maybe ListRepr)))

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List 'Nothing))) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List 'Nothing))) mut))

type AllocHint ('List ('Just 'ListComposite))

Defined in Capnp.Untyped

type AllocHint ('List ('Just 'ListComposite)) = (Int, AllocHint 'Struct)

type AllocHint ('List ('Just ('ListNormal r)))

Defined in Capnp.Untyped

type AllocHint ('List ('Just ('ListNormal r))) = Int

data NormalListRepr where

Information about the representation of a normal (non-composite) list.

Constructors

NormalListData :: DataSz -> NormalListRepr

NormalListPtr :: NormalListRepr

Instances

Show NormalListRepr

Defined in Capnp.Untyped

Methods

showsPrec :: Int -> NormalListRepr -> ShowS

show :: NormalListRepr -> String

showList :: [NormalListRepr] -> ShowS

data DataSz

The size of a non-pointer type. SzN represents an N-bit value.

Constructors

Sz0

Sz1

Sz8

Sz16

Sz32

Sz64

Instances

Show DataSz

Defined in Capnp.Untyped

Methods

showsPrec :: Int -> DataSz -> ShowS

show :: DataSz -> String

showList :: [DataSz] -> ShowS

Mapping representations to value types.

type family Untyped (r :: Repr) :: Mutability -> Type where ...

Untyped r mut is an untyped value with representation r stored in a message with mutability mut.

Note that the return type of this type family has kind Mutability -> Type. This is important, as it allows us to define instances on Untyped r, and use Untyped r in constraints.

This introduces some awkwardnesses though -- we really want this to be (Maybe (Ptr mut)) for 'Ptr 'Nothing, and Int typesBool() for 'Data sz. But we can't because these are the wrong kind.

So, we hack around this by introducing two newtypes, IgnoreMut and MaybePtr, and a type family Unwrapped, which lets us use Unwrapped (Untyped r mut) as the type we really want in some places, though we can't curry it then.

All this is super super awkward, but this is a low level mostly-internal API; most users will intract with this through the Raw type in Capnp.Repr, which hides all of this...

Equations

Untyped ('Data sz) = IgnoreMut (UntypedData sz)

Untyped ('Ptr ptr) = UntypedPtr ptr

type family UntypedData (sz :: DataSz) :: Type where ...

UntypedData sz is an untyped value with size sz.

Equations

UntypedData 'Sz0 = ()

UntypedData 'Sz1 = Bool

UntypedData 'Sz8 = Word8

UntypedData 'Sz16 = Word16

UntypedData 'Sz32 = Word32

UntypedData 'Sz64 = Word64

type family UntypedPtr (r :: Maybe PtrRepr) :: Mutability -> Type where ...

Like Untyped, but for pointers only.

Equations

UntypedPtr 'Nothing = MaybePtr

UntypedPtr ('Just r) = UntypedSomePtr r

type family UntypedSomePtr (r :: PtrRepr) :: Mutability -> Type where ...

Like UntypedPtr, but doesn't allow AnyPointers.

Equations

UntypedSomePtr 'Struct = Struct

UntypedSomePtr 'Cap = Cap

UntypedSomePtr ('List r) = UntypedList r

type family UntypedList (r :: Maybe ListRepr) :: Mutability -> Type where ...

Like Untyped, but for lists only.

Equations

UntypedList 'Nothing = List

UntypedList ('Just r) = UntypedSomeList r

type family UntypedSomeList (r :: ListRepr) :: Mutability -> Type where ...

Like UntypedList, but doesn't allow AnyLists.

Equations

UntypedSomeList r = ListOf (ElemRepr r)

newtype IgnoreMut a (mut :: Mutability)

Wrapper for use with Untyped; see docs for Untyped

Constructors

IgnoreMut a

Instances

MaybeMutable (IgnoreMut a)

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => IgnoreMut a 'Const -> m (IgnoreMut a ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => IgnoreMut a ('Mut s) -> m (IgnoreMut a 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => IgnoreMut a 'Const -> m (IgnoreMut a ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => IgnoreMut a ('Mut s) -> m (IgnoreMut a 'Const)

Bits a => Bits (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

(.&.) :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

(.|.) :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

xor :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

complement :: IgnoreMut a mut -> IgnoreMut a mut

shift :: IgnoreMut a mut -> Int -> IgnoreMut a mut

rotate :: IgnoreMut a mut -> Int -> IgnoreMut a mut

zeroBits :: IgnoreMut a mut

bit :: Int -> IgnoreMut a mut

setBit :: IgnoreMut a mut -> Int -> IgnoreMut a mut

clearBit :: IgnoreMut a mut -> Int -> IgnoreMut a mut

complementBit :: IgnoreMut a mut -> Int -> IgnoreMut a mut

testBit :: IgnoreMut a mut -> Int -> Bool

bitSizeMaybe :: IgnoreMut a mut -> Maybe Int

bitSize :: IgnoreMut a mut -> Int

isSigned :: IgnoreMut a mut -> Bool

shiftL :: IgnoreMut a mut -> Int -> IgnoreMut a mut

unsafeShiftL :: IgnoreMut a mut -> Int -> IgnoreMut a mut

shiftR :: IgnoreMut a mut -> Int -> IgnoreMut a mut

unsafeShiftR :: IgnoreMut a mut -> Int -> IgnoreMut a mut

rotateL :: IgnoreMut a mut -> Int -> IgnoreMut a mut

rotateR :: IgnoreMut a mut -> Int -> IgnoreMut a mut

popCount :: IgnoreMut a mut -> Int

FiniteBits a => FiniteBits (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

finiteBitSize :: IgnoreMut a mut -> Int

countLeadingZeros :: IgnoreMut a mut -> Int

countTrailingZeros :: IgnoreMut a mut -> Int

Bounded a => Bounded (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

minBound :: IgnoreMut a mut

maxBound :: IgnoreMut a mut

Enum a => Enum (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

succ :: IgnoreMut a mut -> IgnoreMut a mut

pred :: IgnoreMut a mut -> IgnoreMut a mut

toEnum :: Int -> IgnoreMut a mut

fromEnum :: IgnoreMut a mut -> Int

enumFrom :: IgnoreMut a mut -> [IgnoreMut a mut]

enumFromThen :: IgnoreMut a mut -> IgnoreMut a mut -> [IgnoreMut a mut]

enumFromTo :: IgnoreMut a mut -> IgnoreMut a mut -> [IgnoreMut a mut]

enumFromThenTo :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut -> [IgnoreMut a mut]

Num a => Num (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

(+) :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

(-) :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

(*) :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

negate :: IgnoreMut a mut -> IgnoreMut a mut

abs :: IgnoreMut a mut -> IgnoreMut a mut

signum :: IgnoreMut a mut -> IgnoreMut a mut

fromInteger :: Integer -> IgnoreMut a mut

Read a => Read (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

readsPrec :: Int -> ReadS (IgnoreMut a mut)

readList :: ReadS [IgnoreMut a mut]

readPrec :: ReadPrec (IgnoreMut a mut)

readListPrec :: ReadPrec [IgnoreMut a mut]

Integral a => Integral (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

quot :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

rem :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

div :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

mod :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

quotRem :: IgnoreMut a mut -> IgnoreMut a mut -> (IgnoreMut a mut, IgnoreMut a mut)

divMod :: IgnoreMut a mut -> IgnoreMut a mut -> (IgnoreMut a mut, IgnoreMut a mut)

toInteger :: IgnoreMut a mut -> Integer

Real a => Real (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

toRational :: IgnoreMut a mut -> Rational

Show a => Show (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

showsPrec :: Int -> IgnoreMut a mut -> ShowS

show :: IgnoreMut a mut -> String

showList :: [IgnoreMut a mut] -> ShowS

Eq a => Eq (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

(==) :: IgnoreMut a mut -> IgnoreMut a mut -> Bool

(/=) :: IgnoreMut a mut -> IgnoreMut a mut -> Bool

Ord a => Ord (IgnoreMut a mut)

Defined in Capnp.Untyped

Methods

compare :: IgnoreMut a mut -> IgnoreMut a mut -> Ordering

(<) :: IgnoreMut a mut -> IgnoreMut a mut -> Bool

(<=) :: IgnoreMut a mut -> IgnoreMut a mut -> Bool

(>) :: IgnoreMut a mut -> IgnoreMut a mut -> Bool

(>=) :: IgnoreMut a mut -> IgnoreMut a mut -> Bool

max :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

min :: IgnoreMut a mut -> IgnoreMut a mut -> IgnoreMut a mut

newtype MaybePtr (mut :: Mutability)

Wrapper for use with Untyped; see docs for Untyped.

Constructors

MaybePtr (Maybe (Ptr mut))

Instances

MaybeMutable MaybePtr

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => MaybePtr 'Const -> m (MaybePtr ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => MaybePtr ('Mut s) -> m (MaybePtr 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => MaybePtr 'Const -> m (MaybePtr ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => MaybePtr ('Mut s) -> m (MaybePtr 'Const)

type family Unwrapped a where ...

Normalizes types returned by Untyped; see docs for Untyped.

Equations

Unwrapped (IgnoreMut a mut) = a

Unwrapped (MaybePtr mut) = Maybe (Ptr mut)

Unwrapped a = a

Relating the representations of lists & their elements.

class Element (r :: Repr) where

Element supports converting between values of representation ElemRepr (ListReprFor r) and values of representation r.

At a glance, you might expect this to just be a no-op, but it is actually *not* always the case that ElemRepr (ListReprFor r) ~ r; in the case of pointer types, ListReprFor r can contain arbitrary pointers, so information is lost, and it is possible for the list to contain pointers of the incorrect type. In this case, fromElement will throw an error.

toElement is more trivial.

Methods

fromElement :: forall m mut. ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor r)) mut) -> m (Unwrapped (Untyped r mut))

toElement :: Unwrapped (Untyped r mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor r)) mut)

Instances

Element ('Data sz)

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Data sz))) mut) -> m (Unwrapped (Untyped ('Data sz) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Data sz) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Data sz))) mut)

Element ('Ptr ('Just 'Cap))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Cap)))) mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Cap)))) mut)

IsPtrRepr ('Just ('List a)) => Element ('Ptr ('Just ('List a)))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just ('List a))))) mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List a))) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List a))) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just ('List a))))) mut)

Element ('Ptr ('Just 'Struct))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Struct)))) mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr ('Just 'Struct)))) mut)

Element ('Ptr ('Nothing :: Maybe PtrRepr))

Defined in Capnp.Untyped

Methods

fromElement :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr 'Nothing))) mut) -> m (Unwrapped (Untyped ('Ptr 'Nothing) mut))

toElement :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr 'Nothing) mut) -> Unwrapped (Untyped (ElemRepr (ListReprFor ('Ptr 'Nothing))) mut)

class Element r => ListItem (r :: Repr) where

ListItem r indicates that r is a representation for elements of some list type. Not every representation is covered; instances exist only for r where ElemRepr (ListReprFor r) ~ r.

Minimal complete definition

Nothing

Methods

length :: ListOf r mut -> Int

Returns the length of a list

default length :: ListRepOf r ~ NormalList => ListOf r mut -> Int

unsafeIndex :: ReadCtx m mut => Int -> ListOf r mut -> m (Unwrapped (Untyped r mut))

default unsafeIndex :: forall m mut. (ReadCtx m mut, Integral (Unwrapped (Untyped r mut)), ListRepOf r ~ NormalList, FiniteBits (Unwrapped (Untyped r mut))) => Int -> ListOf r mut -> m (Unwrapped (Untyped r mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped r ('Mut s))) => a -> Int -> ListOf r ('Mut s) -> m ()

default unsafeSetIndex :: forall m s a. (RWCtx m s, a ~ Unwrapped (Untyped r ('Mut s)), ListRepOf r ~ NormalList, Integral a, Bounded a, FiniteBits a) => a -> Int -> ListOf r ('Mut s) -> m ()

unsafeTake :: Int -> ListOf r mut -> ListOf r mut

default unsafeTake :: ListRepOf r ~ NormalList => Int -> ListOf r mut -> ListOf r mut

checkListOf :: ReadCtx m mut => ListOf r mut -> m ()

default checkListOf :: forall m mut. (ReadCtx m mut, ListRepOf r ~ NormalList, FiniteBits (Untyped r mut)) => ListOf r mut -> m ()

copyListOf :: RWCtx m s => ListOf r ('Mut s) -> ListOf r ('Mut s) -> m ()

Make a copy of the list, in the target message.

Instances

ListItem ('Data 'Sz0)

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Data 'Sz0) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Data 'Sz0) mut -> m (Unwrapped (Untyped ('Data 'Sz0) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Data 'Sz0) ('Mut s))) => a -> Int -> ListOf ('Data 'Sz0) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Data 'Sz0) mut -> ListOf ('Data 'Sz0) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Data 'Sz0) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Data 'Sz0) ('Mut s) -> ListOf ('Data 'Sz0) ('Mut s) -> m ()

ListItem ('Data 'Sz1)

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Data 'Sz1) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Data 'Sz1) mut -> m (Unwrapped (Untyped ('Data 'Sz1) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Data 'Sz1) ('Mut s))) => a -> Int -> ListOf ('Data 'Sz1) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Data 'Sz1) mut -> ListOf ('Data 'Sz1) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Data 'Sz1) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Data 'Sz1) ('Mut s) -> ListOf ('Data 'Sz1) ('Mut s) -> m ()

ListItem ('Data 'Sz16)

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Data 'Sz16) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Data 'Sz16) mut -> m (Unwrapped (Untyped ('Data 'Sz16) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Data 'Sz16) ('Mut s))) => a -> Int -> ListOf ('Data 'Sz16) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Data 'Sz16) mut -> ListOf ('Data 'Sz16) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Data 'Sz16) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Data 'Sz16) ('Mut s) -> ListOf ('Data 'Sz16) ('Mut s) -> m ()

ListItem ('Data 'Sz32)

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Data 'Sz32) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Data 'Sz32) mut -> m (Unwrapped (Untyped ('Data 'Sz32) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Data 'Sz32) ('Mut s))) => a -> Int -> ListOf ('Data 'Sz32) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Data 'Sz32) mut -> ListOf ('Data 'Sz32) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Data 'Sz32) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Data 'Sz32) ('Mut s) -> ListOf ('Data 'Sz32) ('Mut s) -> m ()

ListItem ('Data 'Sz64)

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Data 'Sz64) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Data 'Sz64) mut -> m (Unwrapped (Untyped ('Data 'Sz64) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Data 'Sz64) ('Mut s))) => a -> Int -> ListOf ('Data 'Sz64) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Data 'Sz64) mut -> ListOf ('Data 'Sz64) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Data 'Sz64) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Data 'Sz64) ('Mut s) -> ListOf ('Data 'Sz64) ('Mut s) -> m ()

ListItem ('Data 'Sz8)

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Data 'Sz8) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Data 'Sz8) mut -> m (Unwrapped (Untyped ('Data 'Sz8) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Data 'Sz8) ('Mut s))) => a -> Int -> ListOf ('Data 'Sz8) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Data 'Sz8) mut -> ListOf ('Data 'Sz8) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Data 'Sz8) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Data 'Sz8) ('Mut s) -> ListOf ('Data 'Sz8) ('Mut s) -> m ()

ListItem ('Ptr ('Just 'Struct))

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Ptr ('Just 'Struct)) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Ptr ('Just 'Struct)) mut -> m (Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Ptr ('Just 'Struct)) ('Mut s))) => a -> Int -> ListOf ('Ptr ('Just 'Struct)) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Ptr ('Just 'Struct)) mut -> ListOf ('Ptr ('Just 'Struct)) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Ptr ('Just 'Struct)) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Ptr ('Just 'Struct)) ('Mut s) -> ListOf ('Ptr ('Just 'Struct)) ('Mut s) -> m ()

ListItem ('Ptr ('Nothing :: Maybe PtrRepr))

Defined in Capnp.Untyped

Methods

length :: forall (mut :: Mutability). ListOf ('Ptr 'Nothing) mut -> Int

unsafeIndex :: forall m (mut :: Mutability). ReadCtx m mut => Int -> ListOf ('Ptr 'Nothing) mut -> m (Unwrapped (Untyped ('Ptr 'Nothing) mut))

unsafeSetIndex :: (RWCtx m s, a ~ Unwrapped (Untyped ('Ptr 'Nothing) ('Mut s))) => a -> Int -> ListOf ('Ptr 'Nothing) ('Mut s) -> m ()

unsafeTake :: forall (mut :: Mutability). Int -> ListOf ('Ptr 'Nothing) mut -> ListOf ('Ptr 'Nothing) mut

checkListOf :: forall m (mut :: Mutability). ReadCtx m mut => ListOf ('Ptr 'Nothing) mut -> m ()

copyListOf :: RWCtx m s => ListOf ('Ptr 'Nothing) ('Mut s) -> ListOf ('Ptr 'Nothing) ('Mut s) -> m ()

type family ElemRepr (rl :: ListRepr) :: Repr where ...

ElemRepr r is the representation of elements of lists with representation r.

Equations

ElemRepr 'ListComposite = 'Ptr ('Just 'Struct)

ElemRepr ('ListNormal 'NormalListPtr) = 'Ptr 'Nothing

ElemRepr ('ListNormal ('NormalListData sz)) = 'Data sz

type family ListReprFor (e :: Repr) :: ListRepr where ...

ListReprFor e is the representation of lists with elements whose representation is e.

Equations

ListReprFor ('Data sz) = 'ListNormal ('NormalListData sz)

ListReprFor ('Ptr ('Just 'Struct)) = 'ListComposite

ListReprFor ('Ptr a) = 'ListNormal 'NormalListPtr

Working with pointers

class IsPtrRepr (r :: Maybe PtrRepr) where

Operations on types with pointer representations.

Methods

toPtr :: Unwrapped (Untyped ('Ptr r) mut) -> Maybe (Ptr mut)

Convert an untyped value of this representation to an AnyPointer.

fromPtr :: ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr r) mut))

Extract a value with this representation from an AnyPointer, failing if the pointer is the wrong type for this representation.

Instances

IsPtrRepr ('Nothing :: Maybe PtrRepr)

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr 'Nothing) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr 'Nothing) mut))

IsPtrRepr ('Just 'Cap)

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Cap)) mut))

IsListPtrRepr r => IsPtrRepr ('Just ('List ('Just r)))

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List ('Just r)))) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List ('Just r)))) mut))

IsPtrRepr ('Just ('List ('Nothing :: Maybe ListRepr)))

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just ('List 'Nothing))) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just ('List 'Nothing))) mut))

IsPtrRepr ('Just 'Struct)

Defined in Capnp.Untyped

Methods

toPtr :: forall (mut :: Mutability). Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut) -> Maybe (Ptr mut)

fromPtr :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> Maybe (Ptr mut) -> m (Unwrapped (Untyped ('Ptr ('Just 'Struct)) mut))

class IsListPtrRepr (r :: ListRepr) where

Operations on types with list representations.

Methods

rToList :: UntypedSomeList r mut -> List mut

Convert an untyped value of this representation to an AnyList.

rFromList :: ReadCtx m mut => List mut -> m (UntypedSomeList r mut)

Extract a value with this representation from an AnyList, failing if the list is the wrong type for this representation.

rFromListMsg :: ReadCtx m mut => Message mut -> m (UntypedSomeList r mut)

Create a zero-length value with this representation, living in the provided message.

Instances

IsListPtrRepr 'ListComposite

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList 'ListComposite mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList 'ListComposite mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList 'ListComposite mut)

IsListPtrRepr ('ListNormal ('NormalListData 'Sz0))

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal ('NormalListData 'Sz0)) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz0)) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz0)) mut)

IsListPtrRepr ('ListNormal ('NormalListData 'Sz1))

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal ('NormalListData 'Sz1)) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz1)) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz1)) mut)

IsListPtrRepr ('ListNormal ('NormalListData 'Sz16))

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal ('NormalListData 'Sz16)) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz16)) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz16)) mut)

IsListPtrRepr ('ListNormal ('NormalListData 'Sz32))

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal ('NormalListData 'Sz32)) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz32)) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz32)) mut)

IsListPtrRepr ('ListNormal ('NormalListData 'Sz64))

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal ('NormalListData 'Sz64)) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz64)) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz64)) mut)

IsListPtrRepr ('ListNormal ('NormalListData 'Sz8))

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal ('NormalListData 'Sz8)) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz8)) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz8)) mut)

IsListPtrRepr ('ListNormal 'NormalListPtr)

Defined in Capnp.Untyped

Methods

rToList :: forall (mut :: Mutability). UntypedSomeList ('ListNormal 'NormalListPtr) mut -> List mut

rFromList :: forall m (mut :: Mutability). ReadCtx m mut => List mut -> m (UntypedSomeList ('ListNormal 'NormalListPtr) mut)

rFromListMsg :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (UntypedSomeList ('ListNormal 'NormalListPtr) mut)

Allocating values

class Allocate (r :: PtrRepr) where

An instace of Allocate specifies how to allocate a value with a given representation. This only makes sense for pointers of course, so it is defined on PtrRepr. Of the well-kinded types, only 'List 'Nothing is missing an instance.

Associated Types

type AllocHint r

Extra information needed to allocate a value:

• For structs, the sizes of the sections.
• For capabilities, the client to attach to the messages.
• For lists, the length, and for composite lists, the struct sizes as well.

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint r -> m (Unwrapped (UntypedSomePtr r ('Mut s)))

Allocate a value of the given type.

Instances

Allocate 'Cap

Defined in Capnp.Untyped

Associated Types

type AllocHint 'Cap

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint 'Cap -> m (Unwrapped (UntypedSomePtr 'Cap ('Mut s)))

Allocate 'Struct

Defined in Capnp.Untyped

Associated Types

type AllocHint 'Struct

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint 'Struct -> m (Unwrapped (UntypedSomePtr 'Struct ('Mut s)))

Allocate ('List ('Just 'ListComposite))

Defined in Capnp.Untyped

Associated Types

type AllocHint ('List ('Just 'ListComposite))

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint ('List ('Just 'ListComposite)) -> m (Unwrapped (UntypedSomePtr ('List ('Just 'ListComposite)) ('Mut s)))

AllocateNormalList r => Allocate ('List ('Just ('ListNormal r)))

Defined in Capnp.Untyped

Associated Types

type AllocHint ('List ('Just ('ListNormal r)))

Methods

alloc :: RWCtx m s => Message ('Mut s) -> AllocHint ('List ('Just ('ListNormal r))) -> m (Unwrapped (UntypedSomePtr ('List ('Just ('ListNormal r))) ('Mut s)))

class AllocateNormalList (r :: NormalListRepr) where

Like Allocate, but specialized to normal (non-composite) lists.

Instead of an AllocHint type family, the hint is always an Int, which is the number of elements.

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal r) ('Mut s))

Instances

AllocateNormalList 'NormalListPtr

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal 'NormalListPtr) ('Mut s))

AllocateNormalList ('NormalListData 'Sz0)

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz0)) ('Mut s))

AllocateNormalList ('NormalListData 'Sz1)

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz1)) ('Mut s))

AllocateNormalList ('NormalListData 'Sz16)

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz16)) ('Mut s))

AllocateNormalList ('NormalListData 'Sz32)

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz32)) ('Mut s))

AllocateNormalList ('NormalListData 'Sz64)

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz64)) ('Mut s))

AllocateNormalList ('NormalListData 'Sz8)

Defined in Capnp.Untyped

Methods

allocNormalList :: RWCtx m s => Message ('Mut s) -> Int -> m (UntypedSomeList ('ListNormal ('NormalListData 'Sz8)) ('Mut s))

data Ptr mut

A an absolute pointer to a value (of arbitrary type) in a message. Note that there is no variant for far pointers, which don't make sense with absolute addressing.

Constructors

PtrCap (Cap mut)

PtrList (List mut)

PtrStruct (Struct mut)

Instances

MaybeMutable Ptr

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => Ptr 'Const -> m (Ptr ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => Ptr ('Mut s) -> m (Ptr 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => Ptr 'Const -> m (Ptr ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => Ptr ('Mut s) -> m (Ptr 'Const)

HasMessage Ptr

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (Ptr mut) -> Message mut

TraverseMsg Ptr

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> Ptr mutA -> m (Ptr mutB)

type ReprFor (Ptr mut)

Defined in Capnp.Repr

type ReprFor (Ptr mut) = 'Ptr ('Nothing :: Maybe PtrRepr)

data List mut

A list of values (of arbitrary type) in a message.

Constructors

List0 (ListOf ('Data 'Sz0) mut)

List1 (ListOf ('Data 'Sz1) mut)

List8 (ListOf ('Data 'Sz8) mut)

List16 (ListOf ('Data 'Sz16) mut)

List32 (ListOf ('Data 'Sz32) mut)

List64 (ListOf ('Data 'Sz64) mut)

ListPtr (ListOf ('Ptr 'Nothing) mut)

ListStruct (ListOf ('Ptr ('Just 'Struct)) mut)

Instances

MaybeMutable List

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => List 'Const -> m (List ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => List ('Mut s) -> m (List 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => List 'Const -> m (List ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => List ('Mut s) -> m (List 'Const)

HasMessage List

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (List mut) -> Message mut

TraverseMsg List

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> List mutA -> m (List mutB)

type ReprFor (List mut)

Defined in Capnp.Repr

type ReprFor (List mut) = 'Ptr ('Just ('List ('Nothing :: Maybe ListRepr)))

data Struct mut

A struct value in a message.

Instances

MaybeMutable Struct

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => Struct 'Const -> m (Struct ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => Struct ('Mut s) -> m (Struct 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => Struct 'Const -> m (Struct ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => Struct ('Mut s) -> m (Struct 'Const)

HasMessage Struct

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (Struct mut) -> Message mut

MessageDefault Struct

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (Struct mut))

TraverseMsg Struct

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> Struct mutA -> m (Struct mutB)

type ReprFor (Struct mut)

Defined in Capnp.Repr

type ReprFor (Struct mut) = 'Ptr ('Just 'Struct)

data ListOf r mut

A list of values with representation r in a message.

Instances

MaybeMutable (ListRepOf r) => MaybeMutable (ListOf r)

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => ListOf r 'Const -> m (ListOf r ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => ListOf r ('Mut s) -> m (ListOf r 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => ListOf r 'Const -> m (ListOf r ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => ListOf r ('Mut s) -> m (ListOf r 'Const)

HasMessage (ListOf ('Ptr ('Just 'Struct)))

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (ListOf ('Ptr ('Just 'Struct)) mut) -> Message mut

ListRepOf r ~ NormalList => HasMessage (ListOf r)

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (ListOf r mut) -> Message mut

MessageDefault (ListOf ('Ptr ('Just 'Struct)))

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (ListOf ('Ptr ('Just 'Struct)) mut))

ListRepOf r ~ NormalList => MessageDefault (ListOf r)

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (ListOf r mut))

TraverseMsg (ListRepOf r) => TraverseMsg (ListOf r)

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> ListOf r mutA -> m (ListOf r mutB)

type ReprFor (ListOf r mut)

Defined in Capnp.Repr

type ReprFor (ListOf r mut) = 'Ptr ('Just ('List ('Just (ListReprFor r))))

data Cap mut

A Capability in a message.

Instances

MaybeMutable Cap

Defined in Capnp.Untyped

Methods

thaw :: (PrimMonad m, PrimState m ~ s) => Cap 'Const -> m (Cap ('Mut s))

freeze :: (PrimMonad m, PrimState m ~ s) => Cap ('Mut s) -> m (Cap 'Const)

unsafeThaw :: (PrimMonad m, PrimState m ~ s) => Cap 'Const -> m (Cap ('Mut s))

unsafeFreeze :: (PrimMonad m, PrimState m ~ s) => Cap ('Mut s) -> m (Cap 'Const)

HasMessage Cap

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (Cap mut) -> Message mut

TraverseMsg Cap

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> Cap mutA -> m (Cap mutB)

type ReprFor (Cap mut)

Defined in Capnp.Repr

type ReprFor (Cap mut) = 'Ptr ('Just 'Cap)

structByteCount :: Struct mut -> ByteCount

Get the size (in bytes) of a struct's data section.

structWordCount :: Struct mut -> WordCount

Get the size (in words) of a struct's data section.

structPtrCount :: Struct mut -> Word16

Get the size of a struct's pointer section.

structListByteCount :: ListOf ('Ptr ('Just 'Struct)) mut -> ByteCount

Get the size (in words) of the data sections in a struct list.

structListWordCount :: ListOf ('Ptr ('Just 'Struct)) mut -> WordCount

Get the size (in words) of the data sections in a struct list.

structListPtrCount :: ListOf ('Ptr ('Just 'Struct)) mut -> Word16

Get the size of the pointer sections in a struct list.

getData :: ReadCtx m msg => Int -> Struct msg -> m Word64

getData i struct gets the ith word from the struct's data section, returning 0 if it is absent.

getPtr :: ReadCtx m msg => Int -> Struct msg -> m (Maybe (Ptr msg))

getPtr i struct gets the ith word from the struct's pointer section, returning Nothing if it is absent.

setData :: (ReadCtx m ('Mut s), WriteCtx m s) => Word64 -> Int -> Struct ('Mut s) -> m ()

setData value i struct sets the ith word in the struct's data section to value.

setPtr :: (ReadCtx m ('Mut s), WriteCtx m s) => Maybe (Ptr ('Mut s)) -> Int -> Struct ('Mut s) -> m ()

setData value i struct sets the ith pointer in the struct's pointer section to value.

copyStruct :: RWCtx m s => Struct ('Mut s) -> Struct ('Mut s) -> m ()

copyStruct dest src copies the source struct to the destination struct.

copyPtr :: RWCtx m s => Message ('Mut s) -> Maybe (Ptr ('Mut s)) -> m (Maybe (Ptr ('Mut s)))

Make a copy of the value at the pointer, in the target message.

copyList :: RWCtx m s => Message ('Mut s) -> List ('Mut s) -> m (List ('Mut s))

Make a copy of the list, in the target message.

copyCap :: RWCtx m s => Message ('Mut s) -> Cap ('Mut s) -> m (Cap ('Mut s))

Make a copy of a capability inside the target message.

getClient :: ReadCtx m mut => Cap mut -> m Client

Extract a client (indepedent of the messsage) from the capability.

get :: ReadCtx m mut => WordPtr mut -> m (Maybe (Ptr mut))

get ptr returns the Ptr stored at ptr. Deducts 1 from the quota for each word read (which may be multiple in the case of far pointers).

index :: (ReadCtx m mut, ListItem r) => Int -> ListOf r mut -> m (Unwrapped (Untyped r mut))

index i list returns the ith element in list. Deducts 1 from the quota

setIndex :: (RWCtx m s, ListItem r) => Unwrapped (Untyped r ('Mut s)) -> Int -> ListOf r ('Mut s) -> m ()

'setIndex value i list Set the ith element of list to value.

take :: (ListItem r, MonadThrow m) => Int -> ListOf r mut -> m (ListOf r mut)

Return a prefix of the list, of the given length.

rootPtr :: ReadCtx m mut => Message mut -> m (Struct mut)

Returns the root pointer of a message.

setRoot :: WriteCtx m s => Struct ('Mut s) -> m ()

Make the given struct the root object of its message.

rawBytes :: ReadCtx m 'Const => ListOf ('Data 'Sz8) 'Const -> m ByteString

rawBytes returns the raw bytes corresponding to the list.

type ReadCtx m mut = (MonadReadMessage mut m, MonadThrow m, MonadLimit m)

Type (constraint) synonym for the constraints needed for most read operations.

type RWCtx m s = (ReadCtx m ('Mut s), WriteCtx m s)

Synonym for ReadCtx + WriteCtx

class HasMessage (f :: Mutability -> Type) where

Types whose storage is owned by a message..

Methods

message :: Unwrapped (f mut) -> Message mut

Get the message in which the value is stored.

Instances

HasMessage WordPtr

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (WordPtr mut) -> Message mut

HasMessage Cap

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (Cap mut) -> Message mut

HasMessage List

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (List mut) -> Message mut

HasMessage Ptr

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (Ptr mut) -> Message mut

HasMessage Struct

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (Struct mut) -> Message mut

HasMessage (Untyped (ReprFor a)) => HasMessage (Raw a)

Defined in Capnp.Repr

Methods

message :: forall (mut :: Mutability). Unwrapped (Raw a mut) -> Message mut

HasMessage (ListOf ('Ptr ('Just 'Struct)))

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (ListOf ('Ptr ('Just 'Struct)) mut) -> Message mut

ListRepOf r ~ NormalList => HasMessage (ListOf r)

Defined in Capnp.Untyped

Methods

message :: forall (mut :: Mutability). Unwrapped (ListOf r mut) -> Message mut

class HasMessage f => MessageDefault f where

Types which have a "default" value, but require a message to construct it.

The default is usually conceptually zero-size. This is mostly useful for generated code, so that it can use standard decoding techniques on default values.

Methods

messageDefault :: ReadCtx m mut => Message mut -> m (Unwrapped (f mut))

Instances

MessageDefault Struct

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (Struct mut))

MessageDefault (Untyped (ReprFor a)) => MessageDefault (Raw a)

Defined in Capnp.Repr

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (Raw a mut))

MessageDefault (ListOf ('Ptr ('Just 'Struct)))

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (ListOf ('Ptr ('Just 'Struct)) mut))

ListRepOf r ~ NormalList => MessageDefault (ListOf r)

Defined in Capnp.Untyped

Methods

messageDefault :: forall m (mut :: Mutability). ReadCtx m mut => Message mut -> m (Unwrapped (ListOf r mut))

allocStruct :: WriteCtx m s => Message ('Mut s) -> Word16 -> Word16 -> m (Struct ('Mut s))

Allocate a struct in the message.

allocCompositeList

Arguments

:: WriteCtx m s

=> Message ('Mut s)

The message to allocate in.

-> Word16

The size of the data section

-> Word16

The size of the pointer section

-> Int

The length of the list in elements.

-> m (ListOf ('Ptr ('Just 'Struct)) ('Mut s))

Allocate a composite list.

allocList0 :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Data 'Sz0) ('Mut s))

Allocate a list of capnproto Void values.

allocList1 :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Data 'Sz1) ('Mut s))

Allocate a list of booleans

allocList8 :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Data 'Sz8) ('Mut s))

Allocate a list of 8-bit values.

allocList16 :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Data 'Sz16) ('Mut s))

Allocate a list of 16-bit values.

allocList32 :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Data 'Sz32) ('Mut s))

Allocate a list of 32-bit values.

allocList64 :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Data 'Sz64) ('Mut s))

Allocate a list of 64-bit words.

allocListPtr :: WriteCtx m s => Message ('Mut s) -> Int -> m (ListOf ('Ptr 'Nothing) ('Mut s))

Allocate a list of pointers.

appendCap :: WriteCtx m s => Message ('Mut s) -> Client -> m (Cap ('Mut s))

class TraverseMsg f where

N.B. this should mostly be considered an implementation detail, but it is exposed because it is used by generated code.

TraverseMsg is similar to Traversable from the prelude, but the intent is that rather than conceptually being a "container", the instance is a value backed by a message, and the point of the type class is to be able to apply transformations to the underlying message.

We don't just use Traversable for this for two reasons:

1. While algebraically it makes sense, it would be very unintuitive to e.g. have the Traversable instance for List not traverse over the *elements* of the list.
2. For the instance for WordPtr, we actually need a stronger constraint than Applicative in order for the implementation to type check. A previous version of the library *did* have tMsg :: Applicative m => ..., but performance considerations eventually forced us to open up the hood a bit.

Methods

tMsg :: TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> f mutA -> m (f mutB)

Instances

TraverseMsg WordPtr

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> WordPtr mutA -> m (WordPtr mutB)

TraverseMsg Cap

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> Cap mutA -> m (Cap mutB)

TraverseMsg List

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> List mutA -> m (List mutB)

TraverseMsg Ptr

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> Ptr mutA -> m (Ptr mutB)

TraverseMsg Struct

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> Struct mutA -> m (Struct mutB)

TraverseMsg (ListRepOf r) => TraverseMsg (ListOf r)

Defined in Capnp.Untyped

Methods

tMsg :: forall m (mutA :: Mutability) (mutB :: Mutability). TraverseMsgCtx m mutA mutB => (Message mutA -> m (Message mutB)) -> ListOf r mutA -> m (ListOf r mutB)