Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
Synopsis
- class BorshSize a => ToBorsh a where
- encodeBorsh :: Encoder a
- newtype Encoder a = Encoder {
- runEncoder :: a -> Builder
- serialiseBorsh :: ToBorsh a => a -> ByteString
- class BorshSize a => FromBorsh a where
- decodeBorsh :: Decoder s a
- data Decoder s a
- data DeserialiseFailure = DeserialiseFailure ByteOffset String
- deserialiseBorsh :: FromBorsh a => ByteString -> Either DeserialiseFailure a
- class BorshSize (a :: Type) where
- type StaticBorshSize a :: KnownSize
- borshSize :: Proxy a -> Size (StaticBorshSize a)
- data Size (a :: KnownSize) where
- SizeKnown :: Word32 -> Size 'HasKnownSize
- SizeVariable :: Size 'HasVariableSize
- data KnownSize
- class BorshSizeSum (xss :: [[Type]]) where
- borshSizeSum :: Proxy xss -> Size (SumKnownSize xss)
- class BorshMaxSize (a :: Type) where
- borshMaxSize :: Proxy a -> Word32
- newtype AsEnum a = AsEnum {
- getEnum :: a
- newtype AsStruct a = AsStruct {
- getStruct :: a
- newtype KnownImpliesMax a = KnownImpliesMax {
- getKnownImpliesMax :: a
Serialisation
class BorshSize a => ToBorsh a where Source #
encodeBorsh :: Encoder a Source #
Encoder to Borsh
There is no generic default implementation of encodeBorsh
; instead use
deriving-via using AsStruct
or AsEnum
.
Instances
Encoder
An encoder describes how to serialise a given value in BORSH format.
Encoder | |
|
serialiseBorsh :: ToBorsh a => a -> ByteString Source #
Deserialisation
class BorshSize a => FromBorsh a where Source #
decodeBorsh :: Decoder s a Source #
Decode from Borsh
There is no generic default implementation of decodeBorsh
; instead use
deriving-via using AsStruct
or AsEnum
.
Instances
Decoder
A decoder describes how to match against a single chunk of the input.
For decoders for primitive types, use FromBorsh
instances.
data DeserialiseFailure Source #
Error type for deserialisation.
DeserialiseFailure | |
|
Instances
Exception DeserialiseFailure Source # | |
Show DeserialiseFailure Source # | |
Defined in Codec.Borsh.Incremental.Monad showsPrec :: Int -> DeserialiseFailure -> ShowS # show :: DeserialiseFailure -> String # showList :: [DeserialiseFailure] -> ShowS # | |
Eq DeserialiseFailure Source # | |
Defined in Codec.Borsh.Incremental.Monad (==) :: DeserialiseFailure -> DeserialiseFailure -> Bool # (/=) :: DeserialiseFailure -> DeserialiseFailure -> Bool # |
deserialiseBorsh :: FromBorsh a => ByteString -> Either DeserialiseFailure a Source #
Size of encodings
class BorshSize (a :: Type) where Source #
type StaticBorshSize a :: KnownSize Source #
Instances
data Size (a :: KnownSize) where Source #
The statically known size of encodings of values of a particular type.
SizeKnown :: Word32 -> Size 'HasKnownSize | |
SizeVariable :: Size 'HasVariableSize |
class BorshSizeSum (xss :: [[Type]]) where Source #
Auxiliary class to BorshSize
describing the conditions under which the
size of the encoding of a value of a sum-type is known.
borshSizeSum :: Proxy xss -> Size (SumKnownSize xss) Source #
Instances
BorshSizeSum ('[] :: [[Type]]) Source # | |
Defined in Codec.Borsh.Class borshSizeSum :: Proxy '[] -> Size (SumKnownSize '[]) Source # | |
BorshSizeSum (xs ': (ys ': zss)) Source # | |
Defined in Codec.Borsh.Class borshSizeSum :: Proxy (xs ': (ys ': zss)) -> Size (SumKnownSize (xs ': (ys ': zss))) Source # | |
All BorshSize xs => BorshSizeSum '[xs] Source # | |
Defined in Codec.Borsh.Class borshSizeSum :: Proxy '[xs] -> Size (SumKnownSize '[xs]) Source # |
class BorshMaxSize (a :: Type) where Source #
borshMaxSize :: Proxy a -> Word32 Source #
Maximum size of the Borsh encoding
There is no generic default implementation of borshMaxSize
; instead use
deriving-via using AsStruct
or AsEnum
.
However, while it is possible to use deriving-via to derive BorshMaxSize
for your own types, recursive types should not be given an instance (and
the derived function will not terminate).
Instances
Deriving-via support
Deriving-via support for enums (general ADTs)
The Borsh spec https://borsh.io/ mandates that enums have a tag indicating the constructor, even when there is only a single constructor in the enum. In Rust this makes more sense than in Haskell, since in Rust enums and structs are introduced through different keywords. In Haskell, of course, the only difference between them is that a struct is an enum with a single constructor.
The generic encoder en decoder you get in ToBorsh
and FromBorsh
when
deriving via AsEnum
will therefore add the tag, independent of the number of
constructors:
data MyEnum = .. deriving (BorshSize, ToBorsh, FromBorsh) via AsEnum MyEnum
If you want the encoding of a struct, without the tag, you need to derive via
AsStruct
.
Instances
(Generic a, All2 BorshMaxSize (Code a)) => BorshMaxSize (AsEnum a) Source # | |
Defined in Codec.Borsh.Class | |
BorshSizeSum (Code a) => BorshSize (AsEnum a) Source # | |
Defined in Codec.Borsh.Class type StaticBorshSize (AsEnum a) :: KnownSize Source # | |
(Generic a, BorshSizeSum (Code a), All2 FromBorsh (Code a)) => FromBorsh (AsEnum a) Source # | |
Defined in Codec.Borsh.Class decodeBorsh :: Decoder s (AsEnum a) Source # | |
(Generic a, BorshSizeSum (Code a), All2 ToBorsh (Code a)) => ToBorsh (AsEnum a) Source # | |
Defined in Codec.Borsh.Class encodeBorsh :: Encoder (AsEnum a) Source # | |
type StaticBorshSize (AsEnum a) Source # | |
Defined in Codec.Borsh.Class |
Deriving-via support for structs
Usage:
data MyStruct = .. deriving (BorshSize, ToBorsh, FromBorsh) via AsStruct MyStruct
NOTE: Doing so may have consequences for forwards compatibility: if a tag
is present, additional constructors can be added without invalidating the
encoding of existing constructors. See also AsEnum
.
Instances
(IsProductType a xs, All BorshMaxSize xs) => BorshMaxSize (AsStruct a) Source # | |
Defined in Codec.Borsh.Class | |
(IsProductType a xs, All BorshSize xs) => BorshSize (AsStruct a) Source # | |
Defined in Codec.Borsh.Class type StaticBorshSize (AsStruct a) :: KnownSize Source # | |
(IsProductType a xs, All BorshSize xs, All FromBorsh xs) => FromBorsh (AsStruct a) Source # | |
Defined in Codec.Borsh.Class decodeBorsh :: Decoder s (AsStruct a) Source # | |
(IsProductType a xs, All BorshSize xs, All ToBorsh xs) => ToBorsh (AsStruct a) Source # | |
Defined in Codec.Borsh.Class encodeBorsh :: Encoder (AsStruct a) Source # | |
type StaticBorshSize (AsStruct a) Source # | |
Defined in Codec.Borsh.Class |
newtype KnownImpliesMax a Source #
If the size of a type's Borsh encoding is statically known then we also know the maximum size of the encoding. Useful for deriving-via.
Instances
(BorshSize a, StaticBorshSize a ~ 'HasKnownSize) => BorshMaxSize (KnownImpliesMax a) Source # | |
Defined in Codec.Borsh.Class borshMaxSize :: Proxy (KnownImpliesMax a) -> Word32 Source # |