Module

Cardano.Serialization.Lib.Internal

#IsCsl 

class IsCsl (a :: Type)  where

Members

#IsBytes 

class (IsCsl a) <= IsBytes (a :: Type)

#toBytes 

toBytes :: forall a. IsCsl a => IsBytes a => a -> ByteArray

#fromBytes 

fromBytes :: forall a. IsCsl a => IsBytes a => ByteArray -> Maybe a

#_toBytes 

_toBytes :: forall a. a -> ByteArray

#_fromBytes 

_fromBytes :: forall b. String -> (forall a. Maybe a) -> (forall a. a -> Maybe a) -> ByteArray -> Maybe b

#IsJson 

class (IsCsl a) <= IsJson (a :: Type)

#IsCslEnum 

class IsCslEnum (e :: Type) (f :: Type) | e -> f, f -> e

#toCslEnum 

toCslEnum :: forall e f rep. IsCslEnum e f => Generic e rep => GenericBoundedEnum rep => e -> f

#fromCslEnum 

fromCslEnum :: forall e f rep. IsCslEnum e f => Generic e rep => GenericBoundedEnum rep => f -> e

#IsListContainer 

class IsListContainer (c :: Type) (e :: Type) | c -> e

#packListContainer 

packListContainer :: forall c e. IsCsl c => IsListContainer c e => Array e -> c

#packListContainerWithClone 

packListContainerWithClone :: forall c e. IsCsl c => IsListContainer c e => Array e -> c

#unpackListContainer 

unpackListContainer :: forall c e. IsListContainer c e => c -> Array e

#_packListContainer 

_packListContainer :: forall c e. Boolean -> String -> Array e -> c

#_unpackListContainer 

_unpackListContainer :: forall c e. c -> Array e

#IsMultiMapContainer 

class IsMultiMapContainer (c :: Type) (k :: Type) (vs :: Type) | c -> k, c -> vs

#packMultiMapContainer 

packMultiMapContainer :: forall c k vs. IsMultiMapContainer c k vs => IsCsl c => Array (k /\ vs) -> c

#packMultiMapContainerWithClone 

packMultiMapContainerWithClone :: forall c k vs. IsMultiMapContainer c k vs => IsCsl c => Array (k /\ vs) -> c

#unpackMultiMapContainer 

unpackMultiMapContainer :: forall c k vs. IsMultiMapContainer c k vs => c -> Array (k /\ vs)

#unpackMultiMapContainerToMapWith 

unpackMultiMapContainerToMapWith :: forall c k vs k1 v1. IsMultiMapContainer c k vs => Ord k1 => (k -> k1) -> (vs -> Array v1) -> c -> Map k1 v1

#IsMapContainer 

class IsMapContainer (c :: Type) (k :: Type) (v :: Type) | c -> k, c -> v

#packMapContainer 

packMapContainer :: forall c k v. IsMapContainer c k v => IsCsl c => Array (k /\ v) -> c

#packMapContainerWithClone 

packMapContainerWithClone :: forall c k v. IsMapContainer c k v => IsCsl c => Array (k /\ v) -> c

#packMapContainerFromMap 

packMapContainerFromMap :: forall c k v. IsMapContainer c k v => IsCsl c => IsCsl k => IsCsl v => Map k v -> c

#unpackMapContainer 

unpackMapContainer :: forall c k v. IsMapContainer c k v => c -> Array (k /\ v)

#unpackMapContainerToMapWith 

unpackMapContainerToMapWith :: forall c k v k1 v1. IsMapContainer c k v => Ord k1 => (k -> k1) -> (v -> v1) -> c -> Map k1 v1

#_packMapContainer 

_packMapContainer :: forall c k v. Boolean -> String -> Array { key :: k, value :: v } -> c

#_unpackMapContainer 

_unpackMapContainer :: forall c k v. c -> Array { key :: k, value :: v }

#_unpackMultiMapContainer 

_unpackMultiMapContainer :: forall c k vs. c -> Array { key :: k, values :: vs }

#cslFromAeson 

cslFromAeson :: forall a. IsJson a => Aeson -> Either JsonDecodeError a

#cslToAeson 

cslToAeson :: forall a. IsJson a => a -> Aeson

#cslToAesonViaBytes 

cslToAesonViaBytes :: forall a. IsBytes a => a -> Aeson

#cslFromAesonViaBytes 

cslFromAesonViaBytes :: forall a. IsBytes a => Aeson -> Either JsonDecodeError a

#showViaBytes 

showViaBytes :: forall a. IsBytes a => a -> String

#showViaJson 

showViaJson :: forall a. IsJson a => a -> String

#cslFromJson 

cslFromJson :: forall a. IsCsl a => IsJson a => Json -> Maybe a

#_cslFromJson 

_cslFromJson :: forall b. String -> (forall a. Maybe a) -> (forall a. a -> Maybe a) -> Json -> Maybe b

#_cslToJson 

_cslToJson :: forall a. a -> Json

Modules