Lorentz.StoreClass

This module provides storage interfaces.

Whenever you need to write a generic code applicable to different storage formats, consider using this module.

Use methods like stToField and stUpdate to work with storage from your code.

To explain how e.g. required fields are obtainable from your storage you define StoreHasField instance (and a similar case is for other typeclasses). We provide the most common building blocks for implementing these instances, see Implementations section.

Preliminary

type FieldRefKind = FieldRefTag -> Type

Open kind for various field references.

The simplest field reference could be Label, pointing to a field by its name, but we also support more complex scenarios like deep fields identifiers.

data FieldRefTag

Instances

KnownFieldRef SelfRef

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject SelfRef = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject SelfRef p

StoreHasField store SelfRef store

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store SelfRef store

(StoreHasField store field substore, StoreHasField substore subfield ty, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters substore) => StoreHasField store (field :-| subfield :: FieldRefTag -> Type) ty

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store (field :-| subfield) ty

(StoreHasField store field substore, StoreHasSubmap substore subfield key value, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters store, Dupable substore) => StoreHasSubmap store (field :-| subfield :: FieldRefTag -> Type) key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps store (field :-| subfield) key value

(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key ()

KnownFieldRef (FieldAlias alias :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject (FieldAlias alias) = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (FieldAlias alias) p

(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value

(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value

FieldRefHasFinalName r => FieldRefHasFinalName (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefFinalName (l :-| r) :: Symbol

Methods

fieldRefFinalName :: FieldRef (l :-| r) -> Label (FieldRefFinalName (l :-| r))

(KnownFieldRef l, KnownFieldRef r) => KnownFieldRef (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject (l :-| r) = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (l :-| r) p

type FieldRefObject SelfRef

Defined in Lorentz.StoreClass

type FieldRefObject SelfRef = SelfRef

type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type) = FieldAlias alias

type FieldRefFinalName (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

type FieldRefFinalName (l :-| r :: FieldRefTag -> Type) = FieldRefFinalName r

type FieldRefObject (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

type FieldRefObject (l :-| r :: FieldRefTag -> Type) = l :-| r

class KnownFieldRef (ty :: k) where

For a type-level field reference - an associated term-level representation.

This is similar to singletons Sing + SingI pair but has small differences:

• Dedicated to field references, thus term-level thing has FieldRefKind kind.
• The type of term-level value (FieldRefObject ty) determines the kind of the reference type.

Associated Types

type FieldRefObject ty = (fr :: FieldRefKind) | fr -> ty

Methods

mkFieldRef :: FieldRefObject ty p

Instances

KnownSymbol name => KnownFieldRef (name :: Symbol)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject name = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject name p

KnownFieldRef SelfRef

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject SelfRef = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject SelfRef p

KnownFieldRef (FieldAlias alias :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject (FieldAlias alias) = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (FieldAlias alias) p

(KnownFieldRef l, KnownFieldRef r) => KnownFieldRef (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject (l :-| r) = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (l :-| r) p

data FieldName (n :: Symbol) (p :: FieldRefTag)

The simplest field reference - just a name. Behaves similarly to Label.

type FieldRef name = FieldRefObject name 'FieldRefTag

Some kind of reference to a field.

The idea behind this type is that in trivial case (name :: Symbol) it can be instantiated with a mere label, but it is generic enough to allow complex field references as well.

type FieldSymRef name = FieldRef (name :: Symbol)

Version of FieldRef restricted to symbolic labels.

FieldSymRef name ≡ FieldName name 'FieldRefTag

fieldNameToLabel :: FieldSymRef n -> Label n

Convert a symbolic FieldRef to a label, useful for compatibility with other interfaces.

fieldNameFromLabel :: Label n -> FieldSymRef n

Convert a label to FieldRef, useful for compatibility with other interfaces.

class FieldRefHasFinalName fr where

Provides access to the direct name of the referred field.

This is used in stToFieldNamed.

Associated Types

type FieldRefFinalName fr :: Symbol

Methods

fieldRefFinalName :: FieldRef fr -> Label (FieldRefFinalName fr)

Instances

FieldRefHasFinalName (name :: Symbol)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefFinalName name :: Symbol

Methods

fieldRefFinalName :: FieldRef name -> Label (FieldRefFinalName name)

FieldRefHasFinalName r => FieldRefHasFinalName (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefFinalName (l :-| r) :: Symbol

Methods

fieldRefFinalName :: FieldRef (l :-| r) -> Label (FieldRefFinalName (l :-| r))

Class

class StoreHasField store fname ftype | store fname -> ftype where

Provides operations on fields for storage.

Methods

storeFieldOps :: StoreFieldOps store fname ftype

Instances

HasFieldOfType store fname ftype => StoreHasField store (fname :: Symbol) ftype

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store fname ftype

StoreHasField store SelfRef store

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store SelfRef store

(StoreHasField store field substore, StoreHasField substore subfield ty, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters substore) => StoreHasField store (field :-| subfield :: FieldRefTag -> Type) ty

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store (field :-| subfield) ty

data StoreFieldOps store fname ftype

Datatype containing the full implementation of StoreHasField typeclass.

We use this grouping because in most cases the implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate the DerivingVia extension.)

Constructors

StoreFieldOps

Fields

• sopToField :: forall s. FieldRef fname -> (store ': s) :-> (ftype ': s)
• sopGetFieldOpen :: forall res s. HasDupableGetters store => ('[ftype] :-> '[res, ftype]) -> ('[ftype] :-> '[res]) -> FieldRef fname -> (store ': s) :-> (res ': (store ': s))

  See getFieldOpen for explanation of the signature.

• sopSetFieldOpen :: forall new s. ('[new, ftype] :-> '[ftype]) -> FieldRef fname -> (new ': (store ': s)) :-> (store ': s)

  See setFieldOpen for explanation of the signature.

class StoreHasSubmap store mname key value | store mname -> key value where

Provides operations on submaps of storage.

Methods

storeSubmapOps :: StoreSubmapOps store mname key value

Instances

(StoreHasField store name submap, StoreHasSubmap submap SelfRef key value, KnownSymbol name, HasDupableGetters store, Dupable submap) => StoreHasSubmap store (name :: Symbol) key value

Provides access to the submap via the respective field.

Tricky storages that consolidate submaps in a non-trivial way can define instances overlapping this one.

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps store name key value

(StoreHasField store field substore, StoreHasSubmap substore subfield key value, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters store, Dupable substore) => StoreHasSubmap store (field :-| subfield :: FieldRefTag -> Type) key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps store (field :-| subfield) key value

(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key ()

(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value

(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value

data StoreSubmapOps store mname key value

Datatype containing the full implementation of StoreHasSubmap typeclass.

We use this grouping because in most cases the implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate the DerivingVia extension.)

Constructors

StoreSubmapOps

Fields

• sopMem :: forall s. FieldRef mname -> (key ': (store ': s)) :-> (Bool ': s)
• sopGet :: forall s. KnownValue value => FieldRef mname -> (key ': (store ': s)) :-> (Maybe value ': s)
• sopUpdate :: forall s. FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (store ': s)
• sopGetAndUpdate :: forall s. FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))
• sopDelete :: forall s. FieldRef mname -> (key ': (store ': s)) :-> (store ': s)
• sopInsert :: forall s. FieldRef mname -> (key ': (value ': (store ': s))) :-> (store ': s)

class StoreHasEntrypoint store epName epParam epStore | store epName -> epParam epStore where

Provides operations on stored entrypoints.

store is the storage containing both the entrypoint epName (note: it has to be in a BigMap to take advantage of lazy evaluation) and the epStore field this operates on.

Methods

storeEpOps :: StoreEntrypointOps store epName epParam epStore

data StoreEntrypointOps store epName epParam epStore

Datatype containing the full implementation of StoreHasEntrypoint typeclass.

We use this grouping because in most cases the implementation will be chosen among the default ones, and initializing all methods at once is simpler and more consistent. (One can say that we are trying to emulate the DerivingVia extension.)

Constructors

StoreEntrypointOps

Fields

• sopToEpLambda :: forall s. Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)
• sopSetEpLambda :: forall s. HasDupableGetters store => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)
• sopToEpStore :: forall s. Label epName -> (store ': s) :-> (epStore ': s)
• sopSetEpStore :: forall s. Label epName -> (epStore ': (store ': s)) :-> (store ': s)

Useful type synonyms

type EntrypointLambda param store = Lambda (param, store) ([Operation], store)

Type synonym for a Lambda that can be used as an entrypoint

type EntrypointsField param store = BigMap MText (EntrypointLambda param store)

Type synonym of a BigMap mapping MText (entrypoint names) to EntrypointLambda.

This is useful when defining instances of StoreHasEntrypoint as a storage field containing one or more entrypoints (lambdas) of the same type.

Expressing constraints on storage

data k ~> v infix 9

Indicates a submap with given key and value types.

data param ::-> store infix 9

Indicates a stored entrypoint with the given param and store types.

type family StorageContains store (content :: [NamedField]) :: Constraint where ...

Concise way to write down constraints with expected content of a storage.

Use it like follows:

type StorageConstraint store = StorageContains store
  [ "fieldInt" := Int
  , "fieldNat" := Nat
  , "epsToNat" := Int ::-> Nat
  , "balances" := Address ~> Int
  ]

Note that this won't work with complex field references, they have to be included using e.g. StoreHasField manually.

Equations

StorageContains _ '[] = ()

StorageContains store ((n := Identity ty) ': ct) = (StoreHasField store n ty, StorageContains store ct)

StorageContains store ((n := (k ~> v)) ': ct) = (StoreHasSubmap store n k v, StorageContains store ct)

StorageContains store ((n := (ep ::-> es)) ': ct) = (StoreHasEntrypoint store n ep es, StorageContains store ct)

StorageContains store ((n := ty) ': ct) = (StoreHasField store n ty, StorageContains store ct)

Methods to work with storage

stToField :: StoreHasField store fname ftype => FieldRef fname -> (store ': s) :-> (ftype ': s)

Pick storage field.

stGetField :: (StoreHasField store fname ftype, Dupable ftype, HasDupableGetters store) => FieldRef fname -> (store ': s) :-> (ftype ': (store ': s))

Get storage field, preserving the storage itself on stack.

stToFieldNamed :: (StoreHasField store fname ftype, FieldRefHasFinalName fname) => FieldRef fname -> (store ': s) :-> ((FieldRefFinalName fname :! ftype) ': s)

Pick storage field retaining a name label attached.

For complex refs this tries to attach the immediate name of the referred field.

stGetFieldNamed :: (StoreHasField store fname ftype, FieldRefHasFinalName fname, Dupable ftype, HasDupableGetters store) => FieldRef fname -> (store ': s) :-> ((FieldRefFinalName fname :! ftype) ': (store ': s))

Version of stToFieldNamed that preserves the storage on stack.

stSetField :: StoreHasField store fname ftype => FieldRef fname -> (ftype ': (store ': s)) :-> (store ': s)

Update storage field.

stMem :: StoreHasSubmap store mname key value => FieldRef mname -> (key ': (store ': s)) :-> (Bool ': s)

Check value presence in storage.

stGet :: (StoreHasSubmap store mname key value, KnownValue value) => FieldRef mname -> (key ': (store ': s)) :-> (Maybe value ': s)

Get value in storage.

stUpdate :: StoreHasSubmap store mname key value => FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (store ': s)

Update a value in storage.

stGetAndUpdate :: StoreHasSubmap store mname key value => FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))

Atomically get and update a value in storage.

stDelete :: forall store mname key value s. StoreHasSubmap store mname key value => FieldRef mname -> (key ': (store ': s)) :-> (store ': s)

Delete a value in storage.

stInsert :: StoreHasSubmap store mname key value => FieldRef mname -> (key ': (value ': (store ': s))) :-> (store ': s)

Add a value in storage.

stInsertNew :: (StoreHasSubmap store mname key value, Dupable key) => FieldRef mname -> (forall s0 any. (key ': s0) :-> any) -> (key ': (value ': (store ': s))) :-> (store ': s)

Add a value in storage, but fail if it will overwrite some existing entry.

stEntrypoint :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (epParam ': (store ': s)) :-> (([Operation], store) ': s)

Extracts and executes the epName entrypoint lambda from storage, returing the updated full storage (store) and the produced Operations.

stToEpLambda :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)

Pick stored entrypoint lambda.

stGetEpLambda :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': (store ': s))

Get stored entrypoint lambda, preserving the storage itself on the stack.

stSetEpLambda :: (StoreHasEntrypoint store epName epParam epStore, HasDupableGetters store) => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)

Stores the entrypoint lambda in the storage. Fails if already set.

stToEpStore :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (store ': s) :-> (epStore ': s)

Pick the sub-storage that the entrypoint operates on.

stGetEpStore :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store ': s) :-> (epStore ': (store ': s))

Get the sub-storage that the entrypoint operates on, preserving the storage itself on the stack.

stSetEpStore :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (epStore ': (store ': s)) :-> (store ': s)

Update the sub-storage that the entrypoint operates on.

sopGetField :: (Dupable ftype, HasDupableGetters store) => StoreFieldOps store fname ftype -> FieldRef fname -> (store ': s) :-> (ftype ': (store ': s))

Simplified version of sopGetFieldOpen where res is ftype.

sopSetField :: StoreFieldOps store fname ftype -> FieldRef fname -> (ftype ': (store ': s)) :-> (store ': s)

Simplified version of sopSetFieldOpen where res is ftype.

Implementations

storeFieldOpsADT :: HasFieldOfType dt fname ftype => StoreFieldOps dt (fname :: Symbol) ftype

Implementation of StoreHasField for case of datatype keeping a pack of fields.

storeEntrypointOpsADT :: (HasFieldOfType store epmName (EntrypointsField epParam epStore), HasFieldOfType store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

Implementation of StoreHasEntrypoint for a datatype keeping a pack of fields, among which one contains the entrypoint and another is what such entrypoint operates on.

storeEntrypointOpsFields :: (StoreHasField store epmName (EntrypointsField epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

Implementation of StoreHasEntrypoint for a datatype that has a StoreHasField for an EntrypointsField that contains the entrypoint and a StoreHasField for the field such entrypoint operates on.

storeEntrypointOpsSubmapField :: (StoreHasSubmap store epmName MText (EntrypointLambda epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

Implementation of StoreHasEntrypoint for a datatype that has a StoreHasSubmap that contains the entrypoint and a StoreHasField for the field such entrypoint operates on.

storeFieldOpsDeeper :: (HasFieldOfType storage fieldsPartName fields, StoreHasField fields fname ftype, HasDupableGetters fields) => FieldRef fieldsPartName -> StoreFieldOps storage fname ftype

Implementation of StoreHasField for a data type which has an instance of StoreHasField inside. For instance, it can be used for top-level storage.

storeSubmapOpsDeeper :: (HasFieldOfType storage bigMapPartName fields, StoreHasSubmap fields SelfRef key value, HasDupableGetters storage, Dupable fields) => FieldRef bigMapPartName -> StoreSubmapOps storage mname key value

Implementation of StoreHasSubmap for a data type which has an instance of StoreHasSubmap inside. For instance, it can be used for top-level storage.

storeEntrypointOpsDeeper :: (HasFieldOfType store nameInStore substore, StoreHasEntrypoint substore epName epParam epStore, HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreEntrypointOps store epName epParam epStore

Implementation of StoreHasEntrypoint for a data type which has an instance of StoreHasEntrypoint inside. For instance, it can be used for top-level storage.

storeFieldOpsReferTo :: FieldRef name -> StoreFieldOps storage name field -> StoreFieldOps storage desiredName field

Pretend that given StoreFieldOps implementation is made up for field with name desiredName, not its actual name. Logic of the implementation remains the same.

See also storeSubmapOpsReferTo.

storeSubmapOpsReferTo :: FieldRef name -> StoreSubmapOps storage name key value -> StoreSubmapOps storage desiredName key value

Pretend that given StoreSubmapOps implementation is made up for submap with name desiredName, not its actual name. Logic of the implementation remains the same.

Use case: imagine that your code requires access to submap named X, but in your storage that submap is called Y. Then you implement the instance which makes X refer to Y:

instance StoreHasSubmap Store X Key Value where
  storeSubmapOps = storeSubmapOpsReferTo #Y storeSubmapOpsForY

mapStoreFieldOps :: forall field1 field2 store name. KnownValue field1 => LIso field1 field2 -> StoreFieldOps store name field1 -> StoreFieldOps store name field2

Change field operations so that they work on a modified field.

For instance, to go from StoreFieldOps Storage "name" Integer to StoreFieldOps Storage "name" (value :! Integer) you can use mapStoreFieldOps (namedIso #value)

mapStoreSubmapOpsKey :: Lambda key2 key1 -> StoreSubmapOps store name key1 value -> StoreSubmapOps store name key2 value

Change submap operations so that they work on a modified key.

mapStoreSubmapOpsValue :: (KnownValue value1, KnownValue value2) => LIso value1 value2 -> StoreSubmapOps store name key value1 -> StoreSubmapOps store name key value2

Change submap operations so that they work on a modified value.

storeEntrypointOpsReferTo :: Label epName -> StoreEntrypointOps store epName epParam epStore -> StoreEntrypointOps store desiredName epParam epStore

Pretend that given StoreEntrypointOps implementation is made up for entrypoint with name desiredName, not its actual name. Logic of the implementation remains the same.

See also storeSubmapOpsReferTo.

composeStoreFieldOps :: HasDupableGetters substore => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreFieldOps substore nameInSubstore field -> StoreFieldOps store nameInSubstore field

Chain two implementations of field operations.

Suits for a case when your store does not contain its fields directly rather has a nested structure.

composeStoreSubmapOps :: (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreSubmapOps substore mname key value -> StoreSubmapOps store mname key value

Chain implementations of field and submap operations.

This requires Dupable substore for simplicity, in most cases it is possible to use a different chaining (nameInStore :-| mname :-| this) to avoid that constraint. If this constraint is still an issue, please create a ticket.

sequenceStoreSubmapOps :: forall store substore value name subName key1 key2. (NiceConstant substore, KnownValue value, Dupable (key1, key2), Dupable store) => FieldRef name -> LIso (Maybe substore) substore -> StoreSubmapOps store name key1 substore -> StoreSubmapOps substore subName key2 value -> StoreSubmapOps store subName (key1, key2) value

Chain implementations of two submap operations sets. Used to provide shortcut access to a nested submap.

This is very inefficient since on each access to substore it has to be serialized/deserialized. Use this implementation only if due to historical reasons migrating storage is difficult.

LIso (Maybe substore) substore argument describes how to get substore value if it was absent in map and how to detect when it can be safely removed.

Example of use: sequenceStoreSubmapOps #mySubmap nonDefIso storeSubmapOps storeSubmapOps

composeStoreEntrypointOps :: (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreEntrypointOps substore epName epParam epStore -> StoreEntrypointOps store epName epParam epStore

zoomStoreSubmapOps :: forall store submapName nameInSubmap key value subvalue. (NiceConstant value, NiceConstant subvalue, Dupable key, Dupable store) => FieldRef submapName -> LIso (Maybe value) value -> LIso (Maybe subvalue) subvalue -> StoreSubmapOps store submapName key value -> StoreFieldOps value nameInSubmap subvalue -> StoreSubmapOps store nameInSubmap key subvalue

Turn submap operations into operations on a part of the submap value.

Normally, if you need this set of operations, it would be better to split your submap into several separate submaps, each operating with its own part of the value. This set of operations is pretty inefficient and exists only as a temporary measure, if due to historical reasons you have to leave storage format intact.

This implementation puts no distinction between value == Nothing and value == Just defValue cases. Getters, when notice a value equal to the default value, report its absence. Setters tend to remove the value from submap when possible.

LIso (Maybe value) value and LIso (Maybe subvalue) subvalue arguments describe how to get a value if it was absent in map and how to detect when it can be safely removed from map.

Example of use: zoomStoreSubmapOps #mySubmap nonDefIso nonDefIso storeSubmapOps storeFieldOpsADT

Storage generation

mkStoreEp :: Label epName -> EntrypointLambda epParam epStore -> EntrypointsField epParam epStore

Utility to create EntrypointsFields from an entrypoint name (epName) and an EntrypointLambda implementation. Note that you need to merge multiple of these (with <>) if your field contains more than one entrypoint lambda.

Complex field references

data ((l :: k1) :-| (r :: k2)) (p :: FieldRefTag) infixr 8

Refer to a nested entry in storage.

Example: stToField (#a :-| #b) fetches field b in the type under field a.

If not favouring this name much, you can try an alias from Lorentz.StoreClass.Extra.

Constructors

(FieldRef l) :-| (FieldRef r) infixr 8

Instances

(StoreHasField store field substore, StoreHasField substore subfield ty, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters substore) => StoreHasField store (field :-| subfield :: FieldRefTag -> Type) ty

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store (field :-| subfield) ty

(StoreHasField store field substore, StoreHasSubmap substore subfield key value, KnownFieldRef field, KnownFieldRef subfield, HasDupableGetters store, Dupable substore) => StoreHasSubmap store (field :-| subfield :: FieldRefTag -> Type) key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps store (field :-| subfield) key value

FieldRefHasFinalName r => FieldRefHasFinalName (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefFinalName (l :-| r) :: Symbol

Methods

fieldRefFinalName :: FieldRef (l :-| r) -> Label (FieldRefFinalName (l :-| r))

(KnownFieldRef l, KnownFieldRef r) => KnownFieldRef (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject (l :-| r) = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (l :-| r) p

type FieldRefFinalName (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

type FieldRefFinalName (l :-| r :: FieldRefTag -> Type) = FieldRefFinalName r

type FieldRefObject (l :-| r :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

type FieldRefObject (l :-| r :: FieldRefTag -> Type) = l :-| r

data SelfRef (p :: FieldRefTag)

Refer to no particular field, access itself.

Constructors

SelfRef

Instances

KnownFieldRef SelfRef

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject SelfRef = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject SelfRef p

StoreHasField store SelfRef store

Defined in Lorentz.StoreClass

Methods

storeFieldOps :: StoreFieldOps store SelfRef store

(NiceComparable key, Ord key, Dupable key) => StoreHasSubmap (Set key) SelfRef key ()

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (Set key) SelfRef key ()

(NiceComparable key, KnownValue value) => StoreHasSubmap (Map key value) SelfRef key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (Map key value) SelfRef key value

(NiceComparable key, KnownValue value) => StoreHasSubmap (BigMap key value) SelfRef key value

Defined in Lorentz.StoreClass

Methods

storeSubmapOps :: StoreSubmapOps (BigMap key value) SelfRef key value

type FieldRefObject SelfRef

Defined in Lorentz.StoreClass

type FieldRefObject SelfRef = SelfRef

this :: SelfRef p

An alias for SelfRef.

Examples:

>>> push 5 # stMem this -$ (mempty :: Map Integer MText)
False

>>> stGetField this # pair -$ (5 :: Integer)
(5,5)

stNested :: StNestedImpl f SelfRef => f

Provides alternative variadic interface for deep entries access.

Example: stToField (stNested #a #b #c)

data FieldAlias (alias :: k) (p :: FieldRefTag)

Alias for a field reference.

This allows creating _custom_ field references; you will have to define the respective StoreHasField and StoreHasSubmap instances manually. Since this type occupies a different "namespace" than string labels and :-|, no overlappable instances will be necessary.

Example:

-- Shortcut for a deeply nested field X
data FieldX

instance StoreHasField Storage (FieldAlias FieldX) Integer where
  ...

accessX = stToField (stAlias @FieldX)

Note that alias type argument allows instantiations of any kind.

Instances

KnownFieldRef (FieldAlias alias :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

Associated Types

type FieldRefObject (FieldAlias alias) = (fr :: FieldRefKind)

Methods

mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject (FieldAlias alias) p

type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type)

Defined in Lorentz.StoreClass

type FieldRefObject (FieldAlias alias :: FieldRefTag -> Type) = FieldAlias alias

stAlias :: forall alias. FieldRef (FieldAlias alias)

Construct an alias at term level.

This requires passing the alias via type annotation.

type FieldNickname alias = FieldAlias (alias :: Symbol)

Kind-restricted version of FieldAlias to work solely with string labels.

stNickname :: Label name -> FieldRef (FieldAlias name)

Version of stAlias adopted to labels.

Orphan instances

(x ~ FieldName name, KnownSymbol name) => IsLabel name (x p)

Methods

fromLabel :: x p