| Safe Haskell | Safe-Inferred |
|---|---|
| Language | Haskell2010 |
Indigo.Lorentz
Description
This module is intended to be imported instead of Lorentz by Indigo modules.
The idea is to avoid repeating common hiding rules and to not export any of
Lorentz's Instructions and Macros.
Synopsis
- class Show a
- data Bool
- data Integer
- data Natural
- data Maybe a
- data ByteString
- data Set a
- data Map k a
- withDict :: HasDict c e => e -> (c => r) -> r
- class Default a where
- def :: a
- printLorentzContract :: Bool -> Contract cp st vd -> LText
- printLorentzValue :: NiceUntypedValue v => Bool -> v -> LText
- cdCompilationOptionsL :: Lens' (ContractData cp st vd) CompilationOptions
- cdCodeL :: forall cp st vd cp1. NiceParameterFull cp1 => Lens (ContractData cp st vd) (ContractData cp1 st vd) (ContractCode cp st) (ContractCode cp1 st)
- coStringTransformerL :: Lens' CompilationOptions (Bool, MText -> MText)
- coOptimizerConfL :: Lens' CompilationOptions (Maybe OptimizerConf)
- coBytesTransformerL :: Lens' CompilationOptions (Bool, ByteString -> ByteString)
- analyzeLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> AnalyzerRes
- interpretLorentzLambda :: (IsoValue inp, IsoValue out) => ContractEnv -> (IsNotInView => Fn inp out) -> inp -> Either (MichelsonFailureWithStack Void) out
- interpretLorentzInstr :: forall (inp :: [Type]) (out :: [Type]). (IsoValuesStack inp, IsoValuesStack out) => ContractEnv -> (IsNotInView => inp :-> out) -> Rec Identity inp -> Either (MichelsonFailureWithStack Void) (Rec Identity out)
- noViews :: forall {k1} {k2} contract (cp :: k1) (st :: k2). contract cp st () -> contract cp st ()
- setViewsRec :: forall vd cp st. NiceViewsDescriptor vd => Rec (ContractView st) (RevealViews vd) -> ContractData cp st () -> ContractData cp st vd
- setViews :: forall vd cp st. (RecFromTuple (Rec (ContractView st) (RevealViews vd)), NiceViewsDescriptor vd) => IsoRecTuple (Rec (ContractView st) (RevealViews vd)) -> ContractData cp st () -> ContractData cp st vd
- compileLorentzContract :: ContractData cp st vd -> Contract cp st vd
- defaultContractData :: (NiceParameterFull cp, NiceStorageFull st) => (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractData cp st ()
- mkView :: forall (name :: Symbol) arg ret st. (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret, TypeHasDoc arg, TypeHasDoc ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)
- mkContractWith :: (NiceParameterFull cp, NiceStorageFull st) => CompilationOptions -> ContractCode cp st -> Contract cp st ()
- mkContract :: (NiceParameterFull cp, NiceStorageFull st) => ContractCode cp st -> Contract cp st ()
- defaultContract :: (NiceParameterFull cp, NiceStorageFull st) => (IsNotInView => '[(cp, st)] :-> ContractOut st) -> Contract cp st ()
- compileLorentzWithOptions :: forall (inp :: [Type]) (out :: [Type]). CompilationOptions -> (inp :-> out) -> Instr (ToTs inp) (ToTs out)
- compileLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> Instr (ToTs inp) (ToTs out)
- intactCompilationOptions :: CompilationOptions
- defaultCompilationOptions :: CompilationOptions
- data CompilationOptions = CompilationOptions {
- coOptimizerConf :: Maybe OptimizerConf
- coStringTransformer :: (Bool, MText -> MText)
- coBytesTransformer :: (Bool, ByteString -> ByteString)
- data ContractData cp st vd = (NiceParameterFull cp, NiceStorageFull st, NiceViewsDescriptor vd) => ContractData {
- cdCode :: ContractCode cp st
- cdViews :: Rec (ContractView st) (RevealViews vd)
- cdCompilationOptions :: CompilationOptions
- data ContractView st (v :: ViewTyInfo) where
- ContractView :: forall (name :: Symbol) arg ret st. (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)
- pbsUParam :: forall (ctorName :: Symbol). KnownSymbol ctorName => ParamBuildingStep
- uparamFromAdt :: UParamLinearize up => up -> UParam (UParamLinearized up)
- caseUParamT :: forall (entries :: [EntrypointKind]) (inp :: [Type]) (out :: [Type]) clauses. (clauses ~ Rec (CaseClauseU inp out) entries, RecFromTuple clauses, CaseUParam entries) => IsoRecTuple clauses -> UParamFallback inp out -> (UParam entries ': inp) :-> out
- caseUParam :: forall (entries :: [EntrypointKind]) (inp :: [Type]) (out :: [Type]). (CaseUParam entries, RequireUniqueEntrypoints entries) => Rec (CaseClauseU inp out) entries -> UParamFallback inp out -> (UParam entries ': inp) :-> out
- uparamFallbackFail :: forall (inp :: [Type]) (out :: [Type]). UParamFallback inp out
- unwrapUParam :: forall (entries :: [EntrypointKind]) (s :: [Type]). (UParam entries ': s) :-> ((MText, ByteString) ': s)
- mkUParam :: forall a (name :: Symbol) (entries :: [EntrypointKind]). (NicePackedValue a, LookupEntrypoint name entries ~ a, RequireUniqueEntrypoints entries) => Label name -> a -> UParam entries
- type EntrypointKind = (Symbol, Type)
- type (?:) (n :: Symbol) (a :: k) = '(n, a)
- newtype UParam (entries :: [EntrypointKind]) = UnsafeUParam (MText, ByteString)
- type SomeInterface = '['("SomeEntrypoints", Void)]
- type UParam_ = UParam SomeInterface
- type family LookupEntrypoint (name :: Symbol) (entries :: [EntrypointKind]) where ...
- type family RequireUniqueEntrypoints (entries :: [EntrypointKind]) where ...
- data ConstrainedSome (c :: Type -> Constraint) where
- ConstrainedSome :: forall (c :: Type -> Constraint) a. c a => a -> ConstrainedSome c
- class UnpackUParam (c :: Type -> Constraint) (entries :: [EntrypointKind]) where
- unpackUParam :: UParam entries -> Either EntrypointLookupError (MText, ConstrainedSome c)
- data EntrypointLookupError
- type EntrypointsImpl (inp :: [Type]) (out :: [Type]) (entries :: [EntrypointKind]) = Rec (CaseClauseU inp out) entries
- type UParamFallback (inp :: [Type]) (out :: [Type]) = ((MText, ByteString) ': inp) :-> out
- class CaseUParam (entries :: [EntrypointKind])
- type UParamLinearize p = (Generic p, GUParamLinearize (Rep p))
- type UParamLinearized p = GUParamLinearized (Rep p)
- entryCaseFlattenedHiding :: forall (heps :: [Symbol]) cp (out :: [Type]) (inp :: [Type]) clauses. (CaseTC cp out inp clauses, DocumentEntrypoints (FlattenedEntrypointsKindHiding heps) cp, HasEntrypoints (ParameterEntrypointsDerivation cp) cp heps) => IsoRecTuple clauses -> (cp ': inp) :-> out
- entryCaseFlattenedHiding_ :: forall (heps :: [Symbol]) cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints (FlattenedEntrypointsKindHiding heps) cp, HasEntrypoints (ParameterEntrypointsDerivation cp) cp heps) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out
- entryCaseFlattened :: forall cp (out :: [Type]) (inp :: [Type]) clauses. (CaseTC cp out inp clauses, DocumentEntrypoints FlattenedEntrypointsKind cp) => IsoRecTuple clauses -> (cp ': inp) :-> out
- entryCaseFlattened_ :: forall cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints FlattenedEntrypointsKind cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out
- entryCaseSimple_ :: forall cp (out :: [Type]) (inp :: [Type]). (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp ': inp) :-> out
- areFinalizedParamBuildingSteps :: [ParamBuildingStep] -> Bool
- finalizeParamCallingDoc' :: forall cp (inp :: [Type]) (out :: [Type]). (NiceParameterFull cp, HasCallStack) => Proxy cp -> (inp :-> out) -> inp :-> out
- documentEntrypoint :: forall kind (epName :: Symbol) param (s :: [Type]) (out :: [Type]). (KnownSymbol epName, DocItem (DEntrypoint kind), NiceParameter param, TypeHasDoc param) => ((param ': s) :-> out) -> (param ': s) :-> out
- clarifyParamBuildingSteps :: forall (inp :: [Type]) (out :: [Type]). ParamBuildingStep -> (inp :-> out) -> inp :-> out
- mkDEntrypointArgSimple :: (NiceParameter t, TypeHasDoc t) => DEntrypointArg
- mkDEpUType :: HasAnnotation t => Ty
- emptyDEpArg :: DEntrypointArg
- mkPbsWrapIn :: Text -> ParamBuilder -> ParamBuildingStep
- entrypointSection :: forall kind (i :: [Type]) (o :: [Type]). EntrypointKindHasDoc kind => Text -> Proxy kind -> (i :-> o) -> i :-> o
- diEntrypointToMarkdown :: HeaderLevel -> DEntrypoint level -> Markdown
- pattern DEntrypointDocItem :: () => DEntrypoint kind -> SomeDocItem
- data DEntrypoint kind = DEntrypoint {}
- type family EntrypointKindOverride ep
- class Typeable ep => EntrypointKindHasDoc ep where
- data PlainEntrypointsKind
- data FlattenedEntrypointsKindHiding (hiddenEntrypoints :: [Symbol])
- type FlattenedEntrypointsKind = FlattenedEntrypointsKindHiding ('[] :: [Symbol])
- data CommonContractBehaviourKind
- data CommonEntrypointsBehaviourKind (kind :: k)
- data DEntrypointReference = DEntrypointReference Text Anchor
- newtype ParamBuilder = ParamBuilder {
- unParamBuilder :: Markdown -> Markdown
- data ParamBuildingDesc = ParamBuildingDesc {}
- data ParamBuildingStep
- data SomeEntrypointArg = (NiceParameter a, TypeHasDoc a) => SomeEntrypointArg (Proxy a)
- data DEntrypointArg = DEntrypointArg {}
- class KnownSymbol con => DeriveCtorFieldDoc (con :: Symbol) (cf :: CtorField) where
- type DocumentEntrypoints kind a = (Generic a, GDocumentEntrypoints (BuildEPTree' a) kind (Rep a) ('[] :: [CaseClauseParam]))
- class EntryArrow (kind :: k) (name :: Symbol) body where
- type family RequireFlatParamEps cp where ...
- type family RequireFlatEpDerivation (cp :: t) deriv where ...
- stNickname :: forall (name :: Symbol). Label name -> FieldRef (FieldAlias name)
- stAlias :: forall {k} (alias :: k). FieldRef (FieldAlias alias)
- stNested :: StNestedImpl f SelfRef => f
- this :: forall (p :: FieldRefTag). SelfRef p
- mkStoreEp :: forall (epName :: Symbol) epParam epStore. Label epName -> EntrypointLambda epParam epStore -> EntrypointsField epParam epStore
- zoomStoreSubmapOps :: forall {k1} {k2} store (submapName :: k1) (nameInSubmap :: k2) 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
- composeStoreEntrypointOps :: forall {k} store substore (nameInStore :: k) (epName :: Symbol) epParam epStore. (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreEntrypointOps substore epName epParam epStore -> StoreEntrypointOps store epName epParam epStore
- sequenceStoreSubmapOps :: forall {k1} {k2} store substore value (name :: k1) (subName :: k2) 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
- composeStoreSubmapOps :: forall {k1} {k2} store substore (nameInStore :: k1) (mname :: k2) key value. (HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreSubmapOps substore mname key value -> StoreSubmapOps store mname key value
- composeStoreFieldOps :: forall {k1} {k2} substore (nameInStore :: k1) store (nameInSubstore :: k2) field. HasDupableGetters substore => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreFieldOps substore nameInSubstore field -> StoreFieldOps store nameInSubstore field
- mapStoreSubmapOpsValue :: forall {k} value1 value2 store (name :: k) key. (KnownValue value1, KnownValue value2) => LIso value1 value2 -> StoreSubmapOps store name key value1 -> StoreSubmapOps store name key value2
- mapStoreSubmapOpsKey :: forall {k} key2 key1 store (name :: k) value. Fn key2 key1 -> StoreSubmapOps store name key1 value -> StoreSubmapOps store name key2 value
- mapStoreFieldOps :: forall {k} field1 field2 store (name :: k). KnownValue field1 => LIso field1 field2 -> StoreFieldOps store name field1 -> StoreFieldOps store name field2
- storeEntrypointOpsReferTo :: forall (epName :: Symbol) store epParam epStore (desiredName :: Symbol). Label epName -> StoreEntrypointOps store epName epParam epStore -> StoreEntrypointOps store desiredName epParam epStore
- storeFieldOpsReferTo :: forall {k1} {k2} (name :: k1) storage field (desiredName :: k2). FieldRef name -> StoreFieldOps storage name field -> StoreFieldOps storage desiredName field
- storeSubmapOpsReferTo :: forall {k1} {k2} (name :: k1) storage key value (desiredName :: k2). FieldRef name -> StoreSubmapOps storage name key value -> StoreSubmapOps storage desiredName key value
- storeEntrypointOpsDeeper :: forall store (nameInStore :: Symbol) substore (epName :: Symbol) epParam epStore. (HasFieldOfType store nameInStore substore, StoreHasEntrypoint substore epName epParam epStore, HasDupableGetters store, Dupable substore) => FieldRef nameInStore -> StoreEntrypointOps store epName epParam epStore
- storeSubmapOpsDeeper :: forall {k} storage (bigMapPartName :: Symbol) fields key value (mname :: k). (HasFieldOfType storage bigMapPartName fields, StoreHasSubmap fields SelfRef key value, HasDupableGetters storage, Dupable fields) => FieldRef bigMapPartName -> StoreSubmapOps storage mname key value
- storeFieldOpsDeeper :: forall {k} storage (fieldsPartName :: Symbol) fields (fname :: k) ftype. (HasFieldOfType storage fieldsPartName fields, StoreHasField fields fname ftype, HasDupableGetters fields) => FieldRef fieldsPartName -> StoreFieldOps storage fname ftype
- storeEntrypointOpsSubmapField :: forall store (epmName :: Symbol) epParam epStore (epsName :: Symbol) (epName :: Symbol). (StoreHasSubmap store epmName MText (EntrypointLambda epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore
- storeEntrypointOpsFields :: forall store (epmName :: Symbol) epParam epStore (epsName :: Symbol) (epName :: Symbol). (StoreHasField store epmName (EntrypointsField epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore
- storeEntrypointOpsADT :: forall store (epmName :: Symbol) epParam epStore (epsName :: Symbol) (epName :: Symbol). (HasFieldOfType store epmName (EntrypointsField epParam epStore), HasFieldOfType store epsName epStore, KnownValue epParam, KnownValue epStore) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore
- storeFieldOpsADT :: forall dt (fname :: Symbol) ftype. HasFieldOfType dt fname ftype => StoreFieldOps dt fname ftype
- stSetEpStore :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). StoreHasEntrypoint store epName epParam epStore => Label epName -> (epStore ': (store ': s)) :-> (store ': s)
- stGetEpStore :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store ': s) :-> (epStore ': (store ': s))
- stToEpStore :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). StoreHasEntrypoint store epName epParam epStore => Label epName -> (store ': s) :-> (epStore ': s)
- stSetEpLambda :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, HasDupableGetters store) => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)
- stGetEpLambda :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': (store ': s))
- stToEpLambda :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). StoreHasEntrypoint store epName epParam epStore => Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)
- stEntrypoint :: forall store (epName :: Symbol) epParam epStore (s :: [Type]). (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (epParam ': (store ': s)) :-> (([Operation], store) ': s)
- stGetAndUpdate :: forall {k} store (mname :: k) key value (s :: [Type]). StoreHasSubmap store mname key value => FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))
- stSetField :: forall {k} store (fname :: k) ftype (s :: [Type]). StoreHasField store fname ftype => FieldRef fname -> (ftype ': (store ': s)) :-> (store ': s)
- stGetFieldNamed :: forall {k} store (fname :: k) ftype (s :: [Type]). (StoreHasField store fname ftype, FieldRefHasFinalName fname, Dupable ftype, HasDupableGetters store) => FieldRef fname -> (store ': s) :-> ((FieldRefFinalName fname :! ftype) ': (store ': s))
- stToFieldNamed :: forall {k} store (fname :: k) ftype (s :: [Type]). (StoreHasField store fname ftype, FieldRefHasFinalName fname) => FieldRef fname -> (store ': s) :-> ((FieldRefFinalName fname :! ftype) ': s)
- stGetField :: forall {k} store (fname :: k) ftype (s :: [Type]). (StoreHasField store fname ftype, Dupable ftype, HasDupableGetters store) => FieldRef fname -> (store ': s) :-> (ftype ': (store ': s))
- stToField :: forall {k} store (fname :: k) ftype (s :: [Type]). StoreHasField store fname ftype => FieldRef fname -> (store ': s) :-> (ftype ': s)
- sopSetField :: forall {k} store (fname :: k) ftype (s :: [Type]). StoreFieldOps store fname ftype -> FieldRef fname -> (ftype ': (store ': s)) :-> (store ': s)
- sopGetField :: forall {k} ftype store (fname :: k) (s :: [Type]). (Dupable ftype, HasDupableGetters store) => StoreFieldOps store fname ftype -> FieldRef fname -> (store ': s) :-> (ftype ': (store ': s))
- fieldNameFromLabel :: forall (n :: Symbol). Label n -> FieldSymRef n
- fieldNameToLabel :: forall (n :: Symbol). FieldSymRef n -> Label n
- type FieldRefKind = FieldRefTag -> Type
- data FieldRefTag
- type family FieldRefObject (ty :: k) = (fr :: FieldRefKind) | fr -> k ty
- class KnownFieldRef (ty :: k) where
- type FieldRefObject (ty :: k) = (fr :: FieldRefKind) | fr -> k ty
- mkFieldRef :: forall (p :: FieldRefTag). FieldRefObject ty p
- type FieldRef (name :: k) = FieldRefObject name 'FieldRefTag
- data FieldName (n :: Symbol) (p :: FieldRefTag)
- type FieldSymRef (name :: Symbol) = FieldRef name
- type family FieldRefFinalName (fr :: k) :: Symbol
- class FieldRefHasFinalName (fr :: k) where
- type FieldRefFinalName (fr :: k) :: Symbol
- fieldRefFinalName :: FieldRef fr -> Label (FieldRefFinalName fr)
- data StoreFieldOps store (fname :: k) ftype = StoreFieldOps {
- sopToField :: forall (s :: [Type]). FieldRef fname -> (store ': s) :-> (ftype ': s)
- sopGetFieldOpen :: forall res (s :: [Type]). HasDupableGetters store => ('[ftype] :-> '[res, ftype]) -> ('[ftype] :-> '[res]) -> FieldRef fname -> (store ': s) :-> (res ': (store ': s))
- sopSetFieldOpen :: forall new (s :: [Type]). ('[new, ftype] :-> '[ftype]) -> FieldRef fname -> (new ': (store ': s)) :-> (store ': s)
- class StoreHasField store (fname :: k) ftype | store fname -> ftype where
- storeFieldOps :: StoreFieldOps store fname ftype
- data StoreSubmapOps store (mname :: k) key value = StoreSubmapOps {
- sopMem :: forall (s :: [Type]). FieldRef mname -> (key ': (store ': s)) :-> (Bool ': s)
- sopGet :: forall (s :: [Type]). KnownValue value => FieldRef mname -> (key ': (store ': s)) :-> (Maybe value ': s)
- sopUpdate :: forall (s :: [Type]). FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (store ': s)
- sopGetAndUpdate :: forall (s :: [Type]). FieldRef mname -> (key ': (Maybe value ': (store ': s))) :-> (Maybe value ': (store ': s))
- sopDelete :: forall (s :: [Type]). FieldRef mname -> (key ': (store ': s)) :-> (store ': s)
- sopInsert :: forall (s :: [Type]). FieldRef mname -> (key ': (value ': (store ': s))) :-> (store ': s)
- class StoreHasSubmap store (mname :: k) key value | store mname -> key value where
- storeSubmapOps :: StoreSubmapOps store mname key value
- type EntrypointLambda param store = Lambda (param, store) ([Operation], store)
- type EntrypointsField param store = BigMap MText (EntrypointLambda param store)
- data StoreEntrypointOps store (epName :: Symbol) epParam epStore = StoreEntrypointOps {
- sopToEpLambda :: forall (s :: [Type]). Label epName -> (store ': s) :-> (EntrypointLambda epParam epStore ': s)
- sopSetEpLambda :: forall (s :: [Type]). HasDupableGetters store => Label epName -> (EntrypointLambda epParam epStore ': (store ': s)) :-> (store ': s)
- sopToEpStore :: forall (s :: [Type]). Label epName -> (store ': s) :-> (epStore ': s)
- sopSetEpStore :: forall (s :: [Type]). Label epName -> (epStore ': (store ': s)) :-> (store ': s)
- class StoreHasEntrypoint store (epName :: Symbol) epParam epStore | store epName -> epParam epStore where
- storeEpOps :: StoreEntrypointOps store epName epParam epStore
- data ((l :: k1) :-| (r :: k2)) (p :: FieldRefTag) = (FieldRef l) :-| (FieldRef r)
- data SelfRef (p :: FieldRefTag) = SelfRef
- data FieldAlias (alias :: k) (p :: FieldRefTag)
- type FieldNickname (alias :: Symbol) = FieldAlias alias
- data (k2 :: k) ~> (v :: k1)
- data (param :: k) ::-> (store :: k1)
- type family StorageContains store (content :: [NamedField]) where ...
- baseErrorDocHandlers :: [NumericErrorDocHandler]
- voidResultDocHandler :: NumericErrorDocHandler
- customErrorDocHandler :: NumericErrorDocHandler
- applyErrorTagToErrorsDocWith :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => [NumericErrorDocHandler] -> ErrorTagMap -> (inp :-> out) -> inp :-> out
- applyErrorTagToErrorsDoc :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out
- data DDescribeErrorTagMap = DDescribeErrorTagMap {
- detmSrcLoc :: Text
- data NumericErrorDocHandlerError
- data NumericErrorDocHandler
- data NumericErrorWrapper (numTag :: Nat) err
- voidResultTag :: MText
- data View_ a r
- data Void_ a b
- data VoidResult r
- class NonZero t
- unsafeUnwrap_ :: forall dt (name :: Symbol) (st :: [Type]). InstrUnwrapC dt name => Label name -> (dt ': st) :-> (CtorOnlyField name dt ': st)
- wrapOne :: forall dt (name :: Symbol) (st :: [Type]). InstrWrapOneC dt name => Label name -> (CtorOnlyField name dt ': st) :-> (dt ': st)
- wrap_ :: forall dt (name :: Symbol) (st :: [Type]). InstrWrapC dt name => Label name -> AppendCtorField (GetCtorField dt name) st :-> (dt ': st)
- fieldCtor :: forall (st :: [Type]) f. HasCallStack => (st :-> (f ': st)) -> FieldConstructor st f
- deconstruct :: forall dt (fields :: [Type]) (st :: [Type]). (InstrDeconstructC dt (ToTs st), fields ~ GFieldTypes (Rep dt) ('[] :: [Type]), (ToTs fields ++ ToTs st) ~ ToTs (fields ++ st)) => (dt ': st) :-> (fields ++ st)
- constructStack :: forall dt (fields :: [Type]) (st :: [Type]). (InstrConstructC dt, fields ~ ConstructorFieldTypes dt, (ToTs fields ++ ToTs st) ~ ToTs (fields ++ st)) => (fields ++ st) :-> (dt ': st)
- setFieldOpen :: forall dt (name :: Symbol) new (st :: [Type]). InstrSetFieldC dt name => ('[new, GetFieldType dt name] :-> '[GetFieldType dt name]) -> Label name -> (new ': (dt ': st)) :-> (dt ': st)
- getFieldOpen :: forall dt (name :: Symbol) res (st :: [Type]). (InstrGetFieldC dt name, HasDupableGetters dt) => ('[GetFieldType dt name] :-> '[res, GetFieldType dt name]) -> ('[GetFieldType dt name] :-> '[res]) -> Label name -> (dt ': st) :-> (res ': (dt ': st))
- modifyField :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, InstrSetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (forall (st0 :: [Type]). (GetFieldType dt name ': st0) :-> (GetFieldType dt name ': st0)) -> (dt ': st) :-> (dt ': st)
- getFieldNamed :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (dt ': st) :-> ((name :! GetFieldType dt name) ': (dt ': st))
- getField :: forall dt (name :: Symbol) (st :: [Type]). (InstrGetFieldC dt name, Dupable (GetFieldType dt name), HasDupableGetters dt) => Label name -> (dt ': st) :-> (GetFieldType dt name ': (dt ': st))
- toFieldNamed :: forall dt (name :: Symbol) (st :: [Type]). InstrGetFieldC dt name => Label name -> (dt ': st) :-> ((name :! GetFieldType dt name) ': st)
- toField :: forall dt (name :: Symbol) (st :: [Type]). InstrGetFieldC dt name => Label name -> (dt ': st) :-> (GetFieldType dt name ': st)
- type HasFieldOfType dt (fname :: Symbol) fieldTy = (HasField dt fname, GetFieldType dt fname ~ fieldTy)
- data NamedField = NamedField Symbol Type
- type (:=) (n :: Symbol) ty = 'NamedField n ty
- type family HasFieldsOfType dt (fs :: [NamedField]) where ...
- class HasDupableGetters (a :: k)
- data CaseClauseL (inp :: [Type]) (out :: [Type]) (param :: CaseClauseParam) where
- CaseClauseL :: forall (x :: CtorField) (inp :: [Type]) (out :: [Type]) (ctor :: Symbol). (AppendCtorField x inp :-> out) -> CaseClauseL inp out ('CaseClauseParam ctor x)
- class CaseArrow (name :: Symbol) body clause | clause -> name, clause -> body where
- type CaseTC dt (out :: [Type]) (inp :: [Type]) clauses = (InstrCaseC dt, RMap (CaseClauses dt), RecFromTuple clauses, clauses ~ Rec (CaseClauseL inp out) (CaseClauses dt))
- errorToValNumeric :: IsError e => ErrorTagMap -> e -> (forall (t :: T). ConstantScope t => Value t -> r) -> r
- errorFromValNumeric :: forall (t :: T) e. (SingI t, IsError e) => ErrorTagMap -> Value t -> Either Text e
- useNumericErrors :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => (inp :-> out) -> (inp :-> out, ErrorTagMap)
- applyErrorTagMapWithExclusions :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> ErrorTagExclusions -> (inp :-> out) -> inp :-> out
- applyErrorTagMap :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out
- excludeErrorTags :: HasCallStack => ErrorTagExclusions -> ErrorTagMap -> ErrorTagMap
- buildErrorTagMap :: HashSet MText -> ErrorTagMap
- addNewErrorTags :: ErrorTagMap -> HashSet MText -> ErrorTagMap
- gatherErrorTags :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> HashSet MText
- type ErrorTagMap = Bimap Natural MText
- type ErrorTagExclusions = HashSet MText
- typeDoc :: QuasiQuoter
- errorDocArg :: QuasiQuoter
- entrypointDoc :: QuasiQuoter
- typeDocMdDescriptionReferToError :: IsError e => Markdown
- isInternalErrorClass :: ErrorClass -> Bool
- errorTagToText :: forall (tag :: Symbol). KnownSymbol tag => Text
- errorTagToMText :: forall (tag :: Symbol). Label tag -> MText
- failUnexpected :: forall (s :: [Type]) (t :: [Type]). MText -> s :-> t
- simpleFailUsing :: forall e (s :: [Type]) (t :: [Type]). IsError e => e -> s :-> t
- isoErrorFromVal :: forall (t :: T) e. (SingI t, KnownIsoT e, IsoValue e) => Value t -> Either Text e
- isoErrorToVal :: (KnownError e, IsoValue e) => e -> (forall (t :: T). ErrorScope t => Value t -> r) -> r
- type ErrorScope (t :: T) = ConstantScope t
- class ErrorHasDoc e => IsError e where
- errorToVal :: e -> (forall (t :: T). ErrorScope t => Value t -> r) -> r
- errorFromVal :: forall (t :: T). SingI t => Value t -> Either Text e
- failUsing :: forall (s :: [Type]) (t :: [Type]). IsError e => e -> s :-> t
- type family ErrorRequirements e
- class Typeable e => ErrorHasDoc e where
- data UnspecifiedError = UnspecifiedError
- data Impossible (reason :: Symbol) = HasCallStack => Impossible
- data SomeError = (IsError e, Eq e) => SomeError e
- type family ErrorArg (tag :: Symbol)
- data CustomError (tag :: Symbol) = CustomError {
- ceTag :: Label tag
- ceArg :: CustomErrorRep tag
- data NoErrorArg
- data UnitErrorArg
- type CustomErrorRep (tag :: Symbol) = CustomErrorArgRep (ErrorArg tag)
- class IsCustomErrorArgRep a where
- verifyErrorTag :: MText -> a -> Either Text a
- customErrorRepDocDeps :: [SomeDocDefinitionItem]
- customErrorHaskellRep :: forall (tag :: Symbol). (KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown
- type MustHaveErrorArg (errorTag :: Symbol) expectedArgRep = FailUnlessEqual (CustomErrorRep errorTag) expectedArgRep ((('Text "Error argument type is " :<>: 'ShowType expectedArgRep) :<>: 'Text " but given error requires argument of type ") :<>: 'ShowType (CustomErrorRep errorTag))
- data ErrorClass
- class (KnownSymbol tag, TypeHasDoc (CustomErrorRep tag), IsError (CustomError tag)) => CustomErrorHasDoc (tag :: Symbol) where
- data DError where
- DError :: forall e. ErrorHasDoc e => Proxy e -> DError
- data DThrows where
- DThrows :: forall e. ErrorHasDoc e => Proxy e -> DThrows
- dropT :: forall a (inp :: [Type]) (dinp :: [Type]) (dout :: [Type]) (out :: [Type]). (DipT a inp dinp dout out, dinp ~ (a ': dout)) => inp :-> out
- class st ~ (Head st ': Tail st) => DupT a (st :: [Type]) where
- class dipInp ~ (a ': Tail dipInp) => DipT a (inp :: [Type]) (dipInp :: [Type]) (dipOut :: [Type]) (out :: [Type]) | inp a -> dipInp, dipOut inp a -> out, inp out a -> dipOut where
- mkLambdaRec :: forall (i :: [Type]) (o :: [Type]). (IsNotInView => (i ++ '[WrappedLambda i o]) :-> o) -> WrappedLambda i o
- mkLambda :: forall (i :: [Type]) (o :: [Type]). (IsNotInView => i :-> o) -> WrappedLambda i o
- data WrappedLambda (i :: [Type]) (o :: [Type])
- = WrappedLambda (i :-> o)
- | RecLambda ((i ++ '[WrappedLambda i o]) :-> o)
- type Lambda i o = WrappedLambda '[i] '[o]
- castDummyG :: (Generic a, Generic b, GCanCastTo (Rep a) (Rep b)) => Proxy a -> Proxy b -> ()
- allowCheckedCoerce :: forall {k1} {k2} (a :: k1) (b :: k2). Dict (CanCastTo a b, CanCastTo b a)
- allowCheckedCoerceTo :: forall {k1} {k2} (b :: k1) (a :: k2). Dict (CanCastTo a b)
- checkedCoercing_ :: forall a b (s :: [Type]). Coercible_ a b => ((b ': s) :-> (b ': s)) -> (a ': s) :-> (a ': s)
- checkedCoerce_ :: forall a b (s :: [Type]). Castable_ a b => (a ': s) :-> (b ': s)
- checkedCoerce :: (CanCastTo a b, Coercible a b) => a -> b
- fromNamed :: forall (name :: Symbol) a (s :: [Type]). Label name -> ((name :! a) ': s) :-> (a ': s)
- toNamed :: forall (name :: Symbol) a (s :: [Type]). Label name -> (a ': s) :-> ((name :! a) ': s)
- coerceWrap :: forall a (s :: [Type]). Wrappable a => (Unwrappabled a ': s) :-> (a ': s)
- unsafeCoerceWrap :: forall a (s :: [Type]). Unwrappable a => (Unwrappabled a ': s) :-> (a ': s)
- coerceUnwrap :: forall a (s :: [Type]). Unwrappable a => (a ': s) :-> (Unwrappabled a ': s)
- fakeCoercing :: forall (s1 :: [Type]) (s2 :: [Type]) (s1' :: [Type]) (s2' :: [Type]). (s1 :-> s2) -> s1' :-> s2'
- fakeCoerce :: forall (s1 :: [Type]) (s2 :: [Type]). s1 :-> s2
- gForcedCoerce_ :: forall {k} t (a :: k) (b :: k) (s :: [Type]). MichelsonCoercible (t a) (t b) => (t a ': s) :-> (t b ': s)
- forcedCoerce_ :: forall a b (s :: [Type]). MichelsonCoercible a b => (a ': s) :-> (b ': s)
- forcedCoerce :: Coercible a b => a -> b
- type MichelsonCoercible a b = ToT a ~ ToT b
- class CanCastTo (a :: k) (b :: k1) where
- type Castable_ a b = (MichelsonCoercible a b, CanCastTo a b)
- type Coercible_ a b = (MichelsonCoercible a b, CanCastTo a b, CanCastTo b a)
- newtype ParameterWrapper deriv cp = ParameterWrapper {
- unParameterWraper :: cp
- type family Unwrappabled s
- class ToT s ~ ToT (Unwrappabled s) => Unwrappable s where
- type Unwrappabled s
- class Unwrappable s => Wrappable s
- class ArithOpHs aop n m r where
- evalArithOpHs :: forall (s :: [Type]). (n ': (m ': s)) :-> (r ': s)
- class DefArithOp (aop :: k) where
- type family UnaryArithResHs aop n
- class UnaryArithOpHs aop n where
- type UnaryArithResHs aop n
- evalUnaryArithOpHs :: forall (s :: [Type]). (n ': s) :-> (UnaryArithResHs aop n ': s)
- type family DefUnaryArithOpExtraConstraints (aop :: k) (n :: T)
- class DefUnaryArithOp (aop :: k) where
- type DefUnaryArithOpExtraConstraints (aop :: k) (n :: T)
- defUnaryArithOpHs :: forall (n :: T) (r :: T) (s :: [T]). (UnaryArithOp aop n, r ~ UnaryArithRes aop n, DefUnaryArithOpExtraConstraints aop n) => Instr (n ': s) (r ': s)
- class ToIntegerArithOpHs n where
- evalToIntOpHs :: forall (s :: [Type]). (n ': s) :-> (Integer ': s)
- class ToBytesArithOpHs n where
- evalToBytesOpHs :: forall bs (s :: [Type]). BytesLike bs => (n ': s) :-> (bs ': s)
- expressionToScriptExpr :: Expression -> ByteString
- valueToScriptExpr :: NicePackedValue t => t -> ByteString
- lEncodeValue :: NiceUntypedValue a => a -> ByteString
- lUnpackValue :: NiceUnpackedValue a => Packed a -> Either UnpackError a
- lPackValue :: NicePackedValue a => a -> Packed a
- lUnpackValueRaw :: NiceUnpackedValue a => ByteString -> Either UnpackError a
- lPackValueRaw :: NicePackedValue a => a -> ByteString
- openChestT :: forall a (s :: [Type]). BytesLike a => (ChestKey ': (ChestT a ': (Natural ': s))) :-> (OpenChestT a ': s)
- toHashHs :: forall (alg :: HashAlgorithmKind) bs. (BytesLike bs, KnownHashAlgorithm alg) => bs -> Hash alg bs
- lSign :: (MonadRandom m, BytesLike a) => SecretKey -> a -> m (TSignature a)
- class (KnownValue bs, ToT bs ~ ToT ByteString) => BytesLike bs where
- toBytes :: bs -> ByteString
- newtype Packed a = Packed {}
- newtype TSignature a = TSignature {}
- newtype Hash (alg :: HashAlgorithmKind) a = UnsafeHash {
- unHash :: ByteString
- class Typeable alg => KnownHashAlgorithm (alg :: HashAlgorithmKind) where
- hashAlgorithmName :: Proxy alg -> Text
- computeHash :: ByteString -> ByteString
- toHash :: forall bs (s :: [Type]). BytesLike bs => (bs ': s) :-> (Hash alg bs ': s)
- data DHashAlgorithm
- data Sha256 (a :: HashAlgoTag)
- data Sha512 (a :: HashAlgoTag)
- data Blake2b (a :: HashAlgoTag)
- data Sha3 (a :: HashAlgoTag)
- data Keccak (a :: HashAlgoTag)
- newtype ChestT a = ChestT {}
- data OpenChestT a
- mkDEntrypointExample :: NiceParameter a => a -> DEntrypointExample
- cutLorentzNonDoc :: forall (inp :: [Type]) (out :: [Type]) (s :: [Type]). (inp :-> out) -> s :-> s
- data DEntrypointExample = ParameterScope t => DEntrypointExample (Value t)
- data DView = DView {}
- data DViewArg = (NiceViewable a, TypeHasDoc a) => DViewArg (Proxy a)
- data DViewRet = (NiceViewable a, TypeHasDoc a) => DViewRet (Proxy a)
- class (Typeable vd, RenderViewsImpl (RevealViews vd)) => ViewsDescriptorHasDoc vd where
- viewsDescriptorName :: Proxy vd -> Text
- renderViewsDescriptorDoc :: Proxy vd -> Builder
- data DViewDesc = ViewsDescriptorHasDoc vd => DViewDesc (Proxy vd)
- data EpdPlain
- data EpdRecursive
- data EpdDelegate
- data EpdWithRoot (r :: Symbol) (epd :: k)
- type family MemOpKeyHs c
- class (MemOp (ToT c), ToT (MemOpKeyHs c) ~ MemOpKey (ToT c)) => MemOpHs c where
- type MemOpKeyHs c
- type family IsoMapOpRes c b where ...
- type family MapOpResHs c :: Type -> Type
- type family MapOpInpHs c
- class (MapOp (ToT c), ToT (MapOpInpHs c) ~ MapOpInp (ToT c), ToT (MapOpResHs c ()) ~ MapOpRes (ToT c) (ToT ())) => MapOpHs c where
- type MapOpInpHs c
- type MapOpResHs c :: Type -> Type
- type family IterOpElHs c
- class (IterOp (ToT c), ToT (IterOpElHs c) ~ IterOpEl (ToT c)) => IterOpHs c where
- type IterOpElHs c
- class SizeOp (ToT c) => SizeOpHs c
- type family UpdOpParamsHs c
- type family UpdOpKeyHs c
- class (UpdOp (ToT c), ToT (UpdOpKeyHs c) ~ UpdOpKey (ToT c), ToT (UpdOpParamsHs c) ~ UpdOpParams (ToT c)) => UpdOpHs c where
- type UpdOpKeyHs c
- type UpdOpParamsHs c
- type family GetOpValHs c
- type family GetOpKeyHs c
- class (GetOp (ToT c), ToT (GetOpKeyHs c) ~ GetOpKey (ToT c), ToT (GetOpValHs c) ~ GetOpVal (ToT c)) => GetOpHs c where
- type GetOpKeyHs c
- type GetOpValHs c
- class ConcatOp (ToT c) => ConcatOpHs c
- class SliceOp (ToT c) => SliceOpHs c
- newtype PrintAsValue a = PrintAsValue a
- data OpenChest
- type List = []
- data Never
- data ReadTicket a = ReadTicket {
- rtTicketer :: Address
- rtData :: a
- rtAmount :: Natural
- convertContractRef :: forall cp contract2 contract1. (ToContractRef cp contract1, FromContractRef cp contract2) => contract1 -> contract2
- callingDefAddress :: (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> ContractRef (GetDefaultEntrypointArg cp)
- callingAddress :: forall cp vd addr (mname :: Maybe Symbol). (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)
- newtype TAddress p vd = TAddress {}
- newtype FutureContract arg = FutureContract {
- unFutureContract :: ContractRef arg
- class ToAddress a where
- class ToTAddress cp vd a where
- toTAddress :: a -> TAddress cp vd
- class ToContractRef cp contract where
- toContractRef :: contract -> ContractRef cp
- class FromContractRef cp contract where
- fromContractRef :: ContractRef cp -> contract
- type Entrypoint param store = '[param, store] :-> ContractOut store
- type Entrypoint_ store = '[store] :-> ContractOut store
- stackType :: forall (s :: [Type]). s :-> s
- testAssert :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => Text -> PrintComment (ToTs inp) -> (inp :-> (Bool ': out)) -> inp :-> inp
- commentAroundStmt :: forall (i :: [Type]) (o :: [Type]). Text -> (i :-> o) -> i :-> o
- commentAroundFun :: forall (i :: [Type]) (o :: [Type]). Text -> (i :-> o) -> i :-> o
- comment :: forall (s :: [Type]). CommentType -> s :-> s
- justComment :: forall (s :: [Type]). Text -> s :-> s
- printComment :: forall (s :: [Type]). PrintComment (ToTs s) -> s :-> s
- stackRef :: forall (gn :: Nat) (st :: [T]) (n :: Peano). (n ~ ToPeano gn, SingI n, RequireLongerThan st n) => PrintComment st
- optimizeLorentz :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> inp :-> out
- optimizeLorentzWithConf :: forall (inp :: [Type]) (out :: [Type]). OptimizerConf -> (inp :-> out) -> inp :-> out
- transformBytesLorentz :: forall (inp :: [Type]) (out :: [Type]). Bool -> (ByteString -> ByteString) -> (inp :-> out) -> inp :-> out
- transformStringsLorentz :: forall (inp :: [Type]) (out :: [Type]). Bool -> (MText -> MText) -> (inp :-> out) -> inp :-> out
- parseLorentzValue :: KnownValue v => MichelsonSource -> Text -> Either ParseLorentzError v
- toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)
- mkContractCode :: (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractCode cp st
- iForceNotFail :: forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o
- iMapAnyCode :: forall (i1 :: [Type]) (i2 :: [Type]) (o :: [Type]). (forall (o' :: [T]). Instr (ToTs i1) o' -> Instr (ToTs i2) o') -> (i1 :-> o) -> i2 :-> o
- iNonFailingCode :: forall (inp :: [Type]) (out :: [Type]). HasCallStack => (inp :-> out) -> Instr (ToTs inp) (ToTs out)
- iAnyCode :: forall (inp :: [Type]) (out :: [Type]). (inp :-> out) -> Instr (ToTs inp) (ToTs out)
- iGenericIf :: forall (a :: [Type]) (b :: [Type]) (c :: [Type]) (s :: [Type]). (forall (s' :: [T]). Instr (ToTs a) s' -> Instr (ToTs b) s' -> Instr (ToTs c) s') -> (a :-> s) -> (b :-> s) -> c :-> s
- pattern I :: Instr (ToTs inp) (ToTs out) -> inp :-> out
- pattern FI :: (forall (out' :: [T]). Instr (ToTs inp) out') -> inp :-> out
- newtype (inp :: [Type]) :-> (out :: [Type]) = LorentzInstr {
- unLorentzInstr :: RemFail Instr (ToTs inp) (ToTs out)
- type (%>) = (:->)
- type ContractOut st = '[([Operation], st)]
- newtype ContractCode cp st = ContractCode {
- unContractCode :: '[(cp, st)] :-> ContractOut st
- data SomeContractCode where
- SomeContractCode :: forall cp st. (NiceParameter cp, NiceStorage st) => ContractCode cp st -> SomeContractCode
- type ViewCode arg st ret = '[(arg, st)] :-> '[ret]
- cMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)
- cDocumentedCode :: Contract cp st vd -> ContractCode cp st
- type (&) a (b :: [Type]) = a ': b
- type Fn a b = '[a] :-> '[b]
- class MapLorentzInstr instr where
- mapLorentzInstr :: (forall (i :: [Type]) (o :: [Type]). (i :-> o) -> i :-> o) -> instr -> instr
- decideOnDupable :: KnownValue a => DupableDecision a
- type NiceParameterFull cp = (Typeable cp, ParameterDeclaresEntrypoints cp)
- data DupableDecision a
- = Dupable a => IsDupable
- | IsNotDupable
- type NiceViews (vs :: [ViewTyInfo]) = RequireAllUnique "view" (ViewsNames vs)
- type NiceViewsDescriptor vd = NiceViews (RevealViews vd)
- parameterEntrypointCallCustom :: forall cp (mname :: Maybe Symbol). ParameterDeclaresEntrypoints cp => EntrypointRef mname -> EntrypointCall cp (GetEntrypointArgCustom cp mname)
- eprName :: forall (mname :: Maybe Symbol). EntrypointRef mname -> EpName
- sepcCallRootChecked :: (NiceParameter cp, ForbidExplicitDefaultEntrypoint cp) => SomeEntrypointCall cp
- parameterEntrypointCallDefault :: ParameterDeclaresEntrypoints cp => EntrypointCall cp (GetDefaultEntrypointArg cp)
- parameterEntrypointCall :: forall cp (name :: Symbol). ParameterDeclaresEntrypoints cp => Label name -> EntrypointCall cp (GetEntrypointArg cp name)
- parameterEntrypointsToNotes :: ParameterDeclaresEntrypoints cp => ParamNotes (ToT cp)
- type family EpdLookupEntrypoint (deriv :: k) cp :: Symbol -> Exp (Maybe Type)
- type family EpdAllEntrypoints (deriv :: k) cp :: [(Symbol, Type)]
- class EntrypointsDerivation (deriv :: k) cp where
- type EpdAllEntrypoints (deriv :: k) cp :: [(Symbol, Type)]
- type EpdLookupEntrypoint (deriv :: k) cp :: Symbol -> Exp (Maybe Type)
- epdNotes :: (Notes (ToT cp), RootAnn)
- epdCall :: forall (name :: Symbol). ParameterScope (ToT cp) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint deriv cp name))
- epdDescs :: Rec EpCallingDesc (EpdAllEntrypoints deriv cp)
- type RequireAllUniqueEntrypoints cp = RequireAllUniqueEntrypoints' (ParameterEntrypointsDerivation cp) cp
- type family ParameterEntrypointsDerivation cp
- class (EntrypointsDerivation (ParameterEntrypointsDerivation cp) cp, RequireAllUniqueEntrypoints cp) => ParameterHasEntrypoints cp where
- type ParameterEntrypointsDerivation cp
- type ParameterDeclaresEntrypoints cp = (If (CanHaveEntrypoints cp) (ParameterHasEntrypoints cp) (), NiceParameter cp, EntrypointsDerivation (GetParameterEpDerivation cp) cp)
- type family AllParameterEntrypoints cp :: [(Symbol, Type)] where ...
- type family LookupParameterEntrypoint cp :: Symbol -> Exp (Maybe Type) where ...
- type GetEntrypointArg cp (name :: Symbol) = Eval (LiftM2 (FromMaybe :: Type -> Maybe Type -> Type -> Type) (TError (('Text "Entrypoint not found: " :<>: 'ShowType name) :$$: (('Text "In contract parameter `" :<>: 'ShowType cp) :<>: 'Text "`")) :: Type -> Type) (LookupParameterEntrypoint cp name))
- type GetDefaultEntrypointArg cp = Eval (LiftM2 (FromMaybe :: Type -> Maybe Type -> Type -> Type) (Pure cp) (LookupParameterEntrypoint cp DefaultEpName))
- type ForbidExplicitDefaultEntrypoint cp = Eval (LiftM3 (UnMaybe :: Exp Constraint -> (Type -> Exp Constraint) -> Maybe Type -> Constraint -> Type) (Pure (Pure ())) (TError ('Text "Parameter used here must have no explicit \"default\" entrypoint" :$$: (('Text "In parameter type `" :<>: 'ShowType cp) :<>: 'Text "`")) :: (Type -> Exp Constraint) -> Type) (LookupParameterEntrypoint cp DefaultEpName))
- type NoExplicitDefaultEntrypoint cp = Eval (LookupParameterEntrypoint cp DefaultEpName) ~ ('Nothing :: Maybe Type)
- data EntrypointRef (mname :: Maybe Symbol) where
- CallDefault :: EntrypointRef ('Nothing :: Maybe Symbol)
- Call :: forall (name :: Symbol). NiceEntrypointName name => EntrypointRef ('Just name)
- type family GetEntrypointArgCustom cp (mname :: Maybe Symbol) where ...
- class HasEntrypointArg (cp :: k) name arg where
- useHasEntrypointArg :: name -> (Dict (ParameterScope (ToT arg)), EpName)
- type HasDefEntrypointArg (cp :: k) defEpName defArg = (defEpName ~ EntrypointRef ('Nothing :: Maybe Symbol), HasEntrypointArg cp defEpName defArg)
- newtype TrustEpName = TrustEpName EpName
- type HasEntrypointOfType param (con :: Symbol) exp = (GetEntrypointArgCustom param ('Just con) ~ exp, ParameterDeclaresEntrypoints param)
- type (:>) (n :: Symbol) ty = 'NamedEp n ty
- type family ParameterContainsEntrypoints param (fields :: [NamedEp]) where ...
- data EpdNone
- newtype ShouldHaveEntrypoints a = ShouldHaveEntrypoints {
- unHasEntrypoints :: a
- class (IsoValue a, Typeable a) => KnownValue a
- class (ForbidOp (ToT a), IsoValue a) => NoOperation a
- class (ForbidContract (ToT a), IsoValue a) => NoContractType a
- class (ForbidBigMap (ToT a), IsoValue a) => NoBigMap a
- class (HasNoNestedBigMaps (ToT a), IsoValue a) => CanHaveBigMap a
- type NiceParameter a = (ProperParameterBetterErrors (ToT a), KnownValue a)
- type NiceStorage a = (ProperStorageBetterErrors (ToT a), KnownValue a)
- type NiceStorageFull a = (NiceStorage a, HasAnnotation a)
- type NiceConstant a = (ProperConstantBetterErrors (ToT a), KnownValue a)
- type Dupable a = (ProperDupableBetterErrors (ToT a), KnownValue a)
- type NicePackedValue a = (ProperPackedValBetterErrors (ToT a), KnownValue a)
- type NiceUnpackedValue a = (ProperUnpackedValBetterErrors (ToT a), KnownValue a)
- type NiceFullPackedValue a = (NicePackedValue a, NiceUnpackedValue a)
- type NiceUntypedValue a = (ProperUntypedValBetterErrors (ToT a), KnownValue a)
- type NiceViewable a = (ProperViewableBetterErrors (ToT a), KnownValue a)
- type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n))
- type NiceNoBigMap n = (KnownValue n, HasNoBigMap (ToT n))
- class HasAnnotation a
- data Rec (a :: u -> Type) (b :: [u]) where
- type (:!) (name :: Symbol) a = NamedF Identity a name
- type (:?) (name :: Symbol) a = NamedF Maybe a name
- data GenericStrategy
- withDepths :: [CstrDepth] -> GenericStrategy
- rightBalanced :: GenericStrategy
- leftBalanced :: GenericStrategy
- rightComb :: GenericStrategy
- leftComb :: GenericStrategy
- haskellBalanced :: GenericStrategy
- reorderingConstrs :: EntriesReorder -> GenericStrategy -> GenericStrategy
- reorderingFields :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy
- reorderingData :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy
- alphabetically :: EntriesReorder
- leaveUnnamedFields :: UnnamedEntriesReorder
- forbidUnnamedFields :: UnnamedEntriesReorder
- fromDepthsStrategy :: (Int -> [Natural]) -> GenericStrategy
- fromDepthsStrategy' :: (Int -> [Natural]) -> (Int -> [Natural]) -> GenericStrategy
- makeRightBalDepths :: Int -> [Natural]
- cstr :: forall (n :: Nat). KnownNat n => [Natural] -> CstrDepth
- fld :: forall (n :: Nat). KnownNat n => Natural
- customGeneric :: String -> GenericStrategy -> Q [Dec]
- customGeneric' :: Maybe Type -> Name -> Type -> [Con] -> GenericStrategy -> Q [Dec]
- reifyDataType :: Name -> Q (Name, Cxt, Maybe Kind, [TyVarBndr ()], [Con])
- deriveFullType :: Name -> Maybe Kind -> [TyVarBndr flag] -> TypeQ
- mangleGenericStrategyConstructors :: (Text -> Text) -> GenericStrategy -> GenericStrategy
- mangleGenericStrategyFields :: (Text -> Text) -> GenericStrategy -> GenericStrategy
- ligoLayout :: GenericStrategy
- ligoCombLayout :: GenericStrategy
- type Markdown = Builder
- class (SingI t, WellTyped t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t, HasNoSaplingState t) => ConstantScope (t :: T)
- data Label (name :: Symbol) where
- Label :: forall (name :: Symbol). KnownSymbol name => Label name
- data Chest
- data ChestKey
- data EpName
- pattern DefEpName :: EpName
- data Bls12381Fr
- data Bls12381G2
- data Bls12381G1
- data MText
- mt :: QuasiQuoter
- type KeyHash = Hash 'HashKindPublicKey
- data Signature
- data PublicKey
- data ChainId
- data Timestamp
- data Mutez
- tz :: QuasiQuoter
- toMutez :: (Integral a, CheckIntSubType a Word63) => a -> Mutez
- zeroMutez :: Mutez
- oneMutez :: Mutez
- timestampFromSeconds :: Integer -> Timestamp
- timestampFromUTCTime :: UTCTime -> Timestamp
- timestampQuote :: QuasiQuoter
- type Address = Constrained (NullConstraint :: AddressKind -> Constraint) KindedAddress
- mkUType :: forall (x :: T). Notes x -> Ty
- data EpAddress where
- EpAddress' { }
- pattern EpAddress :: forall (kind :: AddressKind). () => KindedAddress kind -> EpName -> EpAddress
- class IsNotInView
- data ContractDoc = ContractDoc {}
- newtype SubDoc = SubDoc DocBlock
- data DocSection = DocItem d => DocSection (NonEmpty $ DocElem d)
- data DocElem d = DocElem {}
- data SomeDocDefinitionItem where
- SomeDocDefinitionItem :: forall d. (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => d -> SomeDocDefinitionItem
- data SomeDocItem where
- SomeDocItem :: forall d. DocItem d => d -> SomeDocItem
- data DocSectionNameStyle
- data DocItemRef (p :: DocItemPlacementKind) (r :: DocItemReferencedKind) where
- data DocItemPlacementKind
- newtype DocItemPos = DocItemPos (Natural, Text)
- newtype DocItemId = DocItemId Text
- class (Typeable d, DOrd d) => DocItem d where
- type DocItemPlacement d :: DocItemPlacementKind
- type DocItemReferenced d :: DocItemReferencedKind
- docItemPos :: Natural
- docItemSectionName :: Maybe Text
- docItemSectionDescription :: Maybe Markdown
- docItemSectionNameStyle :: DocSectionNameStyle
- docItemRef :: d -> DocItemRef (DocItemPlacement d) (DocItemReferenced d)
- docItemToMarkdown :: HeaderLevel -> d -> Markdown
- docItemToToc :: HeaderLevel -> d -> Markdown
- docItemDependencies :: d -> [SomeDocDefinitionItem]
- docItemsOrder :: [d] -> [d]
- type family DocItemPlacement d :: DocItemPlacementKind
- type family DocItemReferenced d :: DocItemReferencedKind
- mdTocFromRef :: (DocItem d, DocItemReferenced d ~ 'True) => HeaderLevel -> Markdown -> d -> Markdown
- docItemPosition :: DocItem d => DocItemPos
- docDefinitionRef :: (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => Markdown -> d -> Markdown
- docItemSectionRef :: DocItem di => Maybe Markdown
- subDocToMarkdown :: HeaderLevel -> SubDoc -> Markdown
- data DAnchor = DAnchor Anchor
- data DComment = DComment Text
- newtype GitRepoSettings = GitRepoSettings {
- grsMkGitRevision :: Text -> Text
- data DGitRevision
- = DGitRevisionKnown DGitRevisionInfo
- | DGitRevisionUnknown
- data DDescription = DDescription Markdown
- data DName = DName Text SubDoc
- newtype DGeneralInfoSection = DGeneralInfoSection SubDoc
- data WithFinalizedDoc a
- class ContainsDoc a => ContainsUpdateableDoc a where
- modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> a -> a
- class ContainsDoc a where
- buildDocUnfinalized :: a -> ContractDoc
- type DocGrouping = SubDoc -> SomeDocItem
- contractDocToMarkdown :: ContractDoc -> LText
- finalizedAsIs :: a -> WithFinalizedDoc a
- buildDoc :: ContainsDoc a => WithFinalizedDoc a -> ContractDoc
- buildMarkdownDoc :: ContainsDoc a => WithFinalizedDoc a -> LText
- modifyDoc :: (ContainsUpdateableDoc a, DocItem i1, DocItem i2) => (i1 -> Maybe i2) -> a -> a
- morleyRepoSettings :: GitRepoSettings
- mkDGitRevision :: ExpQ
- attachDocCommons :: ContainsUpdateableDoc a => DGitRevision -> a -> WithFinalizedDoc a
- type Operation = Operation' Instr
- type Value = Value' Instr
- data BigMap k v
- newtype BigMapId (k2 :: k) (v :: k1) = BigMapId {}
- data Ticket arg = Ticket {}
- data ContractRef arg = ContractRef {
- crAddress :: Address
- crEntrypoint :: SomeEntrypointCall arg
- type WellTypedToT a = (IsoValue a, WellTyped (ToT a))
- type SomeEntrypointCall arg = SomeEntrypointCallT (ToT arg)
- type EntrypointCall param arg = EntrypointCallT (ToT param) (ToT arg)
- class WellTypedToT a => IsoValue a where
- type family ToT a :: T
- coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b
- type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct (Rep dt) ('[] :: [Type]))
- type ConstructorFieldTypes dt = GFieldTypes (Rep dt) ('[] :: [Type])
- class IsHomomorphic (a :: k)
- class HaveCommonTypeCtor (a :: k) (b :: k1)
- data DType where
- DType :: forall a. TypeHasDoc a => Proxy a -> DType
- data SomeTypeWithDoc where
- SomeTypeWithDoc :: forall td. TypeHasDoc td => Proxy td -> SomeTypeWithDoc
- class (Typeable a, SingI (TypeDocFieldDescriptions a), FieldDescriptionsValid (TypeDocFieldDescriptions a) a) => TypeHasDoc a where
- type TypeDocFieldDescriptions a :: FieldDescriptions
- typeDocName :: Proxy a -> Text
- typeDocMdDescription :: Markdown
- typeDocMdReference :: Proxy a -> WithinParens -> Markdown
- typeDocDependencies :: Proxy a -> [SomeDocDefinitionItem]
- typeDocHaskellRep :: TypeDocHaskellRep a
- typeDocMichelsonRep :: TypeDocMichelsonRep a
- type family TypeDocFieldDescriptions a :: FieldDescriptions
- class TypeHasFieldNamingStrategy (a :: k) where
- typeFieldNamingStrategy :: Text -> Text
- typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder
- dTypeDep :: TypeHasDoc t => SomeDocDefinitionItem
- dStorage :: TypeHasDoc store => DStorageType
- customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown
- homomorphicTypeDocMdReference :: (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown
- poly1TypeDocMdReference :: forall (t :: Type -> Type) r a. (r ~ t a, Typeable t, Each '[TypeHasDoc] '[r, a], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown
- poly2TypeDocMdReference :: forall (t :: Type -> Type -> Type) r a b. (r ~ t a b, Typeable t, Each '[TypeHasDoc] '[r, a, b], IsHomomorphic t) => Proxy r -> WithinParens -> Markdown
- genericTypeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem]
- homomorphicTypeDocHaskellRep :: (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a
- concreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b
- unsafeConcreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b
- haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a
- haskellRepStripFieldPrefix :: TypeDocHaskellRep a -> TypeDocHaskellRep a
- haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a
- homomorphicTypeDocMichelsonRep :: KnownIsoT a => TypeDocMichelsonRep a
- concreteTypeDocMichelsonRep :: forall {k} a (b :: k). (Typeable a, KnownIsoT a, HaveCommonTypeCtor b a) => TypeDocMichelsonRep b
- unsafeConcreteTypeDocMichelsonRep :: forall {k} a (b :: k). (Typeable a, KnownIsoT a) => TypeDocMichelsonRep b
- mkBigMap :: ToBigMap m => m -> BigMap (ToBigMapKey m) (ToBigMapValue m)
- (#) :: (a :-> b) -> (b :-> c) -> a :-> c
Documentation
Conversion of values to readable Strings.
Derived instances of Show have the following properties, which
are compatible with derived instances of Read:
- The result of
showis a syntactically correct Haskell expression containing only constants, given the fixity declarations in force at the point where the type is declared. It contains only the constructor names defined in the data type, parentheses, and spaces. When labelled constructor fields are used, braces, commas, field names, and equal signs are also used. - If the constructor is defined to be an infix operator, then
showsPrecwill produce infix applications of the constructor. - the representation will be enclosed in parentheses if the
precedence of the top-level constructor in
xis less thand(associativity is ignored). Thus, ifdis0then the result is never surrounded in parentheses; ifdis11it is always surrounded in parentheses, unless it is an atomic expression. - If the constructor is defined using record syntax, then
showwill produce the record-syntax form, with the fields given in the same order as the original declaration.
For example, given the declarations
infixr 5 :^: data Tree a = Leaf a | Tree a :^: Tree a
the derived instance of Show is equivalent to
instance (Show a) => Show (Tree a) where
showsPrec d (Leaf m) = showParen (d > app_prec) $
showString "Leaf " . showsPrec (app_prec+1) m
where app_prec = 10
showsPrec d (u :^: v) = showParen (d > up_prec) $
showsPrec (up_prec+1) u .
showString " :^: " .
showsPrec (up_prec+1) v
where up_prec = 5Note that right-associativity of :^: is ignored. For example,
show(Leaf 1 :^: Leaf 2 :^: Leaf 3)"Leaf 1 :^: (Leaf 2 :^: Leaf 3)".