-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | EDSL for the Michelson Language
--   
--   Lorentz is a powerful meta-programming tool which allows one to write
--   Michelson contracts directly in Haskell. It has the same instructions
--   as Michelson, but operates on Haskell values and allows one to use
--   Haskell features.
@package lorentz
@version 0.13.2


-- | Type and field annotations for Lorentz types.
module Lorentz.Annotation

-- | Allow customization of field annotation generated for a type when
--   declaring its <a>HasAnnotation</a> instance.
data AnnOptions
AnnOptions :: (Text -> Text) -> AnnOptions
[fieldAnnModifier] :: AnnOptions -> Text -> Text
defaultAnnOptions :: AnnOptions

-- | Drops the field name prefix from a field. We assume a convention of
--   the prefix always being lower case, and the first letter of the actual
--   field name being uppercase. It also accepts another function which
--   will be applied directly after dropping the prefix.
dropPrefixThen :: (Text -> Text) -> Text -> Text

-- | <tt>appendTo suffix fields field</tt> appends the given suffix to
--   <tt>field</tt> if the field exists in the <tt>fields</tt> list.
appendTo :: Text -> [Text] -> Text -> Text

-- | O(n) Convert casing to <tt>camelCasedPhrase</tt>. <i>Subject to
--   fusion.</i>
toCamel :: Text -> Text

-- | O(n) Convert casing to <tt>PascalCasePhrase</tt>. <i>Subject to
--   fusion.</i>
toPascal :: Text -> Text

-- | O(n) Convert casing to <tt>snake_cased_phrase</tt>. <i>Subject to
--   fusion.</i>
toSnake :: Text -> Text
ctorNameToAnnWithOptions :: forall ctor. (KnownSymbol ctor, HasCallStack) => AnnOptions -> FieldAnn

-- | Used in <a>GHasAnnotation</a> and <a>HasAnnotation</a> as a flag to
--   track whether or not it directly follows an entrypoint to avoid
--   introducing extra entrypoints.
data FollowEntrypointFlag
FollowEntrypoint :: FollowEntrypointFlag
NotFollowEntrypoint :: FollowEntrypointFlag

-- | Used in <a>GHasAnnotation</a> as a flag to track whether or not
--   field/constructor annotations should be generated.
data GenerateFieldAnnFlag
GenerateFieldAnn :: GenerateFieldAnnFlag
NotGenerateFieldAnn :: GenerateFieldAnnFlag

-- | This class defines the type and field annotations for a given type.
--   Right now the type annotations come from names in a named field, and
--   field annotations are generated from the record fields.
class HasAnnotation a
getAnnotation :: HasAnnotation a => FollowEntrypointFlag -> Notes (ToT a)
getAnnotation :: (HasAnnotation a, GHasAnnotation (Rep a), GValueType (Rep a) ~ ToT a) => FollowEntrypointFlag -> Notes (ToT a)
annOptions :: HasAnnotation a => AnnOptions
annOptions :: HasAnnotation a => AnnOptions

-- | A Generic <tt>HasAnnotation</tt> implementation
class GHasAnnotation a
gGetAnnotation :: GHasAnnotation a => AnnOptions -> FollowEntrypointFlag -> GenerateFieldAnnFlag -> (Notes (GValueType a), FieldAnn, VarAnn)

-- | Use this in the instance of <tt>HasAnnotation</tt> when field
--   annotations should not be generated.
gGetAnnotationNoField :: forall a. (GHasAnnotation (Rep a), GValueType (Rep a) ~ ToT a) => FollowEntrypointFlag -> Notes (ToT a)
insertTypeAnn :: forall (b :: T). TypeAnn -> Notes b -> Notes b
instance (Lorentz.Annotation.HasAnnotation a, GHC.TypeLits.KnownSymbol name) => Lorentz.Annotation.HasAnnotation (Named.Internal.NamedF Data.Functor.Identity.Identity a name)
instance (Lorentz.Annotation.HasAnnotation (GHC.Maybe.Maybe a), GHC.TypeLits.KnownSymbol name) => Lorentz.Annotation.HasAnnotation (Named.Internal.NamedF GHC.Maybe.Maybe a name)
instance Lorentz.Annotation.HasAnnotation a => Lorentz.Annotation.HasAnnotation (GHC.Maybe.Maybe a)
instance Lorentz.Annotation.HasAnnotation ()
instance Lorentz.Annotation.HasAnnotation GHC.Integer.Type.Integer
instance Lorentz.Annotation.HasAnnotation GHC.Natural.Natural
instance Lorentz.Annotation.HasAnnotation Morley.Michelson.Text.MText
instance Lorentz.Annotation.HasAnnotation GHC.Types.Bool
instance Lorentz.Annotation.HasAnnotation Data.ByteString.Internal.ByteString
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Core.Mutez
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Address.Address
instance Lorentz.Annotation.HasAnnotation Morley.Michelson.Typed.Entrypoints.EpAddress
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Crypto.KeyHash
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Core.Timestamp
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Crypto.PublicKey
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Crypto.Signature
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Core.ChainId
instance Lorentz.Annotation.HasAnnotation a => Lorentz.Annotation.HasAnnotation (Morley.Michelson.Typed.Haskell.Value.ContractRef a)
instance Lorentz.Annotation.HasAnnotation d => Lorentz.Annotation.HasAnnotation (Morley.Michelson.Typed.Haskell.Value.Ticket d)
instance (Lorentz.Annotation.HasAnnotation k, Lorentz.Annotation.HasAnnotation v) => Lorentz.Annotation.HasAnnotation (Data.Map.Internal.Map k v)
instance (Lorentz.Annotation.HasAnnotation k, Lorentz.Annotation.HasAnnotation v) => Lorentz.Annotation.HasAnnotation (Morley.Michelson.Typed.Haskell.Value.BigMap k v)
instance (Lorentz.Annotation.HasAnnotation k, Lorentz.Annotation.HasAnnotation v) => Lorentz.Annotation.HasAnnotation (Morley.Michelson.Typed.Haskell.Value.BigMapId k v)
instance Morley.Michelson.Typed.Haskell.Value.KnownIsoT v => Lorentz.Annotation.HasAnnotation (Data.Set.Internal.Set v)
instance Lorentz.Annotation.HasAnnotation a => Lorentz.Annotation.HasAnnotation [a]
instance Lorentz.Annotation.HasAnnotation Morley.Michelson.Typed.Aliases.Operation
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Crypto.Timelock.Chest
instance Lorentz.Annotation.HasAnnotation Morley.Tezos.Crypto.Timelock.ChestKey
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b) => Lorentz.Annotation.HasAnnotation (Data.Either.Either a b)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b) => Lorentz.Annotation.HasAnnotation (a, b)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b, Lorentz.Annotation.HasAnnotation c) => Lorentz.Annotation.HasAnnotation (a, b, c)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b, Lorentz.Annotation.HasAnnotation c, Lorentz.Annotation.HasAnnotation d) => Lorentz.Annotation.HasAnnotation (a, b, c, d)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b, Lorentz.Annotation.HasAnnotation c, Lorentz.Annotation.HasAnnotation d, Lorentz.Annotation.HasAnnotation e) => Lorentz.Annotation.HasAnnotation (a, b, c, d, e)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b, Lorentz.Annotation.HasAnnotation c, Lorentz.Annotation.HasAnnotation d, Lorentz.Annotation.HasAnnotation e, Lorentz.Annotation.HasAnnotation f) => Lorentz.Annotation.HasAnnotation (a, b, c, d, e, f)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b, Lorentz.Annotation.HasAnnotation c, Lorentz.Annotation.HasAnnotation d, Lorentz.Annotation.HasAnnotation e, Lorentz.Annotation.HasAnnotation f, Lorentz.Annotation.HasAnnotation g) => Lorentz.Annotation.HasAnnotation (a, b, c, d, e, f, g)
instance Lorentz.Annotation.HasAnnotation x => Lorentz.Annotation.GHasAnnotation (GHC.Generics.Rec0 x)
instance Lorentz.Annotation.GHasAnnotation GHC.Generics.U1
instance Lorentz.Annotation.GHasAnnotation x => Lorentz.Annotation.GHasAnnotation (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel 'GHC.Maybe.Nothing b c d) x)
instance (Lorentz.Annotation.GHasAnnotation x, GHC.TypeLits.KnownSymbol a) => Lorentz.Annotation.GHasAnnotation (GHC.Generics.M1 GHC.Generics.S ('GHC.Generics.MetaSel ('GHC.Maybe.Just a) b c d) x)
instance (Lorentz.Annotation.GHasAnnotation x, GHC.TypeLits.KnownSymbol a) => Lorentz.Annotation.GHasAnnotation (GHC.Generics.M1 GHC.Generics.C ('GHC.Generics.MetaCons a _p _f) x)
instance Lorentz.Annotation.GHasAnnotation x => Lorentz.Annotation.GHasAnnotation (GHC.Generics.M1 GHC.Generics.D i1 x)
instance (Lorentz.Annotation.GHasAnnotation x, Lorentz.Annotation.GHasAnnotation y) => Lorentz.Annotation.GHasAnnotation (x GHC.Generics.:+: y)
instance (Lorentz.Annotation.GHasAnnotation x, Lorentz.Annotation.GHasAnnotation y) => Lorentz.Annotation.GHasAnnotation (x GHC.Generics.:*: y)


-- | Scope-related constraints used in Lorentz.
--   
--   This contains constraints from <a>Morley.Michelson.Typed.Scope</a>
--   modified for use in Lorentz.
module Lorentz.Constraints.Scopes

-- | Constraint applied to any type, to check if Michelson representation
--   (if exists) of this type is Comparable. In case it is not prints
--   human-readable error message
type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n))
type NiceConstant a = (ProperConstantBetterErrors (ToT a), KnownValue a)
type Dupable a = (ProperDupableBetterErrors (ToT a), KnownValue a)
type NiceFullPackedValue a = (NicePackedValue a, NiceUnpackedValue a)
type NicePackedValue a = (ProperPackedValBetterErrors (ToT a), KnownValue a)

-- | Constraint applied to any part of parameter type.
--   
--   Note that you don't usually apply this constraint to the whole
--   parameter, consider using <a>NiceParameterFull</a> in such case.
--   
--   Using this type is justified e.g. when calling another contract, there
--   you usually supply an entrypoint argument, not the whole parameter.
type NiceParameter a = (ProperParameterBetterErrors (ToT a), KnownValue a)
type NiceUntypedValue a = (ProperUntypedValBetterErrors (ToT a), KnownValue a)
type NiceStorage a = (ProperStorageBetterErrors (ToT a), HasAnnotation a, KnownValue a)
type NiceUnpackedValue a = (ProperUnpackedValBetterErrors (ToT a), KnownValue a)
type NiceViewable a = (ProperViewableBetterErrors (ToT a), KnownValue a)
type NiceNoBigMap n = (KnownValue n, HasNoBigMap (ToT n))
niceParameterEvi :: forall a. NiceParameter a :- ParameterScope (ToT a)
niceStorageEvi :: forall a. NiceStorage a :- StorageScope (ToT a)
niceConstantEvi :: forall a. NiceConstant a :- ConstantScope (ToT a)
dupableEvi :: forall a. Dupable a :- DupableScope (ToT a)
nicePackedValueEvi :: forall a. NicePackedValue a :- PackedValScope (ToT a)
niceUnpackedValueEvi :: forall a. NiceUnpackedValue a :- UnpackedValScope (ToT a)
niceUntypedValueEvi :: forall a. NiceUntypedValue a :- UntypedValScope (ToT a)
niceViewableEvi :: forall a. NiceViewable a :- ViewableScope (ToT a)
class (HasNoNestedBigMaps (ToT a), IsoValue a) => CanHaveBigMap a

-- | Gathers constraints, commonly required for values.
class (IsoValue a, Typeable a) => KnownValue a

-- | Ensure given type does not contain "operation".
class (ForbidOp (ToT a), IsoValue a) => NoOperation a
class (ForbidContract (ToT a), IsoValue a) => NoContractType a
class (ForbidBigMap (ToT a), IsoValue a) => NoBigMap a

-- | From a <a>Dict</a>, takes a value in an environment where the instance
--   witnessed by the <a>Dict</a> is in scope, and evaluates it.
--   
--   Essentially a deconstruction of a <a>Dict</a> into its
--   continuation-style form.
--   
--   Can also be used to deconstruct an entailment, <tt>a <a>:-</a> b</tt>,
--   using a context <tt>a</tt>.
--   
--   <pre>
--   withDict :: <a>Dict</a> c -&gt; (c =&gt; r) -&gt; r
--   withDict :: a =&gt; (a <a>:-</a> c) -&gt; (c =&gt; r) -&gt; r
--   </pre>
withDict :: HasDict c e => e -> (c => r) -> r
instance (Morley.Michelson.Typed.Scope.HasNoNestedBigMaps (Morley.Michelson.Typed.Haskell.Value.ToT a), Morley.Michelson.Typed.Haskell.Value.IsoValue a) => Lorentz.Constraints.Scopes.CanHaveBigMap a
instance (Morley.Michelson.Typed.Scope.ForbidBigMap (Morley.Michelson.Typed.Haskell.Value.ToT a), Morley.Michelson.Typed.Haskell.Value.IsoValue a) => Lorentz.Constraints.Scopes.NoBigMap a
instance (Morley.Michelson.Typed.Scope.ForbidContract (Morley.Michelson.Typed.Haskell.Value.ToT a), Morley.Michelson.Typed.Haskell.Value.IsoValue a) => Lorentz.Constraints.Scopes.NoContractType a
instance (Morley.Michelson.Typed.Scope.ForbidOp (Morley.Michelson.Typed.Haskell.Value.ToT a), Morley.Michelson.Typed.Haskell.Value.IsoValue a) => Lorentz.Constraints.Scopes.NoOperation a
instance (Morley.Michelson.Typed.Haskell.Value.IsoValue a, Data.Typeable.Internal.Typeable a) => Lorentz.Constraints.Scopes.KnownValue a

module Lorentz.Entrypoints.Helpers
ctorNameToAnn :: forall ctor. (KnownSymbol ctor, HasCallStack) => FieldAnn
ctorNameToEp :: forall ctor. (KnownSymbol ctor, HasCallStack) => EpName

-- | Used to understand whether a type can potentially declare any
--   entrypoints.
type family CanHaveEntrypoints (p :: Type) :: Bool

-- | A special type which wraps over a primitive type and states that it
--   has entrypoints (one).
--   
--   Assuming that any type can have entrypoints makes use of Lorentz
--   entrypoints too annoying, so for declaring entrypoints for not sum
--   types we require an explicit wrapper.
newtype ShouldHaveEntrypoints a
ShouldHaveEntrypoints :: a -> ShouldHaveEntrypoints a
[unHasEntrypoints] :: ShouldHaveEntrypoints a -> a

-- | Ensure that given type is a sum type.
--   
--   This helps to prevent attempts to apply a function to, for instance, a
--   pair.
type family RequireSumType (a :: Type) :: Constraint
instance GHC.Generics.Generic (Lorentz.Entrypoints.Helpers.ShouldHaveEntrypoints a)
instance Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue r => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Entrypoints.Helpers.ShouldHaveEntrypoints r)


-- | Primitives supplying entrypoints declarations and lookup.
module Lorentz.Entrypoints.Core

-- | Used to understand whether a type can potentially declare any
--   entrypoints.
type family CanHaveEntrypoints (p :: Type) :: Bool

-- | Defines a generalized way to declare entrypoints for various parameter
--   types.
--   
--   When defining instances of this typeclass, set concrete <tt>deriv</tt>
--   argument and leave variable <tt>cp</tt> argument. Also keep in mind,
--   that in presence of explicit default entrypoint, all other <a>Or</a>
--   arms should be callable, though you can put this burden on user if
--   very necessary.
--   
--   Methods of this typeclass aim to better type-safety when making up an
--   implementation and they may be not too convenient to use; users should
--   exploit their counterparts.
class EntrypointsDerivation deriv cp where {
    
    -- | Name and argument of each entrypoint. This may include intermediate
    --   ones, even root if necessary.
    --   
    --   Touching this type family is costly (<tt>O(N^2)</tt>), don't use it
    --   often.
    --   
    --   Note [order of entrypoints children]: If this contains entrypoints
    --   referring to indermediate nodes (not leaves) in <tt>or</tt> tree, then
    --   each such entrypoint should be mentioned eariler than all of its
    --   children.
    type family EpdAllEntrypoints deriv cp :: [(Symbol, Type)];
    
    -- | Get entrypoint argument by name.
    type family EpdLookupEntrypoint deriv cp :: Symbol -> Exp (Maybe Type);
}

-- | Construct parameter annotations corresponding to expected entrypoints
--   set.
--   
--   This method is implementation detail, for actual notes construction
--   use <a>parameterEntrypointsToNotes</a>.
epdNotes :: EntrypointsDerivation deriv cp => (Notes (ToT cp), RootAnn)

-- | Construct entrypoint caller.
--   
--   This does not treat calls to default entrypoint in a special way.
--   
--   This method is implementation detail, for actual entrypoint lookup use
--   <a>parameterEntrypointCall</a>.
epdCall :: (EntrypointsDerivation deriv cp, ParameterScope (ToT cp)) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint deriv cp name))

-- | Description of how each of the entrypoints is constructed.
epdDescs :: EntrypointsDerivation deriv cp => Rec EpCallingDesc (EpdAllEntrypoints deriv cp)

-- | Result of entrypoint lookup at term level.
data EpConstructionRes (param :: T) (marg :: Maybe Type)
[EpConstructed] :: ParameterScope (ToT arg) => EpLiftSequence (ToT arg) param -> EpConstructionRes param ('Just arg)
[EpConstructionFailed] :: EpConstructionRes param 'Nothing

-- | How one of the entrypoints is called.
--   
--   Type arguments are name of the constructor which eventually gave name
--   to the entrypoint and this entrypoint's argument.
data EpCallingDesc (info :: (Symbol, Type))
[EpCallingDesc] :: {epcdArg :: Proxy (arg :: Type) " Entrypoint argument type.", epcdEntrypoint :: EpName " Name of assigned entrypoint.", epcdSteps :: [EpCallingStep] " If we emulated entrypoints calling via just wrapping an argument into constructors until getting the full parameter, how would it look like. Steps are enlisted in reversed order - top-level constructors go last."} -> EpCallingDesc '(name, arg)
data EpCallingStep

-- | Wrap into constructor with given name.
EpsWrapIn :: Text -> EpCallingStep

-- | Ensure that all declared entrypoints are unique.
type RequireAllUniqueEntrypoints cp = RequireAllUniqueEntrypoints' (ParameterEntrypointsDerivation cp) cp

-- | Which entrypoints given parameter declares.
--   
--   Note that usually this function should not be used as constraint, use
--   <a>ParameterDeclaresEntrypoints</a> for this purpose.
class (EntrypointsDerivation (ParameterEntrypointsDerivation cp) cp, RequireAllUniqueEntrypoints cp) => ParameterHasEntrypoints cp where {
    type family ParameterEntrypointsDerivation cp :: Type;
}

-- | Parameter declares some entrypoints.
--   
--   This is a version of <a>ParameterHasEntrypoints</a> which we actually
--   use in constraints. When given type is a sum type or newtype, we refer
--   to <a>ParameterHasEntrypoints</a> instance, otherwise this instance is
--   not necessary.
type ParameterDeclaresEntrypoints cp = (If (CanHaveEntrypoints cp) (ParameterHasEntrypoints cp) (() :: Constraint), NiceParameter cp, EntrypointsDerivation (GetParameterEpDerivation cp) cp)

-- | Version of <a>ParameterEntrypointsDerivation</a> which we actually use
--   in function signatures. When given type is sum type or newtype, we
--   refer to <a>ParameterEntrypointsDerivation</a>, otherwise we suppose
--   that no entrypoints are declared.
type GetParameterEpDerivation cp = If (CanHaveEntrypoints cp) (ParameterEntrypointsDerivation cp) EpdNone

-- | Version of <a>epdNotes</a> which we actually use in code. It hides
--   derivations stuff inside, and treats primitive types specially like
--   <a>GetParameterEpDerivation</a> does.
pepNotes :: forall cp. ParameterDeclaresEntrypoints cp => (Notes (ToT cp), RootAnn)

-- | Version of <a>epdCall</a> which we actually use in code. It hides
--   derivations stuff inside, and treats primitive types specially like
--   <a>GetParameterEpDerivation</a> does.
pepCall :: forall cp name. (ParameterDeclaresEntrypoints cp, ParameterScope (ToT cp)) => Label name -> EpConstructionRes (ToT cp) (Eval (LookupParameterEntrypoint cp name))

-- | Version of <a>epdDescs</a> which we actually use in code. It hides
--   derivations stuff inside, and treats primitive types specially like
--   <a>GetParameterEpDerivation</a> does.
pepDescs :: forall cp. ParameterDeclaresEntrypoints cp => Rec EpCallingDesc (AllParameterEntrypoints cp)

-- | Descriptions of how each of the entrypoints is constructed.
--   
--   Similar to <a>pepDescs</a>, but includes default entrypoint disregard
--   whether it is explicit or not, while <a>pepDescs</a> includes it only
--   if it is explicit. Also this returns list, not <a>Rec</a>, for
--   simplicity.
--   
--   Note that [order of entrypoints children] property still holds here.
pepDescsWithDef :: forall cp. ParameterDeclaresEntrypoints cp => [Some1 EpCallingDesc]

-- | Get all entrypoints declared for parameter.
type family AllParameterEntrypoints (cp :: Type) :: [(Symbol, Type)]

-- | Lookup for entrypoint type by name.
--   
--   Does not treat default entrypoints in a special way.
type family LookupParameterEntrypoint (cp :: Type) :: Symbol -> Exp (Maybe Type)

-- | Derive annotations for given parameter.
parameterEntrypointsToNotes :: forall cp. ParameterDeclaresEntrypoints cp => ParamNotes (ToT cp)

-- | Get type of entrypoint with given name, fail if not found.
type GetEntrypointArg cp name = Eval (LiftM2 FromMaybe (TError ('Text "Entrypoint not found: " :<>: 'ShowType name :$$: 'Text "In contract parameter `" :<>: 'ShowType cp :<>: 'Text "`")) (LookupParameterEntrypoint cp name))

-- | Prepare call to given entrypoint.
--   
--   This does not treat calls to default entrypoint in a special way. To
--   call default entrypoint properly use
--   <a>parameterEntrypointCallDefault</a>.
parameterEntrypointCall :: forall cp name. ParameterDeclaresEntrypoints cp => Label name -> EntrypointCall cp (GetEntrypointArg cp name)

-- | Get type of entrypoint with given name, fail if not found.
type GetDefaultEntrypointArg cp = Eval (LiftM2 FromMaybe (Pure cp) (LookupParameterEntrypoint cp DefaultEpName))

-- | Call the default entrypoint.
parameterEntrypointCallDefault :: forall cp. ParameterDeclaresEntrypoints cp => EntrypointCall cp (GetDefaultEntrypointArg cp)

-- | Ensure that there is no explicit "default" entrypoint.
type ForbidExplicitDefaultEntrypoint cp = Eval (LiftM3 UnMaybe (Pure (Pure (() :: Constraint))) (TError ('Text "Parameter used here must have no explicit \"default\" entrypoint" :$$: 'Text "In parameter type `" :<>: 'ShowType cp :<>: 'Text "`")) (LookupParameterEntrypoint cp DefaultEpName))

-- | Similar to <a>ForbidExplicitDefaultEntrypoint</a>, but in a version
--   which the compiler can work with (and which produces errors confusing
--   for users :/)
type NoExplicitDefaultEntrypoint cp = Eval (LookupParameterEntrypoint cp DefaultEpName) ~ 'Nothing

-- | Call root entrypoint safely.
sepcCallRootChecked :: forall cp. (NiceParameter cp, ForbidExplicitDefaultEntrypoint cp) => SomeEntrypointCall cp

-- | Which entrypoint to call.
--   
--   We intentionally distinguish default and non-default cases because
--   this makes API more details-agnostic.
data EntrypointRef (mname :: Maybe Symbol)

-- | Call the default entrypoint, or root if no explicit default is
--   assigned.
[CallDefault] :: EntrypointRef 'Nothing

-- | Call the given entrypoint; calling default is not treated specially.
--   You have to provide entrypoint name via passing it as type argument.
--   
--   Unfortunatelly, here we cannot accept a label because in most cases
--   our entrypoints begin from capital letter (being derived from
--   constructor name), while labels must start from a lower-case letter,
--   and there is no way to make a conversion at type-level.
[Call] :: NiceEntrypointName name => EntrypointRef ('Just name)

-- | Constraint on type-level entrypoint name specifier.
type NiceEntrypointName name = (KnownSymbol name, ForbidDefaultName name)
eprName :: forall mname. EntrypointRef mname -> EpName

-- | Universal entrypoint lookup.
type family GetEntrypointArgCustom cp mname :: Type

-- | This wrapper allows to pass untyped <a>EpName</a> and bypass checking
--   that entrypoint with given name and type exists.
newtype TrustEpName
TrustEpName :: EpName -> TrustEpName

-- | When we call a Lorentz contract we should pass entrypoint name and
--   corresponding argument. Ideally we want to statically check that
--   parameter has entrypoint with given name and argument. Constraint
--   defined by this type class holds for contract with parameter
--   <tt>cp</tt> that have entrypoint matching <tt>name</tt> with type
--   <tt>arg</tt>.
--   
--   In order to check this property statically, we need to know entrypoint
--   name in compile time, <a>EntrypointRef</a> type serves this purpose.
--   If entrypoint name is not known, one can use <a>TrustEpName</a>
--   wrapper to take responsibility for presence of this entrypoint.
--   
--   If you want to call a function which has this constraint, you have two
--   options: 1. Pass contract parameter <tt>cp</tt> using type
--   application, pass <a>EntrypointRef</a> as a value and pass entrypoint
--   argument. Type system will check that <tt>cp</tt> has an entrypoint
--   with given reference and type. 2. Pass <a>EpName</a> wrapped into
--   <a>TrustEpName</a> and entrypoint argument. In this case passing
--   contract parameter is not necessary, you do not even have to know it.
class HasEntrypointArg cp name arg

-- | Data returned by this method may look somewhat arbitrary.
--   <a>EpName</a> is obviously needed because <tt>name</tt> can be
--   <a>EntrypointRef</a> or <a>TrustEpName</a>. <tt>Dict</tt> is returned
--   because in <a>EntrypointRef</a> case we get this evidence for free and
--   don't want to use it. We seem to always need it anyway.
useHasEntrypointArg :: HasEntrypointArg cp name arg => name -> (Dict (ParameterScope (ToT arg)), EpName)

-- | <a>HasEntrypointArg</a> constraint specialized to default entrypoint.
type HasDefEntrypointArg cp defEpName defArg = (defEpName ~ EntrypointRef 'Nothing, HasEntrypointArg cp defEpName defArg)

-- | Checks that the given parameter consists of some specific entrypoint.
--   Similar as <a>HasEntrypointArg</a> but ensures that the argument
--   matches the following datatype.
type HasEntrypointOfType param con exp = (GetEntrypointArgCustom param ('Just con) ~ exp, ParameterDeclaresEntrypoints param)

-- | Check that the given entrypoint has some fields inside. This interface
--   allows for an abstraction of contract parameter so that it requires
--   some *minimal* specification, but not a concrete one.
type family ParameterContainsEntrypoints param (fields :: [NamedEp]) :: Constraint

-- | Universal entrypoint calling.
parameterEntrypointCallCustom :: forall cp mname. ParameterDeclaresEntrypoints cp => EntrypointRef mname -> EntrypointCall cp (GetEntrypointArgCustom cp mname)

-- | No entrypoints declared, parameter type will serve as argument type of
--   the only existing entrypoint (default one).
data EpdNone
type n :> ty = 'NamedEp n ty
infixr 0 :>
type RequireAllUniqueEntrypoints' deriv cp = RequireAllUnique "entrypoint name" (Eval (Map Fst $ EpdAllEntrypoints deriv cp))
instance GHC.Classes.Eq Lorentz.Entrypoints.Core.EpCallingStep
instance GHC.Show.Show Lorentz.Entrypoints.Core.EpCallingStep
instance GHC.Show.Show (Lorentz.Entrypoints.Core.EpCallingDesc info)
instance (Lorentz.Entrypoints.Core.GetEntrypointArgCustom cp mname GHC.Types.~ arg, Lorentz.Entrypoints.Core.ParameterDeclaresEntrypoints cp) => Lorentz.Entrypoints.Core.HasEntrypointArg cp (Lorentz.Entrypoints.Core.EntrypointRef mname) arg
instance Lorentz.Annotation.HasAnnotation cp => Lorentz.Entrypoints.Core.EntrypointsDerivation Lorentz.Entrypoints.Core.EpdNone cp
instance forall k arg (cp :: k). Lorentz.Constraints.Scopes.NiceParameter arg => Lorentz.Entrypoints.Core.HasEntrypointArg cp Lorentz.Entrypoints.Core.TrustEpName arg


-- | Commonly used parts of regular Prelude.
module Lorentz.Prelude

-- | Application operator. This operator is redundant, since ordinary
--   application <tt>(f x)</tt> means the same as <tt>(f <a>$</a> x)</tt>.
--   However, <a>$</a> has low, right-associative binding precedence, so it
--   sometimes allows parentheses to be omitted; for example:
--   
--   <pre>
--   f $ g $ h x  =  f (g (h x))
--   </pre>
--   
--   It is also useful in higher-order situations, such as <tt><a>map</a>
--   (<a>$</a> 0) xs</tt>, or <tt><a>zipWith</a> (<a>$</a>) fs xs</tt>.
--   
--   Note that <tt>(<a>$</a>)</tt> is levity-polymorphic in its result
--   type, so that <tt>foo <a>$</a> True</tt> where <tt>foo :: Bool -&gt;
--   Int#</tt> is well-typed.
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
infixr 0 $

-- | Function composition.
(.) :: (b -> c) -> (a -> b) -> a -> c
infixr 9 .

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
--   
--   <pre>
--   &gt;&gt;&gt; 5 &amp; (+1) &amp; show
--   "6"
--   </pre>
(&) :: a -> (a -> b) -> b
infixl 1 &

-- | Infix application.
--   
--   <pre>
--   f :: Either String $ Maybe Int
--   =
--   f :: Either String (Maybe Int)
--   </pre>
type (f :: k1 -> k) $ (a :: k1) = f a
infixr 2 $

-- | The <a>Eq</a> class defines equality (<a>==</a>) and inequality
--   (<a>/=</a>). All the basic datatypes exported by the <a>Prelude</a>
--   are instances of <a>Eq</a>, and <a>Eq</a> may be derived for any
--   datatype whose constituents are also instances of <a>Eq</a>.
--   
--   The Haskell Report defines no laws for <a>Eq</a>. However, <a>==</a>
--   is customarily expected to implement an equivalence relationship where
--   two values comparing equal are indistinguishable by "public"
--   functions, with a "public" function being one not allowing to see
--   implementation details. For example, for a type representing
--   non-normalised natural numbers modulo 100, a "public" function doesn't
--   make the difference between 1 and 201. It is expected to have the
--   following properties:
--   
--   <ul>
--   <li><i><b>Reflexivity</b></i> <tt>x == x</tt> = <a>True</a></li>
--   <li><i><b>Symmetry</b></i> <tt>x == y</tt> = <tt>y == x</tt></li>
--   <li><i><b>Transitivity</b></i> if <tt>x == y &amp;&amp; y == z</tt> =
--   <a>True</a>, then <tt>x == z</tt> = <a>True</a></li>
--   <li><i><b>Substitutivity</b></i> if <tt>x == y</tt> = <a>True</a> and
--   <tt>f</tt> is a "public" function whose return type is an instance of
--   <a>Eq</a>, then <tt>f x == f y</tt> = <a>True</a></li>
--   <li><i><b>Negation</b></i> <tt>x /= y</tt> = <tt>not (x ==
--   y)</tt></li>
--   </ul>
--   
--   Minimal complete definition: either <a>==</a> or <a>/=</a>.
class Eq a

-- | The <a>Ord</a> class is used for totally ordered datatypes.
--   
--   Instances of <a>Ord</a> can be derived for any user-defined datatype
--   whose constituent types are in <a>Ord</a>. The declared order of the
--   constructors in the data declaration determines the ordering in
--   derived <a>Ord</a> instances. The <a>Ordering</a> datatype allows a
--   single comparison to determine the precise ordering of two objects.
--   
--   The Haskell Report defines no laws for <a>Ord</a>. However,
--   <a>&lt;=</a> is customarily expected to implement a non-strict partial
--   order and have the following properties:
--   
--   <ul>
--   <li><i><b>Transitivity</b></i> if <tt>x &lt;= y &amp;&amp; y &lt;=
--   z</tt> = <a>True</a>, then <tt>x &lt;= z</tt> = <a>True</a></li>
--   <li><i><b>Reflexivity</b></i> <tt>x &lt;= x</tt> = <a>True</a></li>
--   <li><i><b>Antisymmetry</b></i> if <tt>x &lt;= y &amp;&amp; y &lt;=
--   x</tt> = <a>True</a>, then <tt>x == y</tt> = <a>True</a></li>
--   </ul>
--   
--   Note that the following operator interactions are expected to hold:
--   
--   <ol>
--   <li><tt>x &gt;= y</tt> = <tt>y &lt;= x</tt></li>
--   <li><tt>x &lt; y</tt> = <tt>x &lt;= y &amp;&amp; x /= y</tt></li>
--   <li><tt>x &gt; y</tt> = <tt>y &lt; x</tt></li>
--   <li><tt>x &lt; y</tt> = <tt>compare x y == LT</tt></li>
--   <li><tt>x &gt; y</tt> = <tt>compare x y == GT</tt></li>
--   <li><tt>x == y</tt> = <tt>compare x y == EQ</tt></li>
--   <li><tt>min x y == if x &lt;= y then x else y</tt> = <a>True</a></li>
--   <li><tt>max x y == if x &gt;= y then x else y</tt> = <a>True</a></li>
--   </ol>
--   
--   Note that (7.) and (8.) do <i>not</i> require <a>min</a> and
--   <a>max</a> to return either of their arguments. The result is merely
--   required to <i>equal</i> one of the arguments in terms of <a>(==)</a>.
--   
--   Minimal complete definition: either <a>compare</a> or <a>&lt;=</a>.
--   Using <a>compare</a> can be more efficient for complex types.
class Eq a => Ord a

-- | The <a>Bounded</a> class is used to name the upper and lower limits of
--   a type. <a>Ord</a> is not a superclass of <a>Bounded</a> since types
--   that are not totally ordered may also have upper and lower bounds.
--   
--   The <a>Bounded</a> class may be derived for any enumeration type;
--   <a>minBound</a> is the first constructor listed in the <tt>data</tt>
--   declaration and <a>maxBound</a> is the last. <a>Bounded</a> may also
--   be derived for single-constructor datatypes whose constituent types
--   are in <a>Bounded</a>.
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a

-- | The class of semigroups (types with an associative binary operation).
--   
--   Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt></li>
--   </ul>
class Semigroup a

-- | An associative operation.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3] &lt;&gt; [4,5,6]
--   [1,2,3,4,5,6]
--   </pre>
(<>) :: Semigroup a => a -> a -> a

-- | Reduce a non-empty list with <a>&lt;&gt;</a>
--   
--   The default definition should be sufficient, but this can be
--   overridden for efficiency.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.List.NonEmpty
--   
--   &gt;&gt;&gt; sconcat $ "Hello" :| [" ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
sconcat :: Semigroup a => NonEmpty a -> a

-- | Repeat a value <tt>n</tt> times.
--   
--   Given that this works on a <a>Semigroup</a> it is allowed to fail if
--   you request 0 or fewer repetitions, and the default definition will do
--   so.
--   
--   By making this a member of the class, idempotent semigroups and
--   monoids can upgrade this to execute in &lt;math&gt; by picking
--   <tt>stimes = <a>stimesIdempotent</a></tt> or <tt>stimes =
--   <a>stimesIdempotentMonoid</a></tt> respectively.
--   
--   <pre>
--   &gt;&gt;&gt; stimes 4 [1]
--   [1,1,1,1]
--   </pre>
stimes :: (Semigroup a, Integral b) => b -> a -> a
infixr 6 <>

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Right identity</i> <tt>x <a>&lt;&gt;</a> <a>mempty</a> =
--   x</tt></li>
--   <li><i>Left identity</i> <tt><a>mempty</a> <a>&lt;&gt;</a> x =
--   x</tt></li>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a>
--   law)</li>
--   <li><i>Concatenation</i> <tt><a>mconcat</a> = <a>foldr</a>
--   (<a>&lt;&gt;</a>) <a>mempty</a></tt></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <a>Sum</a> and <a>Product</a>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello world" &lt;&gt; mempty
--   "Hello world"
--   </pre>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = (<a>&lt;&gt;</a>)</tt> since
--   <i>base-4.11.0.0</i>. Should it be implemented manually, since
--   <a>mappend</a> is a synonym for (<a>&lt;&gt;</a>), it is expected that
--   the two functions are defined the same way. In a future GHC release
--   <a>mappend</a> will be removed from <a>Monoid</a>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
--   
--   <pre>
--   &gt;&gt;&gt; mconcat ["Hello", " ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
mconcat :: Monoid a => [a] -> a

-- | Representable types of kind <tt>*</tt>. This class is derivable in GHC
--   with the <tt>DeriveGeneric</tt> flag on.
--   
--   A <a>Generic</a> instance must satisfy the following laws:
--   
--   <pre>
--   <a>from</a> . <a>to</a> ≡ <a>id</a>
--   <a>to</a> . <a>from</a> ≡ <a>id</a>
--   </pre>
class Generic a

-- | A space efficient, packed, unboxed Unicode text type.
data Text

-- | The <a>Either</a> type represents values with two possibilities: a
--   value of type <tt><a>Either</a> a b</tt> is either <tt><a>Left</a>
--   a</tt> or <tt><a>Right</a> b</tt>.
--   
--   The <a>Either</a> type is sometimes used to represent a value which is
--   either correct or an error; by convention, the <a>Left</a> constructor
--   is used to hold an error value and the <a>Right</a> constructor is
--   used to hold a correct value (mnemonic: "right" also means "correct").
--   
--   <h4><b>Examples</b></h4>
--   
--   The type <tt><a>Either</a> <a>String</a> <a>Int</a></tt> is the type
--   of values which can be either a <a>String</a> or an <a>Int</a>. The
--   <a>Left</a> constructor can be used only on <a>String</a>s, and the
--   <a>Right</a> constructor can be used only on <a>Int</a>s:
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; s
--   Left "foo"
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; n
--   Right 3
--   
--   &gt;&gt;&gt; :type s
--   s :: Either String Int
--   
--   &gt;&gt;&gt; :type n
--   n :: Either String Int
--   </pre>
--   
--   The <a>fmap</a> from our <a>Functor</a> instance will ignore
--   <a>Left</a> values, but will apply the supplied function to values
--   contained in a <a>Right</a>:
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; fmap (*2) s
--   Left "foo"
--   
--   &gt;&gt;&gt; fmap (*2) n
--   Right 6
--   </pre>
--   
--   The <a>Monad</a> instance for <a>Either</a> allows us to chain
--   together multiple actions which may fail, and fail overall if any of
--   the individual steps failed. First we'll write a function that can
--   either parse an <a>Int</a> from a <a>Char</a>, or fail.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Char ( digitToInt, isDigit )
--   
--   &gt;&gt;&gt; :{
--       let parseEither :: Char -&gt; Either String Int
--           parseEither c
--             | isDigit c = Right (digitToInt c)
--             | otherwise = Left "parse error"
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   The following should work, since both <tt>'1'</tt> and <tt>'2'</tt>
--   can be parsed as <a>Int</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x &lt;- parseEither '1'
--             y &lt;- parseEither '2'
--             return (x + y)
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseMultiple
--   Right 3
--   </pre>
--   
--   But the following should fail overall, since the first operation where
--   we attempt to parse <tt>'m'</tt> as an <a>Int</a> will fail:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x &lt;- parseEither 'm'
--             y &lt;- parseEither '2'
--             return (x + y)
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseMultiple
--   Left "parse error"
--   </pre>
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b

-- | The <a>Maybe</a> type encapsulates an optional value. A value of type
--   <tt><a>Maybe</a> a</tt> either contains a value of type <tt>a</tt>
--   (represented as <tt><a>Just</a> a</tt>), or it is empty (represented
--   as <a>Nothing</a>). Using <a>Maybe</a> is a good way to deal with
--   errors or exceptional cases without resorting to drastic measures such
--   as <a>error</a>.
--   
--   The <a>Maybe</a> type is also a monad. It is a simple kind of error
--   monad, where all errors are represented by <a>Nothing</a>. A richer
--   error monad can be built using the <a>Either</a> type.
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a

-- | <a>Proxy</a> is a type that holds no data, but has a phantom parameter
--   of arbitrary type (or even kind). Its use is to provide type
--   information, even though there is no value available of that type (or
--   it may be too costly to create one).
--   
--   Historically, <tt><a>Proxy</a> :: <a>Proxy</a> a</tt> is a safer
--   alternative to the <tt><a>undefined</a> :: a</tt> idiom.
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy (Void, Int -&gt; Int)
--   Proxy
--   </pre>
--   
--   Proxy can even hold types of higher kinds,
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Either
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Functor
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy complicatedStructure
--   Proxy
--   </pre>
data Proxy (t :: k)
Proxy :: Proxy (t :: k)
fromString :: IsString a => String -> a

-- | <a>undefined</a> that leaves a warning in code on every usage.
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

-- | <a>error</a> that takes <a>Text</a> as an argument.
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => Text -> a

-- | Supply a parameter to a function:
--   
--   <pre>
--   function <a>!</a> #param_name value
--   </pre>
--   
--   <pre>
--   function <a>!</a> #x 7 <a>!</a> #y 42 <a>!</a> <a>defaults</a>
--   </pre>
--   
--   This is an infix version of <a>with</a>.
(!) :: WithParam p fn fn' => fn -> Param p -> fn'
infixl 9 !

module Lorentz.ViewBase

-- | Type-level information about a view.
data ViewTyInfo
ViewTyInfo :: Symbol -> Type -> Type -> ViewTyInfo

-- | Neat constructor for <a>ViewTyInfo</a>.
--   
--   type View = "view" ?:: Integer &gt;-&gt; Natural
type family (?::) (name :: Symbol) (tys :: (Type, Type))
infix 3 ?::
type arg >-> ret = '(arg, ret)
infix 5 >->

-- | A views descriptor that directly carries the full list of views.
data ViewsList (vl :: [ViewTyInfo])

-- | Get a list of views by a descriptor object.
--   
--   The problem this type family solves: it is unpleasant to carry around
--   a list of views because it may be large, and if we merely hide this
--   list under a type alias, error messages will still mention the type
--   alias expanded. We want e.g. <tt>Contract Parameter Storage Views</tt>
--   to be carried as-is. <tt>Parameter</tt> and <tt>Storage</tt> are
--   usually datatypes and they are fine, while for <tt>Views</tt> to be
--   not automatically expanded we have to take special care.
--   
--   You can still provide the list of <a>ViewTyInfo</a>s to this type
--   family using <a>ViewsList</a>, but generally prefer creating a
--   dedicated datatype that would expand to a views list.
type family RevealViews (desc :: Type) :: [ViewTyInfo]

-- | Find a view in a contract by name.
type family LookupView (name :: Symbol) (views :: [ViewTyInfo]) :: (Type, Type)

-- | Reveal views and find a view there.
type LookupRevealView name viewRef = LookupView name (RevealViews viewRef)

-- | Constraint indicating that presence of the view with the specified
--   parameters is implied by the views descriptor.
type HasView vd name arg ret = (LookupRevealView name vd ~ '(arg, ret))

-- | Map views to get their names.
type family ViewsNames (vs :: [ViewTyInfo]) :: [Symbol]
newtype ViewName
UnsafeViewName :: Text -> ViewName
[unViewName] :: ViewName -> Text
pattern ViewName :: Text -> ViewName

-- | Interface of a single view at term-level.
data ViewInterface
ViewInterface :: ViewName -> T -> T -> ViewInterface
[viName] :: ViewInterface -> ViewName
[viArg] :: ViewInterface -> T
[viRet] :: ViewInterface -> T

-- | Demote view name from type level to term level.
demoteViewName :: forall name. (KnownSymbol name, HasCallStack) => ViewName

-- | Demote <a>ViewTyInfo</a>s to <a>ViewInterface</a>s.
demoteViewTyInfos :: forall (vs :: [ViewTyInfo]). DemoteViewTyInfo vs => [ViewInterface]
type DemoteViewsDescriptor vd = DemoteViewTyInfo (RevealViews vd)

-- | Demote views descriptor to <a>ViewInterface</a>s.
demoteViewsDescriptor :: forall (vd :: Type). DemoteViewTyInfo (RevealViews vd) => [ViewInterface]
data ViewInterfaceMatchError
VIMViewNotFound :: ViewName -> ViewInterfaceMatchError
VIMViewArgMismatch :: T -> T -> ViewInterfaceMatchError
VIMViewRetMismatch :: T -> T -> ViewInterfaceMatchError

-- | Check that the given set of views covers the given view interfaces.
--   Extra views in the set, that do not appear in the interface, are fine.
checkViewsCoverInterface :: forall st. [ViewInterface] -> ViewsSet st -> Either ViewInterfaceMatchError ()
instance GHC.Classes.Eq Lorentz.ViewBase.ViewInterfaceMatchError
instance GHC.Show.Show Lorentz.ViewBase.ViewInterfaceMatchError
instance Formatting.Buildable.Buildable Lorentz.ViewBase.ViewInterfaceMatchError
instance GHC.Exception.Type.Exception Lorentz.ViewBase.ViewInterfaceMatchError
instance Lorentz.ViewBase.DemoteViewTyInfo '[]
instance (GHC.TypeLits.KnownSymbol name, Morley.Michelson.Typed.Haskell.Value.IsoValue arg, Morley.Michelson.Typed.Haskell.Value.IsoValue ret, Lorentz.ViewBase.DemoteViewTyInfo vs) => Lorentz.ViewBase.DemoteViewTyInfo ('Lorentz.ViewBase.ViewTyInfo name arg ret : vs)


-- | Some derivative constraints.
--   
--   They are moved to separate module because they need to lie quite high
--   in modules dependencies graph (unlike
--   <a>Lorentz.Constraints.Scopes</a>).
module Lorentz.Constraints.Derivative

-- | Constraint applied to a whole parameter type.
type NiceParameterFull cp = (Typeable cp, ParameterDeclaresEntrypoints cp)

-- | Tells whether given type is dupable or not.
data DupableDecision a
IsDupable :: DupableDecision a
IsNotDupable :: DupableDecision a

-- | Check whether given value is dupable, returning a proof of that when
--   it is.
--   
--   This lets defining methods that behave differently depending on
--   whether given value is dupable or not. This may be suitable when for
--   the dupable case you can provide a more efficient implementation, but
--   you also want your implementation to be generic.
--   
--   Example:
--   
--   <pre>
--   code = case decideOnDupable @a of
--     IsDupable -&gt; do dup; ...
--     IsNotDupable -&gt; ...
--   </pre>
decideOnDupable :: forall a. KnownValue a => DupableDecision a

-- | Require views set to be proper.
type NiceViews vs = RequireAllUnique "view" (ViewsNames vs)

-- | Require views set referred by the given views descriptor to be proper.
type NiceViewsDescriptor vd = NiceViews (RevealViews vd)

module Lorentz.Constraints


-- | Foundation of Lorentz development.
module Lorentz.Base

-- | Alias for instruction which hides inner types representation via
--   <tt>T</tt>.
newtype (inp :: [Type]) :-> (out :: [Type])
LorentzInstr :: RemFail Instr (ToTs inp) (ToTs out) -> (:->) (inp :: [Type]) (out :: [Type])
[unLorentzInstr] :: (:->) (inp :: [Type]) (out :: [Type]) -> RemFail Instr (ToTs inp) (ToTs out)
infixr 1 :->

-- | Alias for <a>:-&gt;</a>, seems to make signatures more readable
--   sometimes.
--   
--   Let's someday decide which one of these two should remain.
type (%>) = (:->)
infixr 1 %>

-- | An alias for <tt>':</tt>.
--   
--   We discourage its use as this hinders reading error messages (the
--   compiler inserts unnecessary parentheses and indentation).
type (&) (a :: Type) (b :: [Type]) = a : b
infixr 2 &

-- | Function composition for instructions.
--   
--   Note that, unlike Morley's <a>:#</a> operator, <a>(#)</a> is
--   left-associative.
(#) :: (a :-> b) -> (b :-> c) -> a :-> c
infixl 8 #
pattern I :: Instr (ToTs inp) (ToTs out) -> inp :-> out
pattern FI :: (forall out'. Instr (ToTs inp) out') -> inp :-> out
iGenericIf :: (forall s'. Instr (ToTs a) s' -> Instr (ToTs b) s' -> Instr (ToTs c) s') -> (a :-> s) -> (b :-> s) -> c :-> s
iAnyCode :: (inp :-> out) -> Instr (ToTs inp) (ToTs out)
iNonFailingCode :: HasCallStack => (inp :-> out) -> Instr (ToTs inp) (ToTs out)
iMapAnyCode :: (forall o'. Instr (ToTs i1) o' -> Instr (ToTs i2) o') -> (i1 :-> o) -> i2 :-> o
iForceNotFail :: (i :-> o) -> i :-> o

-- | Wrap Lorentz instruction with variable annotations, <tt>annots</tt>
--   list has to be non-empty, otherwise this function raises an error.
iWithVarAnnotations :: HasCallStack => [Text] -> (inp :-> out) -> inp :-> out

-- | Parse textual representation of a Michelson value and turn it into
--   corresponding Haskell value.
--   
--   Note: it won't work in some complex cases, e. g. if there is a lambda
--   which uses an instruction which depends on current contract's type.
--   Obviously it can not work, because we don't have any information about
--   a contract to which this value belongs (there is no such contract at
--   all).
parseLorentzValue :: forall v. KnownValue v => MichelsonSource -> Text -> Either ParseLorentzError v

-- | Lorentz version of <a>transformStrings</a>.
transformStringsLorentz :: Bool -> (MText -> MText) -> (inp :-> out) -> inp :-> out

-- | Lorentz version of <a>transformBytes</a>.
transformBytesLorentz :: Bool -> (ByteString -> ByteString) -> (inp :-> out) -> inp :-> out
optimizeLorentz :: (inp :-> out) -> inp :-> out
optimizeLorentzWithConf :: OptimizerConf -> (inp :-> out) -> inp :-> out

-- | Applicable for wrappers over Lorentz code.
class MapLorentzInstr instr

-- | Modify all the code under given entity.
mapLorentzInstr :: MapLorentzInstr instr => (forall i o. (i :-> o) -> i :-> o) -> instr -> instr
type ContractOut st = '[([Operation], st)]
type ContractCode cp st = '[(cp, st)] :-> ContractOut st
data SomeContractCode
[SomeContractCode] :: (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> SomeContractCode
type ViewCode arg st ret = '[(arg, st)] :-> '[ret]

-- | Compiled Lorentz contract.
--   
--   Note, that the views argument (views descriptor) is added comparing to
--   the Michelson. In Michelson, ability to call a view is fully checked
--   at runtime, but in Lorentz we want to make calls safer at
--   compile-time.
data Contract cp st vd
Contract :: Contract (ToT cp) (ToT st) -> ~ContractCode cp st -> Contract cp st vd

-- | Ready contract code.
[cMichelsonContract] :: Contract cp st vd -> Contract (ToT cp) (ToT st)

-- | Contract that contains documentation.
--   
--   We have to keep it separately, since optimizer is free to destroy
--   documentation blocks. Also, it is not <a>ContractDoc</a> but Lorentz
--   code because the latter is easier to modify.
[cDocumentedCode] :: Contract cp st vd -> ~ContractCode cp st

-- | Demote Lorentz <a>Contract</a> to Michelson typed <a>Contract</a>.
toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)
type Lambda i o = '[i] :-> '[o]
instance GHC.Classes.Eq (inp Lorentz.Base.:-> out)
instance GHC.Show.Show (inp Lorentz.Base.:-> out)
instance GHC.Classes.Eq Lorentz.Base.ParseLorentzError
instance GHC.Show.Show Lorentz.Base.ParseLorentzError
instance GHC.Show.Show (Lorentz.Base.Contract cp st vd)
instance GHC.Classes.Eq (Lorentz.Base.Contract cp st vd)
instance Lorentz.Base.MapLorentzInstr (i Lorentz.Base.:-> o)
instance Formatting.Buildable.Buildable Lorentz.Base.ParseLorentzError
instance Control.DeepSeq.NFData (Lorentz.Base.Contract cp st vd)
instance Morley.Micheline.Class.ToExpression (Lorentz.Base.Contract cp st vd)
instance Formatting.Buildable.Buildable (inp Lorentz.Base.:-> out)
instance Morley.Michelson.Printer.Util.RenderDoc (inp Lorentz.Base.:-> out)
instance Control.DeepSeq.NFData (i Lorentz.Base.:-> o)
instance GHC.Base.Semigroup (s Lorentz.Base.:-> s)
instance GHC.Base.Monoid (s Lorentz.Base.:-> s)


-- | Lorentz wrappers over instructions from Morley extension.
module Lorentz.Ext

-- | Include a value at given position on stack into comment produced by
--   <a>printComment</a>.
--   
--   <pre>
--   stackRef @0
--   </pre>
--   
--   <a>the top of the stack</a>
stackRef :: forall (gn :: Nat) st n. (n ~ ToPeano gn, SingI n, RequireLongerThan st n) => PrintComment st

-- | Print a comment. It will be visible in tests.
--   
--   <pre>
--   printComment "Hello world!"
--   printComment $ "On top of the stack I see " &lt;&gt; stackRef @0
--   </pre>
printComment :: PrintComment (ToTs s) -> s :-> s
justComment :: Text -> s :-> s
comment :: CommentType -> s :-> s
commentAroundFun :: Text -> (i :-> o) -> i :-> o
commentAroundStmt :: Text -> (i :-> o) -> i :-> o

-- | Test an invariant, fail if it does not hold.
--   
--   This won't be included into production contract and is executed only
--   in tests.
testAssert :: HasCallStack => Text -> PrintComment (ToTs inp) -> (inp :-> (Bool : out)) -> inp :-> inp

-- | Fix the current type of the stack to be given one.
--   
--   <pre>
--   stackType @'[Natural]
--   stackType @(Integer : Natural : s)
--   stackType @'["balance" :! Integer, "toSpend" :! Integer, BigMap Address Integer]
--   </pre>
--   
--   Note that you can omit arbitrary parts of the type.
--   
--   <pre>
--   stackType @'["balance" :! Integer, "toSpend" :! _, BigMap _ _]
--   </pre>
stackType :: forall s. s :-> s


-- | Common primitives.
module Lorentz.Common

-- | Single entrypoint of a contract.
--   
--   Note that we cannot make it return <tt>[[Operation], store]</tt>
--   because such entrypoint should've been followed by <tt>pair</tt>, and
--   this is not possible if entrypoint implementation ends with
--   <a>failWith</a>.
type Entrypoint param store = '[param, store] :-> ContractOut store

-- | Version of <a>Entrypoint</a> which accepts no argument.
type Entrypoint_ store = '[store] :-> ContractOut store


-- | This module introduces several types for safe work with
--   <tt>address</tt> and <tt>contract</tt> types. All available types for
--   that are represented in the following table:
--   
--   TODO: table
--   
--   This module also provides functions for converting between these types
--   in Haskell and Michelson worlds. In the latter you can additionally
--   use coercions and dedicated instructions from <a>Lorentz.Instr</a>.
module Lorentz.Address

-- | Address which remembers the parameter and views types of the contract
--   it refers to.
--   
--   It differs from Michelson's <tt>contract</tt> type because it cannot
--   contain entrypoint, and it always refers to entire contract parameter
--   even if this contract has explicit default entrypoint.
newtype TAddress (p :: Type) (vd :: Type)
TAddress :: Address -> TAddress (p :: Type) (vd :: Type)
[unTAddress] :: TAddress (p :: Type) (vd :: Type) -> Address

-- | Address associated with value of <tt>contract arg</tt> type.
--   
--   Places where <a>ContractRef</a> can appear are now severely limited,
--   this type gives you type-safety of <a>ContractRef</a> but still can be
--   used everywhere. This type is not a full-featured one rather a helper;
--   in particular, once pushing it on stack, you cannot return it back to
--   Haskell world.
--   
--   Note that it refers to an entrypoint of the contract, not just the
--   contract as a whole. In this sense this type differs from
--   <a>TAddress</a>.
--   
--   Unlike with <a>ContractRef</a>, having this type you still cannot be
--   sure that the referred contract exists and need to perform a lookup
--   before calling it.
newtype FutureContract arg
FutureContract :: ContractRef arg -> FutureContract arg
[unFutureContract] :: FutureContract arg -> ContractRef arg

-- | For a contract and an address of its instance, construct a typed
--   address.
asAddressOf :: contract cp st vd -> Address -> TAddress cp vd
asAddressOf_ :: contract cp st vd -> (Address : s) :-> (TAddress cp vd : s)

-- | Generalization of <a>callingTAddress</a> to any typed address.
callingAddress :: forall cp vd addr mname. (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)

-- | Generalization of <a>callingDefTAddress</a> to any typed address.
callingDefAddress :: forall cp vd addr. (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> ContractRef (GetDefaultEntrypointArg cp)

-- | Turn <a>TAddress</a> to <a>ContractRef</a> in <i>Haskell</i> world.
--   
--   This is an analogy of <tt>address</tt> to <tt>contract</tt> convertion
--   in Michelson world, thus you have to supply an entrypoint (or call the
--   default one explicitly).

-- | <i>Deprecated: Use <a>callingAddress</a></i>
callingTAddress :: forall cp vd mname. NiceParameterFull cp => TAddress cp vd -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)

-- | Specification of <a>callingTAddress</a> to call the default
--   entrypoint.

-- | <i>Deprecated: Use <a>callingDefAddress</a></i>
callingDefTAddress :: forall cp vd. NiceParameterFull cp => TAddress cp vd -> ContractRef (GetDefaultEntrypointArg cp)

-- | Convert something to <a>Address</a> in <i>Haskell</i> world.
--   
--   Use this when you want to access state of the contract and are not
--   interested in calling it.
class ToAddress a
toAddress :: ToAddress a => a -> Address

-- | Convert something referring to a contract (not specific entrypoint) to
--   <a>TAddress</a> in <i>Haskell</i> world.
class ToTAddress (cp :: Type) (vd :: Type) (a :: Type)
toTAddress :: ToTAddress cp vd a => a -> TAddress cp vd

-- | Something coercible to 'TAddress cp'.
type ToTAddress_ cp vd addr = (ToTAddress cp vd addr, ToT addr ~ ToT Address)

-- | Cast something appropriate to <a>TAddress</a>.
toTAddress_ :: forall cp addr vd s. ToTAddress_ cp vd addr => (addr : s) :-> (TAddress cp vd : s)

-- | Convert something to <a>ContractRef</a> in <i>Haskell</i> world.
class ToContractRef (cp :: Type) (contract :: Type)
toContractRef :: (ToContractRef cp contract, HasCallStack) => contract -> ContractRef cp

-- | Convert something from <a>ContractRef</a> in <i>Haskell</i> world.
class FromContractRef (cp :: Type) (contract :: Type)
fromContractRef :: FromContractRef cp contract => ContractRef cp -> contract
convertContractRef :: forall cp contract2 contract1. (ToContractRef cp contract1, FromContractRef cp contract2) => contract1 -> contract2
data Address
data EpAddress
EpAddress :: Address -> EpName -> EpAddress
[eaAddress] :: EpAddress -> Address
[eaEntrypoint] :: EpAddress -> EpName
data ContractRef arg
ContractRef :: Address -> SomeEntrypointCall arg -> ContractRef arg
[crAddress] :: ContractRef arg -> Address
[crEntrypoint] :: ContractRef arg -> SomeEntrypointCall arg
coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b
instance Lorentz.Annotation.HasAnnotation (Lorentz.Address.TAddress p vd)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Address.TAddress p vd)
instance Formatting.Buildable.Buildable (Lorentz.Address.TAddress p vd)
instance GHC.Classes.Ord (Lorentz.Address.TAddress p vd)
instance GHC.Classes.Eq (Lorentz.Address.TAddress p vd)
instance GHC.Show.Show (Lorentz.Address.TAddress p vd)
instance GHC.Generics.Generic (Lorentz.Address.TAddress p vd)
instance (cp GHC.Types.~ cp') => Lorentz.Address.FromContractRef cp (Morley.Michelson.Typed.Haskell.Value.ContractRef cp')
instance (cp GHC.Types.~ cp') => Lorentz.Address.FromContractRef cp (Lorentz.Address.FutureContract cp')
instance Lorentz.Address.FromContractRef cp Morley.Michelson.Typed.Entrypoints.EpAddress
instance Lorentz.Address.FromContractRef cp Morley.Tezos.Address.Address
instance (cp GHC.Types.~ cp') => Lorentz.Address.ToContractRef cp (Morley.Michelson.Typed.Haskell.Value.ContractRef cp')
instance (Lorentz.Constraints.Scopes.NiceParameter cp, cp GHC.Types.~ cp') => Lorentz.Address.ToContractRef cp (Lorentz.Address.FutureContract cp')
instance (Morley.Util.Type.FailWhen cond msg, cond GHC.Types.~ (Lorentz.Entrypoints.Helpers.CanHaveEntrypoints cp Data.Type.Bool.&& Data.Type.Bool.Not (Lorentz.Entrypoints.Core.ParameterEntrypointsDerivation cp Data.Type.Equality.== Lorentz.Entrypoints.Core.EpdNone)), msg GHC.Types.~ (((('GHC.TypeLits.Text "Cannot apply `ToContractRef` to `TAddress`" 'GHC.TypeLits.:$$: 'GHC.TypeLits.Text "Consider using call(Def)TAddress first`") 'GHC.TypeLits.:$$: 'GHC.TypeLits.Text "(or if you know your parameter type is primitive,") 'GHC.TypeLits.:$$: 'GHC.TypeLits.Text " make sure typechecker also knows about that)") 'GHC.TypeLits.:$$: (('GHC.TypeLits.Text "For parameter `" 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType cp) 'GHC.TypeLits.:<>: 'GHC.TypeLits.Text "`")), cp GHC.Types.~ arg, Lorentz.Constraints.Scopes.NiceParameter arg, Lorentz.Constraints.Derivative.NiceParameterFull cp, Lorentz.Entrypoints.Core.GetDefaultEntrypointArg cp GHC.Types.~ cp) => Lorentz.Address.ToContractRef arg (Lorentz.Address.TAddress cp vd)
instance Lorentz.Address.ToTAddress cp vd Morley.Tezos.Address.Address
instance (cp GHC.Types.~ cp', vd GHC.Types.~ vd') => Lorentz.Address.ToTAddress cp vd (Lorentz.Address.TAddress cp' vd')
instance Lorentz.Address.ToAddress Morley.Tezos.Address.Address
instance Lorentz.Address.ToAddress Morley.Michelson.Typed.Entrypoints.EpAddress
instance Lorentz.Address.ToAddress (Lorentz.Address.TAddress cp vd)
instance Lorentz.Address.ToAddress (Lorentz.Address.FutureContract cp)
instance Lorentz.Address.ToAddress (Morley.Michelson.Typed.Haskell.Value.ContractRef cp)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Address.FutureContract arg)
instance Lorentz.Annotation.HasAnnotation (Lorentz.Address.FutureContract a)


-- | Permissions for casts between wrappers and their inner types.
module Lorentz.Wrappable

-- | Declares that this type is just a wrapper over some other type and it
--   can be safely unwrapped to that inner type.
--   
--   Inspired by lens <tt>Wrapped</tt>.
class ToT s ~ ToT (Unwrappabled s) => Unwrappable (s :: Type) where {
    
    -- | The type we unwrap to (inner type of the newtype).
    --   
    --   Used in constraint for Lorentz instruction wrapping into a Haskell
    --   newtype and vice versa.
    type family Unwrappabled s :: Type;
    type Unwrappabled s = GUnwrappabled s (Rep s);
}

-- | Declares that it is safe to wrap an inner type to the given wrapper
--   type. Can be provided in addition to <a>Unwrappable</a>.
--   
--   You can declare this instance when your wrapper exists just to make
--   type system differentiate the two types. Example: <tt>newtype TokenId
--   = TokenId Natural</tt>.
--   
--   Do <i>not</i> define this instance for wrappers that provide some
--   invariants. Example: <tt>UStore</tt> type from
--   <tt>morley-upgradeable</tt>.
--   
--   <a>Wrappable</a> is similar to lens <tt>Wrapped</tt> class without the
--   method.
class Unwrappable s => Wrappable (s :: Type)
instance Lorentz.Wrappable.Wrappable (Named.Internal.NamedF Data.Functor.Identity.Identity a name)
instance Lorentz.Wrappable.Wrappable (Named.Internal.NamedF GHC.Maybe.Maybe a name)
instance Lorentz.Wrappable.Unwrappable (Named.Internal.NamedF Data.Functor.Identity.Identity a name)
instance Lorentz.Wrappable.Unwrappable (Named.Internal.NamedF GHC.Maybe.Maybe a name)
instance forall k (a :: k). Lorentz.Wrappable.Unwrappable (Data.Fixed.Fixed a)


-- | Re-exports typed Value, CValue, some core types, some helpers and
--   defines aliases for constructors of typed values.
module Lorentz.Value
type Value = Value' Instr
class WellTypedToT a => IsoValue a where {
    type family ToT a :: T;
    type ToT a = GValueType Rep a;
}
toVal :: IsoValue a => a -> Value (ToT a)
fromVal :: IsoValue a => Value (ToT a) -> a
type WellTypedIsoValue a = (WellTyped ToT a, IsoValue a)

-- | Arbitrary precision integers. In contrast with fixed-size integral
--   types such as <a>Int</a>, the <a>Integer</a> type represents the
--   entire infinite range of integers.
--   
--   For more information about this type's representation, see the
--   comments in its implementation.
data Integer

-- | Type representing arbitrary-precision non-negative integers.
--   
--   <pre>
--   &gt;&gt;&gt; 2^100 :: Natural
--   1267650600228229401496703205376
--   </pre>
--   
--   Operations whose result would be negative <tt><a>throw</a>
--   (<a>Underflow</a> :: <a>ArithException</a>)</tt>,
--   
--   <pre>
--   &gt;&gt;&gt; -1 :: Natural
--   *** Exception: arithmetic underflow
--   </pre>
data Natural
data MText
data Bool
False :: Bool
True :: Bool

-- | A space-efficient representation of a <a>Word8</a> vector, supporting
--   many efficient operations.
--   
--   A <a>ByteString</a> contains 8-bit bytes, or by using the operations
--   from <a>Data.ByteString.Char8</a> it can be interpreted as containing
--   8-bit characters.
data ByteString
data Address
data EpAddress
EpAddress :: Address -> EpName -> EpAddress
[eaAddress] :: EpAddress -> Address
[eaEntrypoint] :: EpAddress -> EpName
data Mutez
data Never
data Timestamp
data ChainId
data KeyHash
data PublicKey
data Signature
data Bls12381Fr
data Bls12381G1
data Bls12381G2

-- | A set of values <tt>a</tt>.
data Set a

-- | A Map from keys <tt>k</tt> to values <tt>a</tt>.
--   
--   The <a>Semigroup</a> operation for <a>Map</a> is <a>union</a>, which
--   prefers values from the left operand. If <tt>m1</tt> maps a key
--   <tt>k</tt> to a value <tt>a1</tt>, and <tt>m2</tt> maps the same key
--   to a different value <tt>a2</tt>, then their union <tt>m1 &lt;&gt;
--   m2</tt> maps <tt>k</tt> to <tt>a1</tt>.
data Map k a
newtype BigMapId (k2 :: k) (v :: k1)
BigMapId :: Natural -> BigMapId (k2 :: k) (v :: k1)
[unBigMapId] :: BigMapId (k2 :: k) (v :: k1) -> Natural
data BigMap k v
mkBigMap :: ToBigMap m => m -> BigMap (ToBigMapKey m) (ToBigMapValue m)
type Operation = Operation' Instr

-- | The <a>Maybe</a> type encapsulates an optional value. A value of type
--   <tt><a>Maybe</a> a</tt> either contains a value of type <tt>a</tt>
--   (represented as <tt><a>Just</a> a</tt>), or it is empty (represented
--   as <a>Nothing</a>). Using <a>Maybe</a> is a good way to deal with
--   errors or exceptional cases without resorting to drastic measures such
--   as <a>error</a>.
--   
--   The <a>Maybe</a> type is also a monad. It is a simple kind of error
--   monad, where all errors are represented by <a>Nothing</a>. A richer
--   error monad can be built using the <a>Either</a> type.
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a
type List = []

-- | Value returned by <tt>READ_TICKET</tt> instruction.
data ReadTicket a
ReadTicket :: Address -> a -> Natural -> ReadTicket a
[rtTicketer] :: ReadTicket a -> Address
[rtData] :: ReadTicket a -> a
[rtAmount] :: ReadTicket a -> Natural
data ContractRef arg
ContractRef :: Address -> SomeEntrypointCall arg -> ContractRef arg
[crAddress] :: ContractRef arg -> Address
[crEntrypoint] :: ContractRef arg -> SomeEntrypointCall arg

-- | Address which remembers the parameter and views types of the contract
--   it refers to.
--   
--   It differs from Michelson's <tt>contract</tt> type because it cannot
--   contain entrypoint, and it always refers to entire contract parameter
--   even if this contract has explicit default entrypoint.
newtype TAddress (p :: Type) (vd :: Type)
TAddress :: Address -> TAddress (p :: Type) (vd :: Type)
[unTAddress] :: TAddress (p :: Type) (vd :: Type) -> Address

-- | Address associated with value of <tt>contract arg</tt> type.
--   
--   Places where <a>ContractRef</a> can appear are now severely limited,
--   this type gives you type-safety of <a>ContractRef</a> but still can be
--   used everywhere. This type is not a full-featured one rather a helper;
--   in particular, once pushing it on stack, you cannot return it back to
--   Haskell world.
--   
--   Note that it refers to an entrypoint of the contract, not just the
--   contract as a whole. In this sense this type differs from
--   <a>TAddress</a>.
--   
--   Unlike with <a>ContractRef</a>, having this type you still cannot be
--   sure that the referred contract exists and need to perform a lookup
--   before calling it.
newtype FutureContract arg
FutureContract :: ContractRef arg -> FutureContract arg
[unFutureContract] :: FutureContract arg -> ContractRef arg
data Ticket arg
Ticket :: Address -> arg -> Natural -> Ticket arg
[tTicketer] :: Ticket arg -> Address
[tData] :: Ticket arg -> arg
[tAmount] :: Ticket arg -> Natural
data Chest
data ChestKey
data OpenChest
data EpName
pattern DefEpName :: EpName
type EntrypointCall param arg = EntrypointCallT ToT param ToT arg
type SomeEntrypointCall arg = SomeEntrypointCallT ToT arg

-- | The type parameter should be an instance of <a>HasResolution</a>.
newtype Fixed (a :: k)
MkFixed :: Integer -> Fixed (a :: k)

-- | Like <tt>Fixed</tt> but with a <tt>Natural</tt> value inside
--   constructor
newtype NFixed p
MkNFixed :: Natural -> NFixed p

-- | Datatypes, representing base of the fixed-point values
data DecBase p
[DecBase] :: KnownNat p => DecBase p
data BinBase p
[BinBase] :: KnownNat p => BinBase p
toMutez :: Word32 -> Mutez
zeroMutez :: Mutez
oneMutez :: Mutez
mt :: QuasiQuoter
timestampFromSeconds :: Integer -> Timestamp
timestampFromUTCTime :: UTCTime -> Timestamp
timestampQuote :: QuasiQuoter
coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b

-- | Generalization of <a>callingTAddress</a> to any typed address.
callingAddress :: forall cp vd addr mname. (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)

-- | Generalization of <a>callingDefTAddress</a> to any typed address.
callingDefAddress :: forall cp vd addr. (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> ContractRef (GetDefaultEntrypointArg cp)

-- | Turn <a>TAddress</a> to <a>ContractRef</a> in <i>Haskell</i> world.
--   
--   This is an analogy of <tt>address</tt> to <tt>contract</tt> convertion
--   in Michelson world, thus you have to supply an entrypoint (or call the
--   default one explicitly).

-- | <i>Deprecated: Use <a>callingAddress</a></i>
callingTAddress :: forall cp vd mname. NiceParameterFull cp => TAddress cp vd -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)

-- | Specification of <a>callingTAddress</a> to call the default
--   entrypoint.

-- | <i>Deprecated: Use <a>callingDefAddress</a></i>
callingDefTAddress :: forall cp vd. NiceParameterFull cp => TAddress cp vd -> ContractRef (GetDefaultEntrypointArg cp)

-- | Convert something to <a>Address</a> in <i>Haskell</i> world.
--   
--   Use this when you want to access state of the contract and are not
--   interested in calling it.
class ToAddress a
toAddress :: ToAddress a => a -> Address

-- | Convert something referring to a contract (not specific entrypoint) to
--   <a>TAddress</a> in <i>Haskell</i> world.
class ToTAddress (cp :: Type) (vd :: Type) (a :: Type)
toTAddress :: ToTAddress cp vd a => a -> TAddress cp vd

-- | Convert something to <a>ContractRef</a> in <i>Haskell</i> world.
class ToContractRef (cp :: Type) (contract :: Type)
toContractRef :: (ToContractRef cp contract, HasCallStack) => contract -> ContractRef cp

-- | Convert something from <a>ContractRef</a> in <i>Haskell</i> world.
class FromContractRef (cp :: Type) (contract :: Type)
fromContractRef :: FromContractRef cp contract => ContractRef cp -> contract
convertContractRef :: forall cp contract2 contract1. (ToContractRef cp contract1, FromContractRef cp contract2) => contract1 -> contract2

-- | Conversion of values to readable <a>String</a>s.
--   
--   Derived instances of <a>Show</a> have the following properties, which
--   are compatible with derived instances of <a>Read</a>:
--   
--   <ul>
--   <li>The result of <a>show</a> is 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.</li>
--   <li>If the constructor is defined to be an infix operator, then
--   <a>showsPrec</a> will produce infix applications of the
--   constructor.</li>
--   <li>the representation will be enclosed in parentheses if the
--   precedence of the top-level constructor in <tt>x</tt> is less than
--   <tt>d</tt> (associativity is ignored). Thus, if <tt>d</tt> is
--   <tt>0</tt> then the result is never surrounded in parentheses; if
--   <tt>d</tt> is <tt>11</tt> it is always surrounded in parentheses,
--   unless it is an atomic expression.</li>
--   <li>If the constructor is defined using record syntax, then
--   <a>show</a> will produce the record-syntax form, with the fields given
--   in the same order as the original declaration.</li>
--   </ul>
--   
--   For example, given the declarations
--   
--   <pre>
--   infixr 5 :^:
--   data Tree a =  Leaf a  |  Tree a :^: Tree a
--   </pre>
--   
--   the derived instance of <a>Show</a> is equivalent to
--   
--   <pre>
--   instance (Show a) =&gt; Show (Tree a) where
--   
--          showsPrec d (Leaf m) = showParen (d &gt; app_prec) $
--               showString "Leaf " . showsPrec (app_prec+1) m
--            where app_prec = 10
--   
--          showsPrec d (u :^: v) = showParen (d &gt; up_prec) $
--               showsPrec (up_prec+1) u .
--               showString " :^: "      .
--               showsPrec (up_prec+1) v
--            where up_prec = 5
--   </pre>
--   
--   Note that right-associativity of <tt>:^:</tt> is ignored. For example,
--   
--   <ul>
--   <li><tt><a>show</a> (Leaf 1 :^: Leaf 2 :^: Leaf 3)</tt> produces the
--   string <tt>"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"</tt>.</li>
--   </ul>
class Show a

-- | A class for types with a default value.
class Default a

-- | The default value for this type.
def :: Default a => a
data Label (name :: Symbol)
[Label] :: forall (name :: Symbol). KnownSymbol name => Label name

-- | Provides <a>Buildable</a> instance that prints Lorentz value via
--   Michelson's <a>Value</a>.
--   
--   Result won't be very pretty, but this avoids requiring <a>Show</a> or
--   <a>Buildable</a> instances.
newtype PrintAsValue a
PrintAsValue :: a -> PrintAsValue a
instance forall k (p :: k). GHC.Classes.Ord (Lorentz.Value.NFixed p)
instance forall k (p :: k). GHC.Classes.Eq (Lorentz.Value.NFixed p)
instance Lorentz.Annotation.HasAnnotation Lorentz.Value.OpenChest
instance Morley.Michelson.Typed.Haskell.Value.IsoValue Lorentz.Value.OpenChest
instance GHC.Classes.Eq Lorentz.Value.OpenChest
instance GHC.Show.Show Lorentz.Value.OpenChest
instance GHC.Generics.Generic Lorentz.Value.OpenChest
instance Morley.Michelson.Typed.Haskell.Value.IsoValue a => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Value.ReadTicket a)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc Lorentz.Value.OpenChest
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Show.Show (Lorentz.Value.NFixed a)
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Num.Num (Lorentz.Value.NFixed a)
instance forall k (a :: k). Data.Fixed.HasResolution a => GHC.Real.Fractional (Lorentz.Value.NFixed a)
instance forall k (p :: k). Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Value.NFixed p)
instance forall k (a :: k). Lorentz.Wrappable.Unwrappable (Lorentz.Value.NFixed a)
instance GHC.TypeNats.KnownNat p => Data.Fixed.HasResolution (Lorentz.Value.BinBase p)
instance GHC.TypeNats.KnownNat p => Data.Fixed.HasResolution (Lorentz.Value.DecBase p)
instance Lorentz.Constraints.Scopes.NiceUntypedValue a => Formatting.Buildable.Buildable (Lorentz.Value.PrintAsValue a)
instance GHC.Generics.Generic (Lorentz.Value.ReadTicket a)
instance Control.DeepSeq.NFData Lorentz.Value.Never
instance Morley.Michelson.Typed.Haskell.Value.IsoValue Lorentz.Value.Never
instance GHC.Classes.Ord Lorentz.Value.Never
instance GHC.Classes.Eq Lorentz.Value.Never
instance GHC.Show.Show Lorentz.Value.Never
instance GHC.Generics.Generic Lorentz.Value.Never
instance GHC.Classes.Ord a => GHC.Classes.Ord (Lorentz.Value.ReadTicket a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Lorentz.Value.ReadTicket a)
instance GHC.Show.Show a => GHC.Show.Show (Lorentz.Value.ReadTicket a)
instance Formatting.Buildable.Buildable Lorentz.Value.Never
instance Lorentz.Annotation.HasAnnotation Lorentz.Value.Never
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc Lorentz.Value.Never


-- | Type families from <a>Morley.Michelson.Typed.Polymorphic</a> lifted to
--   Haskell types.
module Lorentz.Polymorphic

-- | Lifted <a>MemOpKey</a>.
class (MemOp (ToT c), ToT (MemOpKeyHs c) ~ MemOpKey (ToT c)) => MemOpHs c where {
    type family MemOpKeyHs c :: Type;
}

-- | Lifted <a>MapOp</a>.
class (MapOp (ToT c), ToT (MapOpInpHs c) ~ MapOpInp (ToT c), ToT (MapOpResHs c ()) ~ MapOpRes (ToT c) (ToT ())) => MapOpHs c where {
    type family MapOpInpHs c :: Type;
    type family MapOpResHs c :: Type -> Type;
}

-- | Lifted <a>IterOp</a>.
class (IterOp (ToT c), ToT (IterOpElHs c) ~ IterOpEl (ToT c)) => IterOpHs c where {
    type family IterOpElHs c :: Type;
}

-- | Lifted <a>SizeOp</a>.
--   
--   This could be just a constraint alias, but to avoid <a>T</a> types
--   appearance in error messages we make a full type class with concrete
--   instances.
class SizeOp (ToT c) => SizeOpHs c

-- | Lifted <a>UpdOp</a>.
class (UpdOp (ToT c), ToT (UpdOpKeyHs c) ~ (UpdOpKey (ToT c)), ToT (UpdOpParamsHs c) ~ UpdOpParams (ToT c)) => UpdOpHs c where {
    type family UpdOpKeyHs c :: Type;
    type family UpdOpParamsHs c :: Type;
}

-- | Lifted <a>GetOp</a>.
class (GetOp (ToT c), ToT (GetOpKeyHs c) ~ (GetOpKey (ToT c)), ToT (GetOpValHs c) ~ GetOpVal (ToT c)) => GetOpHs c where {
    type family GetOpKeyHs c :: Type;
    type family GetOpValHs c :: Type;
}

-- | Lifted <a>ConcatOp</a>.
class ConcatOp (ToT c) => ConcatOpHs c

-- | Lifted <a>SliceOp</a>.
class SliceOp (ToT c) => SliceOpHs c

-- | A useful property which holds for reasonable <a>MapOp</a> instances.
--   
--   It's a separate thing from <a>MapOpHs</a> because it mentions
--   <tt>b</tt> type parameter.
type family IsoMapOpRes c b
instance Lorentz.Polymorphic.SliceOpHs Morley.Michelson.Text.MText
instance Lorentz.Polymorphic.SliceOpHs Data.ByteString.Internal.ByteString
instance Lorentz.Polymorphic.ConcatOpHs Morley.Michelson.Text.MText
instance Lorentz.Polymorphic.ConcatOpHs Data.ByteString.Internal.ByteString
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.GetOpHs (Data.Map.Internal.Map k v)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.GetOpHs (Morley.Michelson.Typed.Haskell.Value.BigMap k v)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.UpdOpHs (Data.Map.Internal.Map k v)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.UpdOpHs (Morley.Michelson.Typed.Haskell.Value.BigMap k v)
instance Lorentz.Constraints.Scopes.NiceComparable a => Lorentz.Polymorphic.UpdOpHs (Data.Set.Internal.Set a)
instance Lorentz.Polymorphic.SizeOpHs Morley.Michelson.Text.MText
instance Lorentz.Polymorphic.SizeOpHs Data.ByteString.Internal.ByteString
instance Lorentz.Polymorphic.SizeOpHs (Data.Set.Internal.Set a)
instance Lorentz.Polymorphic.SizeOpHs [a]
instance Lorentz.Polymorphic.SizeOpHs (Data.Map.Internal.Map k v)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.IterOpHs (Data.Map.Internal.Map k v)
instance Lorentz.Polymorphic.IterOpHs [e]
instance Lorentz.Constraints.Scopes.NiceComparable e => Lorentz.Polymorphic.IterOpHs (Data.Set.Internal.Set e)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.MapOpHs (Data.Map.Internal.Map k v)
instance Lorentz.Polymorphic.MapOpHs [e]
instance Lorentz.Constraints.Scopes.NiceComparable e => Lorentz.Polymorphic.MemOpHs (Data.Set.Internal.Set e)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.MemOpHs (Data.Map.Internal.Map k v)
instance Lorentz.Constraints.Scopes.NiceComparable k => Lorentz.Polymorphic.MemOpHs (Morley.Michelson.Typed.Haskell.Value.BigMap k v)


-- | Common implementations of entrypoints.
module Lorentz.Entrypoints.Impl

-- | Implementation of <a>ParameterHasEntrypoints</a> which fits for case
--   when your contract exposes multiple entrypoints via having sum type as
--   its parameter.
--   
--   In particular, each constructor would produce a homonymous entrypoint
--   with argument type equal to type of constructor field (each
--   constructor should have only one field). Constructor called
--   <a>Default</a> will designate the default entrypoint.
data EpdPlain

-- | Extension of <a>EpdPlain</a> on parameters being defined as several
--   nested datatypes.
--   
--   In particular, this will traverse sum types recursively, stopping at
--   Michelson primitives (like <a>Natural</a>) and constructors with
--   number of fields different from one.
--   
--   It does not assign names to intermediate nodes of <a>Or</a> tree, only
--   to the very leaves.
--   
--   If some entrypoint arguments have custom <a>IsoValue</a> instance,
--   this derivation way will not work. As a workaround, you can wrap your
--   argument into some primitive (e.g. <a>:!</a>).
data EpdRecursive

-- | Extension of <a>EpdPlain</a> on parameters being defined as several
--   nested datatypes.
--   
--   In particular, it will traverse the immediate sum type, and require
--   another <a>ParameterHasEntrypoints</a> for the inner complex
--   datatypes. Only those inner types are considered which are the only
--   fields in their respective constructors. Inner types should not
--   themselves declare default entrypoint, we enforce this for better
--   modularity. Each top-level constructor will be treated as entrypoint
--   even if it contains a complex datatype within, in such case that would
--   be an entrypoint corresponding to intermediate node in <tt>or</tt>
--   tree.
--   
--   Comparing to <a>EpdRecursive</a> this gives you more control over
--   where and how entrypoints will be derived.
data EpdDelegate

-- | Extension of <a>EpdPlain</a>, <a>EpdRecursive</a>, and
--   <a>EpdDelegate</a> which allow specifying root annotation for the
--   parameters.
data EpdWithRoot (r :: Symbol) epd
type PlainEntrypointsC mode cp = (GenericIsoValue cp, EntrypointsNotes mode (BuildEPTree mode cp) cp, RequireSumType cp)

-- | Entrypoints tree - skeleton on <a>TOr</a> tree later used to
--   distinguish between constructors-entrypoints and constructors which
--   consolidate a whole pack of entrypoints.
data EPTree

-- | We are in the intermediate node and need to go deeper.
EPNode :: EPTree -> EPTree -> EPTree

-- | We reached entrypoint argument.
EPLeaf :: EPTree

-- | We reached complex parameter part and will need to ask how to process
--   it.
EPDelegate :: EPTree

-- | Build <a>EPTree</a> by parameter type.
type BuildEPTree mode a = GBuildEntrypointsTree mode (Rep a)
instance (Lorentz.Annotation.GHasAnnotation x, GHC.TypeLits.KnownSymbol ctor, Morley.Michelson.Typed.Haskell.Value.ToT (Lorentz.Entrypoints.Impl.GExtractField x) GHC.Types.~ Morley.Michelson.Typed.Haskell.Value.GValueType x) => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode 'Lorentz.Entrypoints.Impl.EPLeaf (GHC.Generics.C1 ('GHC.Generics.MetaCons ctor _1 _2) x)
instance (ep GHC.Types.~ 'Lorentz.Entrypoints.Impl.EPDelegate, Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ep x, GHC.TypeLits.KnownSymbol ctor, Morley.Michelson.Typed.Haskell.Value.ToT (Lorentz.Entrypoints.Impl.GExtractField x) GHC.Types.~ Morley.Michelson.Typed.Haskell.Value.GValueType x) => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode 'Lorentz.Entrypoints.Impl.EPDelegate (GHC.Generics.C1 ('GHC.Generics.MetaCons ctor _1 _2) x)
instance Lorentz.Entrypoints.Impl.PlainEntrypointsC Lorentz.Entrypoints.Impl.EpdPlain cp => Lorentz.Entrypoints.Core.EntrypointsDerivation Lorentz.Entrypoints.Impl.EpdPlain cp
instance Lorentz.Entrypoints.Impl.PlainEntrypointsC Lorentz.Entrypoints.Impl.EpdRecursive cp => Lorentz.Entrypoints.Core.EntrypointsDerivation Lorentz.Entrypoints.Impl.EpdRecursive cp
instance Lorentz.Entrypoints.Impl.PlainEntrypointsC Lorentz.Entrypoints.Impl.EpdDelegate cp => Lorentz.Entrypoints.Core.EntrypointsDerivation Lorentz.Entrypoints.Impl.EpdDelegate cp
instance (GHC.TypeLits.KnownSymbol r, Lorentz.Entrypoints.Impl.PlainEntrypointsC deriv cp) => Lorentz.Entrypoints.Core.EntrypointsDerivation (Lorentz.Entrypoints.Impl.EpdWithRoot r deriv) cp
instance (Lorentz.Entrypoints.Impl.EntrypointsNotes Lorentz.Entrypoints.Impl.EpdRecursive ep a, Morley.Michelson.Typed.Haskell.Value.GenericIsoValue a) => Lorentz.Entrypoints.Impl.GEntrypointsNotes Lorentz.Entrypoints.Impl.EpdRecursive ep (GHC.Generics.Rec0 a)
instance Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ep x => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ep (GHC.Generics.D1 i x)
instance (Lorentz.Entrypoints.Impl.GEntrypointsNotes mode epx x, Lorentz.Entrypoints.Impl.GEntrypointsNotes mode epy y) => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ('Lorentz.Entrypoints.Impl.EPNode epx epy) (x GHC.Generics.:+: y)
instance (ep GHC.Types.~ 'Lorentz.Entrypoints.Impl.EPNode epx epy, Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ep x, GHC.TypeLits.KnownSymbol ctor) => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ('Lorentz.Entrypoints.Impl.EPNode epx epy) (GHC.Generics.C1 ('GHC.Generics.MetaCons ctor _1 _2) x)
instance Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ep x => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode ep (GHC.Generics.S1 i x)
instance Lorentz.Entrypoints.Core.ParameterDeclaresEntrypoints a => Lorentz.Entrypoints.Impl.GEntrypointsNotes Lorentz.Entrypoints.Impl.EpdDelegate 'Lorentz.Entrypoints.Impl.EPDelegate (GHC.Generics.Rec0 a)
instance Lorentz.Entrypoints.Impl.GEntrypointsNotes mode 'Lorentz.Entrypoints.Impl.EPLeaf GHC.Generics.U1
instance Universum.TypeOps.Each '[Data.Singletons.Internal.SingI] '[Morley.Michelson.Typed.Haskell.Value.GValueType x, Morley.Michelson.Typed.Haskell.Value.GValueType y] => Lorentz.Entrypoints.Impl.GEntrypointsNotes mode 'Lorentz.Entrypoints.Impl.EPLeaf (x GHC.Generics.:*: y)


-- | Type families from <a>Morley.Michelson.Typed.Arith</a> lifted to
--   Haskell types.
module Lorentz.Arith

-- | Lifted <a>ArithOp</a>.
class ArithOpHs (aop :: Type) (n :: Type) (m :: Type) (r :: Type)
evalArithOpHs :: ArithOpHs aop n m r => (n : (m : s)) :-> (r : s)
evalArithOpHs :: (ArithOpHs aop n m r, DefArithOp aop, ArithOp aop (ToT n) (ToT m), ToT r ~ ArithRes aop (ToT n) (ToT m)) => (n : (m : s)) :-> (r : s)

-- | Helper typeclass that provides default definition of
--   <a>evalArithOpHs</a>.
class DefArithOp aop
defEvalOpHs :: (DefArithOp aop, ArithOp aop n m, r ~ ArithRes aop n m) => Instr (n : (m : s)) (r : s)

-- | Lifted <a>UnaryArithOp</a>.
class UnaryArithOpHs (aop :: Type) (n :: Type) where {
    type family UnaryArithResHs aop n :: Type;
}
evalUnaryArithOpHs :: UnaryArithOpHs aop n => (n : s) :-> (UnaryArithResHs aop n : s)
evalUnaryArithOpHs :: (UnaryArithOpHs aop n, DefUnaryArithOp aop, UnaryArithOp aop (ToT n), ToT (UnaryArithResHs aop n) ~ UnaryArithRes aop (ToT n)) => (n : s) :-> (UnaryArithResHs aop n : s)

-- | Helper typeclass that provides default definition of
--   <a>evalUnaryArithOpHs</a>.
class DefUnaryArithOp aop
defUnaryArithOpHs :: (DefUnaryArithOp aop, UnaryArithOp aop n, r ~ UnaryArithRes aop n) => Instr (n : s) (r : s)
class ToIntegerArithOpHs (n :: Type)
evalToIntOpHs :: ToIntegerArithOpHs n => (n : s) :-> (Integer : s)
evalToIntOpHs :: (ToIntegerArithOpHs n, ToIntArithOp (ToT n)) => (n : s) :-> (Integer : s)
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Eq' GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neq GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Lt GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Gt GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Le GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Ge GHC.Natural.Natural
instance Lorentz.Arith.ToIntegerArithOpHs GHC.Natural.Natural
instance forall k (a :: k). Lorentz.Arith.ToIntegerArithOpHs (Lorentz.Value.NFixed a)
instance Lorentz.Arith.ToIntegerArithOpHs Morley.Tezos.Crypto.BLS12381.Bls12381Fr
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg Morley.Tezos.Crypto.BLS12381.Bls12381Fr
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg Morley.Tezos.Crypto.BLS12381.Bls12381G1
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg Morley.Tezos.Crypto.BLS12381.Bls12381G2
instance forall k (p :: k). Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg (Data.Fixed.Fixed p)
instance forall k (p :: k). Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neg (Lorentz.Value.NFixed p)
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Abs GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Not GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Not GHC.Natural.Natural
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Not GHC.Types.Bool
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Eq' GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Neq GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Lt GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Gt GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Le GHC.Integer.Type.Integer
instance Lorentz.Arith.UnaryArithOpHs Morley.Michelson.Typed.Arith.Ge GHC.Integer.Type.Integer
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Not
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Abs
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Eq'
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Neq
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Lt
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Le
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Gt
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Ge
instance Lorentz.Arith.DefUnaryArithOp Morley.Michelson.Typed.Arith.Neg
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Natural.Natural GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Integer.Type.Integer GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Integer.Type.Integer GHC.Integer.Type.Integer r
instance (r GHC.Types.~ Morley.Tezos.Core.Timestamp) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add Morley.Tezos.Core.Timestamp GHC.Integer.Type.Integer r
instance (r GHC.Types.~ Morley.Tezos.Core.Timestamp) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Integer.Type.Integer Morley.Tezos.Core.Timestamp r
instance (r GHC.Types.~ Morley.Tezos.Core.Mutez) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add Morley.Tezos.Core.Mutez Morley.Tezos.Core.Mutez r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381Fr) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add Morley.Tezos.Crypto.BLS12381.Bls12381Fr Morley.Tezos.Crypto.BLS12381.Bls12381Fr r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381G1) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add Morley.Tezos.Crypto.BLS12381.Bls12381G1 Morley.Tezos.Crypto.BLS12381.Bls12381G1 r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381G2) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add Morley.Tezos.Crypto.BLS12381.Bls12381G2 Morley.Tezos.Crypto.BLS12381.Bls12381G2 r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Data.Fixed.Fixed p) (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Data.Fixed.Fixed p) GHC.Integer.Type.Integer r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Data.Fixed.Fixed p) GHC.Natural.Natural r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Integer.Type.Integer (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Natural.Natural (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Lorentz.Value.NFixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Lorentz.Value.NFixed p) (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Lorentz.Value.NFixed p) GHC.Integer.Type.Integer r
instance forall k r (p :: k). (r GHC.Types.~ Lorentz.Value.NFixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Lorentz.Value.NFixed p) GHC.Natural.Natural r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Integer.Type.Integer (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Lorentz.Value.NFixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add GHC.Natural.Natural (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Data.Fixed.Fixed p) (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Add (Lorentz.Value.NFixed p) (Data.Fixed.Fixed p) r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Natural.Natural GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Integer.Type.Integer GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Integer.Type.Integer GHC.Integer.Type.Integer r
instance (r GHC.Types.~ Morley.Tezos.Core.Timestamp) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub Morley.Tezos.Core.Timestamp GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub Morley.Tezos.Core.Timestamp Morley.Tezos.Core.Timestamp r
instance (r GHC.Types.~ Morley.Tezos.Core.Mutez) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub Morley.Tezos.Core.Mutez Morley.Tezos.Core.Mutez r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Data.Fixed.Fixed p) (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Data.Fixed.Fixed p) GHC.Integer.Type.Integer r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Data.Fixed.Fixed p) GHC.Natural.Natural r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Integer.Type.Integer (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Natural.Natural (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Lorentz.Value.NFixed p) (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Lorentz.Value.NFixed p) GHC.Integer.Type.Integer r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Lorentz.Value.NFixed p) GHC.Natural.Natural r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Integer.Type.Integer (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub GHC.Natural.Natural (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Data.Fixed.Fixed p) (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Sub (Lorentz.Value.NFixed p) (Data.Fixed.Fixed p) r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Natural.Natural GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Integer.Type.Integer GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Integer.Type.Integer) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Integer.Type.Integer GHC.Integer.Type.Integer r
instance (r GHC.Types.~ Morley.Tezos.Core.Mutez) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Natural.Natural Morley.Tezos.Core.Mutez r
instance (r GHC.Types.~ Morley.Tezos.Core.Mutez) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Core.Mutez GHC.Natural.Natural r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381Fr) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Integer.Type.Integer Morley.Tezos.Crypto.BLS12381.Bls12381Fr r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381Fr) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Natural.Natural Morley.Tezos.Crypto.BLS12381.Bls12381Fr r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381Fr) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381Fr GHC.Integer.Type.Integer r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381Fr) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381Fr GHC.Natural.Natural r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381Fr) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381Fr Morley.Tezos.Crypto.BLS12381.Bls12381Fr r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381G1) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381G1 Morley.Tezos.Crypto.BLS12381.Bls12381Fr r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381G2) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381G2 Morley.Tezos.Crypto.BLS12381.Bls12381Fr r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381G1) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381Fr Morley.Tezos.Crypto.BLS12381.Bls12381G1 r
instance (r GHC.Types.~ Morley.Tezos.Crypto.BLS12381.Bls12381G2) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul Morley.Tezos.Crypto.BLS12381.Bls12381Fr Morley.Tezos.Crypto.BLS12381.Bls12381G2 r
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) (Data.Fixed.Fixed (Lorentz.Value.DecBase b)) (Data.Fixed.Fixed (Lorentz.Value.DecBase r))
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Data.Fixed.Fixed (Lorentz.Value.BinBase a)) (Data.Fixed.Fixed (Lorentz.Value.BinBase b)) (Data.Fixed.Fixed (Lorentz.Value.BinBase r))
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Data.Fixed.Fixed p) GHC.Integer.Type.Integer r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Data.Fixed.Fixed p) GHC.Natural.Natural r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Integer.Type.Integer (Data.Fixed.Fixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Natural.Natural (Data.Fixed.Fixed p) r
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Lorentz.Value.NFixed (Lorentz.Value.DecBase a)) (Lorentz.Value.NFixed (Lorentz.Value.DecBase b)) (Lorentz.Value.NFixed (Lorentz.Value.DecBase r))
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) (Lorentz.Value.NFixed (Lorentz.Value.BinBase b)) (Lorentz.Value.NFixed (Lorentz.Value.BinBase r))
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Lorentz.Value.NFixed p) GHC.Integer.Type.Integer r
instance forall k r (p :: k). (r GHC.Types.~ Lorentz.Value.NFixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Lorentz.Value.NFixed p) GHC.Natural.Natural r
instance forall k r (p :: k). (r GHC.Types.~ Data.Fixed.Fixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Integer.Type.Integer (Lorentz.Value.NFixed p) r
instance forall k r (p :: k). (r GHC.Types.~ Lorentz.Value.NFixed p) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul GHC.Natural.Natural (Lorentz.Value.NFixed p) r
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Lorentz.Value.NFixed (Lorentz.Value.DecBase a)) (Data.Fixed.Fixed (Lorentz.Value.DecBase b)) (Data.Fixed.Fixed (Lorentz.Value.DecBase r))
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) (Lorentz.Value.NFixed (Lorentz.Value.DecBase b)) (Data.Fixed.Fixed (Lorentz.Value.DecBase r))
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) (Data.Fixed.Fixed (Lorentz.Value.BinBase b)) (Data.Fixed.Fixed (Lorentz.Value.BinBase r))
instance (r GHC.Types.~ (a GHC.TypeNats.+ b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Mul (Data.Fixed.Fixed (Lorentz.Value.BinBase a)) (Lorentz.Value.NFixed (Lorentz.Value.BinBase b)) (Data.Fixed.Fixed (Lorentz.Value.BinBase r))
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, GHC.Natural.Natural)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv GHC.Natural.Natural GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, GHC.Natural.Natural)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv GHC.Integer.Type.Integer GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Natural.Natural, GHC.Natural.Natural)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, GHC.Natural.Natural)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv GHC.Integer.Type.Integer GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Natural.Natural, Morley.Tezos.Core.Mutez)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv Morley.Tezos.Core.Mutez Morley.Tezos.Core.Mutez r
instance (r GHC.Types.~ GHC.Maybe.Maybe (Morley.Tezos.Core.Mutez, Morley.Tezos.Core.Mutez)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv Morley.Tezos.Core.Mutez GHC.Natural.Natural r
instance (r GHC.Types.~ Lorentz.Value.NFixed (Lorentz.Value.BinBase b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Lsl (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) GHC.Natural.Natural r
instance (r GHC.Types.~ Lorentz.Value.NFixed (Lorentz.Value.BinBase b)) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Lsr (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Or GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Types.Bool) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Or GHC.Types.Bool GHC.Types.Bool r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.And GHC.Integer.Type.Integer GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.And GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Types.Bool) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.And GHC.Types.Bool GHC.Types.Bool r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Xor GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Types.Bool) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Xor GHC.Types.Bool GHC.Types.Bool r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Lsl GHC.Natural.Natural GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Natural.Natural) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.Lsr GHC.Natural.Natural GHC.Natural.Natural r
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Add
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Sub
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Mul
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.And
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Or
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Xor
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Lsl
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.Lsr
instance Lorentz.Arith.DefArithOp Morley.Michelson.Typed.Arith.EDiv


-- | Allows specifying entrypoints without declaring
--   <a>ParameterHasEntrypoints</a> instance.
module Lorentz.Entrypoints.Manual

-- | Wrap parameter into this to locally assign a way to derive entrypoints
--   for it.
newtype ParameterWrapper (deriv :: Type) cp
ParameterWrapper :: cp -> ParameterWrapper (deriv :: Type) cp
[unParameterWraper] :: ParameterWrapper (deriv :: Type) cp -> cp
instance Lorentz.Wrappable.Wrappable (Lorentz.Entrypoints.Manual.ParameterWrapper deriv cp)
instance Lorentz.Wrappable.Unwrappable (Lorentz.Entrypoints.Manual.ParameterWrapper deriv cp)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue cp => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Entrypoints.Manual.ParameterWrapper deriv cp)
instance GHC.Generics.Generic (Lorentz.Entrypoints.Manual.ParameterWrapper deriv cp)
instance Lorentz.Entrypoints.Core.EntrypointsDerivation deriv cp => Lorentz.Entrypoints.Core.EntrypointsDerivation (Lorentz.Entrypoints.Manual.PwDeriv deriv) (Lorentz.Entrypoints.Manual.ParameterWrapper deriv cp)
instance (Lorentz.Constraints.Scopes.NiceParameter cp, Lorentz.Entrypoints.Core.EntrypointsDerivation epd cp, Lorentz.Entrypoints.Core.RequireAllUniqueEntrypoints' epd cp) => Lorentz.Entrypoints.Core.ParameterHasEntrypoints (Lorentz.Entrypoints.Manual.ParameterWrapper epd cp)


-- | Entrypoints utilities for Lorentz
module Lorentz.Entrypoints

-- | Defines a generalized way to declare entrypoints for various parameter
--   types.
--   
--   When defining instances of this typeclass, set concrete <tt>deriv</tt>
--   argument and leave variable <tt>cp</tt> argument. Also keep in mind,
--   that in presence of explicit default entrypoint, all other <a>Or</a>
--   arms should be callable, though you can put this burden on user if
--   very necessary.
--   
--   Methods of this typeclass aim to better type-safety when making up an
--   implementation and they may be not too convenient to use; users should
--   exploit their counterparts.
class EntrypointsDerivation deriv cp where {
    
    -- | Name and argument of each entrypoint. This may include intermediate
    --   ones, even root if necessary.
    --   
    --   Touching this type family is costly (<tt>O(N^2)</tt>), don't use it
    --   often.
    --   
    --   Note [order of entrypoints children]: If this contains entrypoints
    --   referring to indermediate nodes (not leaves) in <tt>or</tt> tree, then
    --   each such entrypoint should be mentioned eariler than all of its
    --   children.
    type family EpdAllEntrypoints deriv cp :: [(Symbol, Type)];
    
    -- | Get entrypoint argument by name.
    type family EpdLookupEntrypoint deriv cp :: Symbol -> Exp (Maybe Type);
}

-- | Construct parameter annotations corresponding to expected entrypoints
--   set.
--   
--   This method is implementation detail, for actual notes construction
--   use <a>parameterEntrypointsToNotes</a>.
epdNotes :: EntrypointsDerivation deriv cp => (Notes (ToT cp), RootAnn)

-- | Construct entrypoint caller.
--   
--   This does not treat calls to default entrypoint in a special way.
--   
--   This method is implementation detail, for actual entrypoint lookup use
--   <a>parameterEntrypointCall</a>.
epdCall :: (EntrypointsDerivation deriv cp, ParameterScope (ToT cp)) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint deriv cp name))

-- | Description of how each of the entrypoints is constructed.
epdDescs :: EntrypointsDerivation deriv cp => Rec EpCallingDesc (EpdAllEntrypoints deriv cp)

-- | Which entrypoints given parameter declares.
--   
--   Note that usually this function should not be used as constraint, use
--   <a>ParameterDeclaresEntrypoints</a> for this purpose.
class (EntrypointsDerivation (ParameterEntrypointsDerivation cp) cp, RequireAllUniqueEntrypoints cp) => ParameterHasEntrypoints cp where {
    type family ParameterEntrypointsDerivation cp :: Type;
}

-- | Parameter declares some entrypoints.
--   
--   This is a version of <a>ParameterHasEntrypoints</a> which we actually
--   use in constraints. When given type is a sum type or newtype, we refer
--   to <a>ParameterHasEntrypoints</a> instance, otherwise this instance is
--   not necessary.
type ParameterDeclaresEntrypoints cp = (If (CanHaveEntrypoints cp) (ParameterHasEntrypoints cp) (() :: Constraint), NiceParameter cp, EntrypointsDerivation (GetParameterEpDerivation cp) cp)

-- | Get all entrypoints declared for parameter.
type family AllParameterEntrypoints (cp :: Type) :: [(Symbol, Type)]

-- | Lookup for entrypoint type by name.
--   
--   Does not treat default entrypoints in a special way.
type family LookupParameterEntrypoint (cp :: Type) :: Symbol -> Exp (Maybe Type)

-- | Derive annotations for given parameter.
parameterEntrypointsToNotes :: forall cp. ParameterDeclaresEntrypoints cp => ParamNotes (ToT cp)

-- | Get type of entrypoint with given name, fail if not found.
type GetEntrypointArg cp name = Eval (LiftM2 FromMaybe (TError ('Text "Entrypoint not found: " :<>: 'ShowType name :$$: 'Text "In contract parameter `" :<>: 'ShowType cp :<>: 'Text "`")) (LookupParameterEntrypoint cp name))

-- | Prepare call to given entrypoint.
--   
--   This does not treat calls to default entrypoint in a special way. To
--   call default entrypoint properly use
--   <a>parameterEntrypointCallDefault</a>.
parameterEntrypointCall :: forall cp name. ParameterDeclaresEntrypoints cp => Label name -> EntrypointCall cp (GetEntrypointArg cp name)

-- | Get type of entrypoint with given name, fail if not found.
type GetDefaultEntrypointArg cp = Eval (LiftM2 FromMaybe (Pure cp) (LookupParameterEntrypoint cp DefaultEpName))

-- | Call the default entrypoint.
parameterEntrypointCallDefault :: forall cp. ParameterDeclaresEntrypoints cp => EntrypointCall cp (GetDefaultEntrypointArg cp)

-- | Ensure that there is no explicit "default" entrypoint.
type ForbidExplicitDefaultEntrypoint cp = Eval (LiftM3 UnMaybe (Pure (Pure (() :: Constraint))) (TError ('Text "Parameter used here must have no explicit \"default\" entrypoint" :$$: 'Text "In parameter type `" :<>: 'ShowType cp :<>: 'Text "`")) (LookupParameterEntrypoint cp DefaultEpName))

-- | Similar to <a>ForbidExplicitDefaultEntrypoint</a>, but in a version
--   which the compiler can work with (and which produces errors confusing
--   for users :/)
type NoExplicitDefaultEntrypoint cp = Eval (LookupParameterEntrypoint cp DefaultEpName) ~ 'Nothing

-- | Call root entrypoint safely.
sepcCallRootChecked :: forall cp. (NiceParameter cp, ForbidExplicitDefaultEntrypoint cp) => SomeEntrypointCall cp

-- | Which entrypoint to call.
--   
--   We intentionally distinguish default and non-default cases because
--   this makes API more details-agnostic.
data EntrypointRef (mname :: Maybe Symbol)

-- | Call the default entrypoint, or root if no explicit default is
--   assigned.
[CallDefault] :: EntrypointRef 'Nothing

-- | Call the given entrypoint; calling default is not treated specially.
--   You have to provide entrypoint name via passing it as type argument.
--   
--   Unfortunatelly, here we cannot accept a label because in most cases
--   our entrypoints begin from capital letter (being derived from
--   constructor name), while labels must start from a lower-case letter,
--   and there is no way to make a conversion at type-level.
[Call] :: NiceEntrypointName name => EntrypointRef ('Just name)
eprName :: forall mname. EntrypointRef mname -> EpName

-- | Universal entrypoint lookup.
type family GetEntrypointArgCustom cp mname :: Type

-- | When we call a Lorentz contract we should pass entrypoint name and
--   corresponding argument. Ideally we want to statically check that
--   parameter has entrypoint with given name and argument. Constraint
--   defined by this type class holds for contract with parameter
--   <tt>cp</tt> that have entrypoint matching <tt>name</tt> with type
--   <tt>arg</tt>.
--   
--   In order to check this property statically, we need to know entrypoint
--   name in compile time, <a>EntrypointRef</a> type serves this purpose.
--   If entrypoint name is not known, one can use <a>TrustEpName</a>
--   wrapper to take responsibility for presence of this entrypoint.
--   
--   If you want to call a function which has this constraint, you have two
--   options: 1. Pass contract parameter <tt>cp</tt> using type
--   application, pass <a>EntrypointRef</a> as a value and pass entrypoint
--   argument. Type system will check that <tt>cp</tt> has an entrypoint
--   with given reference and type. 2. Pass <a>EpName</a> wrapped into
--   <a>TrustEpName</a> and entrypoint argument. In this case passing
--   contract parameter is not necessary, you do not even have to know it.
class HasEntrypointArg cp name arg

-- | Data returned by this method may look somewhat arbitrary.
--   <a>EpName</a> is obviously needed because <tt>name</tt> can be
--   <a>EntrypointRef</a> or <a>TrustEpName</a>. <tt>Dict</tt> is returned
--   because in <a>EntrypointRef</a> case we get this evidence for free and
--   don't want to use it. We seem to always need it anyway.
useHasEntrypointArg :: HasEntrypointArg cp name arg => name -> (Dict (ParameterScope (ToT arg)), EpName)

-- | <a>HasEntrypointArg</a> constraint specialized to default entrypoint.
type HasDefEntrypointArg cp defEpName defArg = (defEpName ~ EntrypointRef 'Nothing, HasEntrypointArg cp defEpName defArg)

-- | Checks that the given parameter consists of some specific entrypoint.
--   Similar as <a>HasEntrypointArg</a> but ensures that the argument
--   matches the following datatype.
type HasEntrypointOfType param con exp = (GetEntrypointArgCustom param ('Just con) ~ exp, ParameterDeclaresEntrypoints param)

-- | Check that the given entrypoint has some fields inside. This interface
--   allows for an abstraction of contract parameter so that it requires
--   some *minimal* specification, but not a concrete one.
type family ParameterContainsEntrypoints param (fields :: [NamedEp]) :: Constraint

-- | This wrapper allows to pass untyped <a>EpName</a> and bypass checking
--   that entrypoint with given name and type exists.
newtype TrustEpName
TrustEpName :: EpName -> TrustEpName

-- | Universal entrypoint calling.
parameterEntrypointCallCustom :: forall cp mname. ParameterDeclaresEntrypoints cp => EntrypointRef mname -> EntrypointCall cp (GetEntrypointArgCustom cp mname)

-- | Ensure that all declared entrypoints are unique.
type RequireAllUniqueEntrypoints cp = RequireAllUniqueEntrypoints' (ParameterEntrypointsDerivation cp) cp
type n :> ty = 'NamedEp n ty
infixr 0 :>

-- | No entrypoints declared, parameter type will serve as argument type of
--   the only existing entrypoint (default one).
data EpdNone

-- | Implementation of <a>ParameterHasEntrypoints</a> which fits for case
--   when your contract exposes multiple entrypoints via having sum type as
--   its parameter.
--   
--   In particular, each constructor would produce a homonymous entrypoint
--   with argument type equal to type of constructor field (each
--   constructor should have only one field). Constructor called
--   <a>Default</a> will designate the default entrypoint.
data EpdPlain

-- | Extension of <a>EpdPlain</a> on parameters being defined as several
--   nested datatypes.
--   
--   In particular, this will traverse sum types recursively, stopping at
--   Michelson primitives (like <a>Natural</a>) and constructors with
--   number of fields different from one.
--   
--   It does not assign names to intermediate nodes of <a>Or</a> tree, only
--   to the very leaves.
--   
--   If some entrypoint arguments have custom <a>IsoValue</a> instance,
--   this derivation way will not work. As a workaround, you can wrap your
--   argument into some primitive (e.g. <a>:!</a>).
data EpdRecursive

-- | Extension of <a>EpdPlain</a> on parameters being defined as several
--   nested datatypes.
--   
--   In particular, it will traverse the immediate sum type, and require
--   another <a>ParameterHasEntrypoints</a> for the inner complex
--   datatypes. Only those inner types are considered which are the only
--   fields in their respective constructors. Inner types should not
--   themselves declare default entrypoint, we enforce this for better
--   modularity. Each top-level constructor will be treated as entrypoint
--   even if it contains a complex datatype within, in such case that would
--   be an entrypoint corresponding to intermediate node in <tt>or</tt>
--   tree.
--   
--   Comparing to <a>EpdRecursive</a> this gives you more control over
--   where and how entrypoints will be derived.
data EpdDelegate

-- | Extension of <a>EpdPlain</a>, <a>EpdRecursive</a>, and
--   <a>EpdDelegate</a> which allow specifying root annotation for the
--   parameters.
data EpdWithRoot (r :: Symbol) epd

-- | Wrap parameter into this to locally assign a way to derive entrypoints
--   for it.
newtype ParameterWrapper (deriv :: Type) cp
ParameterWrapper :: cp -> ParameterWrapper (deriv :: Type) cp
[unParameterWraper] :: ParameterWrapper (deriv :: Type) cp -> cp

-- | A special type which wraps over a primitive type and states that it
--   has entrypoints (one).
--   
--   Assuming that any type can have entrypoints makes use of Lorentz
--   entrypoints too annoying, so for declaring entrypoints for not sum
--   types we require an explicit wrapper.
newtype ShouldHaveEntrypoints a
ShouldHaveEntrypoints :: a -> ShouldHaveEntrypoints a
[unHasEntrypoints] :: ShouldHaveEntrypoints a -> a


-- | Stack zipping.
--   
--   This module provides functions for flattening stacks into tuples.
--   
--   Also here we define an instance which turns any instruction, not only
--   lambdas, into a valid value.
module Lorentz.Zip

-- | Zipping stack into tuple and back.
class (KnownIsoT (ZippedStack s)) => ZipInstr (s :: [Type]) where {
    
    -- | A type which contains the whole stack zipped.
    type family ZippedStack s :: Type;
}

-- | Fold given stack into single value in typed Michelson.
zipInstrTyped :: ZipInstr s => Instr (ToTs s) '[ToT (ZippedStack s)]

-- | Unfold given stack from a single value in typed Michelson.
unzipInstrTyped :: ZipInstr s => Instr '[ToT (ZippedStack s)] (ToTs s)

-- | Fold given stack into single value.
zipInstr :: forall s. ZipInstr s => s :-> '[ZippedStack s]

-- | Unfold given stack from a single value.
unzipInstr :: forall s. ZipInstr s => '[ZippedStack s] :-> s

-- | Require several stacks to comply <a>ZipInstr</a> constraint.
type ZipInstrs ss = Each '[ZipInstr] ss

-- | Flatten both ends of instruction stack.
zippingStack :: ZipInstrs [inp, out] => (inp :-> out) -> Lambda (ZippedStack inp) (ZippedStack out)

-- | Unflatten both ends of instruction stack.
unzippingStack :: ZipInstrs [inp, out] => Lambda (ZippedStack inp) (ZippedStack out) -> inp :-> out
instance Lorentz.Zip.ZipInstr '[]
instance Morley.Michelson.Typed.Haskell.Value.KnownIsoT a => Lorentz.Zip.ZipInstr '[a]
instance (Lorentz.Zip.ZipInstr (b : s), Morley.Michelson.Typed.Haskell.Value.KnownIsoT a) => Lorentz.Zip.ZipInstr (a : b : s)
instance (Morley.Michelson.Typed.Haskell.Value.WellTypedToT (Lorentz.Zip.ZippedStack inp), Morley.Michelson.Typed.Haskell.Value.WellTypedToT (Lorentz.Zip.ZippedStack out), Lorentz.Zip.ZipInstr inp, Lorentz.Zip.ZipInstr out) => Morley.Michelson.Typed.Haskell.Value.IsoValue (inp Lorentz.Base.:-> out)
instance (Lorentz.Annotation.HasAnnotation (Lorentz.Zip.ZippedStack i), Lorentz.Annotation.HasAnnotation (Lorentz.Zip.ZippedStack o)) => Lorentz.Annotation.HasAnnotation (i Lorentz.Base.:-> o)

module Lorentz.Doc

-- | Put a document item.
doc :: DocItem di => di -> s :-> s

-- | Group documentation built in the given piece of code into block
--   dedicated to one thing, e.g. to one entrypoint.
--   
--   Examples of doc items you can pass here: <a>DName</a>,
--   <a>DGeneralInfoSection</a>.
docGroup :: DocItem di => (SubDoc -> di) -> (inp :-> out) -> inp :-> out
dStorage :: TypeHasDoc store => DStorageType

-- | Insert documentation of the contract storage type. The type should be
--   passed using type applications.

-- | <i>Deprecated: Use `doc (dStorage @storage)` instead.</i>
docStorage :: forall storage s. TypeHasDoc storage => s :-> s

-- | <i>Deprecated: Use <a>buildDoc</a> instead.</i>
buildLorentzDoc :: (inp :-> out) -> ContractDoc

-- | <i>Deprecated: Use `buildDoc . attachDocCommons gitRev` instead.</i>
buildLorentzDocWithGitRev :: DGitRevision -> (inp :-> out) -> ContractDoc

-- | <i>Deprecated: Use <a>buildMarkdownDoc</a> instead.</i>
renderLorentzDoc :: (inp :-> out) -> LText

-- | <i>Deprecated: Use `buildMarkdownDoc . attachDocCommons gitRev`
--   instead.</i>
renderLorentzDocWithGitRev :: DGitRevision -> (inp :-> out) -> LText

-- | Give a name to given contract. Apply it to the whole contract code.

-- | <i>Deprecated: Use `docGroup name` instead.</i>
contractName :: Text -> (inp :-> out) -> inp :-> out

-- | Takes an instruction that inserts documentation items with general
--   information about the contract. Inserts it into general section. See
--   <a>DGeneralInfoSection</a>.

-- | <i>Deprecated: Use `docGroup DGeneralInfoSection` instead.</i>
contractGeneral :: (inp :-> out) -> inp :-> out

-- | Inserts general information about the contract using the default
--   format.
--   
--   This includes git revision and some other information common for all
--   contracts. Git revision is left unknown in the library code and is
--   supposed to be updated in an executable using e.g.
--   <a>buildLorentzDocWithGitRev</a>.
contractGeneralDefault :: s :-> s

-- | Leave only instructions related to documentation.
--   
--   This function is useful when your method executes a lambda coming from
--   outside, but you know its properties and want to propagate its
--   documentation to your contract code.
cutLorentzNonDoc :: (inp :-> out) -> s :-> s

-- | Renders to a view section.
data DView
DView :: ViewName -> SubDoc -> DView
[dvName] :: DView -> ViewName
[dvSub] :: DView -> SubDoc

-- | Renders to a line mentioning the view's argument.
data DViewArg
DViewArg :: Proxy a -> DViewArg

-- | Renders to a line mentioning the view's argument.
data DViewRet
DViewRet :: Proxy a -> DViewRet

-- | Renders to documentation of view descriptor.
data DViewDesc
DViewDesc :: Proxy vd -> DViewDesc

-- | Provides documentation for views descriptor.
--   
--   Note that views descriptors may describe views that do not belong to
--   the current contract, e.g. <tt>TAddress</tt> may refer to an external
--   contract provided by the user in which we want to call a view.
class (Typeable vd, RenderViewsImpl (RevealViews vd)) => ViewsDescriptorHasDoc (vd :: Type)
viewsDescriptorName :: ViewsDescriptorHasDoc vd => Proxy vd -> Text
viewsDescriptorName :: (ViewsDescriptorHasDoc vd, Generic vd, KnownSymbol (GenericTypeName vd)) => Proxy vd -> Text
renderViewsDescriptorDoc :: ViewsDescriptorHasDoc vd => Proxy vd -> Builder
type Markdown = Builder
data DocElem d
DocElem :: d -> Maybe SubDoc -> DocElem d
[deItem] :: DocElem d -> d
[deSub] :: DocElem d -> Maybe SubDoc
class (Typeable d, DOrd d) => DocItem d where {
    type family DocItemPlacement d :: DocItemPlacementKind;
    type family DocItemReferenced d :: DocItemReferencedKind;
    type DocItemPlacement d = 'DocItemInlined;
    type DocItemReferenced d = 'False;
}
docItemPos :: DocItem d => Natural
docItemSectionName :: DocItem d => Maybe Text
docItemSectionDescription :: DocItem d => Maybe Markdown
docItemSectionNameStyle :: DocItem d => DocSectionNameStyle
docItemRef :: DocItem d => d -> DocItemRef (DocItemPlacement d) (DocItemReferenced d)
docItemToMarkdown :: DocItem d => HeaderLevel -> d -> Markdown
docItemToToc :: DocItem d => HeaderLevel -> d -> Markdown
docItemDependencies :: DocItem d => d -> [SomeDocDefinitionItem]
docItemsOrder :: DocItem d => [d] -> [d]
docItemPosition :: DocItem d => DocItemPos
newtype DocItemId
DocItemId :: Text -> DocItemId
data DocItemPlacementKind
DocItemInlined :: DocItemPlacementKind
DocItemInDefinitions :: DocItemPlacementKind
newtype DocItemPos
DocItemPos :: (Natural, Text) -> DocItemPos
data DocItemRef (p :: DocItemPlacementKind) (r :: DocItemReferencedKind)
[DocItemRef] :: DocItemId -> DocItemRef 'DocItemInDefinitions 'True
[DocItemRefInlined] :: DocItemId -> DocItemRef 'DocItemInlined 'True
[DocItemNoRef] :: DocItemRef 'DocItemInlined 'False
data DocSection
DocSection :: (NonEmpty $ DocElem d) -> DocSection
data DocSectionNameStyle
DocSectionNameBig :: DocSectionNameStyle
DocSectionNameSmall :: DocSectionNameStyle
data SomeDocItem
[SomeDocItem] :: forall d. DocItem d => d -> SomeDocItem
data SomeDocDefinitionItem
[SomeDocDefinitionItem] :: forall d. (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => d -> SomeDocDefinitionItem
newtype SubDoc
SubDoc :: DocBlock -> SubDoc
type DocGrouping = SubDoc -> SomeDocItem
data ContractDoc
ContractDoc :: DocBlock -> DocBlock -> Set SomeDocDefinitionItem -> Set DocItemId -> ContractDoc
[cdContents] :: ContractDoc -> DocBlock
[cdDefinitions] :: ContractDoc -> DocBlock
[cdDefinitionsSet] :: ContractDoc -> Set SomeDocDefinitionItem
[cdDefinitionIds] :: ContractDoc -> Set DocItemId
newtype DGeneralInfoSection
DGeneralInfoSection :: SubDoc -> DGeneralInfoSection
data DName
DName :: Text -> SubDoc -> DName
data DDescription
DDescription :: Markdown -> DDescription

-- | Modify the example value of an entrypoint
data DEntrypointExample
DEntrypointExample :: Value t -> DEntrypointExample
mkDEntrypointExample :: forall a. NiceParameter a => a -> DEntrypointExample
data DGitRevision
DGitRevisionKnown :: DGitRevisionInfo -> DGitRevision
DGitRevisionUnknown :: DGitRevision
newtype GitRepoSettings
GitRepoSettings :: (Text -> Text) -> GitRepoSettings
[grsMkGitRevision] :: GitRepoSettings -> Text -> Text
mkDGitRevision :: ExpQ
morleyRepoSettings :: GitRepoSettings
data DComment
DComment :: Text -> DComment
data DAnchor
DAnchor :: Anchor -> DAnchor
data DType
[DType] :: forall a. TypeHasDoc a => Proxy a -> DType
dTypeDep :: TypeHasDoc t => SomeDocDefinitionItem
docDefinitionRef :: (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => Markdown -> d -> Markdown
contractDocToMarkdown :: ContractDoc -> LText
subDocToMarkdown :: HeaderLevel -> SubDoc -> Markdown
docItemSectionRef :: DocItem di => Maybe Markdown
class ContainsDoc a
buildDocUnfinalized :: ContainsDoc a => a -> ContractDoc
class ContainsDoc a => ContainsUpdateableDoc a
modifyDocEntirely :: ContainsUpdateableDoc a => (SomeDocItem -> SomeDocItem) -> a -> a
data WithFinalizedDoc a
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
attachDocCommons :: ContainsUpdateableDoc a => DGitRevision -> a -> WithFinalizedDoc a
class (Typeable a, SingI TypeDocFieldDescriptions a, FieldDescriptionsValid TypeDocFieldDescriptions a a) => TypeHasDoc a where {
    type family TypeDocFieldDescriptions a :: FieldDescriptions;
    type TypeDocFieldDescriptions a = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))];
}
typeDocName :: TypeHasDoc a => Proxy a -> Text
typeDocMdDescription :: TypeHasDoc a => Markdown
typeDocMdReference :: TypeHasDoc a => Proxy a -> WithinParens -> Markdown
typeDocDependencies :: TypeHasDoc a => Proxy a -> [SomeDocDefinitionItem]
typeDocHaskellRep :: TypeHasDoc a => TypeDocHaskellRep a
typeDocMichelsonRep :: TypeHasDoc a => TypeDocMichelsonRep a
data SomeTypeWithDoc
[SomeTypeWithDoc] :: forall td. TypeHasDoc td => Proxy td -> SomeTypeWithDoc
typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder
class HaveCommonTypeCtor (a :: k) (b :: k1)
class IsHomomorphic (a :: k)
genericTypeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem]
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
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
haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepStripFieldPrefix :: HasCallStack => 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
mdTocFromRef :: (DocItem d, DocItemReferenced d ~ 'True) => HeaderLevel -> Markdown -> d -> Markdown
instance (Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc p, Lorentz.Doc.ViewsDescriptorHasDoc vd) => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Address.TAddress p vd)
instance GHC.Classes.Eq Lorentz.Doc.DViewDesc
instance GHC.Classes.Ord Lorentz.Doc.DViewDesc
instance Morley.Michelson.Doc.DocItem Lorentz.Doc.DViewDesc
instance Lorentz.Doc.RenderViewsImpl '[]
instance (GHC.TypeLits.KnownSymbol name, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc arg, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc ret, Lorentz.Doc.RenderViewsImpl vs) => Lorentz.Doc.RenderViewsImpl ('Lorentz.ViewBase.ViewTyInfo name arg ret : vs)
instance Morley.Michelson.Doc.DocItem Lorentz.Doc.DViewRet
instance Morley.Michelson.Doc.DocItem Lorentz.Doc.DViewArg
instance Morley.Michelson.Doc.DocItem Lorentz.Doc.DView
instance Morley.Michelson.Doc.DocItem Lorentz.Doc.DEntrypointExample
instance Morley.Michelson.Doc.ContainsDoc (i Lorentz.Base.:-> o)
instance Morley.Michelson.Doc.ContainsUpdateableDoc (i Lorentz.Base.:-> o)
instance Morley.Michelson.Doc.ContainsDoc (Lorentz.Base.Contract cp st vd)
instance Morley.Michelson.Doc.ContainsUpdateableDoc (Lorentz.Base.Contract cp st vd)
instance Universum.TypeOps.Each '[Data.Typeable.Internal.Typeable, Morley.Util.Type.ReifyList Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc] '[i, o] => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (i Lorentz.Base.:-> o)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc p => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Address.FutureContract p)


-- | Type-safe operations with <tt>bytes</tt>-like data.
module Lorentz.Bytes

-- | Everything which is represented as bytes inside.
class (KnownValue bs, ToT bs ~ ToT ByteString) => BytesLike bs
toBytes :: BytesLike bs => bs -> ByteString

-- | Represents a <a>ByteString</a> resulting from packing a value of type
--   <tt>a</tt>.
--   
--   This is <i>not</i> guaranteed to keep some packed value, and
--   <tt>unpack</tt> can fail. We do so because often we need to accept
--   values of such type from user, and also because there is no simple way
--   to check validity of packed data without performing full unpack. So
--   this wrapper is rather a hint for users.
newtype Packed a
Packed :: ByteString -> Packed a
[unPacked] :: Packed a -> ByteString

-- | Represents a signature, where signed data has given type.
--   
--   Since we usually sign a packed data, a common pattern for this type is
--   <tt>TSignature (<a>Packed</a> signedData)</tt>. If you don't want to
--   use <a>Packed</a>, use plain <tt>TSignature ByteString</tt> instead.
newtype TSignature a
TSignature :: Signature -> TSignature a
[unTSignature] :: TSignature a -> Signature

-- | Sign data using <a>SecretKey</a>
lSign :: (MonadRandom m, BytesLike a) => SecretKey -> a -> m (TSignature a)

-- | Hash of type <tt>t</tt> evaluated from data of type <tt>a</tt>.
newtype Hash (alg :: HashAlgorithmKind) a
UnsafeHash :: ByteString -> Hash (alg :: HashAlgorithmKind) a
[unHash] :: Hash (alg :: HashAlgorithmKind) a -> ByteString

-- | Documentation item for hash algorithms.
data DHashAlgorithm

-- | Hash algorithm used in Tezos.
class Typeable alg => KnownHashAlgorithm (alg :: HashAlgorithmKind)
hashAlgorithmName :: KnownHashAlgorithm alg => Proxy alg -> Text
computeHash :: KnownHashAlgorithm alg => ByteString -> ByteString
toHash :: (KnownHashAlgorithm alg, BytesLike bs) => (bs : s) :-> (Hash alg bs : s)

-- | Evaluate hash in Haskell world.
toHashHs :: forall alg bs. (BytesLike bs, KnownHashAlgorithm alg) => bs -> Hash alg bs
data Sha256 :: HashAlgorithmKind
data Sha512 :: HashAlgorithmKind
data Blake2b :: HashAlgorithmKind
data Sha3 :: HashAlgorithmKind
data Keccak :: HashAlgorithmKind
newtype ChestT a
ChestT :: Chest -> ChestT a
[unChestT] :: ChestT a -> Chest
data OpenChestT a
ChestContentT :: a -> OpenChestT a
ChestOpenFailedT :: Bool -> OpenChestT a
openChestT :: BytesLike a => (ChestKey : (ChestT a : (Natural : s))) :-> (OpenChestT a : s)
instance Data.Typeable.Internal.Typeable a => Lorentz.Bytes.BytesLike (Lorentz.Bytes.Packed a)
instance Lorentz.Annotation.HasAnnotation (Lorentz.Bytes.Packed a)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Bytes.Packed a)
instance GHC.Generics.Generic (Lorentz.Bytes.Packed a)
instance GHC.Classes.Ord (Lorentz.Bytes.Packed a)
instance GHC.Classes.Eq (Lorentz.Bytes.Packed a)
instance GHC.Show.Show (Lorentz.Bytes.Packed a)
instance Lorentz.Annotation.HasAnnotation (Lorentz.Bytes.TSignature a)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Bytes.TSignature a)
instance GHC.Generics.Generic (Lorentz.Bytes.TSignature a)
instance GHC.Show.Show (Lorentz.Bytes.TSignature a)
instance (Data.Typeable.Internal.Typeable alg, Data.Typeable.Internal.Typeable a) => Lorentz.Bytes.BytesLike (Lorentz.Bytes.Hash alg a)
instance Lorentz.Annotation.HasAnnotation (Lorentz.Bytes.Hash alg a)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Bytes.Hash alg a)
instance GHC.Generics.Generic (Lorentz.Bytes.Hash alg a)
instance GHC.Classes.Ord (Lorentz.Bytes.Hash alg a)
instance GHC.Classes.Eq (Lorentz.Bytes.Hash alg a)
instance GHC.Show.Show (Lorentz.Bytes.Hash alg a)
instance GHC.Generics.Generic (Lorentz.Bytes.ChestT a)
instance Lorentz.Annotation.HasAnnotation (Lorentz.Bytes.ChestT a)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Bytes.ChestT a)
instance Lorentz.Annotation.HasAnnotation a => Lorentz.Annotation.HasAnnotation (Lorentz.Bytes.OpenChestT a)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue a => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Bytes.OpenChestT a)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Lorentz.Bytes.OpenChestT a)
instance GHC.Show.Show a => GHC.Show.Show (Lorentz.Bytes.OpenChestT a)
instance GHC.Generics.Generic (Lorentz.Bytes.OpenChestT a)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc a => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Bytes.OpenChestT a)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc a => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Bytes.ChestT a)
instance Lorentz.Bytes.KnownHashAlgorithm Lorentz.Bytes.Keccak
instance Lorentz.Bytes.KnownHashAlgorithm Lorentz.Bytes.Sha3
instance (Lorentz.Bytes.KnownHashAlgorithm alg, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc a) => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Bytes.Hash alg a)
instance Lorentz.Bytes.KnownHashAlgorithm Lorentz.Bytes.Blake2b
instance Lorentz.Bytes.KnownHashAlgorithm Lorentz.Bytes.Sha512
instance Lorentz.Bytes.KnownHashAlgorithm Lorentz.Bytes.Sha256
instance GHC.Classes.Eq Lorentz.Bytes.DHashAlgorithm
instance GHC.Classes.Ord Lorentz.Bytes.DHashAlgorithm
instance Morley.Michelson.Doc.DocItem Lorentz.Bytes.DHashAlgorithm
instance Formatting.Buildable.Buildable (Lorentz.Bytes.Hash alg a)
instance Formatting.Buildable.Buildable (Lorentz.Bytes.TSignature a)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc a => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Bytes.TSignature a)
instance Formatting.Buildable.Buildable (Lorentz.Bytes.Packed a)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc a => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Bytes.Packed a)
instance Lorentz.Bytes.BytesLike Data.ByteString.Internal.ByteString


-- | Packing utilities.
module Lorentz.Pack
lPackValueRaw :: forall a. NicePackedValue a => a -> ByteString
lUnpackValueRaw :: forall a. NiceUnpackedValue a => ByteString -> Either UnpackError a
lPackValue :: forall a. NicePackedValue a => a -> Packed a
lUnpackValue :: forall a. NiceUnpackedValue a => Packed a -> Either UnpackError a
lEncodeValue :: forall a. NiceUntypedValue a => a -> ByteString

-- | This function transforms Lorentz values into <tt>script_expr</tt>.
--   
--   <tt>script_expr</tt> is used in RPC as an argument in entrypoint
--   designed for getting value by key from the big_map in Babylon. In
--   order to convert value to the <tt>script_expr</tt> we have to pack it,
--   take blake2b hash and add specific <tt>expr</tt> prefix. Take a look
--   at
--   <a>https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/script_expr_hash.ml</a>
--   and
--   <a>https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/contract_services.ml#L136</a>
--   for more information.
valueToScriptExpr :: forall t. NicePackedValue t => t -> ByteString

-- | Similar to <a>valueToScriptExpr</a>, but for values encoded as
--   <a>Expression</a>s. This is only used in tests.
expressionToScriptExpr :: Expression -> ByteString

module Lorentz.Instr
nop :: s :-> s
drop :: (a : s) :-> s

-- | Drop top <tt>n</tt> elements from the stack.
dropN :: forall (n :: Nat) (s :: [Type]). (SingI (ToPeano n), RequireLongerOrSameLength (ToTs s) (ToPeano n), Drop (ToPeano n) (ToTs s) ~ ToTs (Drop (ToPeano n) s)) => s :-> Drop (ToPeano n) s
type ConstraintDUPNLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (a :: Type) = (ConstraintDUPN n (ToTs inp) (ToTs out) (ToT a), ConstraintDUPN' Type n inp out a, SingI n)

-- | Copies a stack argument.
--   
--   Hit the <a>Dupable</a> constraint? Polymorphism and abstractions do
--   not play very well with this constraint, you can enjoy suffering from
--   the linear types feature under various sauces:
--   
--   <ol>
--   <li>The most trivial option is to just propagate <a>Dupable</a>
--   constraint when you want to use <a>dup</a>, this suits for case when
--   you are not planning to work with non-dupable types like tickets.</li>
--   <li>Sometimes it is possible to avoid <a>dup</a> and use other
--   instructions instead (e.g. <a>unpair</a> allows splitting a pair
--   without using <a>dup</a>s, <a>getAndUpdate</a> allows accessing a map
--   value without implicit duplication). But you may have to learn to
--   write code in a completely different way, and the result may be less
--   efficient comparing to the option with using <tt>dup</tt>.</li>
--   <li>Use <a>decideOnDupable</a> to provide two code paths - when type
--   is dupable and when it is not.</li>
--   </ol>
dup :: forall a s. Dupable a => (a : s) :-> (a : (a : s))
dupNPeano :: forall (n :: Peano) a inp out. (ConstraintDUPNLorentz n inp out a, Dupable a) => inp :-> out
dupN :: forall (n :: Nat) a inp out. (ConstraintDUPNLorentz (ToPeano n) inp out a, Dupable a) => inp :-> out
swap :: (a : (b : s)) :-> (b : (a : s))
type ConstraintDIGLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (a :: Type) = (ConstraintDIG n (ToTs inp) (ToTs out) (ToT a), ConstraintDIG' Type n inp out a, SingI n)

-- | Version of <a>dig</a> which uses Peano number. It is intended for
--   internal usage in Lorentz.
digPeano :: forall (n :: Peano) inp out a. ConstraintDIGLorentz n inp out a => inp :-> out
dig :: forall (n :: Nat) inp out a. ConstraintDIGLorentz (ToPeano n) inp out a => inp :-> out
type ConstraintDUGLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (a :: Type) = (ConstraintDUG n (ToTs inp) (ToTs out) (ToT a), ConstraintDUG' Type n inp out a, SingI n)

-- | Version of <a>dug</a> which uses Peano number. It is intended for
--   internal usage in Lorentz.
dugPeano :: forall (n :: Peano) inp out a. ConstraintDUGLorentz n inp out a => inp :-> out
dug :: forall (n :: Nat) inp out a. ConstraintDUGLorentz (ToPeano n) inp out a => inp :-> out
push :: forall t s. NiceConstant t => t -> s :-> (t : s)
some :: (a : s) :-> (Maybe a : s)
none :: forall a s. KnownValue a => s :-> (Maybe a : s)
unit :: s :-> (() : s)
ifNone :: (s :-> s') -> ((a : s) :-> s') -> (Maybe a : s) :-> s'
pair :: (a : (b : s)) :-> ((a, b) : s)
car :: ((a, b) : s) :-> (a : s)
cdr :: ((a, b) : s) :-> (b : s)
unpair :: ((a, b) : s) :-> (a : (b : s))
left :: forall a b s. KnownValue b => (a : s) :-> (Either a b : s)
right :: forall a b s. KnownValue a => (b : s) :-> (Either a b : s)
ifLeft :: ((a : s) :-> s') -> ((b : s) :-> s') -> (Either a b : s) :-> s'
nil :: KnownValue p => s :-> (List p : s)
cons :: (a : (List a : s)) :-> (List a : s)
size :: SizeOpHs c => (c : s) :-> (Natural : s)
emptySet :: NiceComparable e => s :-> (Set e : s)
emptyMap :: (NiceComparable k, KnownValue v) => s :-> (Map k v : s)
emptyBigMap :: (NiceComparable k, KnownValue v, NiceNoBigMap v) => s :-> (BigMap k v : s)
map :: (MapOpHs c, IsoMapOpRes c b, KnownValue b, HasCallStack) => ((MapOpInpHs c : s) :-> (b : s)) -> (c : s) :-> (MapOpResHs c b : s)
iter :: (IterOpHs c, HasCallStack) => ((IterOpElHs c : s) :-> s) -> (c : s) :-> s
mem :: MemOpHs c => (MemOpKeyHs c : (c : s)) :-> (Bool : s)
get :: (GetOpHs c, KnownValue (GetOpValHs c)) => (GetOpKeyHs c : (c : s)) :-> (Maybe (GetOpValHs c) : s)
type ConstraintPairGetLorentz (n :: Nat) (pair :: Type) = (ConstraintGetN (ToPeano n) (ToT pair), ToT (PairGetHs (ToPeano n) pair) ~ GetN (ToPeano n) (ToT pair), SingI (ToPeano n))
type family PairGetHs (ix :: Peano) (pair :: Type) :: Type
pairGet :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz n pair => (pair : s) :-> (PairGetHs (ToPeano n) pair : s)
update :: UpdOpHs c => (UpdOpKeyHs c : (UpdOpParamsHs c : (c : s))) :-> (c : s)
getAndUpdate :: (GetOpHs c, UpdOpHs c, KnownValue (GetOpValHs c), UpdOpKeyHs c ~ GetOpKeyHs c) => (UpdOpKeyHs c : (UpdOpParamsHs c : (c : s))) :-> (Maybe (GetOpValHs c) : (c : s))
type ConstraintPairUpdateLorentz (n :: Nat) (val :: Type) (pair :: Type) = (ConstraintUpdateN (ToPeano n) (ToT pair), ToT (PairUpdateHs (ToPeano n) val pair) ~ UpdateN (ToPeano n) (ToT val) (ToT pair), SingI (ToPeano n))
type family PairUpdateHs (ix :: Peano) (val :: Type) (pair :: Type) :: Type
pairUpdate :: forall (n :: Nat) (val :: Type) (pair :: Type) (s :: [Type]). ConstraintPairUpdateLorentz n val pair => (val : (pair : s)) :-> (PairUpdateHs (ToPeano n) val pair : s)

-- | Helper instruction.
--   
--   Checks whether given key present in the storage and fails if it is.
--   This instruction leaves stack intact.
failingWhenPresent :: forall c k s v st e. (MemOpHs c, k ~ MemOpKeyHs c, NiceConstant e, Dupable c, Dupable (MemOpKeyHs c), st ~ (k : (v : (c : s)))) => (forall s0. (k : s0) :-> (e : s0)) -> st :-> st

-- | Like <a>update</a>, but throw an error on attempt to overwrite
--   existing entry.
updateNew :: forall c k s e. (UpdOpHs c, MemOpHs c, GetOpHs c, k ~ UpdOpKeyHs c, k ~ MemOpKeyHs c, k ~ GetOpKeyHs c, KnownValue (GetOpValHs c), NiceConstant e, Dupable k) => (forall s0. (k : s0) :-> (e : s0)) -> (k : (UpdOpParamsHs c : (c : s))) :-> (c : s)
if_ :: (s :-> s') -> (s :-> s') -> (Bool : s) :-> s'
ifCons :: ((a : (List a : s)) :-> s') -> (s :-> s') -> (List a : s) :-> s'
loop :: (s :-> (Bool : s)) -> (Bool : s) :-> s
loopLeft :: ((a : s) :-> (Either a b : s)) -> (Either a b : s) :-> (b : s)
lambda :: ZipInstrs [i, o] => (i :-> o) -> s :-> ((i :-> o) : s)
exec :: (a : (Lambda a b : s)) :-> (b : s)

-- | Similar to <a>exec</a> but works for lambdas with arbitrary size of
--   input and output.
--   
--   Note that this instruction has its arguments flipped, lambda goes
--   first. This seems to be the only reasonable way to achieve good
--   inference.
execute :: forall i o s. Each [KnownList, ZipInstr] [i, o] => ((i :-> o) : (i ++ s)) :-> (o ++ s)
apply :: forall a b c s. (NiceConstant a, KnownValue b) => (a : (Lambda (a, b) c : s)) :-> (Lambda b c : s)

-- | Version of <a>apply</a> that works for lambdas with arbitrary length
--   input and output.
applicate :: forall a b c inp2nd inpTail s. (NiceConstant a, ZipInstr b, b ~ (inp2nd : inpTail)) => (a : (((a : b) :-> c) : s)) :-> ((b :-> c) : s)
dip :: forall a s s'. HasCallStack => (s :-> s') -> (a : s) :-> (a : s')
type ConstraintDIPNLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]) = (ConstraintDIPN n (ToTs inp) (ToTs out) (ToTs s) (ToTs s'), ConstraintDIPN' Type n inp out s s', SingI n)

-- | Version of <a>dipN</a> which uses Peano number. It is intended for
--   internal usage in Lorentz.
dipNPeano :: forall (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz n inp out s s' => (s :-> s') -> inp :-> out
dipN :: forall (n :: Nat) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz (ToPeano n) inp out s s' => (s :-> s') -> inp :-> out
failWith :: forall a s t. NiceConstant a => (a : s) :-> t
cast :: KnownValue a => (a : s) :-> (a : s)
pack :: forall a s. NicePackedValue a => (a : s) :-> (Packed a : s)
unpack :: forall a s. NiceUnpackedValue a => (Packed a : s) :-> (Maybe a : s)
packRaw :: forall a s. NicePackedValue a => (a : s) :-> (ByteString : s)
unpackRaw :: forall a s. NiceUnpackedValue a => (ByteString : s) :-> (Maybe a : s)
concat :: ConcatOpHs c => (c : (c : s)) :-> (c : s)
concat' :: ConcatOpHs c => (List c : s) :-> (c : s)
slice :: (SliceOpHs c, KnownValue c) => (Natural : (Natural : (c : s))) :-> (Maybe c : s)
isNat :: (Integer : s) :-> (Maybe Natural : s)
add :: ArithOpHs Add n m r => (n : (m : s)) :-> (r : s)
sub :: ArithOpHs Sub n m r => (n : (m : s)) :-> (r : s)
rsub :: ArithOpHs Sub n m r => (m : (n : s)) :-> (r : s)
mul :: ArithOpHs Mul n m r => (n : (m : s)) :-> (r : s)
ediv :: ArithOpHs EDiv n m r => (n : (m : s)) :-> (r : s)
abs :: UnaryArithOpHs Abs n => (n : s) :-> (UnaryArithResHs Abs n : s)
neg :: UnaryArithOpHs Neg n => (n : s) :-> (UnaryArithResHs Neg n : s)
lsl :: ArithOpHs Lsl n m r => (n : (m : s)) :-> (r : s)
lsr :: ArithOpHs Lsr n m r => (n : (m : s)) :-> (r : s)
or :: ArithOpHs Or n m r => (n : (m : s)) :-> (r : s)
and :: ArithOpHs And n m r => (n : (m : s)) :-> (r : s)
xor :: ArithOpHs Xor n m r => (n : (m : s)) :-> (r : s)
not :: UnaryArithOpHs Not n => (n : s) :-> (UnaryArithResHs Not n : s)
compare :: NiceComparable n => (n : (n : s)) :-> (Integer : s)
eq0 :: UnaryArithOpHs Eq' n => (n : s) :-> (UnaryArithResHs Eq' n : s)
neq0 :: UnaryArithOpHs Neq n => (n : s) :-> (UnaryArithResHs Neq n : s)
lt0 :: UnaryArithOpHs Lt n => (n : s) :-> (UnaryArithResHs Lt n : s)
gt0 :: UnaryArithOpHs Gt n => (n : s) :-> (UnaryArithResHs Gt n : s)
le0 :: UnaryArithOpHs Le n => (n : s) :-> (UnaryArithResHs Le n : s)
ge0 :: UnaryArithOpHs Ge n => (n : s) :-> (UnaryArithResHs Ge n : s)
int :: ToIntegerArithOpHs i => (i : s) :-> (Integer : s)

-- | Cast something appropriate to <a>TAddress</a>.
toTAddress_ :: forall cp addr vd s. ToTAddress_ cp vd addr => (addr : s) :-> (TAddress cp vd : s)

-- | Manual variation of <tt>VIEW</tt> instruction. It is pretty much like
--   Michelson's <tt>VIEW</tt>, you must make sure that the compiler can
--   infer the argument and return types of the view.
--   
--   In most cases prefer <a>view</a> instead.
view' :: forall name ret arg s. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret) => (arg : (Address : s)) :-> (Maybe ret : s)

-- | Get a reference to the current contract.
--   
--   Note that, similar to <a>CONTRACT</a> instruction, in Michelson
--   <a>SELF</a> instruction can accept an entrypoint as field annotation,
--   and without annotation specified it creates a <tt>contract</tt> value
--   which calls the default entrypoint.
--   
--   This particular function carries the behaviour of <tt>SELF</tt> before
--   introduction of lightweight entrypoints feature. Thus the contract
--   must <b>not</b> have explicit "default" entrypoint for this to work.
--   
--   If you are going to call a specific entrypoint of the contract, see
--   <a>selfCalling</a>.
self :: forall p s. (NiceParameterFull p, ForbidExplicitDefaultEntrypoint p) => s :-> (ContractRef p : s)

-- | Make a reference to the current contract, maybe a specific entrypoint.
--   
--   Note that, since information about parameter of the current contract
--   is not carried around, in this function you need to specify parameter
--   type <tt>p</tt> explicitly.
selfCalling :: forall p mname s. NiceParameterFull p => EntrypointRef mname -> s :-> (ContractRef (GetEntrypointArgCustom p mname) : s)

-- | Get a reference to a contract by its address.
--   
--   This instruction carries the behaviour of <tt>CONTRACT</tt> before
--   introduction of lightweight entrypoints feature. The contract must
--   <b>not</b> have explicit "default" entrypoint for this to work.
--   
--   If you are going to call a specific entrypoint of the contract, see
--   <a>contractCalling</a>.
contract :: forall p vd addr s. (NiceParameterFull p, ForbidExplicitDefaultEntrypoint p, ToTAddress_ p vd addr) => (addr : s) :-> (Maybe (ContractRef p) : s)

-- | Make a reference to a contract, maybe a specific entrypoint.
--   
--   When calling this function, make sure that parameter type is known.
--   It's recommended that you supply <a>TAddress</a> with a concrete
--   parameter as the stack argument.
contractCalling :: forall cp epRef epArg addr vd s. (HasEntrypointArg cp epRef epArg, ToTAddress_ cp vd addr) => epRef -> (addr : s) :-> (Maybe (ContractRef epArg) : s)

-- | Specialized version of <a>contractCalling</a> for the case when you do
--   not have compile-time evidence of appropriate <a>HasEntrypointArg</a>.
--   For instance, if you have untyped <a>EpName</a> you can not have this
--   evidence (the value is only available in runtime). If you have typed
--   <a>EntrypointRef</a>, use <a>eprName</a> to construct <a>EpName</a>.
unsafeContractCalling :: forall arg s. NiceParameter arg => EpName -> (Address : s) :-> (Maybe (ContractRef arg) : s)

-- | Version of <a>contract</a> instruction which may accept address with
--   already specified entrypoint name.
--   
--   Also you cannot specify entrypoint name here because this could result
--   in conflict.
runFutureContract :: forall p s. NiceParameter p => (FutureContract p : s) :-> (Maybe (ContractRef p) : s)

-- | Similar to <a>runFutureContract</a>, works with <a>EpAddress</a>.
--   
--   Validity of such operation cannot be ensured at compile time.
epAddressToContract :: forall p s. NiceParameter p => (EpAddress : s) :-> (Maybe (ContractRef p) : s)
transferTokens :: forall p s. NiceParameter p => (p : (Mutez : (ContractRef p : s))) :-> (Operation : s)
setDelegate :: (Maybe KeyHash : s) :-> (Operation : s)
createContract :: forall p g vd s. Contract p g vd -> (Maybe KeyHash : (Mutez : (g : s))) :-> (Operation : (TAddress p vd : s))
implicitAccount :: (KeyHash : s) :-> (ContractRef () : s)
now :: s :-> (Timestamp : s)
amount :: s :-> (Mutez : s)
balance :: s :-> (Mutez : s)
votingPower :: (KeyHash : s) :-> (Natural : s)
totalVotingPower :: s :-> (Natural : s)
checkSignature :: BytesLike bs => (PublicKey : (TSignature bs : (bs : s))) :-> (Bool : s)
sha256 :: BytesLike bs => (bs : s) :-> (Hash Sha256 bs : s)
sha512 :: BytesLike bs => (bs : s) :-> (Hash Sha512 bs : s)
blake2B :: BytesLike bs => (bs : s) :-> (Hash Blake2b bs : s)
sha3 :: BytesLike bs => (bs : s) :-> (Hash Sha3 bs : s)
keccak :: BytesLike bs => (bs : s) :-> (Hash Keccak bs : s)
hashKey :: (PublicKey : s) :-> (KeyHash : s)
pairingCheck :: ([(Bls12381G1, Bls12381G2)] : s) :-> (Bool : s)

-- | <i>Warning: Using <a>source</a> is considered a bad practice. Consider
--   using <a>sender</a> instead until further investigation</i>
source :: s :-> (Address : s)
sender :: s :-> (Address : s)
address :: (ContractRef a : s) :-> (Address : s)
selfAddress :: s :-> (Address : s)
ticket :: NiceComparable a => (a : (Natural : s)) :-> (Ticket a : s)

-- | Value returned by <tt>READ_TICKET</tt> instruction.
data ReadTicket a

-- | Note: for more advanced helpers for tickets see <a>Lorentz.Tickets</a>
--   module.
readTicket :: (Ticket a : s) :-> (ReadTicket a : (Ticket a : s))

-- | Note: for more advanced helpers for tickets see <a>Lorentz.Tickets</a>
--   module.
splitTicket :: (Ticket a : ((Natural, Natural) : s)) :-> (Maybe (Ticket a, Ticket a) : s)

-- | Version of <a>splitTicket</a> with entries named.
splitTicketNamed :: forall n1 n2 a s. (Ticket a : ((n1 :! Natural, n2 :! Natural) : s)) :-> (Maybe (n1 :! Ticket a, n2 :! Ticket a) : s)

-- | Note: for more advanced helpers for tickets see <a>Lorentz.Tickets</a>
--   module.
joinTickets :: ((Ticket a, Ticket a) : s) :-> (Maybe (Ticket a) : s)
openChest :: (ChestKey : (Chest : (Natural : s))) :-> (OpenChest : s)
chainId :: s :-> (ChainId : s)
level :: s :-> (Natural : s)
never :: (Never : s) :-> s'

-- | Execute given instruction on truncated stack.
--   
--   This instruction requires you to specify the piece of stack to
--   truncate as type argument.
framed :: forall s i o. (KnownList i, KnownList o) => (i :-> o) -> (i ++ s) :-> (o ++ s)
class LorentzFunctor (c :: Type -> Type)
lmap :: (LorentzFunctor c, KnownValue b) => ((a : s) :-> (b : s)) -> (c a : s) :-> (c b : s)
instance Lorentz.Instr.LorentzFunctor GHC.Maybe.Maybe


-- | Referenced-by-type versions of some instructions.
--   
--   They allow to "dip" into stack or copy elements of stack referring
--   them by type. Their use is justified, because in most cases there is
--   only one element of each type of stack, and in cases when this does
--   not hold (e.g. entrypoint with multiple parameters of the same type),
--   it might be a good idea to wrap those types into a newtype or to use
--   primitives from <tt>named</tt> package.
--   
--   This module is experimental, i.e. everything here should work but may
--   be removed in favor of better development practices.
--   
--   Each instruction is followed with usage example.
module Lorentz.Referenced

-- | Duplicate an element of stack referring it by type.
--   
--   If stack contains multiple entries of this type, compile error is
--   raised.
dupT :: forall a st. DupT st a st => st :-> (a : st)

-- | Dip repeatedly until element of the given type is on top of the stack.
--   
--   If stack contains multiple entries of this type, compile error is
--   raised.
dipT :: forall a inp dinp dout out. DipT inp a inp dinp dout out => (dinp :-> dout) -> inp :-> out

-- | Remove element with the given type from the stack.
dropT :: forall a inp dinp dout out. (DipT inp a inp dinp dout out, dinp ~ (a : dout)) => inp :-> out
instance ((TypeError ...), dipInp GHC.Types.~ (TypeError ...), out GHC.Types.~ (TypeError ...)) => Lorentz.Referenced.DipT origSt a '[] dipInp dipOut out
instance (Data.Type.Bool.If (Morley.Util.Type.IsElem a st) (TypeError ...) (() :: Constraint), dipInp GHC.Types.~ (a : st), dipOut GHC.Types.~ out) => Lorentz.Referenced.DipT origSt a (a : st) dipInp dipOut out
instance (Lorentz.Referenced.DipT origSt a st dipInp dipOut out, out1 GHC.Types.~ (b : out)) => Lorentz.Referenced.DipT origSt a (b : st) dipInp dipOut out1
instance (TypeError ...) => Lorentz.Referenced.DupT origSt a '[]
instance (Data.Type.Bool.If (Morley.Util.Type.IsElem a st) (TypeError ...) (() :: Constraint), Lorentz.Constraints.Scopes.Dupable a) => Lorentz.Referenced.DupT origSt a (a : st)
instance Lorentz.Referenced.DupT origSt a st => Lorentz.Referenced.DupT origSt a (b : st)

module Lorentz.Errors

-- | Haskell type representing error.
class (ErrorHasDoc e) => IsError e

-- | Converts a Haskell error into <tt>Value</tt> representation.
errorToVal :: IsError e => e -> (forall t. ErrorScope t => Value t -> r) -> r

-- | Converts a <tt>Value</tt> into Haskell error.
errorFromVal :: (IsError e, SingI t) => Value t -> Either Text e

-- | Fail with the given Haskell value.
failUsing :: (IsError e, IsError e) => e -> s :-> t

-- | Since 008 it's prohibited to fail with non-packable values and with
--   the 'Contract t' type values, which is equivalent to our
--   <tt>ConstantScope</tt> constraint. See
--   <a>https://gitlab.com/tezos/tezos/-/issues/1093#note_496066354</a> for
--   more information.
type ErrorScope t = ConstantScope t
class (SingI t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t) => ConstantScope (t :: T)

-- | Implementation of <a>errorToVal</a> via <a>IsoValue</a>.
isoErrorToVal :: (KnownError e, IsoValue e) => e -> (forall t. ErrorScope t => Value t -> r) -> r

-- | Implementation of <a>errorFromVal</a> via <a>IsoValue</a>.
isoErrorFromVal :: (SingI t, KnownIsoT e, IsoValue e) => Value t -> Either Text e

-- | Basic implementation for <a>failUsing</a>.
simpleFailUsing :: forall e s t. IsError e => e -> s :-> t
class Typeable e => ErrorHasDoc (e :: Type) where {
    
    -- | Constraints which we require in a particular instance. You are not
    --   oblidged to often instantiate this correctly, it is only useful for
    --   some utilities.
    type family ErrorRequirements e :: Constraint;
    type ErrorRequirements _ = ();
}

-- | Name of error as it appears in the corresponding section title.
errorDocName :: ErrorHasDoc e => Text

-- | What should happen for this error to be raised.
errorDocMdCause :: ErrorHasDoc e => Markdown

-- | Brief version of <a>errorDocMdCause</a>.
--   
--   This will appear along with the error when mentioned in entrypoint
--   description. By default, the first sentence of the full description is
--   used.
errorDocMdCauseInEntrypoint :: ErrorHasDoc e => Markdown

-- | How this error is represented in Haskell.
errorDocHaskellRep :: ErrorHasDoc e => Markdown

-- | Error class.
errorDocClass :: ErrorHasDoc e => ErrorClass

-- | Which definitions documentation for this error mentions.
errorDocDependencies :: ErrorHasDoc e => [SomeDocDefinitionItem]

-- | Captured constraints which we require in a particular instance. This
--   is a way to encode a bidirectional instance in the nowaday Haskell,
--   for <tt>class MyConstraint =&gt; ErrorHasDoc MyType</tt> instance it
--   lets deducing <tt>MyConstraint</tt> by <tt>ErrorHasDoc MyType</tt>.
--   
--   You are not oblidged to always instantiate, it is only useful for some
--   utilities which otherwise would not compile.
errorDocRequirements :: ErrorHasDoc e => Dict (ErrorRequirements e)

-- | Captured constraints which we require in a particular instance. This
--   is a way to encode a bidirectional instance in the nowaday Haskell,
--   for <tt>class MyConstraint =&gt; ErrorHasDoc MyType</tt> instance it
--   lets deducing <tt>MyConstraint</tt> by <tt>ErrorHasDoc MyType</tt>.
--   
--   You are not oblidged to always instantiate, it is only useful for some
--   utilities which otherwise would not compile.
errorDocRequirements :: (ErrorHasDoc e, ErrorRequirements e) => Dict (ErrorRequirements e)

-- | Implementation of <a>typeDocMdDescription</a> (of <a>TypeHasDoc</a>
--   typeclass) for Haskell types which sole purpose is to be error.
typeDocMdDescriptionReferToError :: forall e. IsError e => Markdown

-- | Whether given error class is about internal errors.
--   
--   Internal errors are not enlisted on per-entrypoint basis, only once
--   for the entire contract.
isInternalErrorClass :: ErrorClass -> Bool

-- | Use this type as replacement for <tt>()</tt> when you <b>really</b>
--   want to leave error cause unspecified.
data UnspecifiedError
UnspecifiedError :: UnspecifiedError

-- | Use this error when sure that failing at the current position is
--   possible in no curcumstances (including invalid user input or
--   misconfigured storage).
--   
--   To use this as error, you have to briefly specify the reason why the
--   error scenario is impossible (experimental feature).
data Impossible (reason :: Symbol)
Impossible :: Impossible (reason :: Symbol)

-- | Type wrapper for an <tt>IsError</tt>.
data SomeError
SomeError :: e -> SomeError

-- | Fail, providing a reference to the place in the code where this
--   function is called.
--   
--   Like <a>error</a> in Haskell code, this instruction is for internal
--   errors only.
failUnexpected :: MText -> s :-> t

-- | To be used as <tt>ErrorArg</tt> instance when failing with just a
--   <tt>string</tt> instead of <tt>pair string x</tt>
data NoErrorArg

-- | To be used as <tt>ErrorArg</tt> instances. This is equivalent to using
--   <tt>()</tt> but using <tt>UnitErrorArg</tt> is preferred since
--   <tt>()</tt> behavior could be changed in the future.
data UnitErrorArg

-- | Declares a custom error, defining <tt>error name - error argument</tt>
--   relation.
--   
--   If your error is supposed to carry no argument, then provide
--   <tt>()</tt>.
--   
--   Note that this relation is defined globally rather than on
--   per-contract basis, so define errors accordingly. If your error has
--   argument specific to your contract, call it such that error name
--   reflects its belonging to this contract.
--   
--   This is the basic [error format].
type family ErrorArg (tag :: Symbol) :: Type

-- | Material custom error.
--   
--   Use this in pattern matches against error (e.g. in tests).
data CustomError (tag :: Symbol)
CustomError :: Label tag -> CustomErrorRep tag -> CustomError (tag :: Symbol)
[ceTag] :: CustomError (tag :: Symbol) -> Label tag
[ceArg] :: CustomError (tag :: Symbol) -> CustomErrorRep tag

-- | How <a>CustomError</a> is actually represented in Michelson.
type CustomErrorRep tag = CustomErrorArgRep (ErrorArg tag)

-- | Typeclass implements various method that work with
--   <a>CustomErrorArgRep</a>.
class IsCustomErrorArgRep a
verifyErrorTag :: IsCustomErrorArgRep a => MText -> a -> Either Text a
customErrorRepDocDeps :: IsCustomErrorArgRep a => [SomeDocDefinitionItem]
customErrorHaskellRep :: (IsCustomErrorArgRep a, KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown
type MustHaveErrorArg errorTag expectedArgRep = (AssertTypesEqual (CustomErrorRep errorTag) expectedArgRep ('Text "Error argument type is " :<>: 'ShowType (expectedArgRep) :<>: 'Text " but given error requires argument of type " :<>: 'ShowType (CustomErrorRep errorTag)), CustomErrorRep errorTag ~ expectedArgRep)

-- | Fail with given custom error.
failCustom :: forall tag err s any. (MustHaveErrorArg tag (MText, err), CustomErrorHasDoc tag, KnownError err) => Label tag -> (err : s) :-> any

-- | Specialization of <a>failCustom</a> for unit-arg errors.
failCustom_ :: forall tag s any. (MustHaveErrorArg tag (MText, ()), CustomErrorHasDoc tag) => Label tag -> s :-> any

-- | Fail with given custom error.
failCustomNoArg :: forall tag s any. (MustHaveErrorArg tag MText, CustomErrorHasDoc tag) => Label tag -> s :-> any

-- | Error class on how the error should be handled by the client.
data ErrorClass

-- | Normal expected error. Examples: "insufficient balance", "wallet does
--   not exist".
ErrClassActionException :: ErrorClass

-- | Invalid argument passed to entrypoint. Examples: your entrypoint
--   accepts an enum represented as <tt>nat</tt>, and unknown value is
--   provided. This includes more complex cases which involve multiple
--   entrypoints. E.g. API provides iterator interface, middleware should
--   care about using it hiding complex details and exposing a simpler API
--   to user; then an attempt to request non-existing element would also
--   correspond to an error from this class.
ErrClassBadArgument :: ErrorClass

-- | Unexpected error. Most likely it means that there is a bug in the
--   contract or the contract has been deployed incorrectly.
ErrClassContractInternal :: ErrorClass

-- | It's possible to leave error class unspecified.
ErrClassUnknown :: ErrorClass
class (KnownSymbol tag, TypeHasDoc (CustomErrorRep tag), IsError (CustomError tag)) => CustomErrorHasDoc tag

-- | What should happen for this error to be raised.
customErrDocMdCause :: CustomErrorHasDoc tag => Markdown

-- | Brief version of <a>customErrDocMdCause</a>. This will appear along
--   with the error when mentioned in entrypoint description.
--   
--   By default, the first sentence of the full description is used.
customErrDocMdCauseInEntrypoint :: CustomErrorHasDoc tag => Markdown

-- | Error class.
--   
--   By default this returns "unknown error" class; though you should
--   provide explicit implementation in order to avoid a warning.
customErrClass :: CustomErrorHasDoc tag => ErrorClass

-- | Clarification of error argument meaning.
--   
--   Provide when it's not obvious, e.g. argument is not named with
--   <a>:!</a>.
--   
--   NOTE: This should <i>not</i> be an entire sentence, rather just the
--   semantic backbone.
--   
--   Bad: * <tt>Error argument stands for the previous value of
--   approval.</tt>
--   
--   Good: * <tt>the previous value of approval</tt> * <tt>pair, first
--   argument of which is one thing, and the second is another</tt>
customErrArgumentSemantics :: CustomErrorHasDoc tag => Maybe Markdown

-- | Mentions that contract uses given error.
data DError
[DError] :: ErrorHasDoc e => Proxy e -> DError

-- | Documentation for custom errors.
--   
--   Mentions that entrypoint throws given error.
data DThrows
[DThrows] :: ErrorHasDoc e => Proxy e -> DThrows
errorTagToText :: forall tag. KnownSymbol tag => Text

-- | Demote error tag to term level.
errorTagToMText :: Label tag -> MText
instance Morley.Michelson.Typed.Haskell.Value.IsoValue Lorentz.Errors.UnspecifiedError
instance GHC.Generics.Generic Lorentz.Errors.UnspecifiedError
instance Language.Haskell.TH.Syntax.Lift Lorentz.Errors.ErrorClass
instance GHC.Classes.Eq (Lorentz.Errors.CustomErrorRep tag) => GHC.Classes.Eq (Lorentz.Errors.CustomError tag)
instance GHC.Show.Show (Lorentz.Errors.CustomErrorRep tag) => GHC.Show.Show (Lorentz.Errors.CustomError tag)
instance GHC.Classes.Eq Lorentz.Errors.DThrows
instance Morley.Michelson.Doc.DocItem Lorentz.Errors.DThrows
instance GHC.Classes.Eq Lorentz.Errors.DError
instance GHC.Classes.Ord Lorentz.Errors.DError
instance Morley.Michelson.Doc.DocItem Lorentz.Errors.DError
instance Lorentz.Errors.IsCustomErrorArgRep Morley.Michelson.Text.MText
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc errArg => Lorentz.Errors.IsCustomErrorArgRep (Morley.Michelson.Text.MText, errArg)
instance (Lorentz.Errors.CustomErrorHasDoc tag, Lorentz.Errors.KnownError (Lorentz.Errors.CustomErrorRep tag), Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Errors.CustomErrorRep tag), Lorentz.Errors.IsCustomErrorArgRep (Lorentz.Errors.CustomErrorRep tag)) => Lorentz.Errors.IsError (Lorentz.Errors.CustomError tag)
instance (Lorentz.Errors.CustomErrorHasDoc tag, Lorentz.Errors.IsCustomErrorArgRep (Lorentz.Errors.CustomErrorRep tag)) => Lorentz.Errors.ErrorHasDoc (Lorentz.Errors.CustomError tag)
instance GHC.Classes.Eq Lorentz.Errors.SomeError
instance Formatting.Buildable.Buildable Lorentz.Errors.SomeError
instance GHC.Show.Show Lorentz.Errors.SomeError
instance Lorentz.Errors.IsError Morley.Michelson.Text.MText
instance (TypeError ...) => Lorentz.Errors.IsError ()
instance Lorentz.Errors.IsError Lorentz.Errors.UnspecifiedError
instance GHC.TypeLits.KnownSymbol reason => Lorentz.Errors.IsError (Lorentz.Errors.Impossible reason)
instance (Data.Typeable.Internal.Typeable arg, Lorentz.Errors.IsError (Lorentz.Errors.CustomError tag), Morley.Util.TypeLits.AssertTypesEqual arg () notVoidError, arg GHC.Types.~ Lorentz.Errors.ErrorArg tag, notVoidError GHC.Types.~ ('GHC.TypeLits.Text "This error requires argument of type " 'GHC.TypeLits.:<>: 'GHC.TypeLits.ShowType (Lorentz.Errors.ErrorArg tag))) => Lorentz.Errors.IsError (arg -> Lorentz.Errors.CustomError tag)
instance Lorentz.Errors.ErrorHasDoc Morley.Michelson.Text.MText
instance (TypeError ...) => Lorentz.Errors.ErrorHasDoc ()
instance Lorentz.Errors.ErrorHasDoc Lorentz.Errors.UnspecifiedError
instance GHC.TypeLits.KnownSymbol reason => Lorentz.Errors.ErrorHasDoc (Lorentz.Errors.Impossible reason)
instance (Data.Typeable.Internal.Typeable arg, Lorentz.Errors.ErrorHasDoc (Lorentz.Errors.CustomError tag)) => Lorentz.Errors.ErrorHasDoc (arg -> Lorentz.Errors.CustomError tag)
instance GHC.Read.Read Lorentz.Errors.ErrorClass
instance Formatting.Buildable.Buildable Lorentz.Errors.ErrorClass
instance Formatting.Buildable.Buildable (Lorentz.Errors.CustomError tag)
instance (Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue (Lorentz.Errors.CustomErrorRep tag), (TypeError ...)) => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Errors.CustomError tag)
instance GHC.Classes.Eq (Lorentz.Errors.CustomErrorRep tag) => GHC.Classes.Eq (() -> Lorentz.Errors.CustomError tag)
instance GHC.Show.Show (Lorentz.Errors.CustomErrorRep tag) => GHC.Show.Show (() -> Lorentz.Errors.CustomError tag)


-- | Lorentz template-haskell and quasiquote utilities.
module Lorentz.Util.TH

-- | QuasiQuote that helps generating <tt>ParameterHasEntrypoints</tt>
--   instance.
--   
--   Usage:
--   
--   <pre>
--   [entrypointDoc| Parameter &lt;parameter-type&gt; &lt;optional-root-annotation&gt; |]
--   [entrypointDoc| Parameter plain |]
--   [entrypointDoc| Parameter plain "root"|]
--   </pre>
--   
--   See this <a>tutorial</a> which includes this quasiquote.
entrypointDoc :: QuasiQuoter

-- | QuasiQuote that helps generating <tt>CustomErrorHasDoc</tt> instance.
--   
--   Usage:
--   
--   <pre>
--   [errorDoc| &lt;error-name&gt; &lt;error-type&gt; &lt;error-description&gt; |]
--   [errorDoc| "errorName" exception "Error description" |]
--   </pre>
--   
--   See this <a>tutorial</a> which includes this quasiquote.
errorDoc :: QuasiQuoter

-- | QuasiQuote that helps generating <tt>TypeHasDoc</tt> instance.
--   
--   Usage:
--   
--   <pre>
--   [typeDoc| &lt;type&gt; &lt;description&gt; |]
--   [typeDoc| Storage "This is storage description"  |]
--   </pre>
--   
--   See this <a>tutorial</a> which includes this quasiquote.
typeDoc :: QuasiQuoter


-- | By default we represent error tags using strings. This module makes it
--   possible to use numbers instead. It introduces new [error format].
--   
--   There are two possible ways to use it: 1. If you have just one Lorentz
--   instruction (potentially a big one), just use <a>useNumericErrors</a>
--   function. It will change error representation there and return a map
--   that can be used to interpret new error codes. 2. If your contract
--   consists of multiple parts, start with gathering all error tags
--   (<a>gatherErrorTags</a>). Then build <a>ErrorTagMap</a> using
--   <a>addNewErrorTags</a>. Pass empty map if you are building from
--   scratch (you can use <a>buildErrorTagMap</a> shortcut) or an existing
--   map if you have one (e. g. you are upgrading a contract).
module Lorentz.Errors.Numeric.Contract

-- | This is a bidirectional map with correspondence between numeric and
--   textual error tags.
type ErrorTagMap = Bimap Natural MText

-- | Tags excluded from map.
type ErrorTagExclusions = HashSet MText

-- | Find all textual error tags that are used in typical <tt>FAILWITH</tt>
--   patterns within given instruction. Map them to natural numbers.
gatherErrorTags :: (inp :-> out) -> HashSet MText

-- | Add more error tags to an existing <a>ErrorTagMap</a>. It is useful
--   when your contract consists of multiple parts (e. g. in case of
--   contract upgrade), you have existing map for some part and want to add
--   tags from another part to it. You can pass empty map as existing one
--   if you just want to build <a>ErrorTagMap</a> from a set of textual
--   tags. See <a>buildErrorTagMap</a>.
addNewErrorTags :: ErrorTagMap -> HashSet MText -> ErrorTagMap

-- | Build <a>ErrorTagMap</a> from a set of textual tags.
buildErrorTagMap :: HashSet MText -> ErrorTagMap

-- | Remove some error tags from map. This way you say to remain these
--   string tags intact, while others will be converted to numbers when
--   this map is applied.
--   
--   Note that later you have to apply this map using
--   <a>applyErrorTagMapWithExclusions</a>, otherwise an error would be
--   raised.
excludeErrorTags :: HasCallStack => ErrorTagExclusions -> ErrorTagMap -> ErrorTagMap

-- | For each typical <a>FAILWITH</a> that uses a string to represent error
--   tag this function changes error tag to be a number using the supplied
--   conversion map. It assumes that supplied map contains all such strings
--   (and will error out if it does not). It will always be the case if you
--   gather all error tags using <a>gatherErrorTags</a> and build
--   <a>ErrorTagMap</a> from them using <a>addNewErrorTags</a>.
applyErrorTagMap :: HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out

-- | Similar to <a>applyErrorTagMap</a>, but for case when you have
--   excluded some tags from map via <a>excludeErrorTags</a>. Needed,
--   because both <a>excludeErrorTags</a> and this function do not tolerate
--   unknown errors in contract code (for your safety).
applyErrorTagMapWithExclusions :: HasCallStack => ErrorTagMap -> ErrorTagExclusions -> (inp :-> out) -> inp :-> out

-- | This function implements the simplest scenario of using this module's
--   functionality: 1. Gather all error tags from a single instruction. 2.
--   Turn them into error conversion map. 3. Apply this conversion.
useNumericErrors :: HasCallStack => (inp :-> out) -> (inp :-> out, ErrorTagMap)

-- | If you apply numeric error representation in your contract,
--   <a>errorFromVal</a> will stop working because it doesn't know about
--   this transformation. This function takes this transformation into
--   account. If a number is used as a tag, but it is not found in the
--   passed map, we conservatively preserve that number (because this whole
--   approach is rather a heuristic).
errorFromValNumeric :: (SingI t, IsError e) => ErrorTagMap -> Value t -> Either Text e

-- | If you apply numeric error representation in your contract,
--   <a>errorToVal</a> will stop working because it doesn't know about this
--   transformation. This function takes this transformation into account.
--   If a string is used as a tag, but it is not found in the passed map,
--   we conservatively preserve that string (because this whole approach is
--   rather a heuristic).
errorToValNumeric :: IsError e => ErrorTagMap -> e -> (forall t. ConstantScope t => Value t -> r) -> r


-- | Some common errors.
--   
--   Such registry makes sense, as soon as errors are declared globally.
module Lorentz.Errors.Common
instance Formatting.Buildable.Buildable (Lorentz.Errors.CustomError "senderIsNotAdmin")
instance Lorentz.Errors.CustomErrorHasDoc "senderIsNotAdmin"


-- | Support for uninhabited type.
--   
--   Note: this module exists solely for historical reasons since the time
--   when <a>Never</a> was not yet supported by the Michelson.
--   
--   TODO [#549]: remove this module.
module Lorentz.Empty

-- | Replacement for uninhabited type.

-- | <i>Deprecated: Use Never type instead</i>
data Empty

-- | Witness of that this code is unreachable.
absurd_ :: (Empty : s) :-> s'
instance Lorentz.Annotation.HasAnnotation Lorentz.Empty.Empty
instance Morley.Michelson.Typed.Haskell.Value.IsoValue Lorentz.Empty.Empty
instance GHC.Generics.Generic Lorentz.Empty.Empty
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc Lorentz.Empty.Empty
instance Lorentz.Errors.CustomErrorHasDoc "emptySupplied"
instance Formatting.Buildable.Buildable (Lorentz.Errors.CustomError "emptySupplied")


-- | Identity transformations between different Haskell types.
module Lorentz.Coercions

-- | Explicitly allowed coercions.
--   
--   <tt>a <a>CanCastTo</a> b</tt> proclaims that <tt>a</tt> can be casted
--   to <tt>b</tt> without violating any invariants of <tt>b</tt>.
--   
--   This relation is reflexive; it <i>may</i> be symmetric or not. It
--   tends to be composable: casting complex types usually requires
--   permission to cast their respective parts; for such types consider
--   using <a>castDummyG</a> as implementation of the method of this
--   typeclass.
--   
--   For cases when a cast from <tt>a</tt> to <tt>b</tt> requires some
--   validation, consider rather making a dedicated function which performs
--   the necessary checks and then calls <a>forcedCoerce</a>.
class a `CanCastTo` b

-- | An optional method which helps passing -Wredundant-constraints check.
--   Also, you can set specific implementation for it with specific sanity
--   checks.
castDummy :: CanCastTo a b => Proxy a -> Proxy b -> ()

-- | Implementation of <a>castDummy</a> for types composed from smaller
--   types. It helps to ensure that all necessary constraints are requested
--   in instance head.
castDummyG :: (Generic a, Generic b, GCanCastTo (Rep a) (Rep b)) => Proxy a -> Proxy b -> ()

-- | Coercion in Haskell world which respects <a>CanCastTo</a>.
checkedCoerce :: forall a b. (CanCastTo a b, Coercible a b) => a -> b

-- | Coercion from <tt>a</tt> to <tt>b</tt> is permitted and safe.
type Castable_ a b = (MichelsonCoercible a b, CanCastTo a b)

-- | Coercions between <tt>a</tt> to <tt>b</tt> are permitted and safe.
type Coercible_ a b = (MichelsonCoercible a b, CanCastTo a b, CanCastTo b a)

-- | Coerce between types which have an explicit permission for that in the
--   face of <a>CanCastTo</a> constraint.
checkedCoerce_ :: forall a b s. Castable_ a b => (a : s) :-> (b : s)

-- | Pretends that the top item of the stack was coerced.
checkedCoercing_ :: forall a b s. Coercible_ a b => ((b : s) :-> (b : s)) -> (a : s) :-> (a : s)

-- | Locally provide given <a>CanCastTo</a> instance.
allowCheckedCoerceTo :: forall b a. Dict (CanCastTo a b)

-- | Locally provide bidirectional <a>CanCastTo</a> instance.
allowCheckedCoerce :: forall a b. Dict (CanCastTo a b, CanCastTo b a)

-- | Specialized version of <a>forcedCoerce_</a> to unwrap a haskell
--   newtype.
coerceUnwrap :: forall a s. Unwrappable a => (a : s) :-> (Unwrappabled a : s)

-- | Specialized version of <a>forcedCoerce_</a> to wrap a haskell newtype.
--   
--   Works under <a>Unwrappable</a> constraint, thus is not safe.
unsafeCoerceWrap :: forall a s. Unwrappable a => (Unwrappabled a : s) :-> (a : s)

-- | Specialized version of <a>forcedCoerce_</a> to wrap into a haskell
--   newtype.
--   
--   Requires <a>Wrappable</a> constraint.
coerceWrap :: forall a s. Wrappable a => (Unwrappabled a : s) :-> (a : s)

-- | Lift given value to a named value.
toNamed :: Label name -> (a : s) :-> ((name :! a) : s)

-- | Unpack named value.
fromNamed :: Label name -> ((name :! a) : s) :-> (a : s)

-- | Whether two types have the same Michelson representation.
type MichelsonCoercible a b = ToT a ~ ToT b

-- | Coercion for Haskell world.
--   
--   We discourage using this function on Lorentz types, consider using
--   <a>coerce</a> instead. One of the reasons forthat is that in Lorentz
--   it's common to declare types as newtypes consisting of existing
--   primitives, and <tt>forcedCoerce</tt> tends to ignore all phantom type
--   variables of newtypes thus violating their invariants.
forcedCoerce :: Coercible a b => a -> b

-- | Convert between values of types that have the same representation.
--   
--   This function is not safe in a sense that this allows * breaking
--   invariants of casted type (example: <tt>UStore</tt> from
--   morley-upgradeable), or * may stop compile on code changes (example:
--   coercion of pair to a datatype with two fields will break if new field
--   is added). Still, produced Michelson code will always be valid.
--   
--   Prefer using one of more specific functions from this module.
forcedCoerce_ :: MichelsonCoercible a b => (a : s) :-> (b : s)
gForcedCoerce_ :: MichelsonCoercible (t a) (t b) => (t a : s) :-> (t b : s)

-- | Convert between two stacks via failing.
fakeCoerce :: s1 :-> s2
fakeCoercing :: (s1 :-> s2) -> s1' :-> s2'

-- | Declares that this type is just a wrapper over some other type and it
--   can be safely unwrapped to that inner type.
--   
--   Inspired by lens <tt>Wrapped</tt>.
class ToT s ~ ToT (Unwrappabled s) => Unwrappable (s :: Type) where {
    
    -- | The type we unwrap to (inner type of the newtype).
    --   
    --   Used in constraint for Lorentz instruction wrapping into a Haskell
    --   newtype and vice versa.
    type family Unwrappabled s :: Type;
    type Unwrappabled s = GUnwrappabled s (Rep s);
}

-- | Declares that it is safe to wrap an inner type to the given wrapper
--   type. Can be provided in addition to <a>Unwrappable</a>.
--   
--   You can declare this instance when your wrapper exists just to make
--   type system differentiate the two types. Example: <tt>newtype TokenId
--   = TokenId Natural</tt>.
--   
--   Do <i>not</i> define this instance for wrappers that provide some
--   invariants. Example: <tt>UStore</tt> type from
--   <tt>morley-upgradeable</tt>.
--   
--   <a>Wrappable</a> is similar to lens <tt>Wrapped</tt> class without the
--   method.
class Unwrappable s => Wrappable (s :: Type)
instance forall k (a :: k). Lorentz.Coercions.CanCastTo a a
instance Lorentz.Coercions.CanCastTo a b => Lorentz.Coercions.CanCastTo [a] [b]
instance Lorentz.Coercions.CanCastTo a b => Lorentz.Coercions.CanCastTo (GHC.Maybe.Maybe a) (GHC.Maybe.Maybe b)
instance (Lorentz.Coercions.CanCastTo l1 l2, Lorentz.Coercions.CanCastTo r1 r2) => Lorentz.Coercions.CanCastTo (Data.Either.Either l1 r1) (Data.Either.Either l2 r2)
instance Lorentz.Coercions.CanCastTo k1 k2 => Lorentz.Coercions.CanCastTo (Data.Set.Internal.Set k1) (Data.Set.Internal.Set k2)
instance (Lorentz.Coercions.CanCastTo k1 k2, Lorentz.Coercions.CanCastTo v1 v2) => Lorentz.Coercions.CanCastTo (Data.Map.Internal.Map k1 v1) (Data.Map.Internal.Map k2 v2)
instance (Lorentz.Coercions.CanCastTo k1 k2, Lorentz.Coercions.CanCastTo v1 v2) => Lorentz.Coercions.CanCastTo (Morley.Michelson.Typed.Haskell.Value.BigMap k1 v1) (Morley.Michelson.Typed.Haskell.Value.BigMap k2 v2)
instance (Lorentz.Coercions.CanCastTo (Lorentz.Zip.ZippedStack i1) (Lorentz.Zip.ZippedStack i2), Lorentz.Coercions.CanCastTo (Lorentz.Zip.ZippedStack o1) (Lorentz.Zip.ZippedStack o2)) => Lorentz.Coercions.CanCastTo (i1 Lorentz.Base.:-> o1) (i2 Lorentz.Base.:-> o2)
instance Lorentz.Coercions.CanCastTo a1 a2 => Lorentz.Coercions.CanCastTo (Morley.Michelson.Typed.Haskell.Value.ContractRef a1) (Morley.Michelson.Typed.Haskell.Value.ContractRef a2)
instance Lorentz.Coercions.CanCastTo (f a) (g b) => Lorentz.Coercions.CanCastTo (Named.Internal.NamedF f a n) (Named.Internal.NamedF g b m)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo b1 b2) => Lorentz.Coercions.CanCastTo (a1, b1) (a2, b2)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo b1 b2, Lorentz.Coercions.CanCastTo c1 c2) => Lorentz.Coercions.CanCastTo (a1, b1, c1) (a2, b2, c2)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo b1 b2, Lorentz.Coercions.CanCastTo c1 c2, Lorentz.Coercions.CanCastTo d1 d2) => Lorentz.Coercions.CanCastTo (a1, b1, c1, d1) (a2, b2, c2, d2)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo b1 b2, Lorentz.Coercions.CanCastTo c1 c2, Lorentz.Coercions.CanCastTo d1 d2, Lorentz.Coercions.CanCastTo e1 e2) => Lorentz.Coercions.CanCastTo (a1, b1, c1, d1, e1) (a2, b2, c2, d2, e2)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo b1 b2, Lorentz.Coercions.CanCastTo c1 c2, Lorentz.Coercions.CanCastTo d1 d2, Lorentz.Coercions.CanCastTo e1 e2, Lorentz.Coercions.CanCastTo f1 f2) => Lorentz.Coercions.CanCastTo (a1, b1, c1, d1, e1, f1) (a2, b2, c2, d2, e2, f2)
instance Lorentz.Coercions.CanCastTo (Lorentz.Address.TAddress p vd) Morley.Tezos.Address.Address
instance Lorentz.Coercions.CanCastTo Morley.Tezos.Address.Address (Lorentz.Address.TAddress p vd)
instance Lorentz.Coercions.CanCastTo (Lorentz.Address.FutureContract p) Morley.Michelson.Typed.Entrypoints.EpAddress
instance Lorentz.Coercions.CanCastTo (Lorentz.Bytes.Packed a) Data.ByteString.Internal.ByteString
instance Lorentz.Coercions.CanCastTo (Lorentz.Bytes.TSignature a) Data.ByteString.Internal.ByteString
instance Lorentz.Coercions.CanCastTo (Lorentz.Bytes.Hash alg a) Data.ByteString.Internal.ByteString
instance Lorentz.Coercions.CanCastTo a b => Lorentz.Coercions.CanCastTo (Lorentz.Bytes.Packed a) (Lorentz.Bytes.Packed b)
instance Lorentz.Coercions.CanCastTo a b => Lorentz.Coercions.CanCastTo (Lorentz.Bytes.TSignature a) (Lorentz.Bytes.TSignature b)
instance (Lorentz.Coercions.CanCastTo alg1 alg2, Lorentz.Coercions.CanCastTo a1 a2) => Lorentz.Coercions.CanCastTo (Lorentz.Bytes.Hash alg1 a1) (Lorentz.Bytes.Hash alg2 a2)


-- | This module contains implementation of <a>Extensible</a> values.
--   
--   <tt>Extensible</tt> values are an alternative representation of
--   sum-types for Michelson. Instead of representing them as nested
--   options, we treat them as (Natural, ByteString) pair, where the first
--   element of the pair represents the constructor index, while the second
--   is a packed argument.
--   
--   With such a representation sum types can be easily upgraded: it is
--   possible to add new elements to the sum type, and the representation
--   would not change.
--   
--   However, such representation essentially limits the applicability of
--   the values. This module does not provide Michelson-level function to
--   unwrap the value because it would require traversing all the possible
--   options in the contract code. While this is possible, it is very
--   inefficient. Up to this moment, we have not come up with a decent
--   reason to allow such behavior, so Extensible types are write-only in
--   Michelson code. They can be unwrapped off-chain with
--   <tt>fromExtVal</tt>.
--   
--   In order to preserve previous values during migrations, users should
--   ONLY APPEND items to the underlying sum type. Changing, reordering and
--   deleting items is not allowed and would lead to compatibility
--   breakage. Currently, this restriction in not enforced. Only
--   no-argument and one-argument constructors are supported.
--   
--   GOOD: -- `Extensible GoodSumTypeV1` is backwards compatible -- with
--   `Extensible GoodSumTypeV2` data GoodSumTypeV1 = A Natural | B data
--   GoodSumTypeV2 = A Natural | B | C MText
--   
--   BAD: -- `Extensible BadSumTypeV1` is NOT backwards compatible -- with
--   `Extensible BadSumTypeV2` data BadSumTypeV1 = A | B data BadSumTypeV2
--   = A Natural | B | C MText
module Lorentz.Extensible
newtype Extensible x
Extensible :: (Natural, ByteString) -> Extensible x

-- | Errors related to fromExtVal conversion
data ExtConversionError
ConstructorIndexNotFound :: Natural -> ExtConversionError
ArgumentUnpackFailed :: ExtConversionError
type ExtVal x = (Generic x, GExtVal x (Rep x))

-- | Information to be provided for documenting some <tt><a>Extensible</a>
--   x</tt>.
class Typeable x => ExtensibleHasDoc x

-- | Implementation for <a>typeDocName</a> of the corresponding
--   <tt>Extensible</tt>.
extensibleDocName :: ExtensibleHasDoc x => Proxy x -> Text

-- | Implementation for <a>typeDocDependencies</a> of the corresponding
--   <tt>Extensible</tt>.
extensibleDocDependencies :: ExtensibleHasDoc x => Proxy x -> [SomeDocDefinitionItem]

-- | Implementation for <a>typeDocDependencies</a> of the corresponding
--   <tt>Extensible</tt>.
extensibleDocDependencies :: (ExtensibleHasDoc x, Generic x, GTypeHasDoc (Rep x)) => Proxy x -> [SomeDocDefinitionItem]

-- | Overall description of this type.
extensibleDocMdDescription :: ExtensibleHasDoc x => Markdown

-- | Converts a value from a Haskell representation to its extensible
--   Michelson representation (i.e. (Natural, Bytestring) pair).
toExtVal :: ExtVal a => a -> Extensible a

-- | Converts a value from an extensible Michelson representation to its
--   Haskell sum-type representation. Fails if the Michelson representation
--   points to a nun-existent constructor, or if we failed to unpack the
--   argument.
fromExtVal :: ExtVal a => Extensible a -> Either ExtConversionError a

-- | Wraps an argument on top of the stack into an Extensible
--   representation
wrapExt :: forall t (n :: Nat) name field s. WrapExtC t n name field s => Label ("c" `AppendSymbol` name) -> AppendCtorField field s :-> (Extensible t : s)
type WrapExtC t n name field s = ('Ctor n name field ~ LookupCtor name (EnumerateCtors (GetCtors t)), WrapExt field, KnownNat n)
instance forall k (x :: k). Lorentz.Wrappable.Unwrappable (Lorentz.Extensible.Extensible x)
instance forall k (x :: k). Lorentz.Annotation.HasAnnotation (Lorentz.Extensible.Extensible x)
instance forall k (x :: k). Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Extensible.Extensible x)
instance forall k (x :: k). GHC.Show.Show (Lorentz.Extensible.Extensible x)
instance forall k (x :: k). GHC.Classes.Eq (Lorentz.Extensible.Extensible x)
instance forall k (x :: k). GHC.Generics.Generic (Lorentz.Extensible.Extensible x)
instance GHC.Show.Show Lorentz.Extensible.ExtConversionError
instance GHC.Classes.Eq Lorentz.Extensible.ExtConversionError
instance (GHC.TypeNats.KnownNat pos, GHC.TypeLits.KnownSymbol name, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc param, param GHC.Types.~ Morley.Michelson.Typed.Haskell.Instr.Sum.ExtractCtorField field) => Lorentz.Extensible.DocumentCtor ('Lorentz.Extensible.Ctor pos name field)
instance (Lorentz.Extensible.ExtensibleHasDoc x, Morley.Util.Type.ReifyList Lorentz.Extensible.DocumentCtor (Lorentz.Extensible.EnumerateCtors (Lorentz.Extensible.GetCtors x))) => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Extensible.Extensible x)
instance forall k (t :: k) (x :: * -> *) (i :: GHC.Generics.Meta). Lorentz.Extensible.GExtVal t x => Lorentz.Extensible.GExtVal t (GHC.Generics.D1 i x)
instance ('Lorentz.Extensible.Ctor n name 'Morley.Michelson.Typed.Haskell.Instr.Sum.NoFields GHC.Types.~ Lorentz.Extensible.LookupCtor name (Lorentz.Extensible.EnumerateCtors (Lorentz.Extensible.GetCtors t)), GHC.TypeNats.KnownNat n) => Lorentz.Extensible.GExtVal t (GHC.Generics.C1 ('GHC.Generics.MetaCons name _1 _2) GHC.Generics.U1)
instance (Lorentz.Constraints.Scopes.NiceFullPackedValue param, 'Lorentz.Extensible.Ctor n name ('Morley.Michelson.Typed.Haskell.Instr.Sum.OneField param) GHC.Types.~ Lorentz.Extensible.LookupCtor name (Lorentz.Extensible.EnumerateCtors (Lorentz.Extensible.GetCtors t)), GHC.TypeNats.KnownNat n) => Lorentz.Extensible.GExtVal t (GHC.Generics.C1 ('GHC.Generics.MetaCons name _1 _2) (GHC.Generics.S1 _3 (GHC.Generics.Rec0 param)))
instance forall k (t :: k) (x :: * -> *) (y :: * -> *). (Lorentz.Extensible.GExtVal t x, Lorentz.Extensible.GExtVal t y) => Lorentz.Extensible.GExtVal t (x GHC.Generics.:+: y)
instance Formatting.Buildable.Buildable Lorentz.Extensible.ExtConversionError
instance Lorentz.Constraints.Scopes.NicePackedValue param => Lorentz.Extensible.WrapExt ('Morley.Michelson.Typed.Haskell.Instr.Sum.OneField param)
instance Lorentz.Extensible.WrapExt 'Morley.Michelson.Typed.Haskell.Instr.Sum.NoFields

module Lorentz.ADT

-- | Allows field access and modification.
type HasField dt fname = (InstrGetFieldC dt fname, InstrSetFieldC dt fname)

-- | Like <a>HasField</a>, but allows constrainting field type.
type HasFieldOfType dt fname fieldTy = (HasField dt fname, GetFieldType dt fname ~ fieldTy)

-- | Shortcut for multiple <a>HasFieldOfType</a> constraints.
type family HasFieldsOfType (dt :: Type) (fs :: [NamedField]) :: Constraint

-- | A pair of field name and type.
data NamedField
NamedField :: Symbol -> Type -> NamedField
type n := ty = 'NamedField n ty
infixr 0 :=

-- | Extract a field of a datatype replacing the value of this datatype
--   with the extracted field.
--   
--   For this and the following functions you have to specify field name
--   which is either record name or name attached with <tt>(:!)</tt>
--   operator.
toField :: forall dt name st. InstrGetFieldC dt name => Label name -> (dt : st) :-> (GetFieldType dt name : st)

-- | Like <a>toField</a>, but leaves field named.
toFieldNamed :: forall dt name st. InstrGetFieldC dt name => Label name -> (dt : st) :-> ((name :! GetFieldType dt name) : st)

-- | Extract a field of a datatype, leaving the original datatype on stack.
--   
--   TODO: [#585] Make this and all depending functions require only
--   <tt>Dupable (GetFieldType dt name)</tt>
getField :: forall dt name st. (InstrGetFieldC dt name, Dupable dt) => Label name -> (dt : st) :-> (GetFieldType dt name : (dt : st))

-- | Like <a>getField</a>, but leaves field named.
getFieldNamed :: forall dt name st. (InstrGetFieldC dt name, Dupable dt) => Label name -> (dt : st) :-> ((name :! GetFieldType dt name) : (dt : st))

-- | Set a field of a datatype.
setField :: forall dt name st. InstrSetFieldC dt name => Label name -> (GetFieldType dt name : (dt : st)) :-> (dt : st)

-- | Apply given modifier to a datatype field.
modifyField :: forall dt name st. (InstrGetFieldC dt name, InstrSetFieldC dt name, Dupable dt) => Label name -> (forall st0. (GetFieldType dt name : st0) :-> (GetFieldType dt name : st0)) -> (dt : st) :-> (dt : st)

-- | Make up a datatype. You provide a pack of individual fields
--   constructors.
--   
--   Each element of the accepted record should be an instruction wrapped
--   with <a>fieldCtor</a> function. This instruction will have access to
--   the stack at the moment of calling <tt>construct</tt>. Instructions
--   have to output fields of the built datatype, one per instruction;
--   instructions order is expected to correspond to the order of fields in
--   the datatype.
construct :: forall dt st. (InstrConstructC dt, RMap (ConstructorFieldTypes dt)) => Rec (FieldConstructor st) (ConstructorFieldTypes dt) -> st :-> (dt : st)

-- | Version of <a>construct</a> which accepts tuple of field constructors.
constructT :: forall dt fctors st. (InstrConstructC dt, RMap (ConstructorFieldTypes dt), fctors ~ Rec (FieldConstructor st) (ConstructorFieldTypes dt), RecFromTuple fctors) => IsoRecTuple fctors -> st :-> (dt : st)

-- | Construct an object from fields on the stack.
constructStack :: forall dt fields st. (InstrConstructC dt, fields ~ ConstructorFieldTypes dt, KnownList fields) => (fields ++ st) :-> (dt : st)

-- | Decompose a complex object into its fields
deconstruct :: forall dt fields st. (InstrDeconstructC dt, KnownList fields, fields ~ ConstructorFieldTypes dt) => (dt : st) :-> (fields ++ st)

-- | Lift an instruction to field constructor.
fieldCtor :: HasCallStack => (st :-> (f : st)) -> FieldConstructor st f

-- | Wrap entry in constructor. Useful for sum types.
wrap_ :: forall dt name st. InstrWrapC dt name => Label name -> AppendCtorField (GetCtorField dt name) st :-> (dt : st)

-- | Wrap entry in single-field constructor. Useful for sum types.
wrapOne :: forall dt name st. InstrWrapOneC dt name => Label name -> (CtorOnlyField name dt : st) :-> (dt : st)

-- | Pattern match on the given sum type.
--   
--   You have to provide a <a>Rec</a> containing case branches. To
--   construct a case branch use <a>/-&gt;</a> operator.
case_ :: forall dt out inp. (InstrCaseC dt, RMap (CaseClauses dt)) => Rec (CaseClauseL inp out) (CaseClauses dt) -> (dt : inp) :-> out

-- | Like <a>case_</a>, accepts a tuple of clauses, which may be more
--   convenient.
--   
--   If user is experiencing problems with wierd errors about tuples while
--   using this function, he should take look at
--   <a>Morley.Util.TypeTuple.Instances</a> and ensure that his tuple isn't
--   bigger than generated instances, if so, he should probably extend
--   number of generated instances.
caseT :: forall dt out inp clauses. CaseTC dt out inp clauses => IsoRecTuple clauses -> (dt : inp) :-> out

-- | Unwrap a constructor with the given name. Useful for sum types.
unsafeUnwrap_ :: forall dt name st. InstrUnwrapC dt name => Label name -> (dt : st) :-> (CtorOnlyField name dt : st)
type CaseTC dt out inp clauses = (InstrCaseC dt, RMap (CaseClauses dt), RecFromTuple clauses, clauses ~ Rec (CaseClauseL inp out) (CaseClauses dt))

-- | Provides "case" arrow which works on different wrappers for clauses.
class CaseArrow name body clause | clause -> name, clause -> body

-- | Lift an instruction to case clause.
--   
--   You should write out constructor name corresponding to the clause
--   explicitly. Prefix constructor name with "c" letter, otherwise your
--   label will not be recognized by Haskell parser. Passing constructor
--   name can be circumvented but doing so is not recomended as mentioning
--   contructor name improves readability and allows avoiding some
--   mistakes.
(/->) :: CaseArrow name body clause => Label name -> body -> clause
infixr 0 /->

-- | Lorentz analogy of <a>CaseClause</a>, it works on plain <a>Type</a>
--   types.
data CaseClauseL (inp :: [Type]) (out :: [Type]) (param :: CaseClauseParam)
[CaseClauseL] :: (AppendCtorField x inp :-> out) -> CaseClauseL inp out ('CaseClauseParam ctor x)
type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct Rep dt)
type ConstructorFieldTypes dt = GFieldTypes Rep dt

-- | A record is parameterized by a universe <tt>u</tt>, an interpretation
--   <tt>f</tt> and a list of rows <tt>rs</tt>. The labels or indices of
--   the record are given by inhabitants of the kind <tt>u</tt>; the type
--   of values at any label <tt>r :: u</tt> is given by its interpretation
--   <tt>f r :: *</tt>.
data Rec (a :: u -> Type) (b :: [u])
[RNil] :: forall u (a :: u -> Type). Rec a ('[] :: [u])
[:&] :: forall u (a :: u -> Type) (r :: u) (rs :: [u]). !a r -> !Rec a rs -> Rec a (r : rs)
infixr 7 :&

-- | Infix notation for the type of a named parameter.
type (name :: Symbol) :! a = NamedF Identity a name

-- | Infix notation for the type of an optional named parameter.
type (name :: Symbol) :? a = NamedF Maybe a name
instance (name GHC.Types.~ GHC.TypeLits.AppendSymbol "c" ctor, body GHC.Types.~ (Morley.Michelson.Typed.Haskell.Instr.Sum.AppendCtorField x inp Lorentz.Base.:-> out)) => Lorentz.ADT.CaseArrow name body (Lorentz.ADT.CaseClauseL inp out ('Morley.Michelson.Typed.Haskell.Instr.Sum.CaseClauseParam ctor x))


-- | Referenced-by-name versions of some instructions.
--   
--   They allow to "dig" into stack or copy elements of stack referring
--   them by label.
module Lorentz.ReferencedByName

-- | Indicates that stack <tt>s</tt> contains a <tt>name :! var</tt> or
--   <tt>name :? var</tt> value.
class HasNamedVar (s :: [Type]) (name :: Symbol) (var :: Type) | s name -> var

-- | Version of <a>HasNamedVar</a> for multiple variables.
--   
--   <pre>
--   type HasContext = HasNamedVars s ["x" := Integer, "f" := Lambda MText MText]
--   </pre>
type family HasNamedVars (s :: [Type]) (vs :: [NamedField]) :: Constraint
type n := ty = 'NamedField n ty
infixr 0 :=

-- | Take the element with given label on stack and copy it on top.
--   
--   If there are multiple variables with given label, the one closest to
--   the top of the stack is picked.
dupL :: forall var name s. (HasNamedVar s name var, Dupable var) => Label name -> s :-> (var : s)

-- | Version of <a>dupL</a> that leaves a named variable on stack.
dupLNamed :: forall var name s. (HasNamedVar s name var, Dupable var) => Label name -> s :-> ((name :! var) : s)

-- | Requires type <tt>x</tt> to be an unnamed variable.
--   
--   When e.g. <a>dupL</a> sees a polymorphic variable, it can't judge
--   whether is it a variable we are seeking for or not;
--   <tt>VarIsUnnamed</tt> helps to assure the type system that given
--   variable won't be named.
type VarIsUnnamed x = VarName x ~ 'VarUnnamed
instance Lorentz.ReferencedByName.ElemHasNamedVar (ty : s) name var (Lorentz.ReferencedByName.VarNamePretty ty Data.Type.Equality.== 'Lorentz.ReferencedByName.VarNamed name) => Lorentz.ReferencedByName.HasNamedVar (ty : s) name var
instance (ty GHC.Types.~ Named.Internal.NamedF f var name) => Lorentz.ReferencedByName.ElemHasNamedVar (ty : s) name var 'GHC.Types.True
instance Lorentz.ReferencedByName.HasNamedVar s name var => Lorentz.ReferencedByName.ElemHasNamedVar (ty : s) name var 'GHC.Types.False
instance ((TypeError ...), var GHC.Types.~ Lorentz.ReferencedByName.NamedVariableNotFound name) => Lorentz.ReferencedByName.HasNamedVar '[] name var


-- | Common Michelson macros defined using Lorentz syntax.
module Lorentz.Macro

-- | Constraint applied to any type, to check if Michelson representation
--   (if exists) of this type is Comparable. In case it is not prints
--   human-readable error message
type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n))
eq :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
neq :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
lt :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
gt :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
le :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
ge :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
ifEq0 :: IfCmp0Constraints a Eq' => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifGe0 :: IfCmp0Constraints a Ge => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifGt0 :: IfCmp0Constraints a Gt => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifLe0 :: IfCmp0Constraints a Le => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifLt0 :: IfCmp0Constraints a Lt => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifNeq0 :: IfCmp0Constraints a Neq => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifEq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifGe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifGt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifLe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifLt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifNeq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'

-- | Analog of the FAIL macro in Michelson. Its usage is discouraged
--   because it doesn't carry any information about failure.

-- | <i>Warning: <a>fail_</a> remains in code</i>
fail_ :: a :-> c
assert :: IsError err => err -> (Bool : s) :-> s
assertEq0 :: (IfCmp0Constraints a Eq', IsError err) => err -> (a : s) :-> s
assertNeq0 :: (IfCmp0Constraints a Neq, IsError err) => err -> (a : s) :-> s
assertLt0 :: (IfCmp0Constraints a Lt, IsError err) => err -> (a : s) :-> s
assertGt0 :: (IfCmp0Constraints a Gt, IsError err) => err -> (a : s) :-> s
assertLe0 :: (IfCmp0Constraints a Le, IsError err) => err -> (a : s) :-> s
assertGe0 :: (IfCmp0Constraints a Ge, IsError err) => err -> (a : s) :-> s
assertEq :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertNeq :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertLt :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertGt :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertLe :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertGe :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertNone :: IsError err => err -> (Maybe a : s) :-> s
assertSome :: IsError err => err -> (Maybe a : s) :-> (a : s)
assertLeft :: IsError err => err -> (Either a b : s) :-> (a : s)
assertRight :: IsError err => err -> (Either a b : s) :-> (b : s)
assertUsing :: IsError a => a -> (Bool : s) :-> s

-- | An instruction that always fails.
type ErrInstr s = forall serr. s :-> serr

-- | Constraint for replaceN that combines kind-agnostic constraint for
--   Lorentz (Haskell) types and for our typed Michelson.
type ConstraintReplaceNLorentz (n :: Peano) (s :: [Type]) (a :: Type) (mid :: [Type]) (tail :: [Type]) = (ReplaceNConstraint' T n (ToTs s) (ToT a) (ToTs mid) (ToTs tail), ReplaceNConstraint' Type n s a mid tail)

-- | Constraint for updateN that combines kind-agnostic constraint for
--   Lorentz (Haskell) types and for our typed Michelson.
type ConstraintUpdateNLorentz (n :: Peano) (s :: [Type]) (a :: Type) (b :: Type) (mid :: [Type]) (tail :: [Type]) = (UpdateNConstraint' T n (ToTs s) (ToT a) (ToT b) (ToTs mid) (ToTs tail), UpdateNConstraint' Type n s a b mid tail)
class ReplaceN (n :: Peano) (s :: [Type]) (a :: Type) mid tail
replaceNImpl :: ReplaceN n s a mid tail => (a : s) :-> s
class UpdateN (n :: Peano) (s :: [Type]) (a :: Type) (b :: Type) mid tail
updateNImpl :: UpdateN n s a b mid tail => ('[a, b] :-> '[b]) -> (a : s) :-> s

-- | Custom Lorentz macro that drops element with given index (starting
--   from 0) from the stack.
dropX :: forall (n :: Nat) a inp out s s'. (ConstraintDIPNLorentz (ToPeano n) inp out s s', s ~ (a : s'), SingI (ToPeano n)) => inp :-> out

-- | Duplicate the top of the stack <tt>n</tt> times.
--   
--   For example, `cloneX @3` has type `a : s :-&gt; a : a : a : a : s`.
cloneX :: forall (n :: Nat) a s. CloneX (ToPeano n) a s => (a : s) :-> (a : CloneXT (ToPeano n) a s)

-- | <tt>DUU+P</tt> macro. For example, <tt>duupX </tt>3<tt> is
--   </tt>DUUUP@, it puts the 3-rd (starting from 1) element to the top of
--   the stack.
--   
--   Note that <tt>DUU+P</tt> has since been added as the <tt>DUP n</tt>
--   instruction and so this macro is defined simply as follows:
--   
--   <pre>
--   duupX = dupN @n
--   </pre>
duupX :: forall (n :: Nat) a s s'. (ConstraintDUPNLorentz (ToPeano n) s s' a, Dupable a) => s :-> (a : s)

-- | Version of <a>framed</a> which accepts number of elements on input
--   stack which should be preserved.
--   
--   You can treat this macro as calling a Michelson function with given
--   number of arguments.
framedN :: forall n nNat s i i' o o'. (nNat ~ ToPeano n, i' ~ Take nNat i, s ~ Drop nNat i, i ~ (i' ++ s), o ~ (o' ++ s), KnownList i', KnownList o') => (i' :-> o') -> i :-> o
carN :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz ((2 * n) + 1) pair => (pair : s) :-> (PairGetHs (ToPeano ((2 * n) + 1)) pair : s)
cdrN :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz (2 * n) pair => (pair : s) :-> (PairGetHs (ToPeano (2 * n)) pair : s)
caar :: (((a, b1), b2) : s) :-> (a : s)
cadr :: (((a, b1), b2) : s) :-> (b1 : s)
cdar :: ((a1, (a2, b)) : s) :-> (a2 : s)
cddr :: ((a1, (a2, b)) : s) :-> (b : s)
ifRight :: ((b : s) :-> s') -> ((a : s) :-> s') -> (Either a b : s) :-> s'
ifSome :: ((a : s) :-> s') -> (s :-> s') -> (Maybe a : s) :-> s'
when_ :: (s :-> s) -> (Bool : s) :-> s
unless_ :: (s :-> s) -> (Bool : s) :-> s
whenSome :: ((a : s) :-> s) -> (Maybe a : s) :-> s
whenNone :: (s :-> (a : s)) -> (Maybe a : s) :-> (a : s)
mapCar :: (forall s0. (a : s0) :-> (a1 : s0)) -> ((a, b) : s) :-> ((a1, b) : s)
mapCdr :: (forall s0. (b : s0) :-> (b1 : s0)) -> ((a, b) : s) :-> ((a, b1) : s)
papair :: (a : (b : (c : s))) :-> (((a, b), c) : s)
ppaiir :: (a : (b : (c : s))) :-> ((a, (b, c)) : s)
unpair :: ((a, b) : s) :-> (a : (b : s))
setCar :: ((a, b1) : (b2 : s)) :-> ((b2, b1) : s)
setCdr :: ((a, b1) : (b2 : s)) :-> ((a, b2) : s)

-- | Insert given element into set.
--   
--   This is a separate function from <a>mapUpdate</a> because stacks they
--   operate with differ in length.
setInsert :: NiceComparable e => (e : (Set e : s)) :-> (Set e : s)

-- | Insert given element into map.
mapInsert :: (MapInstrs map, NiceComparable k) => (k : (v : (map k v : s))) :-> (map k v : s)

-- | Insert given element into set, ensuring that it does not overwrite any
--   existing entry.
--   
--   As first argument accepts container name.
setInsertNew :: (NiceConstant err, NiceComparable e, Dupable e, Dupable (Set e)) => (forall s0. (e : s0) :-> (err : s0)) -> (e : (Set e : s)) :-> (Set e : s)

-- | Insert given element into map, ensuring that it does not overwrite any
--   existing entry.
--   
--   As first argument accepts container name (for error message).
mapInsertNew :: (MapInstrs map, IsoValue (map k v), NiceComparable k, NiceConstant e, Dupable k, KnownValue v) => (forall s0. (k : s0) :-> (e : s0)) -> (k : (v : (map k v : s))) :-> (map k v : s)

-- | Delete element from the map.
deleteMap :: forall k v s. (MapInstrs map, NiceComparable k, KnownValue v) => (k : (map k v : s)) :-> (map k v : s)

-- | Delete given element from the set.
setDelete :: NiceComparable e => (e : (Set e : s)) :-> (Set e : s)

-- | Replace nth element (0-indexed) with the one on the top of the stack.
--   For example, `replaceN <tt>3` replaces the 3rd element with the 0th
--   one. `replaceN </tt>0` is not a valid operation (and it is not
--   implemented). `replaceN <tt>1` is equivalent to `swap # drop` (and is
--   the only one implemented like this). In all other cases `replaceN
--   </tt>n` will drop the nth element (`dipN <tt>n drop`) and then put the
--   0th one in its place (`dug </tt>(n-1)`).
replaceN :: forall (n :: Nat) a (s :: [Type]) (s1 :: [Type]) (tail :: [Type]). (ConstraintReplaceNLorentz (ToPeano (n - 1)) s a s1 tail, ReplaceN (ToPeano n) s a s1 tail) => (a : s) :-> s

-- | Replaces the nth element (0-indexed) with the result of the given
--   "updating" instruction (binary with the return type equal to the
--   second argument) applied to the 0th element and the nth element
--   itself. For example, <tt>updateN @3 cons</tt> replaces the 3rd element
--   with the result of <tt>cons</tt> applied to the topmost element and
--   the 3rd one. <tt>updateN @0 instr</tt> is not a valid operation (and
--   it is not implemented). <tt>updateN @1 instr</tt> is equivalent to
--   <tt>instr</tt> (and so is implemented). <tt>updateN @2 instr</tt> is
--   equivalent to <tt>swap # dip instr</tt> (and so is implemented). In
--   all other cases <tt>updateN @n instr</tt> will put the topmost element
--   right above the nth one (<tt>dug @(n-1)</tt>) and then apply the
--   function to them in place (<tt>dipN @(n-1) instr</tt>).
updateN :: forall (n :: Nat) a b (s :: [Type]) (mid :: [Type]) (tail :: [Type]). (ConstraintUpdateNLorentz (ToPeano (n - 1)) s a b mid tail, UpdateN (ToPeano n) s a b mid tail) => ('[a, b] :-> '[b]) -> (a : s) :-> s

-- | <tt>view</tt> type synonym as described in A1.
data View_ (a :: Type) (r :: Type)
View_ :: a -> ContractRef r -> View_ (a :: Type) (r :: Type)
[viewParam] :: View_ (a :: Type) (r :: Type) -> a
[viewCallbackTo] :: View_ (a :: Type) (r :: Type) -> ContractRef r

-- | <tt>void</tt> type synonym as described in A1.
data Void_ (a :: Type) (b :: Type)
Void_ :: a -> Lambda b b -> Void_ (a :: Type) (b :: Type)

-- | Entry point argument.
[voidParam] :: Void_ (a :: Type) (b :: Type) -> a

-- | Type of result reported via <a>failWith</a>.
[voidResProxy] :: Void_ (a :: Type) (b :: Type) -> Lambda b b

-- | Newtype over void result type used in tests to distinguish successful
--   void result from other errors.
--   
--   Usage example: lExpectFailWith (== VoidResult roleMaster)`
--   
--   This error is special - it can contain arguments of different types
--   depending on entrypoint which raises it.
newtype VoidResult r
VoidResult :: r -> VoidResult r
[unVoidResult] :: VoidResult r -> r
view_ :: (NiceParameter r, Dupable storage) => (forall s0. (a : (storage : s0)) :-> (r : s0)) -> (View_ a r : (storage : s)) :-> ((List Operation, storage) : s)

-- | Polymorphic version of <a>View_</a> constructor.
mkView_ :: ToContractRef r contract => a -> contract -> View_ a r

-- | Wrap internal representation of view into <a>View_</a> itself.
--   
--   <a>View_</a> is part of public standard and should not change often.
wrapView_ :: ((a, ContractRef r) : s) :-> (View_ a r : s)

-- | Unwrap <a>View_</a> into its internal representation.
--   
--   <a>View_</a> is part of public standard and should not change often.
unwrapView_ :: (View_ a r : s) :-> ((a, ContractRef r) : s)
void_ :: forall a b s s' anything. (IsError (VoidResult b), NiceConstant b) => ((a : s) :-> (b : s')) -> (Void_ a b : s) :-> anything
mkVoid :: forall b a. a -> Void_ a b

-- | Wrap internal representation of void into <a>Void_</a> itself.
--   
--   <a>Void_</a> is part of public standard and should not change often.
wrapVoid :: ((a, Lambda b b) : s) :-> (Void_ a b : s)

-- | Unwrap <a>Void_</a> into its internal representation.
--   
--   <a>Void_</a> is part of public standard and should not change often.
unwrapVoid :: (Void_ a b : s) :-> ((a, Lambda b b) : s)
voidResultTag :: MText

-- | Duplicate two topmost items on top of the stack.
dupTop2 :: forall (a :: Type) (b :: Type) (s :: [Type]). (Dupable a, Dupable b) => (a : (b : s)) :-> (a : (b : (a : (b : s))))
fromOption :: NiceConstant a => a -> (Maybe a : s) :-> (a : s)
isSome :: (Maybe a : s) :-> (Bool : s)

-- | Retain the value if it is not equal to the given one.
--   
--   <pre>
--   &gt;&gt;&gt; non 0 -$ 5
--   Just 5
--   
--   &gt;&gt;&gt; non 0 -$ 0
--   Nothing
--   </pre>
non :: (NiceConstant a, NiceComparable a) => a -> (a : s) :-> (Maybe a : s)

-- | Version of <a>non</a> with a custom predicate.
--   
--   <pre>
--   &gt;&gt;&gt; non' eq0 -$ 5
--   Just 5
--   
--   &gt;&gt;&gt; non' eq0 -$ 0
--   Nothing
--   </pre>
non' :: NiceConstant a => Lambda a Bool -> (a : s) :-> (Maybe a : s)

-- | Check whether container is empty.
isEmpty :: SizeOpHs c => (c : s) :-> (Bool : s)
class NonZero t

-- | Retain the value only if it is not zero.
nonZero :: NonZero t => (t : s) :-> (Maybe t : s)
buildView_ :: (WellTypedIsoValue r, HasNoOpToT r) => (a -> Builder) -> View_ a r -> Builder
buildViewTuple_ :: (HasNoOpToT r, WellTypedIsoValue r, TupleF a) => View_ a r -> Builder
addressToEpAddress :: (Address : s) :-> (EpAddress : s)

-- | Push a value of <tt>contract</tt> type.
--   
--   Doing this via <a>push</a> instruction is not possible, so we need to
--   perform extra actions here.
--   
--   Aside from <tt>contract</tt> value itself you will need to specify
--   which error to throw in case this value is not valid.
pushContractRef :: NiceParameter arg => (forall s0. (FutureContract arg : s) :-> s0) -> ContractRef arg -> s :-> (ContractRef arg : s)
selfAddress :: s :-> (Address : s)

-- | Call a view.
--   
--   Accepts the view name via a type annotation. This internally asserts
--   the view to be present, as if the supplied <tt>TAddress</tt> argument
--   is valid, the view is guaranteed to be called successfully.
view :: forall name arg ret p vd s. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret, HasView vd name arg ret) => (arg : (TAddress p vd : s)) :-> (ret : s)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation r) => Lorentz.Annotation.HasAnnotation (Lorentz.Macro.View_ a r)
instance GHC.Generics.Generic (Lorentz.Macro.View_ a r)
instance GHC.Show.Show a => GHC.Show.Show (Lorentz.Macro.View_ a r)
instance GHC.Classes.Eq a => GHC.Classes.Eq (Lorentz.Macro.View_ a r)
instance (Lorentz.Annotation.HasAnnotation a, Lorentz.Annotation.HasAnnotation b) => Lorentz.Annotation.HasAnnotation (Lorentz.Macro.Void_ a b)
instance GHC.Show.Show a => GHC.Show.Show (Lorentz.Macro.Void_ a b)
instance GHC.Generics.Generic (Lorentz.Macro.Void_ a b)
instance GHC.Classes.Eq r => GHC.Classes.Eq (Lorentz.Macro.VoidResult r)
instance GHC.Generics.Generic (Lorentz.Macro.VoidResult r)
instance (Morley.Michelson.Typed.Haskell.Value.HasNoOpToT r, Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue r, Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue a) => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Macro.View_ a r)
instance (Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue r, Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue a) => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Macro.Void_ a r)
instance Lorentz.Macro.NonZero GHC.Integer.Type.Integer
instance Lorentz.Macro.NonZero GHC.Natural.Natural
instance Lorentz.Constraints.Scopes.NiceComparable d => Lorentz.Macro.NonZero (Morley.Michelson.Typed.Haskell.Value.Ticket d)
instance (Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc r, Lorentz.Errors.IsError (Lorentz.Macro.VoidResult r)) => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Macro.VoidResult r)
instance (Lorentz.Constraints.Scopes.NiceConstant r, Lorentz.Errors.ErrorHasDoc (Lorentz.Macro.VoidResult r)) => Lorentz.Errors.IsError (Lorentz.Macro.VoidResult r)
instance Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc r => Lorentz.Errors.ErrorHasDoc (Lorentz.Macro.VoidResult r)
instance (Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue (Lorentz.Macro.VoidResult r), (TypeError ...)) => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Macro.VoidResult r)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo r1 r2) => Lorentz.Coercions.CanCastTo (Lorentz.Macro.Void_ a1 r1) (Lorentz.Macro.Void_ a2 r2)
instance Universum.TypeOps.Each '[Data.Typeable.Internal.Typeable, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc] '[a, r] => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Macro.Void_ a r)
instance Formatting.Buildable.Buildable a => Formatting.Buildable.Buildable (Lorentz.Macro.Void_ a b)
instance (Lorentz.Coercions.CanCastTo a1 a2, Lorentz.Coercions.CanCastTo r1 r2) => Lorentz.Coercions.CanCastTo (Lorentz.Macro.View_ a1 r1) (Lorentz.Macro.View_ a2 r2)
instance Universum.TypeOps.Each '[Data.Typeable.Internal.Typeable, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc] '[a, r] => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Macro.View_ a r)
instance (Formatting.Buildable.Buildable a, Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue r, Morley.Michelson.Typed.Haskell.Value.HasNoOpToT r) => Formatting.Buildable.Buildable (Lorentz.Macro.View_ a r)
instance (Morley.Michelson.Typed.Haskell.Value.WellTypedIsoValue r, Morley.Michelson.Typed.Haskell.Value.HasNoOpToT r) => Formatting.Buildable.Buildable (Lorentz.Macro.View_ () r)
instance forall k (s :: [*]) b (tail :: [*]) a (mid :: k). (s GHC.Types.~ (b : tail)) => Lorentz.Macro.UpdateN ('Data.Vinyl.TypeLevel.S 'Data.Vinyl.TypeLevel.Z) s a b mid tail
instance forall k (s :: [*]) x b (tail :: [*]) a (mid :: k). (s GHC.Types.~ (x : b : tail)) => Lorentz.Macro.UpdateN ('Data.Vinyl.TypeLevel.S ('Data.Vinyl.TypeLevel.S 'Data.Vinyl.TypeLevel.Z)) s a b mid tail
instance (Lorentz.Macro.ConstraintUpdateNLorentz ('Data.Vinyl.TypeLevel.S ('Data.Vinyl.TypeLevel.S n)) s a b mid tail, Data.Singletons.Internal.SingI n) => Lorentz.Macro.UpdateN ('Data.Vinyl.TypeLevel.S ('Data.Vinyl.TypeLevel.S ('Data.Vinyl.TypeLevel.S n))) s a b mid tail
instance forall k1 k2 (s :: [*]) a (xs :: [*]) (mid :: k1) (tail :: k2). (s GHC.Types.~ (a : xs)) => Lorentz.Macro.ReplaceN ('Data.Vinyl.TypeLevel.S 'Data.Vinyl.TypeLevel.Z) s a mid tail
instance (Lorentz.Macro.ConstraintReplaceNLorentz ('Data.Vinyl.TypeLevel.S n) s a mid tail, Data.Singletons.Internal.SingI n) => Lorentz.Macro.ReplaceN ('Data.Vinyl.TypeLevel.S ('Data.Vinyl.TypeLevel.S n)) s a mid tail
instance Lorentz.Macro.MapInstrs Data.Map.Internal.Map
instance Lorentz.Macro.MapInstrs Morley.Michelson.Typed.Haskell.Value.BigMap
instance Lorentz.Macro.CloneX 'Data.Vinyl.TypeLevel.Z a s
instance (Lorentz.Macro.CloneX n a s, Lorentz.Constraints.Scopes.Dupable a) => Lorentz.Macro.CloneX ('Data.Vinyl.TypeLevel.S n) a s
instance Lorentz.Errors.CustomErrorHasDoc "no_view"


-- | Reimplementation of some syntax sugar.
--   
--   You need the following module pragmas to make it work smoothly:
module Lorentz.Rebinded

-- | Aliases for <a>(#)</a> used by do-blocks.
(>>) :: (a :-> b) -> (b :-> c) -> a :-> c

-- | Lift a value.
pure :: Applicative f => a -> f a

-- | Inject a value into the monadic type.
return :: Monad m => a -> m a

-- | Everything that can be put after <tt>if</tt> keyword.
--   
--   The first type argument stands for the condition type, and all other
--   type arguments define stack types around/within the <tt>if then
--   else</tt> construction. For semantics of each type argument see
--   <a>Condition</a>.
class IsCondition cond arg argl argr outb out

-- | Defines semantics of <tt>if ... then ... else ...</tt> construction.
ifThenElse :: IsCondition cond arg argl argr outb out => cond -> (argl :-> outb) -> (argr :-> outb) -> arg :-> out

-- | The most basic predicate for <tt>if ... then .. else ...</tt>
--   construction, defines a kind of operation applied to the top elements
--   of the current stack.
--   
--   Type arguments mean: 1. Input of <tt>if</tt> 2. Left branch input 3.
--   Right branch input 4. Output of branches 5. Output of <tt>if</tt>
data Condition arg argl argr outb out
[Holds] :: Condition (Bool : s) s s o o
[IsSome] :: Condition (Maybe a : s) (a : s) s o o
[IsNone] :: Condition (Maybe a : s) s (a : s) o o
[IsLeft] :: Condition (Either l r : s) (l : s) (r : s) o o
[IsRight] :: Condition (Either l r : s) (r : s) (l : s) o o
[IsCons] :: Condition ([a] : s) (a : ([a] : s)) s o o
[IsNil] :: Condition ([a] : s) s (a : ([a] : s)) o o
[Not] :: Condition s s1 s2 ob o -> Condition s s2 s1 ob o
[IsZero] :: (UnaryArithOpHs Eq' a, UnaryArithResHs Eq' a ~ Bool) => Condition (a : s) s s o o

-- | <i>Deprecated: Use `Not IsZero` instead</i>
[IsNotZero] :: (UnaryArithOpHs Eq' a, UnaryArithResHs Eq' a ~ Bool) => Condition (a : s) s s o o
[IsEq] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsNeq] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsLt] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsGt] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsLe] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsGe] :: NiceComparable a => Condition (a : (a : s)) s s o o

-- | Explicitly named binary condition, to ensure proper order of stack
--   arguments.
[NamedBinCondition] :: Condition (a : (a : s)) s s o o -> Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o

-- | Provide the compared arguments to <tt>if</tt> branches.
[PreserveArgsBinCondition] :: (Dupable a, Dupable b) => (forall st o. Condition (a : (b : st)) st st o o) -> Condition (a : (b : s)) (a : (b : s)) (a : (b : s)) (a : (b : s)) s

-- | Named version of <a>IsLt</a>.
--   
--   In this and similar operators you provide names of accepted stack
--   operands as a safety measure of that they go in the expected order.
(<.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 <.

-- | Named version of <a>IsGt</a>.
(>.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 >.

-- | Named version of <a>IsLe</a>.
(<=.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 <=.

-- | Named version of <a>IsGe</a>.
(>=.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 >=.

-- | Named version of <a>IsEq</a>.
(==.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 ==.

-- | Named version of <a>IsNeq</a>.
(/=.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 /=.

-- | Condition modifier, makes stack operands of binary comparison to be
--   available within <tt>if</tt> branches.
keepIfArgs :: (Dupable a, Dupable b) => (forall st o. Condition (a : (b : st)) st st o o) -> Condition (a : (b : s)) (a : (b : s)) (a : (b : s)) (a : (b : s)) s
fromInteger :: (HasCallStack, Integral a) => Integer -> a
fromString :: IsString a => String -> a
fromLabel :: IsLabel x a => a

-- | Unary negation.
negate :: Num a => a -> a
instance (arg GHC.Types.~ arg0, argl GHC.Types.~ argl0, argr GHC.Types.~ argr0, outb GHC.Types.~ outb0, out GHC.Types.~ out0) => Lorentz.Rebinded.IsCondition (Lorentz.Rebinded.Condition arg argl argr outb out) arg0 argl0 argr0 outb0 out0

module Lorentz.FixedArith

-- | Operation that represents division of two values with a given result
div :: forall r n m s. ArithOpHs Div n m r => (n : (m : s)) :-> (r : s)
castNFixedToFixed :: (NFixed p : s) :-> (Fixed p : s)
castFixedToNFixed :: (Fixed p : s) :-> (Maybe (NFixed p) : s)

-- | Class that enables support of rounding operations for Lorentz
--   non-integer values Note: Round is implemented using "banker's
--   rounding" strategy, rounding half-way values towards nearest even
--   value
class LorentzRounding a b
round_ :: LorentzRounding a b => (a : s) :-> (b : s)
ceil_ :: LorentzRounding a b => (a : s) :-> (b : s)
floor_ :: LorentzRounding a b => (a : s) :-> (b : s)

-- | Class that allows casting <tt>Fixed</tt> values to Integer in vice
--   versa
class LorentzFixedCast a
fromFixed :: LorentzFixedCast a => (a : s) :-> (Integer : s)
toFixed :: LorentzFixedCast a => (Integer : s) :-> (a : s)
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) => Lorentz.FixedArith.LorentzRounding (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) (Data.Fixed.Fixed (Lorentz.Value.DecBase b))
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) => Lorentz.FixedArith.LorentzRounding (Data.Fixed.Fixed (Lorentz.Value.BinBase a)) (Data.Fixed.Fixed (Lorentz.Value.BinBase b))
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b, GHC.TypeNats.KnownNat r) => Lorentz.Arith.ArithOpHs Lorentz.FixedArith.Div (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) (Data.Fixed.Fixed (Lorentz.Value.DecBase b)) (GHC.Maybe.Maybe (Data.Fixed.Fixed (Lorentz.Value.DecBase r)))
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b, GHC.TypeNats.KnownNat r) => Lorentz.Arith.ArithOpHs Lorentz.FixedArith.Div (Data.Fixed.Fixed (Lorentz.Value.BinBase a)) (Data.Fixed.Fixed (Lorentz.Value.BinBase b)) (GHC.Maybe.Maybe (Data.Fixed.Fixed (Lorentz.Value.BinBase r)))
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b, GHC.TypeNats.KnownNat r) => Lorentz.Arith.ArithOpHs Lorentz.FixedArith.Div (Lorentz.Value.NFixed (Lorentz.Value.DecBase a)) (Lorentz.Value.NFixed (Lorentz.Value.DecBase b)) (GHC.Maybe.Maybe (Lorentz.Value.NFixed (Lorentz.Value.DecBase r)))
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b, GHC.TypeNats.KnownNat r) => Lorentz.Arith.ArithOpHs Lorentz.FixedArith.Div (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) (Lorentz.Value.NFixed (Lorentz.Value.BinBase b)) (GHC.Maybe.Maybe (Lorentz.Value.NFixed (Lorentz.Value.BinBase r)))
instance GHC.TypeNats.KnownNat a => Lorentz.FixedArith.LorentzFixedCast (Data.Fixed.Fixed (Lorentz.Value.DecBase a))
instance GHC.TypeNats.KnownNat a => Lorentz.FixedArith.LorentzFixedCast (Data.Fixed.Fixed (Lorentz.Value.BinBase a))
instance forall k (a :: k). Lorentz.FixedArith.LorentzFixedCast (Data.Fixed.Fixed a) => Lorentz.FixedArith.LorentzFixedCast (Lorentz.Value.NFixed a)
instance Lorentz.FixedArith.LorentzRounding (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) (Data.Fixed.Fixed (Lorentz.Value.DecBase b)) => Lorentz.FixedArith.LorentzRounding (Lorentz.Value.NFixed (Lorentz.Value.DecBase a)) (Lorentz.Value.NFixed (Lorentz.Value.DecBase b))
instance (GHC.TypeNats.KnownNat a, GHC.TypeNats.KnownNat b) => Lorentz.FixedArith.LorentzRounding (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) (Lorentz.Value.NFixed (Lorentz.Value.BinBase b))
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, Lorentz.Value.NFixed (Lorentz.Value.DecBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, Lorentz.Value.NFixed (Lorentz.Value.DecBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Data.Fixed.Fixed (Lorentz.Value.DecBase a)) GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, Lorentz.Value.NFixed (Lorentz.Value.BinBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Data.Fixed.Fixed (Lorentz.Value.BinBase a)) GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, Lorentz.Value.NFixed (Lorentz.Value.BinBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Data.Fixed.Fixed (Lorentz.Value.BinBase a)) GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, Lorentz.Value.NFixed (Lorentz.Value.DecBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Lorentz.Value.NFixed (Lorentz.Value.DecBase a)) GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Natural.Natural, Lorentz.Value.NFixed (Lorentz.Value.DecBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Lorentz.Value.NFixed (Lorentz.Value.DecBase a)) GHC.Natural.Natural r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Integer.Type.Integer, Lorentz.Value.NFixed (Lorentz.Value.BinBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) GHC.Integer.Type.Integer r
instance (r GHC.Types.~ GHC.Maybe.Maybe (GHC.Natural.Natural, Lorentz.Value.NFixed (Lorentz.Value.BinBase a)), GHC.TypeNats.KnownNat a) => Lorentz.Arith.ArithOpHs Morley.Michelson.Typed.Arith.EDiv (Lorentz.Value.NFixed (Lorentz.Value.BinBase a)) GHC.Natural.Natural r


-- | Evaluation of expressions.
--   
--   Stack-based languages allow convenient expressions evaluation, for
--   that we just need binary instructions in infix notation, not in Polish
--   postfix notation that <a>add</a> and other primitives provide.
--   Compare:
--   
--   <pre>
--   push 1; push 2; push 3; push 4; mul; rsub; add
--   </pre>
--   
--   vs
--   
--   <pre>
--   push 1 |+| push 2 |-| push 3 |*| push 4
--   </pre>
--   
--   In these expressions each atom is some instruction providing a single
--   value on top of the stack, for example:
--   
--   <pre>
--   nthOdd :: Lambda Natural Natural
--   nthOdd = take |*| push <tt>Natural 2 |+| push </tt>Natural 1
--   </pre>
--   
--   For binary operations we provide the respective operators. Unary
--   operations can be lifted with <a>unaryExpr</a>:
--   
--   <pre>
--   implication :: [Bool, Bool] :-&gt; '[Bool]
--   implication = unaryExpr not take |.|.| take
--   </pre>
--   
--   or with its alias in form of an operator:
--   
--   <pre>
--   implication :: [Bool, Bool] :-&gt; '[Bool]
--   implication = not $: take |.|.| take
--   </pre>
--   
--   Stack changes are propagated from left to right. If an atom consumes
--   an element at the top of the stack, the next atom will accept only the
--   remainder of the stack.
--   
--   In most cases you should prefer providing named variables to the
--   formulas in order to avoid messing up with the arguments:
--   
--   <pre>
--   f :: ("a" :! Natural) : ("b" :! Natural) : ("c" :! Natural) : s :-&gt; Integer : s
--   f = fromNamed #a |+| fromNamed #b |-| fromNamed #c
--   </pre>
--   
--   Instead of putting all the elements on the stack upon applying the
--   formula, you may find it more convenient to evaluate most of the
--   arguments right within the formula:
--   
--   <pre>
--   withinRange
--     :: Natural : a : b : c : ("config" :! Config) : s
--     :-&gt; Bool : a : b : c : ("config" :! Config) : s
--   withinRange =
--     dup  |&gt;=| do{ dupL #config; toField #minBound } |&amp;|
--     take |&lt;=| do{ dupL #config; toField #maxBound }
--   </pre>
module Lorentz.Expr

-- | Expression is just an instruction accepting stack <tt>inp</tt> and
--   producing stack <tt>out</tt> with evaluation result <tt>res</tt> at
--   the top.
type Expr inp out res = inp :-> res : out

-- | Consume an element at the top of stack. This is just an alias for
--   <tt>nop</tt>.
take :: Expr (a : s) s a

-- | Lift an instruction to an unary operation on expressions.
unaryExpr :: (forall s. (a : s) :-> (r : s)) -> Expr s0 s1 a -> Expr s0 s1 r

-- | An alias for <a>unaryExpr</a>.
($:) :: (forall s. (a : s) :-> (r : s)) -> Expr s0 s1 a -> Expr s0 s1 r
infixr 9 $:

-- | Lift an instruction to a binary operation on expressions.
binaryExpr :: (forall s. (a : (b : s)) :-> (r : s)) -> Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r

-- | Expressions addition.
(|+|) :: ArithOpHs Add a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 6 |+|

-- | Expressions subtraction.
(|-|) :: ArithOpHs Sub a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 6 |-|

-- | Expressions multiplication.
(|*|) :: ArithOpHs Mul a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 7 |*|

-- | Expressions comparison.
(|==|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |==|

-- | Expressions comparison.
(|/=|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |/=|

-- | Expressions comparison.
(|<|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |<|

-- | Expressions comparison.
(|>|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |>|

-- | Expressions comparison.
(|<=|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |<=|

-- | Expressions comparison.
(|>=|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |>=|

-- | Bitwise/logical <tt>AND</tt> on expressions.
(|&|) :: ArithOpHs And a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 2 |&|

-- | Bitwise/logical <tt>OR</tt> on expressions.
--   
--   In case you find this operator looking weird, see <a>|.|.|</a>
(|||) :: ArithOpHs Or a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 1 |||

-- | An alias for <a>|||</a>.
(|.|.|) :: ArithOpHs Or a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 1 |.|.|

-- | Bitwise/logical <tt>XOR</tt> on expressions.
(|^|) :: ArithOpHs Xor a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 3 |^|

-- | Left shift on expressions.
(|<<|) :: ArithOpHs Lsl a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infix 8 |<<|

-- | Right shift on expressions.
(|>>|) :: ArithOpHs Lsr a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infix 8 |>>|

-- | <a>cons</a> on expressions.
--   
--   <pre>
--   one :: a : s :-&gt; [a] : s
--   one = take |:| nil
--   </pre>
(|:|) :: Expr s0 s1 a -> Expr s1 s2 [a] -> Expr s0 s2 [a]
infixr 1 |:|

-- | An alias for <a>|@|</a>.
--   
--   <pre>
--   trivialContract :: ((), storage) :-&gt; ([Operation], Storage)
--   trivialContract =
--     pairE
--       ( nil
--       , cdr
--       )
--   </pre>
pairE :: (Expr s0 s1 a, Expr s1 s2 b) -> Expr s0 s2 (a, b)

-- | Construct a simple pair.
--   
--   <pre>
--   trivialContract :: ((), storage) :-&gt; ([Operation], Storage)
--   trivialContract = nil |@| cdr
--   </pre>
--   
--   This is useful as pair appears even in simple contracts. For more
--   advanced types, use <a>constructT</a>.
(|@|) :: Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 (a, b)
infixr 0 |@|

-- | Construct a list given the constructor for each element.
listE :: KnownValue a => [Expr s s a] -> Expr s s [a]

-- | Version of <a>transferTokens</a> instruction that accepts all the
--   arguments as expressions.
--   
--   <pre>
--   transferTokensE
--     ! #arg L.unit
--     ! #amount (push zeroMutez)
--     ! #contract take
--     |:| nil
--   </pre>
--   
--   You can provide arguments in arbitrary order, but direction of stack
--   changes flow is fixed: stack change in <tt>arg</tt> expression affects
--   stack available in <tt>amount</tt> expression, and stack changes in
--   <tt>amount</tt> expression affect stack changes in <tt>contract</tt>
--   expression.
transferTokensE :: NiceParameter p => ("arg" :! Expr s0 s1 p) -> ("amount" :! Expr s1 s2 Mutez) -> ("contract" :! Expr s2 s3 (ContractRef p)) -> Expr s0 s3 Operation

-- | Version of <a>createContract</a> instruction that accepts all the
--   arguments as expressions.
--   
--   <pre>
--   createContractE
--     ! #delegate none
--     ! #balance (push zeroMutez)
--     ! #storage unit
--     ! #contract myContract
--   </pre>
--   
--   Note that this returns an operation, and pushes the address of the
--   newly created contract as a side-effect.
createContractE :: ("delegate" :! Expr s0 s1 (Maybe KeyHash)) -> ("balance" :! Expr s1 s2 Mutez) -> ("storage" :! Expr s2 s3 st) -> ("contract" :! Contract p st vd) -> Expr s0 (TAddress p vd : s3) Operation

-- | Version of <a>view</a> instruction that accepts all the arguments as
--   expressions.
--   
--   <pre>
--   viewE @"myview"
--     ! #arg (push zeroMutez)
--     ! #address (push addr)
--   </pre>
viewE :: forall name arg ret p vd s0 s1 s2. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret, HasView vd name arg ret) => ("arg" :! Expr s0 s1 arg) -> ("address" :! Expr s1 s2 (TAddress p vd)) -> Expr s0 s2 ret
instance (i GHC.Types.~ arg, o GHC.Types.~ argl, o GHC.Types.~ argr, r GHC.Types.~ GHC.Types.Bool, outb GHC.Types.~ out) => Lorentz.Rebinded.IsCondition (Lorentz.Expr.Expr i o r) arg argl argr outb out


-- | Extended support for the tickets feature.
--   
--   This module has to be imported explicitly, it is not re-exported by
--   <a>Lorentz</a>.
--   
--   The primary use case for tickets: authorization tokens for specific
--   actions. For instance, in <tt>Pause</tt> entrypoint a contract may
--   accept a ticket, checking that it is emitted from the administrator
--   address. The mechanism of tickets is more flexible than <a>sender</a>
--   and <a>source</a> instructions:
--   
--   <ul>
--   <li>a ticket can be carried through an arbitrary chain of intermediate
--   agents;</li>
--   <li>it can permit a limited number of certain actions;</li>
--   <li>tickets may have a restricted set of authorized actions.</li>
--   </ul>
--   
--   More details below.
--   
--   The amount of tokens in a ticket may stand for a number of allowed
--   actions invocations, in this case accepted tickets are checked to
--   contain just <tt>1</tt> token. This semantics makes sense, taking
--   <tt>SPLIT_TICKET</tt> and <tt>JOIN_TICKETS</tt> instructions into
--   account, and also the fact that tickets are not dupable.
--   
--   One important precaution to be kept in mind is that an emitted ticket
--   must permit exactly one kind of action in exactly one contract. This
--   way the ticket emitter can be sure that his ticket cannot be used in
--   an unexpected way. We see two main approaches to this:
--   
--   <ul>
--   <li>Make the data carried by the ticket identify the target contract
--   and the action that is being permitted. The contract has to verify the
--   data in the ticket.</li>
--   <li>Make tickets carry as little data as possible, and instead let the
--   main authorized entity keep a single tickets emitting contract per
--   target contract per action (the latter is optional). This way, the
--   burden of separating tickets' area of applicability lies on that main
--   authorized entity instead of the target contract, but actions become
--   cheaper.</li>
--   </ul>
--   
--   Some examples of use cases:
--   
--   <ul>
--   <li>An administrator may emit a ticket that permits some delegate to
--   pause the contract. In this case, the ticket should carry a
--   description of the pausing capability (string or enum value) and
--   permission's expiry time.</li>
--   </ul>
--   
--   It is also easy to share admin privileges among other participants by
--   providing them with a ticket with a very large tokens amount. The
--   target contract does not even need to know about many administrators
--   being involved.
--   
--   <ul>
--   <li>A user may wish to delegate some actions to an intermediate
--   service. In this case, tickets can serve as signatures made on behalf
--   of the user's contract, with replay protection provided
--   out-of-the-box.</li>
--   </ul>
--   
--   Note that at the moment of writing, implicit addresses cannot serve as
--   ticket emitters.
--   
--   <ul>
--   <li>The allowances mechanism known by FA1.2/FA2 may be replaced with
--   tickets. In this case, the tokens amount in a ticket will correspond
--   to the amount of tokens that can be spent by an operator.</li>
--   </ul>
--   
--   This module provides helpers to cover the mentioned cases.
module Lorentz.Tickets

-- | Verifies the given ticket value that permits running an action.
--   
--   <ol>
--   <li>Ticketer is checked to match the given address.</li>
--   <li>Tokens amount in the ticket is checked to be equal to
--   <tt>1</tt>.</li>
--   <li>Ticket data is checked with the provided handler. In case the data
--   contains target contract, consider using <a>verifyTargetContract</a>
--   or <a>verifyTargetContractAnd</a>.</li>
--   </ol>
authorizeAction :: IsoValue td => ((td : s) :-> s') -> (TAddress emitterParam vd : (Ticket td : s)) :-> s'

-- | Check data in a ticket when it solely carries target contract address.
verifyTargetContract :: (TAddress selfParam vd : s) :-> s

-- | Check data in a ticket when it carries target contract address and
--   some other data that is to be verified with the given handler.
verifyTargetContractAnd :: ((d : s) :-> s') -> ((TAddress selfParam vd, d) : s) :-> s'

-- | A ticket kept in storage.
--   
--   The common pattern of use here is 1. A ticket that permits spending
--   few tokens comes in, it is partially validated and this <a>STicket</a>
--   type is produced. 2. This type can repeatedly be used to consume up to
--   the amount of permitted tokens.
--   
--   So in order to count allowed tokens, in storage you usually put this
--   type, not bare <a>Ticket</a>.
--   
--   The <tt>action</tt> type parameter serves to distinguish tickets for
--   different actions at type level and usually just matches the value in
--   ticket data:
--   
--   <ul>
--   <li>If the data in ticket is validated to be <tt>"pause"</tt>, then
--   the result of validation can be <tt>STicket "pause" ...</tt>; This is
--   the preferred option.</li>
--   <li>If the data in ticket has enum type, and the value is validated to
--   be some <tt>PauseAction</tt>, then validation can produce <tt>STicket
--   PauseAction ...</tt>.</li>
--   </ul>
--   
--   CAUTION: when working with this type, you <b>must</b> ensure that the
--   expected ticket emitter (the one you validate tickets against, e.g.
--   admin address) is <b>constant</b> for the lifetime of the
--   <a>STicket</a> value. Otherwise, tickets arithmetics (provided via
--   methods below) won't work. So do one of
--   
--   <ul>
--   <li>Either never change the expected ticket emitter;</li>
--   <li>Or, when it is changed, wipe all the <a>STicket</a> values
--   validated against the old ticketer from storage;</li>
--   <li>Or keep ticket values in a map where key is the currently expected
--   ticket emitter.</li>
--   </ul>
--   
--   Note some specificity of this type - its values mostly always appear
--   optionally, either in a map, or in <a>Maybe</a> (this is clear from
--   the potential use cases).
newtype STicket (action :: k) td
STicket :: Ticket td -> STicket (action :: k) td

-- | Constructs an <a>STicket</a>.
--   
--   This also emits the ticketer address and ticket data for further use.
--   You are oblidged to do something with both of them:
--   
--   <ul>
--   <li>Either validate against the expected value, you can use
--   <a>verifyTicketer</a>, <a>verifyTargetContract</a> and
--   <a>verifyTargetContractAnd</a> helpers here.</li>
--   <li>Or use as key in a map where <a>STicket</a> should be put to as a
--   value.</li>
--   </ul>
--   
--   This way you can be sure that arithmetics on <tt>STickets</tt> works
--   smoothly and there are no, for instance, attempts to join two tickets
--   from different emitters.
toSTicket :: IsoValue td => (Ticket td : s) :-> (Address : (td : (STicket action td : s)))

-- | Specialized version of <a>forcedCoerce_</a> to unwrap a haskell
--   newtype.
coerceUnwrap :: forall a s. Unwrappable a => (a : s) :-> (Unwrappabled a : s)

-- | Read contents of <a>STicket</a>.
readSTicket :: (STicket action td : s) :-> (ReadTicket td : (STicket action td : s))

-- | Read tokens amount in <a>STicket</a>.
sTicketAmount :: IsoValue td => (Maybe (STicket action td) : s) :-> (Natural : s)

-- | Consume given amount of tokens from the ticket, failing with given
--   handler if amount of tokens in the ticket is insufficient.
--   
--   We do not provide a ready error for this case since it will probably
--   depend on particular tokens that the given <tt>STicket</tt> serves to
--   permit.
--   
--   Note that you may want to run <tt>isSome nonZero none</tt> on the
--   result to save storage space.
subtractSTicket :: (IsoValue d, KnownValue (STicket action d)) => (forall s0. ErrInstr (("permitted" :! Natural, "spent" :! Natural) : s0)) -> (Natural : (Maybe (STicket action d) : s)) :-> (Maybe (STicket action d) : s)

-- | Similar to <a>subtractSTicket</a>, but without <tt>Maybe</tt>.
--   
--   You may want to run <a>nonZero</a> after this function call to save
--   storage space.
subtractSTicketPlain :: IsoValue d => (forall s0. ErrInstr (("permitted" :! Natural, "spent" :! Natural) : s0)) -> (Natural : (STicket action d : s)) :-> (STicket action d : s)

-- | Adds tokens permitted by an incoming ticket.
--   
--   Useful when someone permits you to spend even more tokens than you
--   already have been allowed to spend.
--   
--   This assumes that the ticket being added has already been verified.
--   The passed tickets must be verified against the same ticket data and
--   ticket emitter.
addSTicket :: (STicket action d : (Maybe (STicket action d) : s)) :-> (Maybe (STicket action d) : s)

-- | Similar to <a>addSTicket</a>, but without <tt>Maybe</tt>.
addSTicketPlain :: (STicket action d : (STicket action d : s)) :-> (STicket action d : s)

-- | Generic method for verifying tickets that authorize some action.
--   
--   For concrete example of use see <a>authorizeAction</a>.
verifyTicketGeneric :: IsoValue td => (forall s0. (Natural : s0) :-> s0) -> ((td : s) :-> s') -> (TAddress emitterParam vd : (Ticket td : s)) :-> (Ticket td : s')

-- | Verifies a ticket.
--   
--   This is an extremely generified <a>verifyTicketGeneric</a>, allows
--   providing verifiers for all the ticket's parts. Provided just in case.
verifyTicketGeneric' :: IsoValue td => (forall s0. (Address : (Address : s0)) :-> s0) -> (forall s0. (Natural : s0) :-> s0) -> ((td : s) :-> s') -> (TAddress emitterParam vd : (Ticket td : s)) :-> (Ticket td : s')

-- | Generic method for verifying the ticketer.
verifyTicketer :: (Address : (Address : s)) :-> s
instance forall k (action :: k) td. Lorentz.Wrappable.Unwrappable (Lorentz.Tickets.STicket action td)
instance forall k (action :: k) td. GHC.Generics.Generic (Lorentz.Tickets.STicket action td)
instance forall k td (action :: k). Lorentz.Constraints.Scopes.NiceComparable td => Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.Tickets.STicket action td)
instance forall k td (action :: k). (Lorentz.Annotation.HasAnnotation td, Lorentz.Constraints.Scopes.NiceComparable td) => Lorentz.Annotation.HasAnnotation (Lorentz.Tickets.STicket action td)
instance forall k1 k2 (a :: k1) (a2 :: k2) td td2. (Lorentz.Coercions.CanCastTo a a2, Lorentz.Coercions.CanCastTo td td2) => Lorentz.Coercions.CanCastTo (Lorentz.Tickets.STicket a td) (Lorentz.Tickets.STicket a2 td2)
instance forall d k (action :: k). (Lorentz.Constraints.Scopes.NiceComparable d, Data.Typeable.Internal.Typeable k, Data.Typeable.Internal.Typeable action) => Lorentz.Macro.NonZero (Lorentz.Tickets.STicket action d)
instance forall k (action :: k) td. (Data.Typeable.Internal.Typeable k, Data.Typeable.Internal.Typeable action, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc td) => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.Tickets.STicket action td)
instance Lorentz.Errors.CustomErrorHasDoc "wRONG_TICKETER"
instance Lorentz.Errors.CustomErrorHasDoc "nOT_TICKET_TARGET"
instance Lorentz.Errors.CustomErrorHasDoc "nOT_SINGLE_TICKET_TOKEN"


-- | Autodoc for numeric errors.
module Lorentz.Errors.Numeric.Doc

-- | Adds a section which explains error tag mapping.
data DDescribeErrorTagMap
DDescribeErrorTagMap :: Text -> DDescribeErrorTagMap

-- | Describes where the error tag map is defined in Haskell code.
[detmSrcLoc] :: DDescribeErrorTagMap -> Text

-- | Modify documentation generated for given code so that all
--   <a>CustomError</a> mention not their textual error tag rather
--   respective numeric one from the given map.
--   
--   If some documented error is not present in the map, it remains
--   unmodified. This function may fail with <a>error</a> if contract uses
--   some uncommon errors, see <a>applyErrorTagToErrorsDocWith</a> for
--   details.
applyErrorTagToErrorsDoc :: HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out

-- | Extended version of <a>applyErrorTagToErrorsDoc</a> which accepts
--   error handlers.
--   
--   In most cases that function should be enough for your purposes, but it
--   uses a fixed set of base handlers which may be not enough in case when
--   you define your own errors. In this case define and pass all the
--   necessary handlers to this function.
--   
--   It fails with <a>error</a> if some of the errors used in the contract
--   cannot be handled with given handlers.
applyErrorTagToErrorsDocWith :: HasCallStack => [NumericErrorDocHandler] -> ErrorTagMap -> (inp :-> out) -> inp :-> out

-- | Handler which changes documentation for one particular error type.
data NumericErrorDocHandler

-- | Errors for <a>NumericErrorDocHandler</a>
data NumericErrorDocHandlerError

-- | Handler for all <a>CustomError</a>s.
customErrorDocHandler :: NumericErrorDocHandler

-- | Handler for <a>VoidResult</a>.
voidResultDocHandler :: NumericErrorDocHandler

-- | Handlers for most common errors defined in Lorentz.
baseErrorDocHandlers :: [NumericErrorDocHandler]

-- | Some error with a numeric tag attached.
data NumericErrorWrapper (numTag :: Nat) (err :: Type)
instance GHC.Classes.Ord Lorentz.Errors.Numeric.Doc.DDescribeErrorTagMap
instance GHC.Classes.Eq Lorentz.Errors.Numeric.Doc.DDescribeErrorTagMap
instance (Lorentz.Errors.ErrorHasDoc err, GHC.TypeNats.KnownNat numTag, Lorentz.Errors.Numeric.Doc.ErrorHasNumericDoc err) => Lorentz.Errors.ErrorHasDoc (Lorentz.Errors.Numeric.Doc.NumericErrorWrapper numTag err)
instance Lorentz.Errors.Numeric.Doc.ErrorHasNumericDoc (Lorentz.Errors.CustomError tag)
instance Lorentz.Errors.ErrorHasDoc (Lorentz.Macro.VoidResult res) => Lorentz.Errors.Numeric.Doc.ErrorHasNumericDoc (Lorentz.Macro.VoidResult res)
instance Lorentz.Errors.ErrorHasDoc Lorentz.Errors.Numeric.Doc.NumericTextError
instance Morley.Michelson.Doc.DocItem Lorentz.Errors.Numeric.Doc.DDescribeErrorTagMap

module Lorentz.Errors.Numeric


-- | Default values for Lorentz.
module Lorentz.Default

-- | Lorentz version of <a>Default</a>.
class LDefault a
ldef :: LDefault a => a
ldef :: (LDefault a, Default a) => a
lIsDef :: LDefault a => (a : s) :-> (Bool : s)
lIsDef :: (LDefault a, NiceConstant a, NiceComparable a) => (a : s) :-> (Bool : s)
instance Lorentz.Default.LDefault GHC.Integer.Type.Integer
instance Lorentz.Default.LDefault GHC.Natural.Natural
instance Lorentz.Default.LDefault [a]
instance Lorentz.Default.LDefault (Data.Set.Internal.Set k)
instance Lorentz.Default.LDefault (Data.Map.Internal.Map k v)
instance (Lorentz.Default.LDefault a, GHC.TypeLits.KnownSymbol n) => Lorentz.Default.LDefault (Named.Internal.NamedF Data.Functor.Identity.Identity a n)
instance (Lorentz.Default.LDefault a, Lorentz.Default.LDefault b) => Lorentz.Default.LDefault (a, b)


-- | Isomorphisms in Lorentz.
module Lorentz.Iso

-- | Lorentz version of <a>Control.Lens.Iso</a>.
data LIso a b
LIso :: (forall s. (a : s) :-> (b : s)) -> (forall s. (b : s) :-> (a : s)) -> LIso a b
[liTo] :: LIso a b -> forall s. (a : s) :-> (b : s)
[liFrom] :: LIso a b -> forall s. (b : s) :-> (a : s)

-- | Invert an isomorphism.
invertIso :: LIso a b -> LIso b a

-- | Given a function that is its own inverse, make an <a>LIso</a> using it
--   in both directions.
involutedIso :: Lambda a a -> LIso a a

-- | The isomorphism between two values with identical representation and
--   semantics.
checkedCoerceIso :: Coercible_ a b => LIso a b

-- | The isomorphism between two values with identical representation.
--   
--   The same precautions as for <a>forcedCoerce</a> apply here.
forcedCoerceIso :: MichelsonCoercible a b => LIso a b

-- | The isomorphism between raw and named value.
namedIso :: Label n -> LIso a (n :! a)

-- | Absence of value on the left hand side is associated with the given
--   value on the right hand side.
nonIso :: (NiceConstant a, NiceComparable a) => a -> LIso (Maybe a) a

-- | Absence of value on the left hand side is associated with the default
--   value on the right hand side.
--   
--   This is more general version of <tt>nonIso ldef</tt> since it can work
--   with e.g. containers.
nonDefIso :: (LDefault a, NiceConstant a) => LIso (Maybe a) a


-- | 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 <a>stToField</a> and <a>stUpdate</a> to work with
--   storage from your code.
--   
--   To explain how e.g. required fields are obtainable from your storage
--   you define <a>StoreHasField</a> instance (and a similar case is for
--   other typeclasses). We provide the most common building blocks for
--   implementing these instances, see <tt>Implementations</tt> section.
module Lorentz.StoreClass

-- | Open kind for various field references.
--   
--   The simplest field reference could be <a>Label</a>, pointing to a
--   field by its name, but we also support more complex scenarios like
--   deep fields identifiers.
type FieldRefKind = FieldRefTag -> Type
data FieldRefTag

-- | For a type-level field reference - an associated term-level
--   representation.
--   
--   This is similar to <tt>singletons</tt> <tt>Sing</tt> + <tt>SingI</tt>
--   pair but has small differences:
--   
--   <ul>
--   <li>Dedicated to field references, thus term-level thing has
--   <a>FieldRefKind</a> kind.</li>
--   <li>The type of term-level value (<tt>FieldRefObject ty</tt>)
--   determines the kind of the reference type.</li>
--   </ul>
class KnownFieldRef (ty :: k) where {
    type family FieldRefObject ty = (fr :: FieldRefKind) | fr -> ty;
}
mkFieldRef :: KnownFieldRef ty => FieldRefObject ty p

-- | The simplest field reference - just a name. Behaves similarly to
--   <a>Label</a>.
data FieldName (n :: Symbol) (p :: FieldRefTag)

-- | Some kind of reference to a field.
--   
--   The idea behind this type is that in trivial case (<tt>name ::
--   Symbol</tt>) it can be instantiated with a mere label, but it is
--   generic enough to allow complex field references as well.
type FieldRef name = FieldRefObject name 'FieldRefTag

-- | Version of <a>FieldRef</a> restricted to symbolic labels.
--   
--   <pre>
--   FieldSymRef name ≡ FieldName name 'FieldRefTag
--   </pre>
type FieldSymRef name = FieldRef (name :: Symbol)

-- | Convert a symbolic <a>FieldRef</a> to a label, useful for
--   compatibility with other interfaces.
fieldNameToLabel :: FieldSymRef n -> Label n

-- | Convert a label to <a>FieldRef</a>, useful for compatibility with
--   other interfaces.
fieldNameFromLabel :: Label n -> FieldSymRef n

-- | Provides access to the direct name of the referred field.
--   
--   This is used in <a>stToFieldNamed</a>.
class FieldRefHasFinalName fr where {
    type family FieldRefFinalName fr :: Symbol;
}
fieldRefFinalName :: FieldRefHasFinalName fr => FieldRef fr -> Label (FieldRefFinalName fr)

-- | Provides operations on fields for storage.
class StoreHasField store fname ftype | store fname -> ftype
storeFieldOps :: StoreHasField store fname ftype => StoreFieldOps store fname ftype

-- | Datatype containing the full implementation of <a>StoreHasField</a>
--   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 <tt>DerivingVia</tt> extension.)
data StoreFieldOps store fname ftype
StoreFieldOps :: (forall s. FieldRef fname -> (store : s) :-> (ftype : s)) -> (forall s. Dupable store => FieldRef fname -> (store : s) :-> (ftype : (store : s))) -> (forall s. FieldRef fname -> (ftype : (store : s)) :-> (store : s)) -> StoreFieldOps store fname ftype
[sopToField] :: StoreFieldOps store fname ftype -> forall s. FieldRef fname -> (store : s) :-> (ftype : s)
[sopGetField] :: StoreFieldOps store fname ftype -> forall s. Dupable store => FieldRef fname -> (store : s) :-> (ftype : (store : s))
[sopSetField] :: StoreFieldOps store fname ftype -> forall s. FieldRef fname -> (ftype : (store : s)) :-> (store : s)

-- | Provides operations on submaps of storage.
class StoreHasSubmap store mname key value | store mname -> key value
storeSubmapOps :: StoreHasSubmap store mname key value => StoreSubmapOps store mname key value

-- | Datatype containing the full implementation of <a>StoreHasSubmap</a>
--   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 <tt>DerivingVia</tt> extension.)
data StoreSubmapOps store mname key value
StoreSubmapOps :: (forall s. FieldRef mname -> (key : (store : s)) :-> (Bool : s)) -> (forall s. KnownValue value => FieldRef mname -> (key : (store : s)) :-> (Maybe value : s)) -> (forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (store : s)) -> (forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (Maybe value : (store : s))) -> (forall s. FieldRef mname -> (key : (store : s)) :-> (store : s)) -> (forall s. FieldRef mname -> (key : (value : (store : s))) :-> (store : s)) -> StoreSubmapOps store mname key value
[sopMem] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (store : s)) :-> (Bool : s)
[sopGet] :: StoreSubmapOps store mname key value -> forall s. KnownValue value => FieldRef mname -> (key : (store : s)) :-> (Maybe value : s)
[sopUpdate] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (store : s)
[sopGetAndUpdate] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (Maybe value : (store : s))
[sopDelete] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (store : s)) :-> (store : s)
[sopInsert] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (value : (store : s))) :-> (store : s)

-- | Provides operations on stored entrypoints.
--   
--   <tt>store</tt> is the storage containing both the entrypoint
--   <tt>epName</tt> (note: it has to be in a <a>BigMap</a> to take
--   advantage of lazy evaluation) and the <tt>epStore</tt> field this
--   operates on.
class StoreHasEntrypoint store epName epParam epStore | store epName -> epParam epStore
storeEpOps :: StoreHasEntrypoint store epName epParam epStore => StoreEntrypointOps store epName epParam epStore

-- | Datatype containing the full implementation of
--   <a>StoreHasEntrypoint</a> 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 <tt>DerivingVia</tt> extension.)
data StoreEntrypointOps store epName epParam epStore
StoreEntrypointOps :: (forall s. Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : s)) -> (forall s. Label epName -> (EntrypointLambda epParam epStore : (store : s)) :-> (store : s)) -> (forall s. Label epName -> (store : s) :-> (epStore : s)) -> (forall s. Label epName -> (epStore : (store : s)) :-> (store : s)) -> StoreEntrypointOps store epName epParam epStore
[sopToEpLambda] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : s)
[sopSetEpLambda] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (EntrypointLambda epParam epStore : (store : s)) :-> (store : s)
[sopToEpStore] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (store : s) :-> (epStore : s)
[sopSetEpStore] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (epStore : (store : s)) :-> (store : s)

-- | Type synonym for a <a>Lambda</a> that can be used as an entrypoint
type EntrypointLambda param store = Lambda (param, store) ([Operation], store)

-- | Type synonym of a <a>BigMap</a> mapping <a>MText</a> (entrypoint
--   names) to <a>EntrypointLambda</a>.
--   
--   This is useful when defining instances of <a>StoreHasEntrypoint</a> as
--   a storage field containing one or more entrypoints (lambdas) of the
--   same type.
type EntrypointsField param store = BigMap MText (EntrypointLambda param store)

-- | Indicates a submap with given key and value types.
data k ~> v
infix 9 ~>

-- | Indicates a stored entrypoint with the given <tt>param</tt> and
--   <tt>store</tt> types.
data param ::-> store
infix 9 ::->

-- | Concise way to write down constraints with expected content of a
--   storage.
--   
--   Use it like follows:
--   
--   <pre>
--   type StorageConstraint store = StorageContains store
--     [ "fieldInt" := Int
--     , "fieldNat" := Nat
--     , "epsToNat" := Int ::-&gt; Nat
--     , "balances" := Address ~&gt; Int
--     ]
--   </pre>
--   
--   Note that this won't work with complex field references, they have to
--   be included using e.g. <a>StoreHasField</a> manually.
type family StorageContains store (content :: [NamedField]) :: Constraint

-- | Pick storage field.
stToField :: StoreHasField store fname ftype => FieldRef fname -> (store : s) :-> (ftype : s)

-- | Get storage field, preserving the storage itself on stack.
stGetField :: (StoreHasField store fname ftype, Dupable store) => FieldRef fname -> (store : s) :-> (ftype : (store : s))

-- | Pick storage field retaining a name label attached.
--   
--   For complex refs this tries to attach the immediate name of the
--   referred field.
stToFieldNamed :: (StoreHasField store fname ftype, FieldRefHasFinalName fname) => FieldRef fname -> (store : s) :-> ((FieldRefFinalName fname :! ftype) : s)

-- | Version of <a>stToFieldNamed</a> that preserves the storage on stack.
stGetFieldNamed :: (StoreHasField store fname ftype, FieldRefHasFinalName fname, Dupable ftype) => FieldRef fname -> (store : s) :-> ((FieldRefFinalName fname :! ftype) : (store : s))

-- | Update storage field.
stSetField :: StoreHasField store fname ftype => FieldRef fname -> (ftype : (store : s)) :-> (store : s)

-- | Check value presence in storage.
stMem :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (store : s)) :-> (Bool : s)

-- | Get value in storage.
stGet :: (StoreHasSubmap store mname key value, KnownValue value) => FieldRef mname -> (key : (store : s)) :-> (Maybe value : s)

-- | Update a value in storage.
stUpdate :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (Maybe value : (store : s))) :-> (store : s)

-- | Atomically get and update a value in storage.
stGetAndUpdate :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (Maybe value : (store : s))) :-> (Maybe value : (store : s))

-- | Delete a value in storage.
stDelete :: forall store mname key value s. StoreHasSubmap store mname key value => FieldRef mname -> (key : (store : s)) :-> (store : s)

-- | Add a value in storage.
stInsert :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (value : (store : s))) :-> (store : s)

-- | Add a value in storage, but fail if it will overwrite some existing
--   entry.
stInsertNew :: (StoreHasSubmap store mname key value, Dupable key) => FieldRef mname -> (forall s0 any. (key : s0) :-> any) -> (key : (value : (store : s))) :-> (store : s)

-- | Extracts and executes the <tt>epName</tt> entrypoint lambda from
--   storage, returing the updated full storage (<tt>store</tt>) and the
--   produced <a>Operation</a>s.
stEntrypoint :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (epParam : (store : s)) :-> (([Operation], store) : s)

-- | Pick stored entrypoint lambda.
stToEpLambda :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : s)

-- | Get stored entrypoint lambda, preserving the storage itself on the
--   stack.
stGetEpLambda :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : (store : s))

-- | Stores the entrypoint lambda in the storage. Fails if already set.
stSetEpLambda :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (EntrypointLambda epParam epStore : (store : s)) :-> (store : s)

-- | Pick the sub-storage that the entrypoint operates on.
stToEpStore :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (store : s) :-> (epStore : s)

-- | Get the sub-storage that the entrypoint operates on, preserving the
--   storage itself on the stack.
stGetEpStore :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store : s) :-> (epStore : (store : s))

-- | Update the sub-storage that the entrypoint operates on.
stSetEpStore :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (epStore : (store : s)) :-> (store : s)

-- | Implementation of <a>StoreHasField</a> for case of datatype keeping a
--   pack of fields.
storeFieldOpsADT :: HasFieldOfType dt fname ftype => StoreFieldOps dt (fname :: Symbol) ftype

-- | Implementation of <a>StoreHasEntrypoint</a> for a datatype keeping a
--   pack of fields, among which one contains the entrypoint and another is
--   what such entrypoint operates on.
storeEntrypointOpsADT :: (HasFieldOfType store epmName (EntrypointsField epParam epStore), HasFieldOfType store epsName epStore, KnownValue epParam, KnownValue epStore, Dupable store) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

-- | Implementation of <a>StoreHasEntrypoint</a> for a datatype that has a
--   <a>StoreHasField</a> for an <a>EntrypointsField</a> that contains the
--   entrypoint and a <a>StoreHasField</a> for the field such entrypoint
--   operates on.
storeEntrypointOpsFields :: (StoreHasField store epmName (EntrypointsField epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore, Dupable store) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

-- | Implementation of <a>StoreHasEntrypoint</a> for a datatype that has a
--   <a>StoreHasSubmap</a> that contains the entrypoint and a
--   <a>StoreHasField</a> 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 <a>StoreHasField</a> for a data type which has an
--   instance of <a>StoreHasField</a> inside. For instance, it can be used
--   for top-level storage.
storeFieldOpsDeeper :: (HasFieldOfType storage fieldsPartName fields, StoreHasField fields fname ftype, Dupable storage) => FieldRef fieldsPartName -> StoreFieldOps storage fname ftype

-- | Implementation of <a>StoreHasSubmap</a> for a data type which has an
--   instance of <a>StoreHasSubmap</a> inside. For instance, it can be used
--   for top-level storage.
storeSubmapOpsDeeper :: (HasFieldOfType storage bigMapPartName fields, StoreHasSubmap fields SelfRef key value, Dupable storage) => FieldRef bigMapPartName -> StoreSubmapOps storage mname key value

-- | Implementation of <a>StoreHasEntrypoint</a> for a data type which has
--   an instance of <a>StoreHasEntrypoint</a> inside. For instance, it can
--   be used for top-level storage.
storeEntrypointOpsDeeper :: (HasFieldOfType store nameInStore substore, StoreHasEntrypoint substore epName epParam epStore, Dupable store) => FieldRef nameInStore -> StoreEntrypointOps store epName epParam epStore

-- | Pretend that given <a>StoreFieldOps</a> implementation is made up for
--   field with name <tt>desiredName</tt>, not its actual name. Logic of
--   the implementation remains the same.
--   
--   See also <a>storeSubmapOpsReferTo</a>.
storeFieldOpsReferTo :: FieldRef name -> StoreFieldOps storage name field -> StoreFieldOps storage desiredName field

-- | Pretend that given <a>StoreSubmapOps</a> implementation is made up for
--   submap with name <tt>desiredName</tt>, not its actual name. Logic of
--   the implementation remains the same.
--   
--   Use case: imagine that your code requires access to submap named
--   <tt>X</tt>, but in your storage that submap is called <tt>Y</tt>. Then
--   you implement the instance which makes <tt>X</tt> refer to <tt>Y</tt>:
--   
--   <pre>
--   instance StoreHasSubmap Store X Key Value where
--     storeSubmapOps = storeSubmapOpsReferTo #Y storeSubmapOpsForY
--   </pre>
storeSubmapOpsReferTo :: FieldRef name -> StoreSubmapOps storage name key value -> StoreSubmapOps storage desiredName key value

-- | Change field operations so that they work on a modified field.
--   
--   For instance, to go from <tt>StoreFieldOps Storage "name" Integer</tt>
--   to <tt>StoreFieldOps Storage "name" (value :! Integer)</tt> you can
--   use <tt>mapStoreFieldOps (namedIso #value)</tt>
mapStoreFieldOps :: LIso field1 field2 -> StoreFieldOps store name field1 -> StoreFieldOps store name field2

-- | Change submap operations so that they work on a modified key.
mapStoreSubmapOpsKey :: Lambda key2 key1 -> StoreSubmapOps store name key1 value -> StoreSubmapOps store name key2 value

-- | Change submap operations so that they work on a modified value.
mapStoreSubmapOpsValue :: (KnownValue value1, KnownValue value2) => LIso value1 value2 -> StoreSubmapOps store name key value1 -> StoreSubmapOps store name key value2

-- | Pretend that given <a>StoreEntrypointOps</a> implementation is made up
--   for entrypoint with name <tt>desiredName</tt>, not its actual name.
--   Logic of the implementation remains the same.
--   
--   See also <a>storeSubmapOpsReferTo</a>.
storeEntrypointOpsReferTo :: Label epName -> StoreEntrypointOps store epName epParam epStore -> StoreEntrypointOps store desiredName epParam epStore

-- | Chain two implementations of field operations.
--   
--   Suits for a case when your store does not contain its fields directly
--   rather has a nested structure.
composeStoreFieldOps :: Dupable store => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreFieldOps substore nameInSubstore field -> StoreFieldOps store nameInSubstore field

-- | Chain implementations of field and submap operations.
composeStoreSubmapOps :: Dupable store => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreSubmapOps substore mname key value -> StoreSubmapOps store mname key 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.
--   
--   <tt>LIso (Maybe substore) substore</tt> argument describes how to get
--   <tt>substore</tt> value if it was absent in map and how to detect when
--   it can be safely removed.
--   
--   Example of use: <tt>sequenceStoreSubmapOps #mySubmap nonDefIso
--   storeSubmapOps storeSubmapOps</tt>
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
composeStoreEntrypointOps :: Dupable store => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreEntrypointOps substore epName epParam epStore -> StoreEntrypointOps store epName epParam epStore

-- | 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 <tt>value ==
--   Nothing</tt> and <tt>value == Just defValue</tt> cases. Getters, when
--   notice a value equal to the default value, report its absence. Setters
--   tend to remove the value from submap when possible.
--   
--   <tt>LIso (Maybe value) value</tt> and <tt>LIso (Maybe subvalue)
--   subvalue</tt> 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: <tt>zoomStoreSubmapOps #mySubmap nonDefIso nonDefIso
--   storeSubmapOps storeFieldOpsADT</tt>
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

-- | Utility to create <a>EntrypointsField</a>s from an entrypoint name
--   (<tt>epName</tt>) and an <a>EntrypointLambda</a> implementation. Note
--   that you need to merge multiple of these (with <a>&lt;&gt;</a>) if
--   your field contains more than one entrypoint lambda.
mkStoreEp :: Label epName -> EntrypointLambda epParam epStore -> EntrypointsField epParam epStore

-- | Refer to a nested entry in storage.
--   
--   Example: <tt>stToField (#a :-| #b)</tt> fetches field <tt>b</tt> in
--   the type under field <tt>a</tt>.
--   
--   If not favouring this name much, you can try an alias from
--   <a>Lorentz.StoreClass.Extra</a>.
data (:-|) (l :: k1) (r :: k2) (p :: FieldRefTag)
(:-|) :: FieldRef l -> FieldRef r -> (:-|) (l :: k1) (r :: k2) (p :: FieldRefTag)
infixr 8 :-|
infixr 8 :-|

-- | Refer to no particular field, access itself.
data SelfRef (p :: FieldRefTag)
SelfRef :: SelfRef (p :: FieldRefTag)

-- | An alias for <a>SelfRef</a>.
--   
--   Examples:
--   
--   <pre>
--   &gt;&gt;&gt; push 5 # stMem this -$ (mempty :: Map Integer MText)
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stGetField this # pair -$ (5 :: Integer)
--   (5,5)
--   </pre>
this :: SelfRef p

-- | Provides alternative variadic interface for deep entries access.
--   
--   Example: <tt>stToField (stNested #a #b #c)</tt>
stNested :: StNestedImpl f SelfRef => f

-- | Alias for a field reference.
--   
--   This allows creating _custom_ field references; you will have to
--   define the respective <a>StoreHasField</a> and <a>StoreHasSubmap</a>
--   instances manually. Since this type occupies a different "namespace"
--   than string labels and <a>:-|</a>, no overlappable instances will be
--   necessary.
--   
--   Example:
--   
--   <pre>
--   -- Shortcut for a deeply nested field X
--   data FieldX
--   
--   instance StoreHasField Storage (FieldAlias FieldX) Integer where
--     ...
--   
--   accessX = stToField (stAlias @FieldX)
--   </pre>
--   
--   Note that <tt>alias</tt> type argument allows instantiations of any
--   kind.
data FieldAlias (alias :: k) (p :: FieldRefTag)

-- | Construct an alias at term level.
--   
--   This requires passing the alias via type annotation.
stAlias :: forall alias. FieldRef (FieldAlias alias)

-- | Kind-restricted version of <a>FieldAlias</a> to work solely with
--   string labels.
type FieldNickname alias = FieldAlias (alias :: Symbol)

-- | Version of <a>stAlias</a> adopted to labels.
stNickname :: Label name -> FieldRef (FieldAlias name)
instance forall k (alias :: k). Lorentz.StoreClass.KnownFieldRef (Lorentz.StoreClass.FieldAlias alias)
instance forall k (p :: Lorentz.StoreClass.FieldRefTag) (res :: Lorentz.StoreClass.FieldRefTag -> *) (acc :: k). (p GHC.Types.~ 'Lorentz.StoreClass.FieldRefTag, res p GHC.Types.~ Lorentz.StoreClass.FieldRef acc) => Lorentz.StoreClass.StNestedImpl (res p) acc
instance forall k2 k label (name :: k2) f (acc :: k). (label GHC.Types.~ Lorentz.StoreClass.FieldRef name, Lorentz.StoreClass.StNestedImpl f (acc Lorentz.StoreClass.:-| name)) => Lorentz.StoreClass.StNestedImpl (label -> f) acc
instance (Lorentz.StoreClass.StoreHasField store name submap, Lorentz.StoreClass.StoreHasSubmap submap Lorentz.StoreClass.SelfRef key value, GHC.TypeLits.KnownSymbol name, Lorentz.Constraints.Scopes.Dupable store) => Lorentz.StoreClass.StoreHasSubmap store name key value
instance Lorentz.StoreClass.KnownFieldRef Lorentz.StoreClass.SelfRef
instance Lorentz.StoreClass.StoreHasField store Lorentz.StoreClass.SelfRef store
instance (Lorentz.Constraints.Scopes.NiceComparable key, Lorentz.Constraints.Scopes.KnownValue value) => Lorentz.StoreClass.StoreHasSubmap (Morley.Michelson.Typed.Haskell.Value.BigMap key value) Lorentz.StoreClass.SelfRef key value
instance (Lorentz.Constraints.Scopes.NiceComparable key, Lorentz.Constraints.Scopes.KnownValue value) => Lorentz.StoreClass.StoreHasSubmap (Data.Map.Internal.Map key value) Lorentz.StoreClass.SelfRef key value
instance (Lorentz.Constraints.Scopes.NiceComparable key, GHC.Classes.Ord key, Lorentz.Constraints.Scopes.Dupable key) => Lorentz.StoreClass.StoreHasSubmap (Data.Set.Internal.Set key) Lorentz.StoreClass.SelfRef key ()
instance forall k1 k2 (l :: k1) (r :: k2). (Lorentz.StoreClass.KnownFieldRef l, Lorentz.StoreClass.KnownFieldRef r) => Lorentz.StoreClass.KnownFieldRef (l Lorentz.StoreClass.:-| r)
instance forall k2 k1 (r :: k2) (l :: k1). Lorentz.StoreClass.FieldRefHasFinalName r => Lorentz.StoreClass.FieldRefHasFinalName (l Lorentz.StoreClass.:-| r)
instance forall k1 k2 store (field :: k1) substore (subfield :: k2) ty. (Lorentz.StoreClass.StoreHasField store field substore, Lorentz.StoreClass.StoreHasField substore subfield ty, Lorentz.StoreClass.KnownFieldRef field, Lorentz.StoreClass.KnownFieldRef subfield, Lorentz.Constraints.Scopes.Dupable store) => Lorentz.StoreClass.StoreHasField store (field Lorentz.StoreClass.:-| subfield) ty
instance forall k1 k2 store (field :: k1) substore (subfield :: k2) key value. (Lorentz.StoreClass.StoreHasField store field substore, Lorentz.StoreClass.StoreHasSubmap substore subfield key value, Lorentz.StoreClass.KnownFieldRef field, Lorentz.StoreClass.KnownFieldRef subfield, Lorentz.Constraints.Scopes.Dupable store) => Lorentz.StoreClass.StoreHasSubmap store (field Lorentz.StoreClass.:-| subfield) key value
instance Lorentz.ADT.HasFieldOfType store fname ftype => Lorentz.StoreClass.StoreHasField store fname ftype
instance Lorentz.StoreClass.FieldRefHasFinalName name
instance (x GHC.Types.~ Lorentz.StoreClass.FieldName name, GHC.TypeLits.KnownSymbol name) => GHC.OverloadedLabels.IsLabel name (x p)
instance GHC.TypeLits.KnownSymbol name => Lorentz.StoreClass.KnownFieldRef name


-- | Some conveniences for <a>Lorentz.StoreClass</a> module.
--   
--   This is not part of the umbrella <a>Lorentz</a> module, you have to
--   import this specially.
module Lorentz.StoreClass.Extra

-- | Alias for <a>:-|</a>.
--   
--   This makes nested field access look just like in other languages.
--   
--   Though it may collide with the dot operator from Haskell world, for
--   instance, in tests, so we do not yet provide it directly in
--   <a>Lorentz.StoreClass</a>.
(.) :: FieldRef l -> FieldRef r -> FieldRef (l :-| r)
infixr 8 .


-- | Utilities for declaring and documenting entry points.
module Lorentz.Entrypoints.Doc

-- | Gathers information about single entrypoint.
--   
--   We assume that entry points might be of different kinds, which is
--   designated by phantom type parameter. For instance, you may want to
--   have several groups of entry points corresponding to various parts of
--   a contract - specifying different <tt>kind</tt> type argument for each
--   of those groups will allow you defining different <a>DocItem</a>
--   instances with appropriate custom descriptions for them.
data DEntrypoint (kind :: Type)
DEntrypoint :: Text -> SubDoc -> DEntrypoint (kind :: Type)
[depName] :: DEntrypoint (kind :: Type) -> Text
[depSub] :: DEntrypoint (kind :: Type) -> SubDoc

-- | Pattern that checks whether given <a>SomeDocItem</a> hides
--   <a>DEntrypoint</a> inside (of any entrypoint kind).
--   
--   In case a specific kind is necessary, use plain <tt>(cast -&gt; Just
--   DEntrypoint{..})</tt> construction instead.
pattern DEntrypointDocItem :: DEntrypoint kind -> SomeDocItem

-- | Describes location of entrypoints of the given kind.
--   
--   All such entrypoints will be placed under the same "entrypoints"
--   section, and this instance defines characteristics of this section.
class Typeable ep => EntrypointKindHasDoc (ep :: Type)

-- | Position of the respective entrypoints section in the doc. This shares
--   the same positions space with all other doc items.
entrypointKindPos :: EntrypointKindHasDoc ep => Natural

-- | Name of the respective entrypoints section.
entrypointKindSectionName :: EntrypointKindHasDoc ep => Text

-- | Description in the respective entrypoints section.
entrypointKindSectionDescription :: EntrypointKindHasDoc ep => Maybe Markdown

-- | Mark code as part of entrypoint with given name.
--   
--   This is automatically called at most of the appropriate situations,
--   like <a>entryCase</a> calls.
entrypointSection :: EntrypointKindHasDoc kind => Text -> Proxy kind -> (i :-> o) -> i :-> o

-- | Inserts a reference to an existing entrypoint.
--   
--   This helps to avoid duplication in the generated documentation, in
--   order not to overwhelm the reader.
data DEntrypointReference
DEntrypointReference :: Text -> Anchor -> DEntrypointReference

-- | Provides arror for convenient entrypoint documentation
class EntryArrow kind name body

-- | Lift entrypoint implementation.
--   
--   Entrypoint names should go with "e" prefix.
(#->) :: EntryArrow kind name body => (Label name, Proxy kind) -> body -> body

-- | Default value for <a>DEntrypoint</a> type argument.
data PlainEntrypointsKind

-- | Describes the behaviour common for all entrypoints.
--   
--   For instance, if your contract runs some checks before calling any
--   entrypoint, you probably want to wrap those checks into
--   <tt>entrypointSection "Prior checks" (Proxy
--   @CommonContractBehaviourKind)</tt>.
data CommonContractBehaviourKind

-- | Describes the behaviour common for entrypoints of given kind.
--   
--   This has very special use cases, like contracts with mix of
--   upgradeable and permanent entrypoints.
data CommonEntrypointsBehaviourKind kind

-- | Default implementation of <a>docItemToMarkdown</a> for entrypoints.
diEntrypointToMarkdown :: HeaderLevel -> DEntrypoint level -> Markdown

-- | Entrypoint argument type in typed representation.
data SomeEntrypointArg
SomeEntrypointArg :: Proxy a -> SomeEntrypointArg

-- | Describes argument of an entrypoint.
data DEntrypointArg
DEntrypointArg :: Maybe SomeEntrypointArg -> [ParamBuildingStep] -> DEntrypointArg

-- | Argument of the entrypoint. Pass <a>Nothing</a> if no argument is
--   required.
[epaArg] :: DEntrypointArg -> Maybe SomeEntrypointArg

-- | Describes a way to lift an entrypoint argument into full parameter
--   which can be passed to the contract.
--   
--   Steps are supposed to be applied in the order opposite to one in which
--   they are given. E.g. suppose that an entrypoint is called as <tt>Run
--   (Service1 arg)</tt>; then the first step (actual last) should describe
--   wrapping into <tt>Run</tt> constructor, and the second step (actual
--   first) should be about wrapping into <tt>Service1</tt> constructor.
[epaBuilding] :: DEntrypointArg -> [ParamBuildingStep]
data DType
[DType] :: forall a. TypeHasDoc a => Proxy a -> DType

-- | Pick a type documentation from <a>CtorField</a>.
class (KnownSymbol con) => DeriveCtorFieldDoc con (cf :: CtorField)
deriveCtorFieldDoc :: DeriveCtorFieldDoc con cf => DEntrypointArg

-- | When describing the way of parameter construction - piece of
--   incremental builder for this description.
newtype ParamBuilder
ParamBuilder :: (Markdown -> Markdown) -> ParamBuilder

-- | Argument stands for previously constructed parameter piece, and
--   returned value - a piece constructed after our step.
[unParamBuilder] :: ParamBuilder -> Markdown -> Markdown
data ParamBuildingDesc
ParamBuildingDesc :: Markdown -> ParamBuilder -> ParamBuilder -> ParamBuildingDesc

-- | Plain english description of this step.
[pbdEnglish] :: ParamBuildingDesc -> Markdown

-- | How to construct parameter in Haskell code.
[pbdHaskell] :: ParamBuildingDesc -> ParamBuilder

-- | How to construct parameter working on raw Michelson.
[pbdMichelson] :: ParamBuildingDesc -> ParamBuilder

-- | Describes a parameter building step.
--   
--   This can be wrapping into (Haskell) constructor, or a more complex
--   transformation.
data ParamBuildingStep

-- | Wraps something into constructor with given name. Constructor should
--   be the one which corresponds to an entrypoint defined via field
--   annotation, for more complex cases use <a>PbsCustom</a>.
PbsWrapIn :: Text -> ParamBuildingDesc -> ParamBuildingStep

-- | Directly call an entrypoint marked with a field annotation.
PbsCallEntrypoint :: EpName -> ParamBuildingStep

-- | Other action.
PbsCustom :: ParamBuildingDesc -> ParamBuildingStep

-- | This entrypoint cannot be called, which is possible when an explicit
--   default entrypoint is present. This is not a true entrypoint but just
--   some intermediate node in <tt>or</tt> tree and neither it nor any of
--   its parents are marked with a field annotation.
--   
--   It contains dummy <a>ParamBuildingStep</a>s which were assigned before
--   entrypoints were taken into account.
PbsUncallable :: [ParamBuildingStep] -> ParamBuildingStep

-- | Make a <a>ParamBuildingStep</a> that tells about wrapping an argument
--   into a constructor with given name and uses given <a>ParamBuilder</a>
--   as description of Michelson part.
mkPbsWrapIn :: Text -> ParamBuilder -> ParamBuildingStep

-- | Go over contract code and update every occurrence of
--   <a>DEntrypointArg</a> documentation item, adding the given step to its
--   "how to build parameter" description.
clarifyParamBuildingSteps :: ParamBuildingStep -> (inp :-> out) -> inp :-> out
constructDEpArg :: forall arg. (NiceParameter arg, TypeHasDoc arg) => DEntrypointArg
emptyDEpArg :: DEntrypointArg
mkUType :: forall (x :: T). SingI x => Notes x -> Ty
mkDEpUType :: forall t. (KnownValue t, HasAnnotation t) => Ty
mkDEntrypointArgSimple :: forall t. (NiceParameter t, TypeHasDoc t) => DEntrypointArg

-- | Constraint for <a>documentEntrypoints</a>.
type DocumentEntrypoints kind a = (Generic a, GDocumentEntrypoints kind (Rep a))

-- | Wrapper for documenting single entrypoint which parameter isn't going
--   to be unwrapped from some datatype.
--   
--   <tt>entryCase</tt> unwraps a datatype, however, sometimes we want to
--   have entrypoint parameter to be not wrapped into some datatype.
documentEntrypoint :: forall kind epName param s out. (KnownSymbol epName, DocItem (DEntrypoint kind), NiceParameter param, TypeHasDoc param) => ((param : s) :-> out) -> (param : s) :-> out

-- | Version of <a>entryCase_</a> for tuples.
entryCase :: forall dt entrypointKind out inp clauses. (CaseTC dt out inp clauses, DocumentEntrypoints entrypointKind dt) => Proxy entrypointKind -> IsoRecTuple clauses -> (dt : inp) :-> out

-- | Like <a>case_</a>, to be used for pattern-matching on a parameter or
--   its part.
--   
--   Modifies documentation accordingly. Including description of
--   entrypoints' arguments, thus for them you will need to supply
--   <a>TypeHasDoc</a> instance.
entryCase_ :: forall dt entrypointKind out inp. (InstrCaseC dt, RMap (CaseClauses dt), DocumentEntrypoints entrypointKind dt) => Proxy entrypointKind -> Rec (CaseClauseL inp out) (CaseClauses dt) -> (dt : inp) :-> out

-- | Version of 'finalizeParamCallingDoc'' more convenient for manual call
--   in a contract.
finalizeParamCallingDoc :: forall cp inp out. (NiceParameterFull cp, RequireSumType cp, HasCallStack) => ((cp : inp) :-> out) -> (cp : inp) :-> out

-- | Modify param building steps with respect to entrypoints that given
--   parameter declares.
--   
--   Each contract with entrypoints should eventually call this function,
--   otherwise, in case if contract uses built-in entrypoints feature, the
--   resulting parameter building steps in the generated documentation will
--   not consider entrypoints and thus may be incorrect.
--   
--   Calling this twice over the same code is also prohibited.
--   
--   This method is for internal use, if you want to apply it to a contract
--   manually, use <a>finalizeParamCallingDoc</a>.
finalizeParamCallingDoc' :: forall cp inp out. (NiceParameterFull cp, HasCallStack) => Proxy cp -> (inp :-> out) -> inp :-> out

-- | Whether <a>finalizeParamCallingDoc</a> has already been applied to
--   these steps.
areFinalizedParamBuildingSteps :: [ParamBuildingStep] -> Bool
entryCaseSimple_ :: forall cp out inp. (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp : inp) :-> out

-- | Version of <a>entryCase</a> for contracts with flat parameter, use it
--   when you need only one <a>entryCase</a> all over the contract
--   implementation.
entryCaseSimple :: forall cp out inp clauses. (CaseTC cp out inp clauses, DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => IsoRecTuple clauses -> (cp : inp) :-> out
type family RequireFlatParamEps cp :: Constraint
type family RequireFlatEpDerivation cp deriv :: Constraint
instance GHC.Classes.Eq Lorentz.Entrypoints.Doc.ParamBuildingDesc
instance GHC.Show.Show Lorentz.Entrypoints.Doc.ParamBuildingDesc
instance GHC.Classes.Eq Lorentz.Entrypoints.Doc.ParamBuildingStep
instance GHC.Show.Show Lorentz.Entrypoints.Doc.ParamBuildingStep
instance (name GHC.Types.~ GHC.TypeLits.AppendSymbol "e" epName, body GHC.Types.~ ((param : s) Lorentz.Base.:-> out), GHC.TypeLits.KnownSymbol epName, Morley.Michelson.Doc.DocItem (Lorentz.Entrypoints.Doc.DEntrypoint kind), Lorentz.Constraints.Scopes.NiceParameter param, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc param, Lorentz.Constraints.Scopes.KnownValue param) => Lorentz.Entrypoints.Doc.EntryArrow kind name body
instance Lorentz.Entrypoints.Doc.GDocumentEntrypoints kind x => Lorentz.Entrypoints.Doc.GDocumentEntrypoints kind (GHC.Generics.D1 i x)
instance (Lorentz.Entrypoints.Doc.GDocumentEntrypoints kind x, Lorentz.Entrypoints.Doc.GDocumentEntrypoints kind y, Morley.Util.Type.RSplit (Morley.Michelson.Typed.Haskell.Instr.Sum.GCaseClauses x) (Morley.Michelson.Typed.Haskell.Instr.Sum.GCaseClauses y)) => Lorentz.Entrypoints.Doc.GDocumentEntrypoints kind (x GHC.Generics.:+: y)
instance ('Morley.Michelson.Typed.Haskell.Instr.Sum.CaseClauseParam ctor cf GHC.Types.~ Morley.Michelson.Typed.Haskell.Instr.Sum.GCaseBranchInput ctor x, GHC.TypeLits.KnownSymbol ctor, Morley.Michelson.Doc.DocItem (Lorentz.Entrypoints.Doc.DEntrypoint kind), Lorentz.Entrypoints.Doc.DeriveCtorFieldDoc ctor cf) => Lorentz.Entrypoints.Doc.GDocumentEntrypoints kind (GHC.Generics.C1 ('GHC.Generics.MetaCons ctor _1 _2) x)
instance GHC.TypeLits.KnownSymbol con => Lorentz.Entrypoints.Doc.DeriveCtorFieldDoc con 'Morley.Michelson.Typed.Haskell.Instr.Sum.NoFields
instance (Lorentz.Constraints.Scopes.NiceParameter ty, Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc ty, Lorentz.Constraints.Scopes.KnownValue ty, GHC.TypeLits.KnownSymbol con) => Lorentz.Entrypoints.Doc.DeriveCtorFieldDoc con ('Morley.Michelson.Typed.Haskell.Instr.Sum.OneField ty)
instance Morley.Michelson.Doc.DocItem Lorentz.Entrypoints.Doc.DEntrypointArg
instance Formatting.Buildable.Buildable Lorentz.Entrypoints.Doc.ParamBuildingStep
instance Formatting.Buildable.Buildable Lorentz.Entrypoints.Doc.ParamBuilder
instance GHC.Show.Show Lorentz.Entrypoints.Doc.ParamBuilder
instance GHC.Classes.Eq Lorentz.Entrypoints.Doc.ParamBuilder
instance Morley.Michelson.Doc.DocItem Lorentz.Entrypoints.Doc.DEntrypointReference
instance Lorentz.Entrypoints.Doc.EntrypointKindHasDoc kind => Lorentz.Entrypoints.Doc.EntrypointKindHasDoc (Lorentz.Entrypoints.Doc.CommonEntrypointsBehaviourKind kind)
instance Lorentz.Entrypoints.Doc.EntrypointKindHasDoc Lorentz.Entrypoints.Doc.CommonContractBehaviourKind
instance Lorentz.Entrypoints.Doc.EntrypointKindHasDoc Lorentz.Entrypoints.Doc.PlainEntrypointsKind
instance Lorentz.Entrypoints.Doc.EntrypointKindHasDoc ep => Morley.Michelson.Doc.DocItem (Lorentz.Entrypoints.Doc.DEntrypoint ep)

module Lorentz.UParam

-- | Encapsulates parameter for one of entry points. It keeps entrypoint
--   name and corresponding argument serialized.
--   
--   In Haskell world, we keep an invariant of that contained value relates
--   to one of entry points from <tt>entries</tt> list.
newtype UParam (entries :: [EntrypointKind])
UnsafeUParam :: (MText, ByteString) -> UParam (entries :: [EntrypointKind])

-- | An entrypoint is described by two types: its name and type of
--   argument.
type EntrypointKind = (Symbol, Type)

-- | A convenient alias for type-level name-something pair.
type (n :: Symbol) ?: (a :: k) = '(n, a)

-- | Construct a <a>UParam</a> safely.
mkUParam :: (NicePackedValue a, LookupEntrypoint name entries ~ a, RequireUniqueEntrypoints entries) => Label name -> a -> UParam entries

-- | This type can store any value that satisfies a certain constraint.
data ConstrainedSome (c :: Type -> Constraint)
[ConstrainedSome] :: c a => a -> ConstrainedSome c

-- | This class is needed to implement <a>unpackUParam</a>.
class UnpackUParam (c :: Type -> Constraint) entries

-- | Turn <a>UParam</a> into a Haskell value. Since we don't know its type
--   in compile time, we have to erase it using <a>ConstrainedSome</a>. The
--   user of this function can require arbitrary constraint to hold
--   (depending on how they want to use the result).
unpackUParam :: UnpackUParam c entries => UParam entries -> Either EntrypointLookupError (MText, ConstrainedSome c)

-- | Pseudo value for <a>UParam</a> type variable.
type SomeInterface = '[ '("SomeEntrypoints", Void)]

-- | Homomorphic version of <a>UParam</a>, forgets the exact interface.
type UParam_ = UParam SomeInterface

-- | Implementations of some entry points.
--   
--   Note that this thing inherits properties of <a>Rec</a>, e.g. you can
--   <tt>Data.Vinyl.Core.rappend</tt> implementations for two entrypoint
--   sets when assembling scattered parts of a contract.
type EntrypointsImpl inp out entries = Rec (CaseClauseU inp out) entries

-- | An action invoked when user-provided entrypoint is not found.
type UParamFallback inp out = ((MText, ByteString) : inp) :-> out
data EntrypointLookupError
NoSuchEntrypoint :: MText -> EntrypointLookupError
ArgumentUnpackFailed :: EntrypointLookupError

-- | Make up a "case" over entry points.
class CaseUParam (entries :: [EntrypointKind])

-- | Pattern-match on given <tt>UParam entries</tt>.
--   
--   You have to provide all case branches and a fallback action on case
--   when entrypoint is not found.
caseUParam :: (CaseUParam entries, RequireUniqueEntrypoints entries) => Rec (CaseClauseU inp out) entries -> UParamFallback inp out -> (UParam entries : inp) :-> out

-- | Like <a>caseUParam</a>, but accepts a tuple of clauses, not a
--   <a>Rec</a>.
caseUParamT :: forall entries inp out clauses. (clauses ~ Rec (CaseClauseU inp out) entries, RecFromTuple clauses, CaseUParam entries) => IsoRecTuple clauses -> UParamFallback inp out -> (UParam entries : inp) :-> out

-- | Default implementation for <a>UParamFallback</a>, simply reports an
--   error.
uparamFallbackFail :: UParamFallback inp out

-- | Get type of entrypoint argument by its name.
type family LookupEntrypoint (name :: Symbol) (entries :: [EntrypointKind]) :: Type

-- | Ensure that given entry points do no contain duplicated names.
type family RequireUniqueEntrypoints (entries :: [EntrypointKind]) :: Constraint

-- | Make up <a>UParam</a> from ADT sum.
--   
--   Entry points template will consist of <tt>(constructorName,
--   constructorFieldType)</tt> pairs. Each constructor is expected to have
--   exactly one field.
uparamFromAdt :: UParamLinearize up => up -> UParam (UParamLinearized up)

-- | Constraint required by <a>uparamFromAdt</a>.
type UParamLinearize p = (Generic p, GUParamLinearize (Rep p))

-- | Entry points template derived from given ADT sum.
type UParamLinearized p = GUParamLinearized (Rep p)

-- | Note that calling given entrypoints involves constructing
--   <a>UParam</a>.
pbsUParam :: forall ctorName. KnownSymbol ctorName => ParamBuildingStep

-- | Helper instruction which extracts content of <a>UParam</a>.
unwrapUParam :: (UParam entries : s) :-> ((MText, ByteString) : s)
instance Lorentz.Wrappable.Unwrappable (Lorentz.UParam.UParam entries)
instance Lorentz.Annotation.HasAnnotation (Lorentz.UParam.UParam entries)
instance Morley.Michelson.Typed.Haskell.Value.IsoValue (Lorentz.UParam.UParam entries)
instance GHC.Show.Show (Lorentz.UParam.UParam entries)
instance GHC.Classes.Eq (Lorentz.UParam.UParam entries)
instance GHC.Generics.Generic (Lorentz.UParam.UParam entries)
instance GHC.Show.Show Lorentz.UParam.EntrypointLookupError
instance GHC.Classes.Eq Lorentz.UParam.EntrypointLookupError
instance GHC.Generics.Generic Lorentz.UParam.EntrypointLookupError
instance Lorentz.UParam.GUParamLinearize x => Lorentz.UParam.GUParamLinearize (GHC.Generics.D1 i x)
instance (Lorentz.UParam.GUParamLinearize x, Lorentz.UParam.GUParamLinearize y) => Lorentz.UParam.GUParamLinearize (x GHC.Generics.:+: y)
instance (GHC.TypeLits.KnownSymbol name, Lorentz.Constraints.Scopes.NicePackedValue a) => Lorentz.UParam.GUParamLinearize (GHC.Generics.C1 ('GHC.Generics.MetaCons name _1 _2) (GHC.Generics.S1 si (GHC.Generics.Rec0 a)))
instance (TypeError ...) => Lorentz.UParam.GUParamLinearize (GHC.Generics.C1 i GHC.Generics.U1)
instance (TypeError ...) => Lorentz.UParam.GUParamLinearize (GHC.Generics.C1 i (x GHC.Generics.:*: y))
instance Lorentz.UParam.CaseUParam '[]
instance (GHC.TypeLits.KnownSymbol name, Lorentz.UParam.CaseUParam entries, Data.Typeable.Internal.Typeable entries, Lorentz.Constraints.Scopes.NiceUnpackedValue arg) => Lorentz.UParam.CaseUParam ((name Lorentz.UParam.?: arg) : entries)
instance Lorentz.UParam.UnpackUParam c '[]
instance (GHC.TypeLits.KnownSymbol name, Lorentz.UParam.UnpackUParam c entries, Lorentz.Constraints.Scopes.NiceUnpackedValue arg, c arg) => Lorentz.UParam.UnpackUParam c ((name Lorentz.UParam.?: arg) : entries)
instance Formatting.Buildable.Buildable Lorentz.UParam.EntrypointLookupError
instance (name GHC.Types.~ name', body GHC.Types.~ ((arg : inp) Lorentz.Base.:-> out)) => Lorentz.ADT.CaseArrow name' body (Lorentz.UParam.CaseClauseU inp out '(name, arg))
instance GHC.Show.Show (Lorentz.UParam.ConstrainedSome GHC.Show.Show)
instance Formatting.Buildable.Buildable (Lorentz.UParam.ConstrainedSome Formatting.Buildable.Buildable)
instance Lorentz.UParam.SameEntries entries1 entries2 => Lorentz.Coercions.CanCastTo (Lorentz.UParam.UParam entries1) (Lorentz.UParam.UParam entries2)
instance Data.Typeable.Internal.Typeable interface => Morley.Michelson.Typed.Haskell.Doc.TypeHasDoc (Lorentz.UParam.UParam interface)
instance Formatting.Buildable.Buildable (Lorentz.Errors.CustomError "uparamNoSuchEntrypoint")
instance Formatting.Buildable.Buildable (Lorentz.Errors.CustomError "uparamArgumentUnpackFailed")
instance Lorentz.Errors.CustomErrorHasDoc "uparamNoSuchEntrypoint"
instance Lorentz.Errors.CustomErrorHasDoc "uparamArgumentUnpackFailed"


-- | Lorentz contracts compilation.
--   
--   Compilation in one scheme:
--   
--   <pre>
--                       mkContract
--                     mkContractWith
--     ContractCode  -----------------→  Contract
--    (Lorentz code)              (ready compiled contract)
--           ↓                                ↑
--           ↓                                ↑
--   defaultContractData            compileLorentzContract
--      ContractData                          ↑
--           ↓         ContractData           ↑
--          (Lorentz code + compilation options)
--   </pre>
module Lorentz.Run

-- | Compiled Lorentz contract.
--   
--   Note, that the views argument (views descriptor) is added comparing to
--   the Michelson. In Michelson, ability to call a view is fully checked
--   at runtime, but in Lorentz we want to make calls safer at
--   compile-time.
data Contract cp st vd
Contract :: Contract (ToT cp) (ToT st) -> ~ContractCode cp st -> Contract cp st vd

-- | Ready contract code.
[cMichelsonContract] :: Contract cp st vd -> Contract (ToT cp) (ToT st)

-- | Contract that contains documentation.
--   
--   We have to keep it separately, since optimizer is free to destroy
--   documentation blocks. Also, it is not <a>ContractDoc</a> but Lorentz
--   code because the latter is easier to modify.
[cDocumentedCode] :: Contract cp st vd -> ~ContractCode cp st

-- | Demote Lorentz <a>Contract</a> to Michelson typed <a>Contract</a>.
toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)

-- | Construct and compile Lorentz contract.
--   
--   This is an alias for <a>mkContract</a>.
defaultContract :: (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> Contract cp st ()

-- | Options to control Lorentz to Michelson compilation.
data CompilationOptions
CompilationOptions :: Maybe OptimizerConf -> (Bool, MText -> MText) -> (Bool, ByteString -> ByteString) -> Bool -> CompilationOptions

-- | Config for Michelson optimizer.
[coOptimizerConf] :: CompilationOptions -> Maybe OptimizerConf

-- | Function to transform strings with. See
--   <a>transformStringsLorentz</a>.
[coStringTransformer] :: CompilationOptions -> (Bool, MText -> MText)

-- | Function to transform byte strings with. See
--   <a>transformBytesLorentz</a>.
[coBytesTransformer] :: CompilationOptions -> (Bool, ByteString -> ByteString)

-- | Flag which defines whether compiled Michelson contract will have
--   <tt>CAST</tt> (which drops parameter annotations) as a first
--   instruction. Note that when flag is false, there still may be no
--   <tt>CAST</tt> (in case when parameter type has no annotations).
[coDisableInitialCast] :: CompilationOptions -> Bool

-- | Runs Michelson optimizer with default config and does not touch
--   strings and bytes.
defaultCompilationOptions :: CompilationOptions

-- | Leave contract without any modifications. For testing purposes.
intactCompilationOptions :: CompilationOptions
coBytesTransformerL :: Lens' CompilationOptions (Bool, ByteString -> ByteString)
coOptimizerConfL :: Lens' CompilationOptions (Maybe OptimizerConf)
coStringTransformerL :: Lens' CompilationOptions (Bool, MText -> MText)

-- | For use outside of Lorentz. Will use <a>defaultCompilationOptions</a>.
compileLorentz :: (inp :-> out) -> Instr (ToTs inp) (ToTs out)

-- | Compile Lorentz code, optionally running the optimizer, string and
--   byte transformers.
compileLorentzWithOptions :: CompilationOptions -> (inp :-> out) -> Instr (ToTs inp) (ToTs out)

-- | Construct and compile Lorentz contract.
--   
--   Note that this accepts code with initial and final stacks unpaired for
--   simplicity.
mkContract :: (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> Contract cp st ()

-- | Version of <a>mkContract</a> that accepts custom compilation options.
mkContractWith :: (NiceParameterFull cp, NiceStorage st) => CompilationOptions -> ContractCode cp st -> Contract cp st ()

-- | Code for a contract along with compilation options for the Lorentz
--   compiler.
--   
--   It is expected that a <a>Contract</a> is one packaged entity, wholly
--   controlled by its author. Therefore the author should be able to set
--   all options that control contract's behavior.
--   
--   This helps ensure that a given contract will be interpreted in the
--   same way in all environments, like production and testing.
--   
--   Raw <a>ContractCode</a> should not be used for distribution of
--   contracts.
data ContractData cp st vd
ContractData :: ContractCode cp st -> Rec (ContractView st) (RevealViews vd) -> CompilationOptions -> ContractData cp st vd

-- | The contract itself.
[cdCode] :: ContractData cp st vd -> ContractCode cp st

-- | Contract views.
[cdViews] :: ContractData cp st vd -> Rec (ContractView st) (RevealViews vd)

-- | General compilation options for the Lorentz compiler.
[cdCompilationOptions] :: ContractData cp st vd -> CompilationOptions

-- | Single contract view.
data ContractView st (v :: ViewTyInfo)
[ContractView] :: (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)

-- | Compile contract with <a>defaultCompilationOptions</a>.
defaultContractData :: forall cp st. (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> ContractData cp st ()

-- | Compile a whole contract to Michelson.
--   
--   Note that compiled contract can be ill-typed in terms of Michelson
--   code when some of the compilation options are used (e.g. when
--   <a>coDisableInitialCast</a> is <tt>True</tt>, resulted contract can be
--   ill-typed). However, compilation with <a>defaultCompilationOptions</a>
--   should be valid.
compileLorentzContract :: forall cp st vd. ContractData cp st vd -> Contract cp st vd

-- | Construct a view.
--   
--   <pre>
--   mkView @"add" @(Integer, Integer) do
--    car; unpair; add
--   </pre>
mkView :: forall name 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)

-- | Set all the contract's views.
--   
--   <pre>
--   compileLorentzContract $
--     defaultContractData do
--       ...
--     &amp; setViews
--       ( mkView <tt>"myView" </tt>() do
--           ...
--       , mkView <tt>"anotherView" </tt>Integer do
--           ...
--       )
--   </pre>
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

-- | Version of <a>setViews</a> that accepts a <a>Rec</a>.
--   
--   May be useful if you have too many views or want to combine views
--   sets.
setViewsRec :: forall vd cp st. NiceViewsDescriptor vd => Rec (ContractView st) (RevealViews vd) -> ContractData cp st () -> ContractData cp st vd

-- | Restrict type of <a>Contract</a>, <a>ContractData</a> or other similar
--   type to have no views.
noViews :: contract cp st () -> contract cp st ()
cdCodeL :: forall cp st vd cp1. (NiceParameterFull cp1, NiceStorage st) => Lens (ContractData cp st vd) (ContractData cp1 st vd) (ContractCode cp st) (ContractCode cp1 st)
coDisableInitialCastL :: Lens' CompilationOptions Bool
cdCompilationOptionsL :: forall cp st vd. Lens' (ContractData cp st vd) CompilationOptions

-- | Interpret a Lorentz instruction, for test purposes. Note that this
--   does not run the optimizer.
interpretLorentzInstr :: (IsoValuesStack inp, IsoValuesStack out) => ContractEnv -> (inp :-> out) -> Rec Identity inp -> Either MichelsonFailureWithStack (Rec Identity out)

-- | Like <a>interpretLorentzInstr</a>, but works on lambda rather than
--   arbitrary instruction.
interpretLorentzLambda :: (IsoValue inp, IsoValue out) => ContractEnv -> Lambda inp out -> inp -> Either MichelsonFailureWithStack out

-- | Lorentz version of analyzer.
analyzeLorentz :: (inp :-> out) -> AnalyzerRes
instance Morley.Michelson.Doc.ContainsDoc (Lorentz.Run.ContractData cp st vd)
instance Morley.Michelson.Doc.ContainsUpdateableDoc (Lorentz.Run.ContractData cp st vd)


-- | Running Lorentz code easily.
--   
--   For testing and demonstration purposes.
module Lorentz.Run.Simple

-- | Run a lambda with given input.
--   
--   Note that this always returns one value, but can accept multiple input
--   values (in such case they are grouped into nested pairs).
--   
--   For testing and demonstration purposes.
(-$?) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out) => (inps :-> '[out]) -> ZippedStack inps -> Either MichelsonFailureWithStack out
infixr 2 -$?

-- | Like <tt><a>-$?</a></tt>, assumes that no failure is possible.
--   
--   For testing and demonstration purposes. Note, that here types of
--   variables are specified, because the result type of arithmetic
--   operations depends on them.
--   
--   <pre>
--   &gt;&gt;&gt; nop -$ 5
--   5
--   
--   &gt;&gt;&gt; sub -$ ((3 :: Integer), (2 :: Integer))
--   1
--   
--   &gt;&gt;&gt; push 9 -$ ()
--   9
--   
--   &gt;&gt;&gt; add # add -$ ((1 :: Integer), ((2 :: Integer), (3 :: Integer)))
--   6
--   </pre>
(-$) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out, HasCallStack) => (inps :-> '[out]) -> ZippedStack inps -> out
infixr 2 -$

-- | Version of (-$?) with arguments flipped.
(&?-) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out) => ZippedStack inps -> (inps :-> '[out]) -> Either MichelsonFailureWithStack out
infixl 2 &?-

-- | Version of (-$) with arguments flipped.
(&-) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out, HasCallStack) => ZippedStack inps -> (inps :-> '[out]) -> out
infixl 2 &-

-- | Version of (-$) applicable to a series of values.
(<-$>) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out, HasCallStack) => (inps :-> '[out]) -> [ZippedStack inps] -> [out]
infixl 2 <-$>


-- | Printing lorentz contracts.
module Lorentz.Print

-- | Pretty-print a Haskell value as Michelson one.
printLorentzValue :: forall v. NiceUntypedValue v => Bool -> v -> LText

-- | Pretty-print a Lorentz contract into Michelson code.
printLorentzContract :: Bool -> Contract cp st vd -> LText


-- | Operation size evaluation.
module Lorentz.OpSize
newtype OpSize
OpSize :: Word -> OpSize
[unOpSize] :: OpSize -> Word
opSizeHardLimit :: OpSize
smallTransferOpSize :: OpSize

-- | Estimate code operation size.
contractOpSize :: Contract cp st vd -> OpSize

-- | Estimate value operation size.
valueOpSize :: forall a. NiceUntypedValue a => a -> OpSize


-- | This module contains various datatypes and functions which are common
--   for contract registry packages (e.g. <a>morley-ledgers</a>).
module Lorentz.ContractRegistry
data ContractInfo
ContractInfo :: Contract cp st vd -> Bool -> Maybe (Parser st) -> Maybe (Notes (ToT st)) -> ContractInfo
[ciContract] :: ContractInfo -> Contract cp st vd
[ciIsDocumented] :: ContractInfo -> Bool

-- | Specifies how to parse initial storage value.
--   
--   Normally you pass some user data and call a function that constructs
--   storage from that data.
--   
--   If storage is simple and can be easilly constructed manually, you can
--   use <a>Nothing</a>.
[ciStorageParser] :: ContractInfo -> Maybe (Parser st)

-- | Rewrite annotations in storage. We don't won't to uncoditionally
--   override storage notes since after #20 we require notes to be
--   non-empty, so we wrap them into <a>Maybe</a>.
[ciStorageNotes] :: ContractInfo -> Maybe (Notes (ToT st))
newtype ContractRegistry
ContractRegistry :: Map Text ContractInfo -> ContractRegistry
[unContractRegistry] :: ContractRegistry -> Map Text ContractInfo
(?::) :: Text -> a -> (Text, a)

-- | <a>ContractRegistry</a> actions parsed from CLI.
data CmdLnArgs
List :: CmdLnArgs
Print :: Maybe Text -> Maybe FilePath -> Bool -> Bool -> CmdLnArgs
Document :: Maybe Text -> Maybe FilePath -> DGitRevision -> CmdLnArgs
Analyze :: Maybe Text -> CmdLnArgs
PrintStorage :: SomeNiceStorage -> Bool -> CmdLnArgs
argParser :: ContractRegistry -> DGitRevision -> Parser CmdLnArgs

-- | Run an action operating with <a>ContractRegistry</a>.
runContractRegistry :: ContractRegistry -> CmdLnArgs -> IO ()
printContractFromRegistryDoc :: Maybe Text -> ContractRegistry -> DGitRevision -> Maybe FilePath -> IO ()
instance Formatting.Buildable.Buildable Lorentz.ContractRegistry.ContractRegistry

module Lorentz

-- | Application operator. This operator is redundant, since ordinary
--   application <tt>(f x)</tt> means the same as <tt>(f <a>$</a> x)</tt>.
--   However, <a>$</a> has low, right-associative binding precedence, so it
--   sometimes allows parentheses to be omitted; for example:
--   
--   <pre>
--   f $ g $ h x  =  f (g (h x))
--   </pre>
--   
--   It is also useful in higher-order situations, such as <tt><a>map</a>
--   (<a>$</a> 0) xs</tt>, or <tt><a>zipWith</a> (<a>$</a>) fs xs</tt>.
--   
--   Note that <tt>(<a>$</a>)</tt> is levity-polymorphic in its result
--   type, so that <tt>foo <a>$</a> True</tt> where <tt>foo :: Bool -&gt;
--   Int#</tt> is well-typed.
($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b
infixr 0 $

-- | The <a>Bounded</a> class is used to name the upper and lower limits of
--   a type. <a>Ord</a> is not a superclass of <a>Bounded</a> since types
--   that are not totally ordered may also have upper and lower bounds.
--   
--   The <a>Bounded</a> class may be derived for any enumeration type;
--   <a>minBound</a> is the first constructor listed in the <tt>data</tt>
--   declaration and <a>maxBound</a> is the last. <a>Bounded</a> may also
--   be derived for single-constructor datatypes whose constituent types
--   are in <a>Bounded</a>.
class Bounded a
minBound :: Bounded a => a
maxBound :: Bounded a => a

-- | The <a>Eq</a> class defines equality (<a>==</a>) and inequality
--   (<a>/=</a>). All the basic datatypes exported by the <a>Prelude</a>
--   are instances of <a>Eq</a>, and <a>Eq</a> may be derived for any
--   datatype whose constituents are also instances of <a>Eq</a>.
--   
--   The Haskell Report defines no laws for <a>Eq</a>. However, <a>==</a>
--   is customarily expected to implement an equivalence relationship where
--   two values comparing equal are indistinguishable by "public"
--   functions, with a "public" function being one not allowing to see
--   implementation details. For example, for a type representing
--   non-normalised natural numbers modulo 100, a "public" function doesn't
--   make the difference between 1 and 201. It is expected to have the
--   following properties:
--   
--   <ul>
--   <li><i><b>Reflexivity</b></i> <tt>x == x</tt> = <a>True</a></li>
--   <li><i><b>Symmetry</b></i> <tt>x == y</tt> = <tt>y == x</tt></li>
--   <li><i><b>Transitivity</b></i> if <tt>x == y &amp;&amp; y == z</tt> =
--   <a>True</a>, then <tt>x == z</tt> = <a>True</a></li>
--   <li><i><b>Substitutivity</b></i> if <tt>x == y</tt> = <a>True</a> and
--   <tt>f</tt> is a "public" function whose return type is an instance of
--   <a>Eq</a>, then <tt>f x == f y</tt> = <a>True</a></li>
--   <li><i><b>Negation</b></i> <tt>x /= y</tt> = <tt>not (x ==
--   y)</tt></li>
--   </ul>
--   
--   Minimal complete definition: either <a>==</a> or <a>/=</a>.
class Eq a

-- | Inject a value into the monadic type.
return :: Monad m => a -> m a

-- | Unary negation.
negate :: Num a => a -> a

-- | The <a>Ord</a> class is used for totally ordered datatypes.
--   
--   Instances of <a>Ord</a> can be derived for any user-defined datatype
--   whose constituent types are in <a>Ord</a>. The declared order of the
--   constructors in the data declaration determines the ordering in
--   derived <a>Ord</a> instances. The <a>Ordering</a> datatype allows a
--   single comparison to determine the precise ordering of two objects.
--   
--   The Haskell Report defines no laws for <a>Ord</a>. However,
--   <a>&lt;=</a> is customarily expected to implement a non-strict partial
--   order and have the following properties:
--   
--   <ul>
--   <li><i><b>Transitivity</b></i> if <tt>x &lt;= y &amp;&amp; y &lt;=
--   z</tt> = <a>True</a>, then <tt>x &lt;= z</tt> = <a>True</a></li>
--   <li><i><b>Reflexivity</b></i> <tt>x &lt;= x</tt> = <a>True</a></li>
--   <li><i><b>Antisymmetry</b></i> if <tt>x &lt;= y &amp;&amp; y &lt;=
--   x</tt> = <a>True</a>, then <tt>x == y</tt> = <a>True</a></li>
--   </ul>
--   
--   Note that the following operator interactions are expected to hold:
--   
--   <ol>
--   <li><tt>x &gt;= y</tt> = <tt>y &lt;= x</tt></li>
--   <li><tt>x &lt; y</tt> = <tt>x &lt;= y &amp;&amp; x /= y</tt></li>
--   <li><tt>x &gt; y</tt> = <tt>y &lt; x</tt></li>
--   <li><tt>x &lt; y</tt> = <tt>compare x y == LT</tt></li>
--   <li><tt>x &gt; y</tt> = <tt>compare x y == GT</tt></li>
--   <li><tt>x == y</tt> = <tt>compare x y == EQ</tt></li>
--   <li><tt>min x y == if x &lt;= y then x else y</tt> = <a>True</a></li>
--   <li><tt>max x y == if x &gt;= y then x else y</tt> = <a>True</a></li>
--   </ol>
--   
--   Note that (7.) and (8.) do <i>not</i> require <a>min</a> and
--   <a>max</a> to return either of their arguments. The result is merely
--   required to <i>equal</i> one of the arguments in terms of <a>(==)</a>.
--   
--   Minimal complete definition: either <a>compare</a> or <a>&lt;=</a>.
--   Using <a>compare</a> can be more efficient for complex types.
class Eq a => Ord a

-- | Conversion of values to readable <a>String</a>s.
--   
--   Derived instances of <a>Show</a> have the following properties, which
--   are compatible with derived instances of <a>Read</a>:
--   
--   <ul>
--   <li>The result of <a>show</a> is 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.</li>
--   <li>If the constructor is defined to be an infix operator, then
--   <a>showsPrec</a> will produce infix applications of the
--   constructor.</li>
--   <li>the representation will be enclosed in parentheses if the
--   precedence of the top-level constructor in <tt>x</tt> is less than
--   <tt>d</tt> (associativity is ignored). Thus, if <tt>d</tt> is
--   <tt>0</tt> then the result is never surrounded in parentheses; if
--   <tt>d</tt> is <tt>11</tt> it is always surrounded in parentheses,
--   unless it is an atomic expression.</li>
--   <li>If the constructor is defined using record syntax, then
--   <a>show</a> will produce the record-syntax form, with the fields given
--   in the same order as the original declaration.</li>
--   </ul>
--   
--   For example, given the declarations
--   
--   <pre>
--   infixr 5 :^:
--   data Tree a =  Leaf a  |  Tree a :^: Tree a
--   </pre>
--   
--   the derived instance of <a>Show</a> is equivalent to
--   
--   <pre>
--   instance (Show a) =&gt; Show (Tree a) where
--   
--          showsPrec d (Leaf m) = showParen (d &gt; app_prec) $
--               showString "Leaf " . showsPrec (app_prec+1) m
--            where app_prec = 10
--   
--          showsPrec d (u :^: v) = showParen (d &gt; up_prec) $
--               showsPrec (up_prec+1) u .
--               showString " :^: "      .
--               showsPrec (up_prec+1) v
--            where up_prec = 5
--   </pre>
--   
--   Note that right-associativity of <tt>:^:</tt> is ignored. For example,
--   
--   <ul>
--   <li><tt><a>show</a> (Leaf 1 :^: Leaf 2 :^: Leaf 3)</tt> produces the
--   string <tt>"Leaf 1 :^: (Leaf 2 :^: Leaf 3)"</tt>.</li>
--   </ul>
class Show a
fromString :: IsString a => String -> a

-- | Lift a value.
pure :: Applicative f => a -> f a

-- | Representable types of kind <tt>*</tt>. This class is derivable in GHC
--   with the <tt>DeriveGeneric</tt> flag on.
--   
--   A <a>Generic</a> instance must satisfy the following laws:
--   
--   <pre>
--   <a>from</a> . <a>to</a> ≡ <a>id</a>
--   <a>to</a> . <a>from</a> ≡ <a>id</a>
--   </pre>
class Generic a
fromLabel :: IsLabel x a => a

-- | The class of semigroups (types with an associative binary operation).
--   
--   Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt></li>
--   </ul>
class Semigroup a

-- | An associative operation.
--   
--   <pre>
--   &gt;&gt;&gt; [1,2,3] &lt;&gt; [4,5,6]
--   [1,2,3,4,5,6]
--   </pre>
(<>) :: Semigroup a => a -> a -> a

-- | Reduce a non-empty list with <a>&lt;&gt;</a>
--   
--   The default definition should be sufficient, but this can be
--   overridden for efficiency.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.List.NonEmpty
--   
--   &gt;&gt;&gt; sconcat $ "Hello" :| [" ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
sconcat :: Semigroup a => NonEmpty a -> a

-- | Repeat a value <tt>n</tt> times.
--   
--   Given that this works on a <a>Semigroup</a> it is allowed to fail if
--   you request 0 or fewer repetitions, and the default definition will do
--   so.
--   
--   By making this a member of the class, idempotent semigroups and
--   monoids can upgrade this to execute in &lt;math&gt; by picking
--   <tt>stimes = <a>stimesIdempotent</a></tt> or <tt>stimes =
--   <a>stimesIdempotentMonoid</a></tt> respectively.
--   
--   <pre>
--   &gt;&gt;&gt; stimes 4 [1]
--   [1,1,1,1]
--   </pre>
stimes :: (Semigroup a, Integral b) => b -> a -> a
infixr 6 <>

-- | The class of monoids (types with an associative binary operation that
--   has an identity). Instances should satisfy the following:
--   
--   <ul>
--   <li><i>Right identity</i> <tt>x <a>&lt;&gt;</a> <a>mempty</a> =
--   x</tt></li>
--   <li><i>Left identity</i> <tt><a>mempty</a> <a>&lt;&gt;</a> x =
--   x</tt></li>
--   <li><i>Associativity</i> <tt>x <a>&lt;&gt;</a> (y <a>&lt;&gt;</a> z) =
--   (x <a>&lt;&gt;</a> y) <a>&lt;&gt;</a> z</tt> (<a>Semigroup</a>
--   law)</li>
--   <li><i>Concatenation</i> <tt><a>mconcat</a> = <a>foldr</a>
--   (<a>&lt;&gt;</a>) <a>mempty</a></tt></li>
--   </ul>
--   
--   The method names refer to the monoid of lists under concatenation, but
--   there are many other instances.
--   
--   Some types can be viewed as a monoid in more than one way, e.g. both
--   addition and multiplication on numbers. In such cases we often define
--   <tt>newtype</tt>s and make those instances of <a>Monoid</a>, e.g.
--   <a>Sum</a> and <a>Product</a>.
--   
--   <b>NOTE</b>: <a>Semigroup</a> is a superclass of <a>Monoid</a> since
--   <i>base-4.11.0.0</i>.
class Semigroup a => Monoid a

-- | Identity of <a>mappend</a>
--   
--   <pre>
--   &gt;&gt;&gt; "Hello world" &lt;&gt; mempty
--   "Hello world"
--   </pre>
mempty :: Monoid a => a

-- | An associative operation
--   
--   <b>NOTE</b>: This method is redundant and has the default
--   implementation <tt><a>mappend</a> = (<a>&lt;&gt;</a>)</tt> since
--   <i>base-4.11.0.0</i>. Should it be implemented manually, since
--   <a>mappend</a> is a synonym for (<a>&lt;&gt;</a>), it is expected that
--   the two functions are defined the same way. In a future GHC release
--   <a>mappend</a> will be removed from <a>Monoid</a>.
mappend :: Monoid a => a -> a -> a

-- | Fold a list using the monoid.
--   
--   For most types, the default definition for <a>mconcat</a> will be
--   used, but the function is included in the class definition so that an
--   optimized version can be provided for specific types.
--   
--   <pre>
--   &gt;&gt;&gt; mconcat ["Hello", " ", "Haskell", "!"]
--   "Hello Haskell!"
--   </pre>
mconcat :: Monoid a => [a] -> a
data Bool
False :: Bool
True :: Bool

-- | Arbitrary precision integers. In contrast with fixed-size integral
--   types such as <a>Int</a>, the <a>Integer</a> type represents the
--   entire infinite range of integers.
--   
--   For more information about this type's representation, see the
--   comments in its implementation.
data Integer

-- | Type representing arbitrary-precision non-negative integers.
--   
--   <pre>
--   &gt;&gt;&gt; 2^100 :: Natural
--   1267650600228229401496703205376
--   </pre>
--   
--   Operations whose result would be negative <tt><a>throw</a>
--   (<a>Underflow</a> :: <a>ArithException</a>)</tt>,
--   
--   <pre>
--   &gt;&gt;&gt; -1 :: Natural
--   *** Exception: arithmetic underflow
--   </pre>
data Natural

-- | The <a>Maybe</a> type encapsulates an optional value. A value of type
--   <tt><a>Maybe</a> a</tt> either contains a value of type <tt>a</tt>
--   (represented as <tt><a>Just</a> a</tt>), or it is empty (represented
--   as <a>Nothing</a>). Using <a>Maybe</a> is a good way to deal with
--   errors or exceptional cases without resorting to drastic measures such
--   as <a>error</a>.
--   
--   The <a>Maybe</a> type is also a monad. It is a simple kind of error
--   monad, where all errors are represented by <a>Nothing</a>. A richer
--   error monad can be built using the <a>Either</a> type.
data Maybe a
Nothing :: Maybe a
Just :: a -> Maybe a

-- | The <a>Either</a> type represents values with two possibilities: a
--   value of type <tt><a>Either</a> a b</tt> is either <tt><a>Left</a>
--   a</tt> or <tt><a>Right</a> b</tt>.
--   
--   The <a>Either</a> type is sometimes used to represent a value which is
--   either correct or an error; by convention, the <a>Left</a> constructor
--   is used to hold an error value and the <a>Right</a> constructor is
--   used to hold a correct value (mnemonic: "right" also means "correct").
--   
--   <h4><b>Examples</b></h4>
--   
--   The type <tt><a>Either</a> <a>String</a> <a>Int</a></tt> is the type
--   of values which can be either a <a>String</a> or an <a>Int</a>. The
--   <a>Left</a> constructor can be used only on <a>String</a>s, and the
--   <a>Right</a> constructor can be used only on <a>Int</a>s:
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; s
--   Left "foo"
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; n
--   Right 3
--   
--   &gt;&gt;&gt; :type s
--   s :: Either String Int
--   
--   &gt;&gt;&gt; :type n
--   n :: Either String Int
--   </pre>
--   
--   The <a>fmap</a> from our <a>Functor</a> instance will ignore
--   <a>Left</a> values, but will apply the supplied function to values
--   contained in a <a>Right</a>:
--   
--   <pre>
--   &gt;&gt;&gt; let s = Left "foo" :: Either String Int
--   
--   &gt;&gt;&gt; let n = Right 3 :: Either String Int
--   
--   &gt;&gt;&gt; fmap (*2) s
--   Left "foo"
--   
--   &gt;&gt;&gt; fmap (*2) n
--   Right 6
--   </pre>
--   
--   The <a>Monad</a> instance for <a>Either</a> allows us to chain
--   together multiple actions which may fail, and fail overall if any of
--   the individual steps failed. First we'll write a function that can
--   either parse an <a>Int</a> from a <a>Char</a>, or fail.
--   
--   <pre>
--   &gt;&gt;&gt; import Data.Char ( digitToInt, isDigit )
--   
--   &gt;&gt;&gt; :{
--       let parseEither :: Char -&gt; Either String Int
--           parseEither c
--             | isDigit c = Right (digitToInt c)
--             | otherwise = Left "parse error"
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   The following should work, since both <tt>'1'</tt> and <tt>'2'</tt>
--   can be parsed as <a>Int</a>s.
--   
--   <pre>
--   &gt;&gt;&gt; :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x &lt;- parseEither '1'
--             y &lt;- parseEither '2'
--             return (x + y)
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseMultiple
--   Right 3
--   </pre>
--   
--   But the following should fail overall, since the first operation where
--   we attempt to parse <tt>'m'</tt> as an <a>Int</a> will fail:
--   
--   <pre>
--   &gt;&gt;&gt; :{
--       let parseMultiple :: Either String Int
--           parseMultiple = do
--             x &lt;- parseEither 'm'
--             y &lt;- parseEither '2'
--             return (x + y)
--   
--   &gt;&gt;&gt; :}
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; parseMultiple
--   Left "parse error"
--   </pre>
data Either a b
Left :: a -> Either a b
Right :: b -> Either a b

-- | A space-efficient representation of a <a>Word8</a> vector, supporting
--   many efficient operations.
--   
--   A <a>ByteString</a> contains 8-bit bytes, or by using the operations
--   from <a>Data.ByteString.Char8</a> it can be interpreted as containing
--   8-bit characters.
data ByteString

-- | A space efficient, packed, unboxed Unicode text type.
data Text

-- | Function composition.
(.) :: (b -> c) -> (a -> b) -> a -> c
infixr 9 .

-- | A Map from keys <tt>k</tt> to values <tt>a</tt>.
--   
--   The <a>Semigroup</a> operation for <a>Map</a> is <a>union</a>, which
--   prefers values from the left operand. If <tt>m1</tt> maps a key
--   <tt>k</tt> to a value <tt>a1</tt>, and <tt>m2</tt> maps the same key
--   to a different value <tt>a2</tt>, then their union <tt>m1 &lt;&gt;
--   m2</tt> maps <tt>k</tt> to <tt>a1</tt>.
data Map k a

-- | The type parameter should be an instance of <a>HasResolution</a>.
newtype Fixed (a :: k)
MkFixed :: Integer -> Fixed (a :: k)

-- | <a>Proxy</a> is a type that holds no data, but has a phantom parameter
--   of arbitrary type (or even kind). Its use is to provide type
--   information, even though there is no value available of that type (or
--   it may be too costly to create one).
--   
--   Historically, <tt><a>Proxy</a> :: <a>Proxy</a> a</tt> is a safer
--   alternative to the <tt><a>undefined</a> :: a</tt> idiom.
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy (Void, Int -&gt; Int)
--   Proxy
--   </pre>
--   
--   Proxy can even hold types of higher kinds,
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Either
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy Functor
--   Proxy
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; Proxy :: Proxy complicatedStructure
--   Proxy
--   </pre>
data Proxy (t :: k)
Proxy :: Proxy (t :: k)

-- | <a>&amp;</a> is a reverse application operator. This provides
--   notational convenience. Its precedence is one higher than that of the
--   forward application operator <a>$</a>, which allows <a>&amp;</a> to be
--   nested in <a>$</a>.
--   
--   <pre>
--   &gt;&gt;&gt; 5 &amp; (+1) &amp; show
--   "6"
--   </pre>
(&) :: a -> (a -> b) -> b
infixl 1 &

-- | From a <a>Dict</a>, takes a value in an environment where the instance
--   witnessed by the <a>Dict</a> is in scope, and evaluates it.
--   
--   Essentially a deconstruction of a <a>Dict</a> into its
--   continuation-style form.
--   
--   Can also be used to deconstruct an entailment, <tt>a <a>:-</a> b</tt>,
--   using a context <tt>a</tt>.
--   
--   <pre>
--   withDict :: <a>Dict</a> c -&gt; (c =&gt; r) -&gt; r
--   withDict :: a =&gt; (a <a>:-</a> c) -&gt; (c =&gt; r) -&gt; r
--   </pre>
withDict :: HasDict c e => e -> (c => r) -> r

-- | A set of values <tt>a</tt>.
data Set a

-- | A class for types with a default value.
class Default a

-- | The default value for this type.
def :: Default a => a

-- | Supply a parameter to a function:
--   
--   <pre>
--   function <a>!</a> #param_name value
--   </pre>
--   
--   <pre>
--   function <a>!</a> #x 7 <a>!</a> #y 42 <a>!</a> <a>defaults</a>
--   </pre>
--   
--   This is an infix version of <a>with</a>.
(!) :: WithParam p fn fn' => fn -> Param p -> fn'
infixl 9 !

-- | Infix notation for the type of a named parameter.
type (name :: Symbol) :! a = NamedF Identity a name

-- | Infix notation for the type of an optional named parameter.
type (name :: Symbol) :? a = NamedF Maybe a name

-- | O(n) Convert casing to <tt>snake_cased_phrase</tt>. <i>Subject to
--   fusion.</i>
toSnake :: Text -> Text

-- | O(n) Convert casing to <tt>PascalCasePhrase</tt>. <i>Subject to
--   fusion.</i>
toPascal :: Text -> Text

-- | O(n) Convert casing to <tt>camelCasedPhrase</tt>. <i>Subject to
--   fusion.</i>
toCamel :: Text -> Text

-- | Infix application.
--   
--   <pre>
--   f :: Either String $ Maybe Int
--   =
--   f :: Either String (Maybe Int)
--   </pre>
type (f :: k1 -> k) $ (a :: k1) = f a
infixr 2 $

-- | <a>undefined</a> that leaves a warning in code on every usage.
undefined :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => a

-- | <a>error</a> that takes <a>Text</a> as an argument.
error :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => Text -> a

-- | A record is parameterized by a universe <tt>u</tt>, an interpretation
--   <tt>f</tt> and a list of rows <tt>rs</tt>. The labels or indices of
--   the record are given by inhabitants of the kind <tt>u</tt>; the type
--   of values at any label <tt>r :: u</tt> is given by its interpretation
--   <tt>f r :: *</tt>.
data Rec (a :: u -> Type) (b :: [u])
[RNil] :: forall u (a :: u -> Type). Rec a ('[] :: [u])
[:&] :: forall u (a :: u -> Type) (r :: u) (rs :: [u]). !a r -> !Rec a rs -> Rec a (r : rs)
infixr 7 :&
fromInteger :: (HasCallStack, Integral a) => Integer -> a
mt :: QuasiQuoter
data MText
data Label (name :: Symbol)
[Label] :: forall (name :: Symbol). KnownSymbol name => Label name
insertTypeAnn :: forall (b :: T). TypeAnn -> Notes b -> Notes b
mkUType :: forall (x :: T). SingI x => Notes x -> Ty
ligoCombLayout :: GenericStrategy
ligoLayout :: GenericStrategy
concreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a), HaveCommonTypeCtor b a) => TypeDocHaskellRep b
concreteTypeDocMichelsonRep :: forall k a (b :: k). (Typeable a, KnownIsoT a, HaveCommonTypeCtor b a) => TypeDocMichelsonRep b
customTypeDocMdReference :: (Text, DType) -> [DType] -> WithinParens -> Markdown
dStorage :: TypeHasDoc store => DStorageType
dTypeDep :: TypeHasDoc t => SomeDocDefinitionItem
genericTypeDocDependencies :: (Generic a, GTypeHasDoc (Rep a)) => Proxy a -> [SomeDocDefinitionItem]
haskellAddNewtypeField :: Text -> TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepNoFields :: TypeDocHaskellRep a -> TypeDocHaskellRep a
haskellRepStripFieldPrefix :: HasCallStack => TypeDocHaskellRep a -> TypeDocHaskellRep a
homomorphicTypeDocHaskellRep :: (Generic a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep a
homomorphicTypeDocMdReference :: (Typeable t, TypeHasDoc t, IsHomomorphic t) => Proxy t -> WithinParens -> Markdown
homomorphicTypeDocMichelsonRep :: KnownIsoT a => TypeDocMichelsonRep a
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
typeDocBuiltMichelsonRep :: TypeHasDoc a => Proxy a -> Builder
unsafeConcreteTypeDocHaskellRep :: (Typeable a, GenericIsoValue a, GTypeHasDoc (Rep a)) => TypeDocHaskellRep b
unsafeConcreteTypeDocMichelsonRep :: forall k a (b :: k). (Typeable a, KnownIsoT a) => TypeDocMichelsonRep b
coerceContractRef :: ToT a ~ ToT b => ContractRef a -> ContractRef b
pattern DefEpName :: EpName
opSizeHardLimit :: OpSize
smallTransferOpSize :: OpSize
type Operation = Operation' Instr
type Value = Value' Instr
data EpAddress
EpAddress :: Address -> EpName -> EpAddress
[eaAddress] :: EpAddress -> Address
[eaEntrypoint] :: EpAddress -> EpName
data DType
[DType] :: forall a. TypeHasDoc a => Proxy a -> DType
class HaveCommonTypeCtor (a :: k) (b :: k1)
class IsHomomorphic (a :: k)
data SomeTypeWithDoc
[SomeTypeWithDoc] :: forall td. TypeHasDoc td => Proxy td -> SomeTypeWithDoc
type family TypeDocFieldDescriptions a :: FieldDescriptions
class (Typeable a, SingI TypeDocFieldDescriptions a, FieldDescriptionsValid TypeDocFieldDescriptions a a) => TypeHasDoc a where {
    type family TypeDocFieldDescriptions a :: FieldDescriptions;
    type TypeDocFieldDescriptions a = '[] :: [(Symbol, (Maybe Symbol, [(Symbol, Symbol)]))];
}
typeDocName :: TypeHasDoc a => Proxy a -> Text
typeDocMdDescription :: TypeHasDoc a => Markdown
typeDocMdReference :: TypeHasDoc a => Proxy a -> WithinParens -> Markdown
typeDocDependencies :: TypeHasDoc a => Proxy a -> [SomeDocDefinitionItem]
typeDocHaskellRep :: TypeHasDoc a => TypeDocHaskellRep a
typeDocMichelsonRep :: TypeHasDoc a => TypeDocMichelsonRep a
type ConstructorFieldTypes dt = GFieldTypes Rep dt
type InstrConstructC dt = (GenericIsoValue dt, GInstrConstruct Rep dt)
data BigMap k v
newtype BigMapId (k2 :: k) (v :: k1)
BigMapId :: Natural -> BigMapId (k2 :: k) (v :: k1)
[unBigMapId] :: BigMapId (k2 :: k) (v :: k1) -> Natural
data ContractRef arg
ContractRef :: Address -> SomeEntrypointCall arg -> ContractRef arg
[crAddress] :: ContractRef arg -> Address
[crEntrypoint] :: ContractRef arg -> SomeEntrypointCall arg
type EntrypointCall param arg = EntrypointCallT ToT param ToT arg
class WellTypedToT a => IsoValue a where {
    type family ToT a :: T;
    type ToT a = GValueType Rep a;
}
toVal :: IsoValue a => a -> Value (ToT a)
fromVal :: IsoValue a => Value (ToT a) -> a
type family ToT a :: T
type SomeEntrypointCall arg = SomeEntrypointCallT ToT arg
data Ticket arg
Ticket :: Address -> arg -> Natural -> Ticket arg
[tTicketer] :: Ticket arg -> Address
[tData] :: Ticket arg -> arg
[tAmount] :: Ticket arg -> Natural
mkBigMap :: ToBigMap m => m -> BigMap (ToBigMapKey m) (ToBigMapValue m)
type WellTypedIsoValue a = (WellTyped ToT a, IsoValue a)
class (SingI t, HasNoOp t, HasNoBigMap t, HasNoContract t, HasNoTicket t) => ConstantScope (t :: T)
data EpName
newtype OpSize
OpSize :: Word -> OpSize
[unOpSize] :: OpSize -> Word
newtype ViewName
UnsafeViewName :: Text -> ViewName
[unViewName] :: ViewName -> Text
pattern ViewName :: Text -> ViewName
data Address
data Bls12381Fr
data Bls12381G1
data Bls12381G2
data ChainId
data Chest
data ChestKey
data KeyHash
data Mutez
data PublicKey
data Signature
data Timestamp
oneMutez :: Mutez
timestampFromSeconds :: Integer -> Timestamp
timestampFromUTCTime :: UTCTime -> Timestamp
timestampQuote :: QuasiQuoter
toMutez :: Word32 -> Mutez
zeroMutez :: Mutez
class ContainsDoc a
buildDocUnfinalized :: ContainsDoc a => a -> ContractDoc
data ContractDoc
ContractDoc :: DocBlock -> DocBlock -> Set SomeDocDefinitionItem -> Set DocItemId -> ContractDoc
[cdContents] :: ContractDoc -> DocBlock
[cdDefinitions] :: ContractDoc -> DocBlock
[cdDefinitionsSet] :: ContractDoc -> Set SomeDocDefinitionItem
[cdDefinitionIds] :: ContractDoc -> Set DocItemId
newtype SubDoc
SubDoc :: DocBlock -> SubDoc
newtype DocItemPos
DocItemPos :: (Natural, Text) -> DocItemPos
data DocSection
DocSection :: (NonEmpty $ DocElem d) -> DocSection
class ContainsDoc a => ContainsUpdateableDoc a
modifyDocEntirely :: ContainsUpdateableDoc a => (SomeDocItem -> SomeDocItem) -> a -> a
data SomeDocItem
[SomeDocItem] :: forall d. DocItem d => d -> SomeDocItem
data SomeDocDefinitionItem
[SomeDocDefinitionItem] :: forall d. (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => d -> SomeDocDefinitionItem
data DGitRevision
DGitRevisionKnown :: DGitRevisionInfo -> DGitRevision
DGitRevisionUnknown :: DGitRevision
class (Typeable d, DOrd d) => DocItem d where {
    type family DocItemPlacement d :: DocItemPlacementKind;
    type family DocItemReferenced d :: DocItemReferencedKind;
    type DocItemPlacement d = 'DocItemInlined;
    type DocItemReferenced d = 'False;
}
docItemPos :: DocItem d => Natural
docItemSectionName :: DocItem d => Maybe Text
docItemSectionDescription :: DocItem d => Maybe Markdown
docItemSectionNameStyle :: DocItem d => DocSectionNameStyle
docItemRef :: DocItem d => d -> DocItemRef (DocItemPlacement d) (DocItemReferenced d)
docItemToMarkdown :: DocItem d => HeaderLevel -> d -> Markdown
docItemToToc :: DocItem d => HeaderLevel -> d -> Markdown
docItemDependencies :: DocItem d => d -> [SomeDocDefinitionItem]
docItemsOrder :: DocItem d => [d] -> [d]

-- | A Generic <tt>HasAnnotation</tt> implementation
class GHasAnnotation a
gGetAnnotation :: GHasAnnotation a => AnnOptions -> FollowEntrypointFlag -> GenerateFieldAnnFlag -> (Notes (GValueType a), FieldAnn, VarAnn)

-- | This class defines the type and field annotations for a given type.
--   Right now the type annotations come from names in a named field, and
--   field annotations are generated from the record fields.
class HasAnnotation a
getAnnotation :: HasAnnotation a => FollowEntrypointFlag -> Notes (ToT a)
getAnnotation :: (HasAnnotation a, GHasAnnotation (Rep a), GValueType (Rep a) ~ ToT a) => FollowEntrypointFlag -> Notes (ToT a)
annOptions :: HasAnnotation a => AnnOptions
annOptions :: HasAnnotation a => AnnOptions

-- | Used in <a>GHasAnnotation</a> as a flag to track whether or not
--   field/constructor annotations should be generated.
data GenerateFieldAnnFlag
GenerateFieldAnn :: GenerateFieldAnnFlag
NotGenerateFieldAnn :: GenerateFieldAnnFlag

-- | Used in <a>GHasAnnotation</a> and <a>HasAnnotation</a> as a flag to
--   track whether or not it directly follows an entrypoint to avoid
--   introducing extra entrypoints.
data FollowEntrypointFlag
FollowEntrypoint :: FollowEntrypointFlag
NotFollowEntrypoint :: FollowEntrypointFlag

-- | Allow customization of field annotation generated for a type when
--   declaring its <a>HasAnnotation</a> instance.
data AnnOptions
AnnOptions :: (Text -> Text) -> AnnOptions
[fieldAnnModifier] :: AnnOptions -> Text -> Text
defaultAnnOptions :: AnnOptions

-- | Drops the field name prefix from a field. We assume a convention of
--   the prefix always being lower case, and the first letter of the actual
--   field name being uppercase. It also accepts another function which
--   will be applied directly after dropping the prefix.
dropPrefixThen :: (Text -> Text) -> Text -> Text

-- | <tt>appendTo suffix fields field</tt> appends the given suffix to
--   <tt>field</tt> if the field exists in the <tt>fields</tt> list.
appendTo :: Text -> [Text] -> Text -> Text
ctorNameToAnnWithOptions :: forall ctor. (KnownSymbol ctor, HasCallStack) => AnnOptions -> FieldAnn

-- | Use this in the instance of <tt>HasAnnotation</tt> when field
--   annotations should not be generated.
gGetAnnotationNoField :: forall a. (GHasAnnotation (Rep a), GValueType (Rep a) ~ ToT a) => FollowEntrypointFlag -> Notes (ToT a)
type DocGrouping = SubDoc -> SomeDocItem
attachDocCommons :: ContainsUpdateableDoc a => DGitRevision -> a -> WithFinalizedDoc a
buildDoc :: ContainsDoc a => WithFinalizedDoc a -> ContractDoc
buildMarkdownDoc :: ContainsDoc a => WithFinalizedDoc a -> LText
contractDocToMarkdown :: ContractDoc -> LText
docDefinitionRef :: (DocItem d, DocItemPlacement d ~ 'DocItemInDefinitions) => Markdown -> d -> Markdown
docItemPosition :: DocItem d => DocItemPos
docItemSectionRef :: DocItem di => Maybe Markdown
finalizedAsIs :: a -> WithFinalizedDoc a
mdTocFromRef :: (DocItem d, DocItemReferenced d ~ 'True) => HeaderLevel -> Markdown -> d -> Markdown
mkDGitRevision :: ExpQ
modifyDoc :: (ContainsUpdateableDoc a, DocItem i1, DocItem i2) => (i1 -> Maybe i2) -> a -> a
morleyRepoSettings :: GitRepoSettings
subDocToMarkdown :: HeaderLevel -> SubDoc -> Markdown
data DAnchor
DAnchor :: Anchor -> DAnchor
data DComment
DComment :: Text -> DComment
data DDescription
DDescription :: Markdown -> DDescription
newtype DGeneralInfoSection
DGeneralInfoSection :: SubDoc -> DGeneralInfoSection
data DName
DName :: Text -> SubDoc -> DName
data DocElem d
DocElem :: d -> Maybe SubDoc -> DocElem d
[deItem] :: DocElem d -> d
[deSub] :: DocElem d -> Maybe SubDoc
type family DocItemPlacement d :: DocItemPlacementKind
type family DocItemReferenced d :: DocItemReferencedKind
newtype DocItemId
DocItemId :: Text -> DocItemId
data DocItemPlacementKind
DocItemInlined :: DocItemPlacementKind
DocItemInDefinitions :: DocItemPlacementKind
data DocItemRef (p :: DocItemPlacementKind) (r :: DocItemReferencedKind)
[DocItemRef] :: DocItemId -> DocItemRef 'DocItemInDefinitions 'True
[DocItemRefInlined] :: DocItemId -> DocItemRef 'DocItemInlined 'True
[DocItemNoRef] :: DocItemRef 'DocItemInlined 'False
data DocSectionNameStyle
DocSectionNameBig :: DocSectionNameStyle
DocSectionNameSmall :: DocSectionNameStyle
newtype GitRepoSettings
GitRepoSettings :: (Text -> Text) -> GitRepoSettings
[grsMkGitRevision] :: GitRepoSettings -> Text -> Text
data WithFinalizedDoc a
type Markdown = Builder
type NiceNoBigMap n = (KnownValue n, HasNoBigMap (ToT n))

-- | Constraint applied to any type, to check if Michelson representation
--   (if exists) of this type is Comparable. In case it is not prints
--   human-readable error message
type NiceComparable n = (ProperNonComparableValBetterErrors (ToT n), KnownValue n, Comparable (ToT n))
type NiceViewable a = (ProperViewableBetterErrors (ToT a), KnownValue a)
type NiceUntypedValue a = (ProperUntypedValBetterErrors (ToT a), KnownValue a)
type NiceFullPackedValue a = (NicePackedValue a, NiceUnpackedValue a)
type NiceUnpackedValue a = (ProperUnpackedValBetterErrors (ToT a), KnownValue a)
type NicePackedValue a = (ProperPackedValBetterErrors (ToT a), KnownValue a)
type Dupable a = (ProperDupableBetterErrors (ToT a), KnownValue a)
type NiceConstant a = (ProperConstantBetterErrors (ToT a), KnownValue a)
type NiceStorage a = (ProperStorageBetterErrors (ToT a), HasAnnotation a, KnownValue a)

-- | Constraint applied to any part of parameter type.
--   
--   Note that you don't usually apply this constraint to the whole
--   parameter, consider using <a>NiceParameterFull</a> in such case.
--   
--   Using this type is justified e.g. when calling another contract, there
--   you usually supply an entrypoint argument, not the whole parameter.
type NiceParameter a = (ProperParameterBetterErrors (ToT a), KnownValue a)
class (HasNoNestedBigMaps (ToT a), IsoValue a) => CanHaveBigMap a
class (ForbidBigMap (ToT a), IsoValue a) => NoBigMap a
class (ForbidContract (ToT a), IsoValue a) => NoContractType a

-- | Ensure given type does not contain "operation".
class (ForbidOp (ToT a), IsoValue a) => NoOperation a

-- | Gathers constraints, commonly required for values.
class (IsoValue a, Typeable a) => KnownValue a
niceParameterEvi :: forall a. NiceParameter a :- ParameterScope (ToT a)
niceStorageEvi :: forall a. NiceStorage a :- StorageScope (ToT a)
niceConstantEvi :: forall a. NiceConstant a :- ConstantScope (ToT a)
dupableEvi :: forall a. Dupable a :- DupableScope (ToT a)
nicePackedValueEvi :: forall a. NicePackedValue a :- PackedValScope (ToT a)
niceUnpackedValueEvi :: forall a. NiceUnpackedValue a :- UnpackedValScope (ToT a)
niceUntypedValueEvi :: forall a. NiceUntypedValue a :- UntypedValScope (ToT a)
niceViewableEvi :: forall a. NiceViewable a :- ViewableScope (ToT a)

-- | A special type which wraps over a primitive type and states that it
--   has entrypoints (one).
--   
--   Assuming that any type can have entrypoints makes use of Lorentz
--   entrypoints too annoying, so for declaring entrypoints for not sum
--   types we require an explicit wrapper.
newtype ShouldHaveEntrypoints a
ShouldHaveEntrypoints :: a -> ShouldHaveEntrypoints a
[unHasEntrypoints] :: ShouldHaveEntrypoints a -> a

-- | No entrypoints declared, parameter type will serve as argument type of
--   the only existing entrypoint (default one).
data EpdNone

-- | Check that the given entrypoint has some fields inside. This interface
--   allows for an abstraction of contract parameter so that it requires
--   some *minimal* specification, but not a concrete one.
type family ParameterContainsEntrypoints param (fields :: [NamedEp]) :: Constraint
type n :> ty = 'NamedEp n ty
infixr 0 :>

-- | Checks that the given parameter consists of some specific entrypoint.
--   Similar as <a>HasEntrypointArg</a> but ensures that the argument
--   matches the following datatype.
type HasEntrypointOfType param con exp = (GetEntrypointArgCustom param ('Just con) ~ exp, ParameterDeclaresEntrypoints param)

-- | This wrapper allows to pass untyped <a>EpName</a> and bypass checking
--   that entrypoint with given name and type exists.
newtype TrustEpName
TrustEpName :: EpName -> TrustEpName

-- | <a>HasEntrypointArg</a> constraint specialized to default entrypoint.
type HasDefEntrypointArg cp defEpName defArg = (defEpName ~ EntrypointRef 'Nothing, HasEntrypointArg cp defEpName defArg)

-- | When we call a Lorentz contract we should pass entrypoint name and
--   corresponding argument. Ideally we want to statically check that
--   parameter has entrypoint with given name and argument. Constraint
--   defined by this type class holds for contract with parameter
--   <tt>cp</tt> that have entrypoint matching <tt>name</tt> with type
--   <tt>arg</tt>.
--   
--   In order to check this property statically, we need to know entrypoint
--   name in compile time, <a>EntrypointRef</a> type serves this purpose.
--   If entrypoint name is not known, one can use <a>TrustEpName</a>
--   wrapper to take responsibility for presence of this entrypoint.
--   
--   If you want to call a function which has this constraint, you have two
--   options: 1. Pass contract parameter <tt>cp</tt> using type
--   application, pass <a>EntrypointRef</a> as a value and pass entrypoint
--   argument. Type system will check that <tt>cp</tt> has an entrypoint
--   with given reference and type. 2. Pass <a>EpName</a> wrapped into
--   <a>TrustEpName</a> and entrypoint argument. In this case passing
--   contract parameter is not necessary, you do not even have to know it.
class HasEntrypointArg cp name arg

-- | Data returned by this method may look somewhat arbitrary.
--   <a>EpName</a> is obviously needed because <tt>name</tt> can be
--   <a>EntrypointRef</a> or <a>TrustEpName</a>. <tt>Dict</tt> is returned
--   because in <a>EntrypointRef</a> case we get this evidence for free and
--   don't want to use it. We seem to always need it anyway.
useHasEntrypointArg :: HasEntrypointArg cp name arg => name -> (Dict (ParameterScope (ToT arg)), EpName)

-- | Universal entrypoint lookup.
type family GetEntrypointArgCustom cp mname :: Type

-- | Which entrypoint to call.
--   
--   We intentionally distinguish default and non-default cases because
--   this makes API more details-agnostic.
data EntrypointRef (mname :: Maybe Symbol)

-- | Call the default entrypoint, or root if no explicit default is
--   assigned.
[CallDefault] :: EntrypointRef 'Nothing

-- | Call the given entrypoint; calling default is not treated specially.
--   You have to provide entrypoint name via passing it as type argument.
--   
--   Unfortunatelly, here we cannot accept a label because in most cases
--   our entrypoints begin from capital letter (being derived from
--   constructor name), while labels must start from a lower-case letter,
--   and there is no way to make a conversion at type-level.
[Call] :: NiceEntrypointName name => EntrypointRef ('Just name)

-- | Similar to <a>ForbidExplicitDefaultEntrypoint</a>, but in a version
--   which the compiler can work with (and which produces errors confusing
--   for users :/)
type NoExplicitDefaultEntrypoint cp = Eval (LookupParameterEntrypoint cp DefaultEpName) ~ 'Nothing

-- | Ensure that there is no explicit "default" entrypoint.
type ForbidExplicitDefaultEntrypoint cp = Eval (LiftM3 UnMaybe (Pure (Pure (() :: Constraint))) (TError ('Text "Parameter used here must have no explicit \"default\" entrypoint" :$$: 'Text "In parameter type `" :<>: 'ShowType cp :<>: 'Text "`")) (LookupParameterEntrypoint cp DefaultEpName))

-- | Get type of entrypoint with given name, fail if not found.
type GetDefaultEntrypointArg cp = Eval (LiftM2 FromMaybe (Pure cp) (LookupParameterEntrypoint cp DefaultEpName))

-- | Get type of entrypoint with given name, fail if not found.
type GetEntrypointArg cp name = Eval (LiftM2 FromMaybe (TError ('Text "Entrypoint not found: " :<>: 'ShowType name :$$: 'Text "In contract parameter `" :<>: 'ShowType cp :<>: 'Text "`")) (LookupParameterEntrypoint cp name))

-- | Lookup for entrypoint type by name.
--   
--   Does not treat default entrypoints in a special way.
type family LookupParameterEntrypoint (cp :: Type) :: Symbol -> Exp (Maybe Type)

-- | Get all entrypoints declared for parameter.
type family AllParameterEntrypoints (cp :: Type) :: [(Symbol, Type)]

-- | Parameter declares some entrypoints.
--   
--   This is a version of <a>ParameterHasEntrypoints</a> which we actually
--   use in constraints. When given type is a sum type or newtype, we refer
--   to <a>ParameterHasEntrypoints</a> instance, otherwise this instance is
--   not necessary.
type ParameterDeclaresEntrypoints cp = (If (CanHaveEntrypoints cp) (ParameterHasEntrypoints cp) (() :: Constraint), NiceParameter cp, EntrypointsDerivation (GetParameterEpDerivation cp) cp)

-- | Which entrypoints given parameter declares.
--   
--   Note that usually this function should not be used as constraint, use
--   <a>ParameterDeclaresEntrypoints</a> for this purpose.
class (EntrypointsDerivation (ParameterEntrypointsDerivation cp) cp, RequireAllUniqueEntrypoints cp) => ParameterHasEntrypoints cp where {
    type family ParameterEntrypointsDerivation cp :: Type;
}

-- | Ensure that all declared entrypoints are unique.
type RequireAllUniqueEntrypoints cp = RequireAllUniqueEntrypoints' (ParameterEntrypointsDerivation cp) cp

-- | Defines a generalized way to declare entrypoints for various parameter
--   types.
--   
--   When defining instances of this typeclass, set concrete <tt>deriv</tt>
--   argument and leave variable <tt>cp</tt> argument. Also keep in mind,
--   that in presence of explicit default entrypoint, all other <a>Or</a>
--   arms should be callable, though you can put this burden on user if
--   very necessary.
--   
--   Methods of this typeclass aim to better type-safety when making up an
--   implementation and they may be not too convenient to use; users should
--   exploit their counterparts.
class EntrypointsDerivation deriv cp where {
    
    -- | Name and argument of each entrypoint. This may include intermediate
    --   ones, even root if necessary.
    --   
    --   Touching this type family is costly (<tt>O(N^2)</tt>), don't use it
    --   often.
    --   
    --   Note [order of entrypoints children]: If this contains entrypoints
    --   referring to indermediate nodes (not leaves) in <tt>or</tt> tree, then
    --   each such entrypoint should be mentioned eariler than all of its
    --   children.
    type family EpdAllEntrypoints deriv cp :: [(Symbol, Type)];
    
    -- | Get entrypoint argument by name.
    type family EpdLookupEntrypoint deriv cp :: Symbol -> Exp (Maybe Type);
}

-- | Construct parameter annotations corresponding to expected entrypoints
--   set.
--   
--   This method is implementation detail, for actual notes construction
--   use <a>parameterEntrypointsToNotes</a>.
epdNotes :: EntrypointsDerivation deriv cp => (Notes (ToT cp), RootAnn)

-- | Construct entrypoint caller.
--   
--   This does not treat calls to default entrypoint in a special way.
--   
--   This method is implementation detail, for actual entrypoint lookup use
--   <a>parameterEntrypointCall</a>.
epdCall :: (EntrypointsDerivation deriv cp, ParameterScope (ToT cp)) => Label name -> EpConstructionRes (ToT cp) (Eval (EpdLookupEntrypoint deriv cp name))

-- | Description of how each of the entrypoints is constructed.
epdDescs :: EntrypointsDerivation deriv cp => Rec EpCallingDesc (EpdAllEntrypoints deriv cp)

-- | Derive annotations for given parameter.
parameterEntrypointsToNotes :: forall cp. ParameterDeclaresEntrypoints cp => ParamNotes (ToT cp)

-- | Prepare call to given entrypoint.
--   
--   This does not treat calls to default entrypoint in a special way. To
--   call default entrypoint properly use
--   <a>parameterEntrypointCallDefault</a>.
parameterEntrypointCall :: forall cp name. ParameterDeclaresEntrypoints cp => Label name -> EntrypointCall cp (GetEntrypointArg cp name)

-- | Call the default entrypoint.
parameterEntrypointCallDefault :: forall cp. ParameterDeclaresEntrypoints cp => EntrypointCall cp (GetDefaultEntrypointArg cp)

-- | Call root entrypoint safely.
sepcCallRootChecked :: forall cp. (NiceParameter cp, ForbidExplicitDefaultEntrypoint cp) => SomeEntrypointCall cp
eprName :: forall mname. EntrypointRef mname -> EpName

-- | Universal entrypoint calling.
parameterEntrypointCallCustom :: forall cp mname. ParameterDeclaresEntrypoints cp => EntrypointRef mname -> EntrypointCall cp (GetEntrypointArgCustom cp mname)
data ViewInterfaceMatchError
VIMViewNotFound :: ViewName -> ViewInterfaceMatchError
VIMViewArgMismatch :: T -> T -> ViewInterfaceMatchError
VIMViewRetMismatch :: T -> T -> ViewInterfaceMatchError
type DemoteViewsDescriptor vd = DemoteViewTyInfo (RevealViews vd)

-- | Interface of a single view at term-level.
data ViewInterface
ViewInterface :: ViewName -> T -> T -> ViewInterface
[viName] :: ViewInterface -> ViewName
[viArg] :: ViewInterface -> T
[viRet] :: ViewInterface -> T

-- | Map views to get their names.
type family ViewsNames (vs :: [ViewTyInfo]) :: [Symbol]

-- | Constraint indicating that presence of the view with the specified
--   parameters is implied by the views descriptor.
type HasView vd name arg ret = (LookupRevealView name vd ~ '(arg, ret))

-- | Reveal views and find a view there.
type LookupRevealView name viewRef = LookupView name (RevealViews viewRef)

-- | Find a view in a contract by name.
type family LookupView (name :: Symbol) (views :: [ViewTyInfo]) :: (Type, Type)

-- | A views descriptor that directly carries the full list of views.
data ViewsList (vl :: [ViewTyInfo])

-- | Get a list of views by a descriptor object.
--   
--   The problem this type family solves: it is unpleasant to carry around
--   a list of views because it may be large, and if we merely hide this
--   list under a type alias, error messages will still mention the type
--   alias expanded. We want e.g. <tt>Contract Parameter Storage Views</tt>
--   to be carried as-is. <tt>Parameter</tt> and <tt>Storage</tt> are
--   usually datatypes and they are fine, while for <tt>Views</tt> to be
--   not automatically expanded we have to take special care.
--   
--   You can still provide the list of <a>ViewTyInfo</a>s to this type
--   family using <a>ViewsList</a>, but generally prefer creating a
--   dedicated datatype that would expand to a views list.
type family RevealViews (desc :: Type) :: [ViewTyInfo]
type arg >-> ret = '(arg, ret)
infix 5 >->

-- | Neat constructor for <a>ViewTyInfo</a>.
--   
--   type View = "view" ?:: Integer &gt;-&gt; Natural
type family (?::) (name :: Symbol) (tys :: (Type, Type))
infix 3 ?::

-- | Type-level information about a view.
data ViewTyInfo
ViewTyInfo :: Symbol -> Type -> Type -> ViewTyInfo

-- | Demote view name from type level to term level.
demoteViewName :: forall name. (KnownSymbol name, HasCallStack) => ViewName

-- | Demote <a>ViewTyInfo</a>s to <a>ViewInterface</a>s.
demoteViewTyInfos :: forall (vs :: [ViewTyInfo]). DemoteViewTyInfo vs => [ViewInterface]

-- | Demote views descriptor to <a>ViewInterface</a>s.
demoteViewsDescriptor :: forall (vd :: Type). DemoteViewTyInfo (RevealViews vd) => [ViewInterface]

-- | Check that the given set of views covers the given view interfaces.
--   Extra views in the set, that do not appear in the interface, are fine.
checkViewsCoverInterface :: forall st. [ViewInterface] -> ViewsSet st -> Either ViewInterfaceMatchError ()

-- | Require views set referred by the given views descriptor to be proper.
type NiceViewsDescriptor vd = NiceViews (RevealViews vd)

-- | Require views set to be proper.
type NiceViews vs = RequireAllUnique "view" (ViewsNames vs)

-- | Tells whether given type is dupable or not.
data DupableDecision a
IsDupable :: DupableDecision a
IsNotDupable :: DupableDecision a

-- | Constraint applied to a whole parameter type.
type NiceParameterFull cp = (Typeable cp, ParameterDeclaresEntrypoints cp)

-- | Check whether given value is dupable, returning a proof of that when
--   it is.
--   
--   This lets defining methods that behave differently depending on
--   whether given value is dupable or not. This may be suitable when for
--   the dupable case you can provide a more efficient implementation, but
--   you also want your implementation to be generic.
--   
--   Example:
--   
--   <pre>
--   code = case decideOnDupable @a of
--     IsDupable -&gt; do dup; ...
--     IsNotDupable -&gt; ...
--   </pre>
decideOnDupable :: forall a. KnownValue a => DupableDecision a

-- | Applicable for wrappers over Lorentz code.
class MapLorentzInstr instr

-- | Modify all the code under given entity.
mapLorentzInstr :: MapLorentzInstr instr => (forall i o. (i :-> o) -> i :-> o) -> instr -> instr
type Lambda i o = '[i] :-> '[o]

-- | An alias for <tt>':</tt>.
--   
--   We discourage its use as this hinders reading error messages (the
--   compiler inserts unnecessary parentheses and indentation).
type (&) (a :: Type) (b :: [Type]) = a : b
infixr 2 &

-- | Compiled Lorentz contract.
--   
--   Note, that the views argument (views descriptor) is added comparing to
--   the Michelson. In Michelson, ability to call a view is fully checked
--   at runtime, but in Lorentz we want to make calls safer at
--   compile-time.
data Contract cp st vd
Contract :: Contract (ToT cp) (ToT st) -> ~ContractCode cp st -> Contract cp st vd

-- | Ready contract code.
[cMichelsonContract] :: Contract cp st vd -> Contract (ToT cp) (ToT st)

-- | Contract that contains documentation.
--   
--   We have to keep it separately, since optimizer is free to destroy
--   documentation blocks. Also, it is not <a>ContractDoc</a> but Lorentz
--   code because the latter is easier to modify.
[cDocumentedCode] :: Contract cp st vd -> ~ContractCode cp st
type ViewCode arg st ret = '[(arg, st)] :-> '[ret]
data SomeContractCode
[SomeContractCode] :: (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> SomeContractCode
type ContractCode cp st = '[(cp, st)] :-> ContractOut st
type ContractOut st = '[([Operation], st)]

-- | Alias for <a>:-&gt;</a>, seems to make signatures more readable
--   sometimes.
--   
--   Let's someday decide which one of these two should remain.
type (%>) = (:->)
infixr 1 %>

-- | Alias for instruction which hides inner types representation via
--   <tt>T</tt>.
newtype (inp :: [Type]) :-> (out :: [Type])
LorentzInstr :: RemFail Instr (ToTs inp) (ToTs out) -> (:->) (inp :: [Type]) (out :: [Type])
[unLorentzInstr] :: (:->) (inp :: [Type]) (out :: [Type]) -> RemFail Instr (ToTs inp) (ToTs out)
infixr 1 :->
pattern FI :: (forall out'. Instr (ToTs inp) out') -> inp :-> out
pattern I :: Instr (ToTs inp) (ToTs out) -> inp :-> out
iGenericIf :: (forall s'. Instr (ToTs a) s' -> Instr (ToTs b) s' -> Instr (ToTs c) s') -> (a :-> s) -> (b :-> s) -> c :-> s
iAnyCode :: (inp :-> out) -> Instr (ToTs inp) (ToTs out)
iNonFailingCode :: HasCallStack => (inp :-> out) -> Instr (ToTs inp) (ToTs out)
iMapAnyCode :: (forall o'. Instr (ToTs i1) o' -> Instr (ToTs i2) o') -> (i1 :-> o) -> i2 :-> o
iForceNotFail :: (i :-> o) -> i :-> o

-- | Wrap Lorentz instruction with variable annotations, <tt>annots</tt>
--   list has to be non-empty, otherwise this function raises an error.
iWithVarAnnotations :: HasCallStack => [Text] -> (inp :-> out) -> inp :-> out

-- | Demote Lorentz <a>Contract</a> to Michelson typed <a>Contract</a>.
toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)

-- | Function composition for instructions.
--   
--   Note that, unlike Morley's <a>:#</a> operator, <a>(#)</a> is
--   left-associative.
(#) :: (a :-> b) -> (b :-> c) -> a :-> c
infixl 8 #

-- | Parse textual representation of a Michelson value and turn it into
--   corresponding Haskell value.
--   
--   Note: it won't work in some complex cases, e. g. if there is a lambda
--   which uses an instruction which depends on current contract's type.
--   Obviously it can not work, because we don't have any information about
--   a contract to which this value belongs (there is no such contract at
--   all).
parseLorentzValue :: forall v. KnownValue v => MichelsonSource -> Text -> Either ParseLorentzError v

-- | Lorentz version of <a>transformStrings</a>.
transformStringsLorentz :: Bool -> (MText -> MText) -> (inp :-> out) -> inp :-> out

-- | Lorentz version of <a>transformBytes</a>.
transformBytesLorentz :: Bool -> (ByteString -> ByteString) -> (inp :-> out) -> inp :-> out
optimizeLorentzWithConf :: OptimizerConf -> (inp :-> out) -> inp :-> out
optimizeLorentz :: (inp :-> out) -> inp :-> out

-- | Include a value at given position on stack into comment produced by
--   <a>printComment</a>.
--   
--   <pre>
--   stackRef @0
--   </pre>
--   
--   <a>the top of the stack</a>
stackRef :: forall (gn :: Nat) st n. (n ~ ToPeano gn, SingI n, RequireLongerThan st n) => PrintComment st

-- | Print a comment. It will be visible in tests.
--   
--   <pre>
--   printComment "Hello world!"
--   printComment $ "On top of the stack I see " &lt;&gt; stackRef @0
--   </pre>
printComment :: PrintComment (ToTs s) -> s :-> s
justComment :: Text -> s :-> s
comment :: CommentType -> s :-> s
commentAroundFun :: Text -> (i :-> o) -> i :-> o
commentAroundStmt :: Text -> (i :-> o) -> i :-> o

-- | Test an invariant, fail if it does not hold.
--   
--   This won't be included into production contract and is executed only
--   in tests.
testAssert :: HasCallStack => Text -> PrintComment (ToTs inp) -> (inp :-> (Bool : out)) -> inp :-> inp

-- | Fix the current type of the stack to be given one.
--   
--   <pre>
--   stackType @'[Natural]
--   stackType @(Integer : Natural : s)
--   stackType @'["balance" :! Integer, "toSpend" :! Integer, BigMap Address Integer]
--   </pre>
--   
--   Note that you can omit arbitrary parts of the type.
--   
--   <pre>
--   stackType @'["balance" :! Integer, "toSpend" :! _, BigMap _ _]
--   </pre>
stackType :: forall s. s :-> s

-- | Version of <a>Entrypoint</a> which accepts no argument.
type Entrypoint_ store = '[store] :-> ContractOut store

-- | Single entrypoint of a contract.
--   
--   Note that we cannot make it return <tt>[[Operation], store]</tt>
--   because such entrypoint should've been followed by <tt>pair</tt>, and
--   this is not possible if entrypoint implementation ends with
--   <a>failWith</a>.
type Entrypoint param store = '[param, store] :-> ContractOut store

-- | Convert something from <a>ContractRef</a> in <i>Haskell</i> world.
class FromContractRef (cp :: Type) (contract :: Type)
fromContractRef :: FromContractRef cp contract => ContractRef cp -> contract

-- | Convert something to <a>ContractRef</a> in <i>Haskell</i> world.
class ToContractRef (cp :: Type) (contract :: Type)
toContractRef :: (ToContractRef cp contract, HasCallStack) => contract -> ContractRef cp

-- | Convert something referring to a contract (not specific entrypoint) to
--   <a>TAddress</a> in <i>Haskell</i> world.
class ToTAddress (cp :: Type) (vd :: Type) (a :: Type)
toTAddress :: ToTAddress cp vd a => a -> TAddress cp vd

-- | Convert something to <a>Address</a> in <i>Haskell</i> world.
--   
--   Use this when you want to access state of the contract and are not
--   interested in calling it.
class ToAddress a
toAddress :: ToAddress a => a -> Address

-- | Address associated with value of <tt>contract arg</tt> type.
--   
--   Places where <a>ContractRef</a> can appear are now severely limited,
--   this type gives you type-safety of <a>ContractRef</a> but still can be
--   used everywhere. This type is not a full-featured one rather a helper;
--   in particular, once pushing it on stack, you cannot return it back to
--   Haskell world.
--   
--   Note that it refers to an entrypoint of the contract, not just the
--   contract as a whole. In this sense this type differs from
--   <a>TAddress</a>.
--   
--   Unlike with <a>ContractRef</a>, having this type you still cannot be
--   sure that the referred contract exists and need to perform a lookup
--   before calling it.
newtype FutureContract arg
FutureContract :: ContractRef arg -> FutureContract arg
[unFutureContract] :: FutureContract arg -> ContractRef arg

-- | Something coercible to 'TAddress cp'.
type ToTAddress_ cp vd addr = (ToTAddress cp vd addr, ToT addr ~ ToT Address)

-- | Address which remembers the parameter and views types of the contract
--   it refers to.
--   
--   It differs from Michelson's <tt>contract</tt> type because it cannot
--   contain entrypoint, and it always refers to entire contract parameter
--   even if this contract has explicit default entrypoint.
newtype TAddress (p :: Type) (vd :: Type)
TAddress :: Address -> TAddress (p :: Type) (vd :: Type)
[unTAddress] :: TAddress (p :: Type) (vd :: Type) -> Address

-- | For a contract and an address of its instance, construct a typed
--   address.
asAddressOf :: contract cp st vd -> Address -> TAddress cp vd
asAddressOf_ :: contract cp st vd -> (Address : s) :-> (TAddress cp vd : s)

-- | Turn <a>TAddress</a> to <a>ContractRef</a> in <i>Haskell</i> world.
--   
--   This is an analogy of <tt>address</tt> to <tt>contract</tt> convertion
--   in Michelson world, thus you have to supply an entrypoint (or call the
--   default one explicitly).

-- | <i>Deprecated: Use <a>callingAddress</a></i>
callingTAddress :: forall cp vd mname. NiceParameterFull cp => TAddress cp vd -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)

-- | Specification of <a>callingTAddress</a> to call the default
--   entrypoint.

-- | <i>Deprecated: Use <a>callingDefAddress</a></i>
callingDefTAddress :: forall cp vd. NiceParameterFull cp => TAddress cp vd -> ContractRef (GetDefaultEntrypointArg cp)

-- | Generalization of <a>callingTAddress</a> to any typed address.
callingAddress :: forall cp vd addr mname. (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> EntrypointRef mname -> ContractRef (GetEntrypointArgCustom cp mname)

-- | Generalization of <a>callingDefTAddress</a> to any typed address.
callingDefAddress :: forall cp vd addr. (ToTAddress cp vd addr, NiceParameterFull cp) => addr -> ContractRef (GetDefaultEntrypointArg cp)

-- | Cast something appropriate to <a>TAddress</a>.
toTAddress_ :: forall cp addr vd s. ToTAddress_ cp vd addr => (addr : s) :-> (TAddress cp vd : s)
convertContractRef :: forall cp contract2 contract1. (ToContractRef cp contract1, FromContractRef cp contract2) => contract1 -> contract2

-- | Declares that it is safe to wrap an inner type to the given wrapper
--   type. Can be provided in addition to <a>Unwrappable</a>.
--   
--   You can declare this instance when your wrapper exists just to make
--   type system differentiate the two types. Example: <tt>newtype TokenId
--   = TokenId Natural</tt>.
--   
--   Do <i>not</i> define this instance for wrappers that provide some
--   invariants. Example: <tt>UStore</tt> type from
--   <tt>morley-upgradeable</tt>.
--   
--   <a>Wrappable</a> is similar to lens <tt>Wrapped</tt> class without the
--   method.
class Unwrappable s => Wrappable (s :: Type)

-- | Declares that this type is just a wrapper over some other type and it
--   can be safely unwrapped to that inner type.
--   
--   Inspired by lens <tt>Wrapped</tt>.
class ToT s ~ ToT (Unwrappabled s) => Unwrappable (s :: Type) where {
    
    -- | The type we unwrap to (inner type of the newtype).
    --   
    --   Used in constraint for Lorentz instruction wrapping into a Haskell
    --   newtype and vice versa.
    type family Unwrappabled s :: Type;
    type Unwrappabled s = GUnwrappabled s (Rep s);
}
data GenericStrategy
rightComb :: GenericStrategy
alphabetically :: EntriesReorder
forbidUnnamedFields :: UnnamedEntriesReorder
cstr :: forall (n :: Nat). KnownNat n => [Natural] -> CstrDepth
customGeneric :: String -> GenericStrategy -> Q [Dec]
customGeneric' :: Maybe Type -> Name -> Type -> [Con] -> GenericStrategy -> Q [Dec]
deriveFullType :: Name -> Maybe Kind -> [TyVarBndr] -> TypeQ
fld :: forall (n :: Nat). KnownNat n => Natural
fromDepthsStrategy :: (Int -> [Natural]) -> GenericStrategy
haskellBalanced :: GenericStrategy
leaveUnnamedFields :: UnnamedEntriesReorder
leftBalanced :: GenericStrategy
leftComb :: GenericStrategy
reifyDataType :: Name -> Q (Name, Cxt, Maybe Kind, [TyVarBndr], [Con])
reorderingConstrs :: EntriesReorder -> GenericStrategy -> GenericStrategy
reorderingData :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy
reorderingFields :: UnnamedEntriesReorder -> EntriesReorder -> GenericStrategy -> GenericStrategy
rightBalanced :: GenericStrategy
withDepths :: [CstrDepth] -> GenericStrategy

-- | Value returned by <tt>READ_TICKET</tt> instruction.
data ReadTicket a
ReadTicket :: Address -> a -> Natural -> ReadTicket a
[rtTicketer] :: ReadTicket a -> Address
[rtData] :: ReadTicket a -> a
[rtAmount] :: ReadTicket a -> Natural
data Never
type List = []
data OpenChest

-- | Like <tt>Fixed</tt> but with a <tt>Natural</tt> value inside
--   constructor
newtype NFixed p
MkNFixed :: Natural -> NFixed p
data BinBase p
[BinBase] :: KnownNat p => BinBase p

-- | Datatypes, representing base of the fixed-point values
data DecBase p
[DecBase] :: KnownNat p => DecBase p

-- | Provides <a>Buildable</a> instance that prints Lorentz value via
--   Michelson's <a>Value</a>.
--   
--   Result won't be very pretty, but this avoids requiring <a>Show</a> or
--   <a>Buildable</a> instances.
newtype PrintAsValue a
PrintAsValue :: a -> PrintAsValue a

-- | Lifted <a>SliceOp</a>.
class SliceOp (ToT c) => SliceOpHs c

-- | Lifted <a>ConcatOp</a>.
class ConcatOp (ToT c) => ConcatOpHs c

-- | Lifted <a>GetOp</a>.
class (GetOp (ToT c), ToT (GetOpKeyHs c) ~ (GetOpKey (ToT c)), ToT (GetOpValHs c) ~ GetOpVal (ToT c)) => GetOpHs c where {
    type family GetOpKeyHs c :: Type;
    type family GetOpValHs c :: Type;
}

-- | Lifted <a>UpdOp</a>.
class (UpdOp (ToT c), ToT (UpdOpKeyHs c) ~ (UpdOpKey (ToT c)), ToT (UpdOpParamsHs c) ~ UpdOpParams (ToT c)) => UpdOpHs c where {
    type family UpdOpKeyHs c :: Type;
    type family UpdOpParamsHs c :: Type;
}

-- | Lifted <a>SizeOp</a>.
--   
--   This could be just a constraint alias, but to avoid <a>T</a> types
--   appearance in error messages we make a full type class with concrete
--   instances.
class SizeOp (ToT c) => SizeOpHs c

-- | Lifted <a>IterOp</a>.
class (IterOp (ToT c), ToT (IterOpElHs c) ~ IterOpEl (ToT c)) => IterOpHs c where {
    type family IterOpElHs c :: Type;
}

-- | Lifted <a>MapOp</a>.
class (MapOp (ToT c), ToT (MapOpInpHs c) ~ MapOpInp (ToT c), ToT (MapOpResHs c ()) ~ MapOpRes (ToT c) (ToT ())) => MapOpHs c where {
    type family MapOpInpHs c :: Type;
    type family MapOpResHs c :: Type -> Type;
}

-- | A useful property which holds for reasonable <a>MapOp</a> instances.
--   
--   It's a separate thing from <a>MapOpHs</a> because it mentions
--   <tt>b</tt> type parameter.
type family IsoMapOpRes c b

-- | Lifted <a>MemOpKey</a>.
class (MemOp (ToT c), ToT (MemOpKeyHs c) ~ MemOpKey (ToT c)) => MemOpHs c where {
    type family MemOpKeyHs c :: Type;
}

-- | Extension of <a>EpdPlain</a>, <a>EpdRecursive</a>, and
--   <a>EpdDelegate</a> which allow specifying root annotation for the
--   parameters.
data EpdWithRoot (r :: Symbol) epd

-- | Extension of <a>EpdPlain</a> on parameters being defined as several
--   nested datatypes.
--   
--   In particular, it will traverse the immediate sum type, and require
--   another <a>ParameterHasEntrypoints</a> for the inner complex
--   datatypes. Only those inner types are considered which are the only
--   fields in their respective constructors. Inner types should not
--   themselves declare default entrypoint, we enforce this for better
--   modularity. Each top-level constructor will be treated as entrypoint
--   even if it contains a complex datatype within, in such case that would
--   be an entrypoint corresponding to intermediate node in <tt>or</tt>
--   tree.
--   
--   Comparing to <a>EpdRecursive</a> this gives you more control over
--   where and how entrypoints will be derived.
data EpdDelegate

-- | Extension of <a>EpdPlain</a> on parameters being defined as several
--   nested datatypes.
--   
--   In particular, this will traverse sum types recursively, stopping at
--   Michelson primitives (like <a>Natural</a>) and constructors with
--   number of fields different from one.
--   
--   It does not assign names to intermediate nodes of <a>Or</a> tree, only
--   to the very leaves.
--   
--   If some entrypoint arguments have custom <a>IsoValue</a> instance,
--   this derivation way will not work. As a workaround, you can wrap your
--   argument into some primitive (e.g. <a>:!</a>).
data EpdRecursive

-- | Implementation of <a>ParameterHasEntrypoints</a> which fits for case
--   when your contract exposes multiple entrypoints via having sum type as
--   its parameter.
--   
--   In particular, each constructor would produce a homonymous entrypoint
--   with argument type equal to type of constructor field (each
--   constructor should have only one field). Constructor called
--   <a>Default</a> will designate the default entrypoint.
data EpdPlain
class ToIntegerArithOpHs (n :: Type)
evalToIntOpHs :: ToIntegerArithOpHs n => (n : s) :-> (Integer : s)
evalToIntOpHs :: (ToIntegerArithOpHs n, ToIntArithOp (ToT n)) => (n : s) :-> (Integer : s)

-- | Helper typeclass that provides default definition of
--   <a>evalUnaryArithOpHs</a>.
class DefUnaryArithOp aop
defUnaryArithOpHs :: (DefUnaryArithOp aop, UnaryArithOp aop n, r ~ UnaryArithRes aop n) => Instr (n : s) (r : s)

-- | Lifted <a>UnaryArithOp</a>.
class UnaryArithOpHs (aop :: Type) (n :: Type) where {
    type family UnaryArithResHs aop n :: Type;
}
evalUnaryArithOpHs :: UnaryArithOpHs aop n => (n : s) :-> (UnaryArithResHs aop n : s)
evalUnaryArithOpHs :: (UnaryArithOpHs aop n, DefUnaryArithOp aop, UnaryArithOp aop (ToT n), ToT (UnaryArithResHs aop n) ~ UnaryArithRes aop (ToT n)) => (n : s) :-> (UnaryArithResHs aop n : s)

-- | Helper typeclass that provides default definition of
--   <a>evalArithOpHs</a>.
class DefArithOp aop
defEvalOpHs :: (DefArithOp aop, ArithOp aop n m, r ~ ArithRes aop n m) => Instr (n : (m : s)) (r : s)

-- | Lifted <a>ArithOp</a>.
class ArithOpHs (aop :: Type) (n :: Type) (m :: Type) (r :: Type)
evalArithOpHs :: ArithOpHs aop n m r => (n : (m : s)) :-> (r : s)
evalArithOpHs :: (ArithOpHs aop n m r, DefArithOp aop, ArithOp aop (ToT n) (ToT m), ToT r ~ ArithRes aop (ToT n) (ToT m)) => (n : (m : s)) :-> (r : s)

-- | Wrap parameter into this to locally assign a way to derive entrypoints
--   for it.
newtype ParameterWrapper (deriv :: Type) cp
ParameterWrapper :: cp -> ParameterWrapper (deriv :: Type) cp
[unParameterWraper] :: ParameterWrapper (deriv :: Type) cp -> cp

-- | Renders to documentation of view descriptor.
data DViewDesc
DViewDesc :: Proxy vd -> DViewDesc

-- | Provides documentation for views descriptor.
--   
--   Note that views descriptors may describe views that do not belong to
--   the current contract, e.g. <tt>TAddress</tt> may refer to an external
--   contract provided by the user in which we want to call a view.
class (Typeable vd, RenderViewsImpl (RevealViews vd)) => ViewsDescriptorHasDoc (vd :: Type)
viewsDescriptorName :: ViewsDescriptorHasDoc vd => Proxy vd -> Text
viewsDescriptorName :: (ViewsDescriptorHasDoc vd, Generic vd, KnownSymbol (GenericTypeName vd)) => Proxy vd -> Text
renderViewsDescriptorDoc :: ViewsDescriptorHasDoc vd => Proxy vd -> Builder

-- | Renders to a line mentioning the view's argument.
data DViewRet
DViewRet :: Proxy a -> DViewRet

-- | Renders to a line mentioning the view's argument.
data DViewArg
DViewArg :: Proxy a -> DViewArg

-- | Renders to a view section.
data DView
DView :: ViewName -> SubDoc -> DView
[dvName] :: DView -> ViewName
[dvSub] :: DView -> SubDoc

-- | Modify the example value of an entrypoint
data DEntrypointExample
DEntrypointExample :: Value t -> DEntrypointExample

-- | Put a document item.
doc :: DocItem di => di -> s :-> s

-- | Group documentation built in the given piece of code into block
--   dedicated to one thing, e.g. to one entrypoint.
--   
--   Examples of doc items you can pass here: <a>DName</a>,
--   <a>DGeneralInfoSection</a>.
docGroup :: DocItem di => (SubDoc -> di) -> (inp :-> out) -> inp :-> out

-- | Insert documentation of the contract storage type. The type should be
--   passed using type applications.

-- | <i>Deprecated: Use `doc (dStorage @storage)` instead.</i>
docStorage :: forall storage s. TypeHasDoc storage => s :-> s

-- | Give a name to given contract. Apply it to the whole contract code.

-- | <i>Deprecated: Use `docGroup name` instead.</i>
contractName :: Text -> (inp :-> out) -> inp :-> out

-- | <i>Deprecated: Use <a>buildDoc</a> instead.</i>
buildLorentzDoc :: (inp :-> out) -> ContractDoc

-- | Takes an instruction that inserts documentation items with general
--   information about the contract. Inserts it into general section. See
--   <a>DGeneralInfoSection</a>.

-- | <i>Deprecated: Use `docGroup DGeneralInfoSection` instead.</i>
contractGeneral :: (inp :-> out) -> inp :-> out

-- | Inserts general information about the contract using the default
--   format.
--   
--   This includes git revision and some other information common for all
--   contracts. Git revision is left unknown in the library code and is
--   supposed to be updated in an executable using e.g.
--   <a>buildLorentzDocWithGitRev</a>.
contractGeneralDefault :: s :-> s

-- | <i>Deprecated: Use `buildDoc . attachDocCommons gitRev` instead.</i>
buildLorentzDocWithGitRev :: DGitRevision -> (inp :-> out) -> ContractDoc

-- | <i>Deprecated: Use <a>buildMarkdownDoc</a> instead.</i>
renderLorentzDoc :: (inp :-> out) -> LText

-- | <i>Deprecated: Use `buildMarkdownDoc . attachDocCommons gitRev`
--   instead.</i>
renderLorentzDocWithGitRev :: DGitRevision -> (inp :-> out) -> LText

-- | Leave only instructions related to documentation.
--   
--   This function is useful when your method executes a lambda coming from
--   outside, but you know its properties and want to propagate its
--   documentation to your contract code.
cutLorentzNonDoc :: (inp :-> out) -> s :-> s
mkDEntrypointExample :: forall a. NiceParameter a => a -> DEntrypointExample
data OpenChestT a
ChestContentT :: a -> OpenChestT a
ChestOpenFailedT :: Bool -> OpenChestT a
newtype ChestT a
ChestT :: Chest -> ChestT a
[unChestT] :: ChestT a -> Chest
data Keccak :: HashAlgorithmKind
data Sha3 :: HashAlgorithmKind
data Blake2b :: HashAlgorithmKind
data Sha512 :: HashAlgorithmKind
data Sha256 :: HashAlgorithmKind

-- | Documentation item for hash algorithms.
data DHashAlgorithm

-- | Hash algorithm used in Tezos.
class Typeable alg => KnownHashAlgorithm (alg :: HashAlgorithmKind)
hashAlgorithmName :: KnownHashAlgorithm alg => Proxy alg -> Text
computeHash :: KnownHashAlgorithm alg => ByteString -> ByteString
toHash :: (KnownHashAlgorithm alg, BytesLike bs) => (bs : s) :-> (Hash alg bs : s)

-- | Hash of type <tt>t</tt> evaluated from data of type <tt>a</tt>.
newtype Hash (alg :: HashAlgorithmKind) a
UnsafeHash :: ByteString -> Hash (alg :: HashAlgorithmKind) a
[unHash] :: Hash (alg :: HashAlgorithmKind) a -> ByteString

-- | Represents a signature, where signed data has given type.
--   
--   Since we usually sign a packed data, a common pattern for this type is
--   <tt>TSignature (<a>Packed</a> signedData)</tt>. If you don't want to
--   use <a>Packed</a>, use plain <tt>TSignature ByteString</tt> instead.
newtype TSignature a
TSignature :: Signature -> TSignature a
[unTSignature] :: TSignature a -> Signature

-- | Represents a <a>ByteString</a> resulting from packing a value of type
--   <tt>a</tt>.
--   
--   This is <i>not</i> guaranteed to keep some packed value, and
--   <tt>unpack</tt> can fail. We do so because often we need to accept
--   values of such type from user, and also because there is no simple way
--   to check validity of packed data without performing full unpack. So
--   this wrapper is rather a hint for users.
newtype Packed a
Packed :: ByteString -> Packed a
[unPacked] :: Packed a -> ByteString

-- | Everything which is represented as bytes inside.
class (KnownValue bs, ToT bs ~ ToT ByteString) => BytesLike bs
toBytes :: BytesLike bs => bs -> ByteString

-- | Sign data using <a>SecretKey</a>
lSign :: (MonadRandom m, BytesLike a) => SecretKey -> a -> m (TSignature a)

-- | Evaluate hash in Haskell world.
toHashHs :: forall alg bs. (BytesLike bs, KnownHashAlgorithm alg) => bs -> Hash alg bs
openChestT :: BytesLike a => (ChestKey : (ChestT a : (Natural : s))) :-> (OpenChestT a : s)
lPackValueRaw :: forall a. NicePackedValue a => a -> ByteString
lUnpackValueRaw :: forall a. NiceUnpackedValue a => ByteString -> Either UnpackError a
lPackValue :: forall a. NicePackedValue a => a -> Packed a
lUnpackValue :: forall a. NiceUnpackedValue a => Packed a -> Either UnpackError a
lEncodeValue :: forall a. NiceUntypedValue a => a -> ByteString

-- | This function transforms Lorentz values into <tt>script_expr</tt>.
--   
--   <tt>script_expr</tt> is used in RPC as an argument in entrypoint
--   designed for getting value by key from the big_map in Babylon. In
--   order to convert value to the <tt>script_expr</tt> we have to pack it,
--   take blake2b hash and add specific <tt>expr</tt> prefix. Take a look
--   at
--   <a>https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/script_expr_hash.ml</a>
--   and
--   <a>https://gitlab.com/tezos/tezos/blob/6e25ae8eb385d9975a30388c7a7aa2a9a65bf184/src/proto_005_PsBabyM1/lib_protocol/contract_services.ml#L136</a>
--   for more information.
valueToScriptExpr :: forall t. NicePackedValue t => t -> ByteString

-- | Similar to <a>valueToScriptExpr</a>, but for values encoded as
--   <a>Expression</a>s. This is only used in tests.
expressionToScriptExpr :: Expression -> ByteString
class LorentzFunctor (c :: Type -> Type)
lmap :: (LorentzFunctor c, KnownValue b) => ((a : s) :-> (b : s)) -> (c a : s) :-> (c b : s)
type ConstraintDIPNLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]) = (ConstraintDIPN n (ToTs inp) (ToTs out) (ToTs s) (ToTs s'), ConstraintDIPN' Type n inp out s s', SingI n)
type family PairUpdateHs (ix :: Peano) (val :: Type) (pair :: Type) :: Type
type ConstraintPairUpdateLorentz (n :: Nat) (val :: Type) (pair :: Type) = (ConstraintUpdateN (ToPeano n) (ToT pair), ToT (PairUpdateHs (ToPeano n) val pair) ~ UpdateN (ToPeano n) (ToT val) (ToT pair), SingI (ToPeano n))
type family PairGetHs (ix :: Peano) (pair :: Type) :: Type
type ConstraintPairGetLorentz (n :: Nat) (pair :: Type) = (ConstraintGetN (ToPeano n) (ToT pair), ToT (PairGetHs (ToPeano n) pair) ~ GetN (ToPeano n) (ToT pair), SingI (ToPeano n))
type ConstraintDUGLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (a :: Type) = (ConstraintDUG n (ToTs inp) (ToTs out) (ToT a), ConstraintDUG' Type n inp out a, SingI n)
type ConstraintDIGLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (a :: Type) = (ConstraintDIG n (ToTs inp) (ToTs out) (ToT a), ConstraintDIG' Type n inp out a, SingI n)
type ConstraintDUPNLorentz (n :: Peano) (inp :: [Type]) (out :: [Type]) (a :: Type) = (ConstraintDUPN n (ToTs inp) (ToTs out) (ToT a), ConstraintDUPN' Type n inp out a, SingI n)
nop :: s :-> s
drop :: (a : s) :-> s

-- | Drop top <tt>n</tt> elements from the stack.
dropN :: forall (n :: Nat) (s :: [Type]). (SingI (ToPeano n), RequireLongerOrSameLength (ToTs s) (ToPeano n), Drop (ToPeano n) (ToTs s) ~ ToTs (Drop (ToPeano n) s)) => s :-> Drop (ToPeano n) s

-- | Copies a stack argument.
--   
--   Hit the <a>Dupable</a> constraint? Polymorphism and abstractions do
--   not play very well with this constraint, you can enjoy suffering from
--   the linear types feature under various sauces:
--   
--   <ol>
--   <li>The most trivial option is to just propagate <a>Dupable</a>
--   constraint when you want to use <a>dup</a>, this suits for case when
--   you are not planning to work with non-dupable types like tickets.</li>
--   <li>Sometimes it is possible to avoid <a>dup</a> and use other
--   instructions instead (e.g. <a>unpair</a> allows splitting a pair
--   without using <a>dup</a>s, <a>getAndUpdate</a> allows accessing a map
--   value without implicit duplication). But you may have to learn to
--   write code in a completely different way, and the result may be less
--   efficient comparing to the option with using <tt>dup</tt>.</li>
--   <li>Use <a>decideOnDupable</a> to provide two code paths - when type
--   is dupable and when it is not.</li>
--   </ol>
dup :: forall a s. Dupable a => (a : s) :-> (a : (a : s))
dupNPeano :: forall (n :: Peano) a inp out. (ConstraintDUPNLorentz n inp out a, Dupable a) => inp :-> out
dupN :: forall (n :: Nat) a inp out. (ConstraintDUPNLorentz (ToPeano n) inp out a, Dupable a) => inp :-> out
swap :: (a : (b : s)) :-> (b : (a : s))

-- | Version of <a>dig</a> which uses Peano number. It is intended for
--   internal usage in Lorentz.
digPeano :: forall (n :: Peano) inp out a. ConstraintDIGLorentz n inp out a => inp :-> out
dig :: forall (n :: Nat) inp out a. ConstraintDIGLorentz (ToPeano n) inp out a => inp :-> out

-- | Version of <a>dug</a> which uses Peano number. It is intended for
--   internal usage in Lorentz.
dugPeano :: forall (n :: Peano) inp out a. ConstraintDUGLorentz n inp out a => inp :-> out
dug :: forall (n :: Nat) inp out a. ConstraintDUGLorentz (ToPeano n) inp out a => inp :-> out
push :: forall t s. NiceConstant t => t -> s :-> (t : s)
some :: (a : s) :-> (Maybe a : s)
none :: forall a s. KnownValue a => s :-> (Maybe a : s)
unit :: s :-> (() : s)
ifNone :: (s :-> s') -> ((a : s) :-> s') -> (Maybe a : s) :-> s'
pair :: (a : (b : s)) :-> ((a, b) : s)
car :: ((a, b) : s) :-> (a : s)
cdr :: ((a, b) : s) :-> (b : s)
unpair :: ((a, b) : s) :-> (a : (b : s))
left :: forall a b s. KnownValue b => (a : s) :-> (Either a b : s)
right :: forall a b s. KnownValue a => (b : s) :-> (Either a b : s)
ifLeft :: ((a : s) :-> s') -> ((b : s) :-> s') -> (Either a b : s) :-> s'
nil :: KnownValue p => s :-> (List p : s)
cons :: (a : (List a : s)) :-> (List a : s)
ifCons :: ((a : (List a : s)) :-> s') -> (s :-> s') -> (List a : s) :-> s'
size :: SizeOpHs c => (c : s) :-> (Natural : s)
emptySet :: NiceComparable e => s :-> (Set e : s)
emptyMap :: (NiceComparable k, KnownValue v) => s :-> (Map k v : s)
emptyBigMap :: (NiceComparable k, KnownValue v, NiceNoBigMap v) => s :-> (BigMap k v : s)
map :: (MapOpHs c, IsoMapOpRes c b, KnownValue b, HasCallStack) => ((MapOpInpHs c : s) :-> (b : s)) -> (c : s) :-> (MapOpResHs c b : s)
iter :: (IterOpHs c, HasCallStack) => ((IterOpElHs c : s) :-> s) -> (c : s) :-> s
mem :: MemOpHs c => (MemOpKeyHs c : (c : s)) :-> (Bool : s)
get :: (GetOpHs c, KnownValue (GetOpValHs c)) => (GetOpKeyHs c : (c : s)) :-> (Maybe (GetOpValHs c) : s)
pairGet :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz n pair => (pair : s) :-> (PairGetHs (ToPeano n) pair : s)
update :: UpdOpHs c => (UpdOpKeyHs c : (UpdOpParamsHs c : (c : s))) :-> (c : s)
getAndUpdate :: (GetOpHs c, UpdOpHs c, KnownValue (GetOpValHs c), UpdOpKeyHs c ~ GetOpKeyHs c) => (UpdOpKeyHs c : (UpdOpParamsHs c : (c : s))) :-> (Maybe (GetOpValHs c) : (c : s))
pairUpdate :: forall (n :: Nat) (val :: Type) (pair :: Type) (s :: [Type]). ConstraintPairUpdateLorentz n val pair => (val : (pair : s)) :-> (PairUpdateHs (ToPeano n) val pair : s)
if_ :: (s :-> s') -> (s :-> s') -> (Bool : s) :-> s'
loop :: (s :-> (Bool : s)) -> (Bool : s) :-> s
loopLeft :: ((a : s) :-> (Either a b : s)) -> (Either a b : s) :-> (b : s)
lambda :: ZipInstrs [i, o] => (i :-> o) -> s :-> ((i :-> o) : s)
exec :: (a : (Lambda a b : s)) :-> (b : s)

-- | Similar to <a>exec</a> but works for lambdas with arbitrary size of
--   input and output.
--   
--   Note that this instruction has its arguments flipped, lambda goes
--   first. This seems to be the only reasonable way to achieve good
--   inference.
execute :: forall i o s. Each [KnownList, ZipInstr] [i, o] => ((i :-> o) : (i ++ s)) :-> (o ++ s)
apply :: forall a b c s. (NiceConstant a, KnownValue b) => (a : (Lambda (a, b) c : s)) :-> (Lambda b c : s)

-- | Version of <a>apply</a> that works for lambdas with arbitrary length
--   input and output.
applicate :: forall a b c inp2nd inpTail s. (NiceConstant a, ZipInstr b, b ~ (inp2nd : inpTail)) => (a : (((a : b) :-> c) : s)) :-> ((b :-> c) : s)
dip :: forall a s s'. HasCallStack => (s :-> s') -> (a : s) :-> (a : s')

-- | Version of <a>dipN</a> which uses Peano number. It is intended for
--   internal usage in Lorentz.
dipNPeano :: forall (n :: Peano) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz n inp out s s' => (s :-> s') -> inp :-> out
dipN :: forall (n :: Nat) (inp :: [Type]) (out :: [Type]) (s :: [Type]) (s' :: [Type]). ConstraintDIPNLorentz (ToPeano n) inp out s s' => (s :-> s') -> inp :-> out
failWith :: forall a s t. NiceConstant a => (a : s) :-> t
cast :: KnownValue a => (a : s) :-> (a : s)
pack :: forall a s. NicePackedValue a => (a : s) :-> (Packed a : s)
unpack :: forall a s. NiceUnpackedValue a => (Packed a : s) :-> (Maybe a : s)
packRaw :: forall a s. NicePackedValue a => (a : s) :-> (ByteString : s)
unpackRaw :: forall a s. NiceUnpackedValue a => (ByteString : s) :-> (Maybe a : s)
concat :: ConcatOpHs c => (c : (c : s)) :-> (c : s)
concat' :: ConcatOpHs c => (List c : s) :-> (c : s)
slice :: (SliceOpHs c, KnownValue c) => (Natural : (Natural : (c : s))) :-> (Maybe c : s)
isNat :: (Integer : s) :-> (Maybe Natural : s)
add :: ArithOpHs Add n m r => (n : (m : s)) :-> (r : s)
sub :: ArithOpHs Sub n m r => (n : (m : s)) :-> (r : s)
rsub :: ArithOpHs Sub n m r => (m : (n : s)) :-> (r : s)
mul :: ArithOpHs Mul n m r => (n : (m : s)) :-> (r : s)
ediv :: ArithOpHs EDiv n m r => (n : (m : s)) :-> (r : s)
abs :: UnaryArithOpHs Abs n => (n : s) :-> (UnaryArithResHs Abs n : s)
neg :: UnaryArithOpHs Neg n => (n : s) :-> (UnaryArithResHs Neg n : s)
lsl :: ArithOpHs Lsl n m r => (n : (m : s)) :-> (r : s)
lsr :: ArithOpHs Lsr n m r => (n : (m : s)) :-> (r : s)
or :: ArithOpHs Or n m r => (n : (m : s)) :-> (r : s)
and :: ArithOpHs And n m r => (n : (m : s)) :-> (r : s)
xor :: ArithOpHs Xor n m r => (n : (m : s)) :-> (r : s)
not :: UnaryArithOpHs Not n => (n : s) :-> (UnaryArithResHs Not n : s)
compare :: NiceComparable n => (n : (n : s)) :-> (Integer : s)
eq0 :: UnaryArithOpHs Eq' n => (n : s) :-> (UnaryArithResHs Eq' n : s)
neq0 :: UnaryArithOpHs Neq n => (n : s) :-> (UnaryArithResHs Neq n : s)
lt0 :: UnaryArithOpHs Lt n => (n : s) :-> (UnaryArithResHs Lt n : s)
gt0 :: UnaryArithOpHs Gt n => (n : s) :-> (UnaryArithResHs Gt n : s)
le0 :: UnaryArithOpHs Le n => (n : s) :-> (UnaryArithResHs Le n : s)
ge0 :: UnaryArithOpHs Ge n => (n : s) :-> (UnaryArithResHs Ge n : s)
int :: ToIntegerArithOpHs i => (i : s) :-> (Integer : s)

-- | Manual variation of <tt>VIEW</tt> instruction. It is pretty much like
--   Michelson's <tt>VIEW</tt>, you must make sure that the compiler can
--   infer the argument and return types of the view.
--   
--   In most cases prefer <a>view</a> instead.
view' :: forall name ret arg s. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret) => (arg : (Address : s)) :-> (Maybe ret : s)

-- | Get a reference to the current contract.
--   
--   Note that, similar to <a>CONTRACT</a> instruction, in Michelson
--   <a>SELF</a> instruction can accept an entrypoint as field annotation,
--   and without annotation specified it creates a <tt>contract</tt> value
--   which calls the default entrypoint.
--   
--   This particular function carries the behaviour of <tt>SELF</tt> before
--   introduction of lightweight entrypoints feature. Thus the contract
--   must <b>not</b> have explicit "default" entrypoint for this to work.
--   
--   If you are going to call a specific entrypoint of the contract, see
--   <a>selfCalling</a>.
self :: forall p s. (NiceParameterFull p, ForbidExplicitDefaultEntrypoint p) => s :-> (ContractRef p : s)

-- | Make a reference to the current contract, maybe a specific entrypoint.
--   
--   Note that, since information about parameter of the current contract
--   is not carried around, in this function you need to specify parameter
--   type <tt>p</tt> explicitly.
selfCalling :: forall p mname s. NiceParameterFull p => EntrypointRef mname -> s :-> (ContractRef (GetEntrypointArgCustom p mname) : s)

-- | Get a reference to a contract by its address.
--   
--   This instruction carries the behaviour of <tt>CONTRACT</tt> before
--   introduction of lightweight entrypoints feature. The contract must
--   <b>not</b> have explicit "default" entrypoint for this to work.
--   
--   If you are going to call a specific entrypoint of the contract, see
--   <a>contractCalling</a>.
contract :: forall p vd addr s. (NiceParameterFull p, ForbidExplicitDefaultEntrypoint p, ToTAddress_ p vd addr) => (addr : s) :-> (Maybe (ContractRef p) : s)

-- | Make a reference to a contract, maybe a specific entrypoint.
--   
--   When calling this function, make sure that parameter type is known.
--   It's recommended that you supply <a>TAddress</a> with a concrete
--   parameter as the stack argument.
contractCalling :: forall cp epRef epArg addr vd s. (HasEntrypointArg cp epRef epArg, ToTAddress_ cp vd addr) => epRef -> (addr : s) :-> (Maybe (ContractRef epArg) : s)

-- | Specialized version of <a>contractCalling</a> for the case when you do
--   not have compile-time evidence of appropriate <a>HasEntrypointArg</a>.
--   For instance, if you have untyped <a>EpName</a> you can not have this
--   evidence (the value is only available in runtime). If you have typed
--   <a>EntrypointRef</a>, use <a>eprName</a> to construct <a>EpName</a>.
unsafeContractCalling :: forall arg s. NiceParameter arg => EpName -> (Address : s) :-> (Maybe (ContractRef arg) : s)

-- | Version of <a>contract</a> instruction which may accept address with
--   already specified entrypoint name.
--   
--   Also you cannot specify entrypoint name here because this could result
--   in conflict.
runFutureContract :: forall p s. NiceParameter p => (FutureContract p : s) :-> (Maybe (ContractRef p) : s)

-- | Similar to <a>runFutureContract</a>, works with <a>EpAddress</a>.
--   
--   Validity of such operation cannot be ensured at compile time.
epAddressToContract :: forall p s. NiceParameter p => (EpAddress : s) :-> (Maybe (ContractRef p) : s)
transferTokens :: forall p s. NiceParameter p => (p : (Mutez : (ContractRef p : s))) :-> (Operation : s)
setDelegate :: (Maybe KeyHash : s) :-> (Operation : s)
createContract :: forall p g vd s. Contract p g vd -> (Maybe KeyHash : (Mutez : (g : s))) :-> (Operation : (TAddress p vd : s))
implicitAccount :: (KeyHash : s) :-> (ContractRef () : s)
now :: s :-> (Timestamp : s)
amount :: s :-> (Mutez : s)
balance :: s :-> (Mutez : s)
votingPower :: (KeyHash : s) :-> (Natural : s)
totalVotingPower :: s :-> (Natural : s)
checkSignature :: BytesLike bs => (PublicKey : (TSignature bs : (bs : s))) :-> (Bool : s)
sha256 :: BytesLike bs => (bs : s) :-> (Hash Sha256 bs : s)
sha512 :: BytesLike bs => (bs : s) :-> (Hash Sha512 bs : s)
blake2B :: BytesLike bs => (bs : s) :-> (Hash Blake2b bs : s)
sha3 :: BytesLike bs => (bs : s) :-> (Hash Sha3 bs : s)
keccak :: BytesLike bs => (bs : s) :-> (Hash Keccak bs : s)
hashKey :: (PublicKey : s) :-> (KeyHash : s)
pairingCheck :: ([(Bls12381G1, Bls12381G2)] : s) :-> (Bool : s)

-- | <i>Warning: Using <a>source</a> is considered a bad practice. Consider
--   using <a>sender</a> instead until further investigation</i>
source :: s :-> (Address : s)
sender :: s :-> (Address : s)
address :: (ContractRef a : s) :-> (Address : s)
chainId :: s :-> (ChainId : s)
level :: s :-> (Natural : s)
selfAddress :: s :-> (Address : s)
never :: (Never : s) :-> s'
ticket :: NiceComparable a => (a : (Natural : s)) :-> (Ticket a : s)

-- | Note: for more advanced helpers for tickets see <a>Lorentz.Tickets</a>
--   module.
readTicket :: (Ticket a : s) :-> (ReadTicket a : (Ticket a : s))

-- | Note: for more advanced helpers for tickets see <a>Lorentz.Tickets</a>
--   module.
splitTicket :: (Ticket a : ((Natural, Natural) : s)) :-> (Maybe (Ticket a, Ticket a) : s)

-- | Version of <a>splitTicket</a> with entries named.
splitTicketNamed :: forall n1 n2 a s. (Ticket a : ((n1 :! Natural, n2 :! Natural) : s)) :-> (Maybe (n1 :! Ticket a, n2 :! Ticket a) : s)

-- | Note: for more advanced helpers for tickets see <a>Lorentz.Tickets</a>
--   module.
joinTickets :: ((Ticket a, Ticket a) : s) :-> (Maybe (Ticket a) : s)
openChest :: (ChestKey : (Chest : (Natural : s))) :-> (OpenChest : s)

-- | Execute given instruction on truncated stack.
--   
--   This instruction requires you to specify the piece of stack to
--   truncate as type argument.
framed :: forall s i o. (KnownList i, KnownList o) => (i :-> o) -> (i ++ s) :-> (o ++ s)

-- | Helper instruction.
--   
--   Checks whether given key present in the storage and fails if it is.
--   This instruction leaves stack intact.
failingWhenPresent :: forall c k s v st e. (MemOpHs c, k ~ MemOpKeyHs c, NiceConstant e, Dupable c, Dupable (MemOpKeyHs c), st ~ (k : (v : (c : s)))) => (forall s0. (k : s0) :-> (e : s0)) -> st :-> st

-- | Like <a>update</a>, but throw an error on attempt to overwrite
--   existing entry.
updateNew :: forall c k s e. (UpdOpHs c, MemOpHs c, GetOpHs c, k ~ UpdOpKeyHs c, k ~ MemOpKeyHs c, k ~ GetOpKeyHs c, KnownValue (GetOpValHs c), NiceConstant e, Dupable k) => (forall s0. (k : s0) :-> (e : s0)) -> (k : (UpdOpParamsHs c : (c : s))) :-> (c : s)

-- | Duplicate an element of stack referring it by type.
--   
--   If stack contains multiple entries of this type, compile error is
--   raised.
dupT :: forall a st. DupT st a st => st :-> (a : st)

-- | Dip repeatedly until element of the given type is on top of the stack.
--   
--   If stack contains multiple entries of this type, compile error is
--   raised.
dipT :: forall a inp dinp dout out. DipT inp a inp dinp dout out => (dinp :-> dout) -> inp :-> out

-- | Remove element with the given type from the stack.
dropT :: forall a inp dinp dout out. (DipT inp a inp dinp dout out, dinp ~ (a : dout)) => inp :-> out

-- | Documentation for custom errors.
--   
--   Mentions that entrypoint throws given error.
data DThrows
[DThrows] :: ErrorHasDoc e => Proxy e -> DThrows

-- | Mentions that contract uses given error.
data DError
[DError] :: ErrorHasDoc e => Proxy e -> DError
class (KnownSymbol tag, TypeHasDoc (CustomErrorRep tag), IsError (CustomError tag)) => CustomErrorHasDoc tag

-- | What should happen for this error to be raised.
customErrDocMdCause :: CustomErrorHasDoc tag => Markdown

-- | Brief version of <a>customErrDocMdCause</a>. This will appear along
--   with the error when mentioned in entrypoint description.
--   
--   By default, the first sentence of the full description is used.
customErrDocMdCauseInEntrypoint :: CustomErrorHasDoc tag => Markdown

-- | Error class.
--   
--   By default this returns "unknown error" class; though you should
--   provide explicit implementation in order to avoid a warning.
customErrClass :: CustomErrorHasDoc tag => ErrorClass

-- | Clarification of error argument meaning.
--   
--   Provide when it's not obvious, e.g. argument is not named with
--   <a>:!</a>.
--   
--   NOTE: This should <i>not</i> be an entire sentence, rather just the
--   semantic backbone.
--   
--   Bad: * <tt>Error argument stands for the previous value of
--   approval.</tt>
--   
--   Good: * <tt>the previous value of approval</tt> * <tt>pair, first
--   argument of which is one thing, and the second is another</tt>
customErrArgumentSemantics :: CustomErrorHasDoc tag => Maybe Markdown

-- | Error class on how the error should be handled by the client.
data ErrorClass

-- | Normal expected error. Examples: "insufficient balance", "wallet does
--   not exist".
ErrClassActionException :: ErrorClass

-- | Invalid argument passed to entrypoint. Examples: your entrypoint
--   accepts an enum represented as <tt>nat</tt>, and unknown value is
--   provided. This includes more complex cases which involve multiple
--   entrypoints. E.g. API provides iterator interface, middleware should
--   care about using it hiding complex details and exposing a simpler API
--   to user; then an attempt to request non-existing element would also
--   correspond to an error from this class.
ErrClassBadArgument :: ErrorClass

-- | Unexpected error. Most likely it means that there is a bug in the
--   contract or the contract has been deployed incorrectly.
ErrClassContractInternal :: ErrorClass

-- | It's possible to leave error class unspecified.
ErrClassUnknown :: ErrorClass
type MustHaveErrorArg errorTag expectedArgRep = (AssertTypesEqual (CustomErrorRep errorTag) expectedArgRep ('Text "Error argument type is " :<>: 'ShowType (expectedArgRep) :<>: 'Text " but given error requires argument of type " :<>: 'ShowType (CustomErrorRep errorTag)), CustomErrorRep errorTag ~ expectedArgRep)

-- | Typeclass implements various method that work with
--   <a>CustomErrorArgRep</a>.
class IsCustomErrorArgRep a
verifyErrorTag :: IsCustomErrorArgRep a => MText -> a -> Either Text a
customErrorRepDocDeps :: IsCustomErrorArgRep a => [SomeDocDefinitionItem]
customErrorHaskellRep :: (IsCustomErrorArgRep a, KnownSymbol tag, CustomErrorHasDoc tag) => Proxy tag -> Markdown

-- | How <a>CustomError</a> is actually represented in Michelson.
type CustomErrorRep tag = CustomErrorArgRep (ErrorArg tag)

-- | To be used as <tt>ErrorArg</tt> instances. This is equivalent to using
--   <tt>()</tt> but using <tt>UnitErrorArg</tt> is preferred since
--   <tt>()</tt> behavior could be changed in the future.
data UnitErrorArg

-- | To be used as <tt>ErrorArg</tt> instance when failing with just a
--   <tt>string</tt> instead of <tt>pair string x</tt>
data NoErrorArg

-- | Material custom error.
--   
--   Use this in pattern matches against error (e.g. in tests).
data CustomError (tag :: Symbol)
CustomError :: Label tag -> CustomErrorRep tag -> CustomError (tag :: Symbol)
[ceTag] :: CustomError (tag :: Symbol) -> Label tag
[ceArg] :: CustomError (tag :: Symbol) -> CustomErrorRep tag

-- | Declares a custom error, defining <tt>error name - error argument</tt>
--   relation.
--   
--   If your error is supposed to carry no argument, then provide
--   <tt>()</tt>.
--   
--   Note that this relation is defined globally rather than on
--   per-contract basis, so define errors accordingly. If your error has
--   argument specific to your contract, call it such that error name
--   reflects its belonging to this contract.
--   
--   This is the basic [error format].
type family ErrorArg (tag :: Symbol) :: Type

-- | Type wrapper for an <tt>IsError</tt>.
data SomeError
SomeError :: e -> SomeError

-- | Use this error when sure that failing at the current position is
--   possible in no curcumstances (including invalid user input or
--   misconfigured storage).
--   
--   To use this as error, you have to briefly specify the reason why the
--   error scenario is impossible (experimental feature).
data Impossible (reason :: Symbol)
Impossible :: Impossible (reason :: Symbol)

-- | Use this type as replacement for <tt>()</tt> when you <b>really</b>
--   want to leave error cause unspecified.
data UnspecifiedError
UnspecifiedError :: UnspecifiedError
class Typeable e => ErrorHasDoc (e :: Type) where {
    
    -- | Constraints which we require in a particular instance. You are not
    --   oblidged to often instantiate this correctly, it is only useful for
    --   some utilities.
    type family ErrorRequirements e :: Constraint;
    type ErrorRequirements _ = ();
}

-- | Name of error as it appears in the corresponding section title.
errorDocName :: ErrorHasDoc e => Text

-- | What should happen for this error to be raised.
errorDocMdCause :: ErrorHasDoc e => Markdown

-- | Brief version of <a>errorDocMdCause</a>.
--   
--   This will appear along with the error when mentioned in entrypoint
--   description. By default, the first sentence of the full description is
--   used.
errorDocMdCauseInEntrypoint :: ErrorHasDoc e => Markdown

-- | How this error is represented in Haskell.
errorDocHaskellRep :: ErrorHasDoc e => Markdown

-- | Error class.
errorDocClass :: ErrorHasDoc e => ErrorClass

-- | Which definitions documentation for this error mentions.
errorDocDependencies :: ErrorHasDoc e => [SomeDocDefinitionItem]

-- | Captured constraints which we require in a particular instance. This
--   is a way to encode a bidirectional instance in the nowaday Haskell,
--   for <tt>class MyConstraint =&gt; ErrorHasDoc MyType</tt> instance it
--   lets deducing <tt>MyConstraint</tt> by <tt>ErrorHasDoc MyType</tt>.
--   
--   You are not oblidged to always instantiate, it is only useful for some
--   utilities which otherwise would not compile.
errorDocRequirements :: ErrorHasDoc e => Dict (ErrorRequirements e)

-- | Captured constraints which we require in a particular instance. This
--   is a way to encode a bidirectional instance in the nowaday Haskell,
--   for <tt>class MyConstraint =&gt; ErrorHasDoc MyType</tt> instance it
--   lets deducing <tt>MyConstraint</tt> by <tt>ErrorHasDoc MyType</tt>.
--   
--   You are not oblidged to always instantiate, it is only useful for some
--   utilities which otherwise would not compile.
errorDocRequirements :: (ErrorHasDoc e, ErrorRequirements e) => Dict (ErrorRequirements e)

-- | Haskell type representing error.
class (ErrorHasDoc e) => IsError e

-- | Converts a Haskell error into <tt>Value</tt> representation.
errorToVal :: IsError e => e -> (forall t. ErrorScope t => Value t -> r) -> r

-- | Converts a <tt>Value</tt> into Haskell error.
errorFromVal :: (IsError e, SingI t) => Value t -> Either Text e

-- | Fail with the given Haskell value.
failUsing :: (IsError e, IsError e) => e -> s :-> t

-- | Since 008 it's prohibited to fail with non-packable values and with
--   the 'Contract t' type values, which is equivalent to our
--   <tt>ConstantScope</tt> constraint. See
--   <a>https://gitlab.com/tezos/tezos/-/issues/1093#note_496066354</a> for
--   more information.
type ErrorScope t = ConstantScope t

-- | Implementation of <a>errorToVal</a> via <a>IsoValue</a>.
isoErrorToVal :: (KnownError e, IsoValue e) => e -> (forall t. ErrorScope t => Value t -> r) -> r

-- | Implementation of <a>errorFromVal</a> via <a>IsoValue</a>.
isoErrorFromVal :: (SingI t, KnownIsoT e, IsoValue e) => Value t -> Either Text e

-- | Basic implementation for <a>failUsing</a>.
simpleFailUsing :: forall e s t. IsError e => e -> s :-> t

-- | Fail, providing a reference to the place in the code where this
--   function is called.
--   
--   Like <a>error</a> in Haskell code, this instruction is for internal
--   errors only.
failUnexpected :: MText -> s :-> t

-- | Demote error tag to term level.
errorTagToMText :: Label tag -> MText
errorTagToText :: forall tag. KnownSymbol tag => Text

-- | Fail with given custom error.
failCustom :: forall tag err s any. (MustHaveErrorArg tag (MText, err), CustomErrorHasDoc tag, KnownError err) => Label tag -> (err : s) :-> any

-- | Fail with given custom error.
failCustomNoArg :: forall tag s any. (MustHaveErrorArg tag MText, CustomErrorHasDoc tag) => Label tag -> s :-> any

-- | Specialization of <a>failCustom</a> for unit-arg errors.
failCustom_ :: forall tag s any. (MustHaveErrorArg tag (MText, ()), CustomErrorHasDoc tag) => Label tag -> s :-> any

-- | Whether given error class is about internal errors.
--   
--   Internal errors are not enlisted on per-entrypoint basis, only once
--   for the entire contract.
isInternalErrorClass :: ErrorClass -> Bool

-- | Implementation of <a>typeDocMdDescription</a> (of <a>TypeHasDoc</a>
--   typeclass) for Haskell types which sole purpose is to be error.
typeDocMdDescriptionReferToError :: forall e. IsError e => Markdown

-- | QuasiQuote that helps generating <tt>ParameterHasEntrypoints</tt>
--   instance.
--   
--   Usage:
--   
--   <pre>
--   [entrypointDoc| Parameter &lt;parameter-type&gt; &lt;optional-root-annotation&gt; |]
--   [entrypointDoc| Parameter plain |]
--   [entrypointDoc| Parameter plain "root"|]
--   </pre>
--   
--   See this <a>tutorial</a> which includes this quasiquote.
entrypointDoc :: QuasiQuoter

-- | QuasiQuote that helps generating <tt>CustomErrorHasDoc</tt> instance.
--   
--   Usage:
--   
--   <pre>
--   [errorDoc| &lt;error-name&gt; &lt;error-type&gt; &lt;error-description&gt; |]
--   [errorDoc| "errorName" exception "Error description" |]
--   </pre>
--   
--   See this <a>tutorial</a> which includes this quasiquote.
errorDoc :: QuasiQuoter

-- | QuasiQuote that helps generating <tt>TypeHasDoc</tt> instance.
--   
--   Usage:
--   
--   <pre>
--   [typeDoc| &lt;type&gt; &lt;description&gt; |]
--   [typeDoc| Storage "This is storage description"  |]
--   </pre>
--   
--   See this <a>tutorial</a> which includes this quasiquote.
typeDoc :: QuasiQuoter

-- | Tags excluded from map.
type ErrorTagExclusions = HashSet MText

-- | This is a bidirectional map with correspondence between numeric and
--   textual error tags.
type ErrorTagMap = Bimap Natural MText

-- | Find all textual error tags that are used in typical <tt>FAILWITH</tt>
--   patterns within given instruction. Map them to natural numbers.
gatherErrorTags :: (inp :-> out) -> HashSet MText

-- | Add more error tags to an existing <a>ErrorTagMap</a>. It is useful
--   when your contract consists of multiple parts (e. g. in case of
--   contract upgrade), you have existing map for some part and want to add
--   tags from another part to it. You can pass empty map as existing one
--   if you just want to build <a>ErrorTagMap</a> from a set of textual
--   tags. See <a>buildErrorTagMap</a>.
addNewErrorTags :: ErrorTagMap -> HashSet MText -> ErrorTagMap

-- | Build <a>ErrorTagMap</a> from a set of textual tags.
buildErrorTagMap :: HashSet MText -> ErrorTagMap

-- | Remove some error tags from map. This way you say to remain these
--   string tags intact, while others will be converted to numbers when
--   this map is applied.
--   
--   Note that later you have to apply this map using
--   <a>applyErrorTagMapWithExclusions</a>, otherwise an error would be
--   raised.
excludeErrorTags :: HasCallStack => ErrorTagExclusions -> ErrorTagMap -> ErrorTagMap

-- | For each typical <a>FAILWITH</a> that uses a string to represent error
--   tag this function changes error tag to be a number using the supplied
--   conversion map. It assumes that supplied map contains all such strings
--   (and will error out if it does not). It will always be the case if you
--   gather all error tags using <a>gatherErrorTags</a> and build
--   <a>ErrorTagMap</a> from them using <a>addNewErrorTags</a>.
applyErrorTagMap :: HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out

-- | Similar to <a>applyErrorTagMap</a>, but for case when you have
--   excluded some tags from map via <a>excludeErrorTags</a>. Needed,
--   because both <a>excludeErrorTags</a> and this function do not tolerate
--   unknown errors in contract code (for your safety).
applyErrorTagMapWithExclusions :: HasCallStack => ErrorTagMap -> ErrorTagExclusions -> (inp :-> out) -> inp :-> out

-- | This function implements the simplest scenario of using this module's
--   functionality: 1. Gather all error tags from a single instruction. 2.
--   Turn them into error conversion map. 3. Apply this conversion.
useNumericErrors :: HasCallStack => (inp :-> out) -> (inp :-> out, ErrorTagMap)

-- | If you apply numeric error representation in your contract,
--   <a>errorFromVal</a> will stop working because it doesn't know about
--   this transformation. This function takes this transformation into
--   account. If a number is used as a tag, but it is not found in the
--   passed map, we conservatively preserve that number (because this whole
--   approach is rather a heuristic).
errorFromValNumeric :: (SingI t, IsError e) => ErrorTagMap -> Value t -> Either Text e

-- | If you apply numeric error representation in your contract,
--   <a>errorToVal</a> will stop working because it doesn't know about this
--   transformation. This function takes this transformation into account.
--   If a string is used as a tag, but it is not found in the passed map,
--   we conservatively preserve that string (because this whole approach is
--   rather a heuristic).
errorToValNumeric :: IsError e => ErrorTagMap -> e -> (forall t. ConstantScope t => Value t -> r) -> r

-- | Replacement for uninhabited type.

-- | <i>Deprecated: Use Never type instead</i>
data Empty

-- | Witness of that this code is unreachable.
absurd_ :: (Empty : s) :-> s'

-- | Coercions between <tt>a</tt> to <tt>b</tt> are permitted and safe.
type Coercible_ a b = (MichelsonCoercible a b, CanCastTo a b, CanCastTo b a)

-- | Coercion from <tt>a</tt> to <tt>b</tt> is permitted and safe.
type Castable_ a b = (MichelsonCoercible a b, CanCastTo a b)

-- | Explicitly allowed coercions.
--   
--   <tt>a <a>CanCastTo</a> b</tt> proclaims that <tt>a</tt> can be casted
--   to <tt>b</tt> without violating any invariants of <tt>b</tt>.
--   
--   This relation is reflexive; it <i>may</i> be symmetric or not. It
--   tends to be composable: casting complex types usually requires
--   permission to cast their respective parts; for such types consider
--   using <a>castDummyG</a> as implementation of the method of this
--   typeclass.
--   
--   For cases when a cast from <tt>a</tt> to <tt>b</tt> requires some
--   validation, consider rather making a dedicated function which performs
--   the necessary checks and then calls <a>forcedCoerce</a>.
class a `CanCastTo` b

-- | An optional method which helps passing -Wredundant-constraints check.
--   Also, you can set specific implementation for it with specific sanity
--   checks.
castDummy :: CanCastTo a b => Proxy a -> Proxy b -> ()

-- | Whether two types have the same Michelson representation.
type MichelsonCoercible a b = ToT a ~ ToT b

-- | Coercion for Haskell world.
--   
--   We discourage using this function on Lorentz types, consider using
--   <a>coerce</a> instead. One of the reasons forthat is that in Lorentz
--   it's common to declare types as newtypes consisting of existing
--   primitives, and <tt>forcedCoerce</tt> tends to ignore all phantom type
--   variables of newtypes thus violating their invariants.
forcedCoerce :: Coercible a b => a -> b

-- | Convert between values of types that have the same representation.
--   
--   This function is not safe in a sense that this allows * breaking
--   invariants of casted type (example: <tt>UStore</tt> from
--   morley-upgradeable), or * may stop compile on code changes (example:
--   coercion of pair to a datatype with two fields will break if new field
--   is added). Still, produced Michelson code will always be valid.
--   
--   Prefer using one of more specific functions from this module.
forcedCoerce_ :: MichelsonCoercible a b => (a : s) :-> (b : s)
gForcedCoerce_ :: MichelsonCoercible (t a) (t b) => (t a : s) :-> (t b : s)

-- | Convert between two stacks via failing.
fakeCoerce :: s1 :-> s2
fakeCoercing :: (s1 :-> s2) -> s1' :-> s2'

-- | Specialized version of <a>forcedCoerce_</a> to unwrap a haskell
--   newtype.
coerceUnwrap :: forall a s. Unwrappable a => (a : s) :-> (Unwrappabled a : s)

-- | Specialized version of <a>forcedCoerce_</a> to wrap a haskell newtype.
--   
--   Works under <a>Unwrappable</a> constraint, thus is not safe.
unsafeCoerceWrap :: forall a s. Unwrappable a => (Unwrappabled a : s) :-> (a : s)

-- | Specialized version of <a>forcedCoerce_</a> to wrap into a haskell
--   newtype.
--   
--   Requires <a>Wrappable</a> constraint.
coerceWrap :: forall a s. Wrappable a => (Unwrappabled a : s) :-> (a : s)

-- | Lift given value to a named value.
toNamed :: Label name -> (a : s) :-> ((name :! a) : s)

-- | Unpack named value.
fromNamed :: Label name -> ((name :! a) : s) :-> (a : s)

-- | Coercion in Haskell world which respects <a>CanCastTo</a>.
checkedCoerce :: forall a b. (CanCastTo a b, Coercible a b) => a -> b

-- | Coerce between types which have an explicit permission for that in the
--   face of <a>CanCastTo</a> constraint.
checkedCoerce_ :: forall a b s. Castable_ a b => (a : s) :-> (b : s)

-- | Pretends that the top item of the stack was coerced.
checkedCoercing_ :: forall a b s. Coercible_ a b => ((b : s) :-> (b : s)) -> (a : s) :-> (a : s)

-- | Locally provide given <a>CanCastTo</a> instance.
allowCheckedCoerceTo :: forall b a. Dict (CanCastTo a b)

-- | Locally provide bidirectional <a>CanCastTo</a> instance.
allowCheckedCoerce :: forall a b. Dict (CanCastTo a b, CanCastTo b a)

-- | Implementation of <a>castDummy</a> for types composed from smaller
--   types. It helps to ensure that all necessary constraints are requested
--   in instance head.
castDummyG :: (Generic a, Generic b, GCanCastTo (Rep a) (Rep b)) => Proxy a -> Proxy b -> ()
type CaseTC dt out inp clauses = (InstrCaseC dt, RMap (CaseClauses dt), RecFromTuple clauses, clauses ~ Rec (CaseClauseL inp out) (CaseClauses dt))

-- | Provides "case" arrow which works on different wrappers for clauses.
class CaseArrow name body clause | clause -> name, clause -> body

-- | Lift an instruction to case clause.
--   
--   You should write out constructor name corresponding to the clause
--   explicitly. Prefix constructor name with "c" letter, otherwise your
--   label will not be recognized by Haskell parser. Passing constructor
--   name can be circumvented but doing so is not recomended as mentioning
--   contructor name improves readability and allows avoiding some
--   mistakes.
(/->) :: CaseArrow name body clause => Label name -> body -> clause
infixr 0 /->

-- | Lorentz analogy of <a>CaseClause</a>, it works on plain <a>Type</a>
--   types.
data CaseClauseL (inp :: [Type]) (out :: [Type]) (param :: CaseClauseParam)
[CaseClauseL] :: (AppendCtorField x inp :-> out) -> CaseClauseL inp out ('CaseClauseParam ctor x)

-- | Shortcut for multiple <a>HasFieldOfType</a> constraints.
type family HasFieldsOfType (dt :: Type) (fs :: [NamedField]) :: Constraint
type n := ty = 'NamedField n ty
infixr 0 :=

-- | A pair of field name and type.
data NamedField
NamedField :: Symbol -> Type -> NamedField

-- | Like <a>HasField</a>, but allows constrainting field type.
type HasFieldOfType dt fname fieldTy = (HasField dt fname, GetFieldType dt fname ~ fieldTy)

-- | Allows field access and modification.
type HasField dt fname = (InstrGetFieldC dt fname, InstrSetFieldC dt fname)

-- | Extract a field of a datatype replacing the value of this datatype
--   with the extracted field.
--   
--   For this and the following functions you have to specify field name
--   which is either record name or name attached with <tt>(:!)</tt>
--   operator.
toField :: forall dt name st. InstrGetFieldC dt name => Label name -> (dt : st) :-> (GetFieldType dt name : st)

-- | Like <a>toField</a>, but leaves field named.
toFieldNamed :: forall dt name st. InstrGetFieldC dt name => Label name -> (dt : st) :-> ((name :! GetFieldType dt name) : st)

-- | Extract a field of a datatype, leaving the original datatype on stack.
--   
--   TODO: [#585] Make this and all depending functions require only
--   <tt>Dupable (GetFieldType dt name)</tt>
getField :: forall dt name st. (InstrGetFieldC dt name, Dupable dt) => Label name -> (dt : st) :-> (GetFieldType dt name : (dt : st))

-- | Like <a>getField</a>, but leaves field named.
getFieldNamed :: forall dt name st. (InstrGetFieldC dt name, Dupable dt) => Label name -> (dt : st) :-> ((name :! GetFieldType dt name) : (dt : st))

-- | Set a field of a datatype.
setField :: forall dt name st. InstrSetFieldC dt name => Label name -> (GetFieldType dt name : (dt : st)) :-> (dt : st)

-- | Apply given modifier to a datatype field.
modifyField :: forall dt name st. (InstrGetFieldC dt name, InstrSetFieldC dt name, Dupable dt) => Label name -> (forall st0. (GetFieldType dt name : st0) :-> (GetFieldType dt name : st0)) -> (dt : st) :-> (dt : st)

-- | Make up a datatype. You provide a pack of individual fields
--   constructors.
--   
--   Each element of the accepted record should be an instruction wrapped
--   with <a>fieldCtor</a> function. This instruction will have access to
--   the stack at the moment of calling <tt>construct</tt>. Instructions
--   have to output fields of the built datatype, one per instruction;
--   instructions order is expected to correspond to the order of fields in
--   the datatype.
construct :: forall dt st. (InstrConstructC dt, RMap (ConstructorFieldTypes dt)) => Rec (FieldConstructor st) (ConstructorFieldTypes dt) -> st :-> (dt : st)

-- | Version of <a>construct</a> which accepts tuple of field constructors.
constructT :: forall dt fctors st. (InstrConstructC dt, RMap (ConstructorFieldTypes dt), fctors ~ Rec (FieldConstructor st) (ConstructorFieldTypes dt), RecFromTuple fctors) => IsoRecTuple fctors -> st :-> (dt : st)

-- | Construct an object from fields on the stack.
constructStack :: forall dt fields st. (InstrConstructC dt, fields ~ ConstructorFieldTypes dt, KnownList fields) => (fields ++ st) :-> (dt : st)

-- | Decompose a complex object into its fields
deconstruct :: forall dt fields st. (InstrDeconstructC dt, KnownList fields, fields ~ ConstructorFieldTypes dt) => (dt : st) :-> (fields ++ st)

-- | Lift an instruction to field constructor.
fieldCtor :: HasCallStack => (st :-> (f : st)) -> FieldConstructor st f

-- | Wrap entry in constructor. Useful for sum types.
wrap_ :: forall dt name st. InstrWrapC dt name => Label name -> AppendCtorField (GetCtorField dt name) st :-> (dt : st)

-- | Wrap entry in single-field constructor. Useful for sum types.
wrapOne :: forall dt name st. InstrWrapOneC dt name => Label name -> (CtorOnlyField name dt : st) :-> (dt : st)

-- | Pattern match on the given sum type.
--   
--   You have to provide a <a>Rec</a> containing case branches. To
--   construct a case branch use <a>/-&gt;</a> operator.
case_ :: forall dt out inp. (InstrCaseC dt, RMap (CaseClauses dt)) => Rec (CaseClauseL inp out) (CaseClauses dt) -> (dt : inp) :-> out

-- | Like <a>case_</a>, accepts a tuple of clauses, which may be more
--   convenient.
--   
--   If user is experiencing problems with wierd errors about tuples while
--   using this function, he should take look at
--   <a>Morley.Util.TypeTuple.Instances</a> and ensure that his tuple isn't
--   bigger than generated instances, if so, he should probably extend
--   number of generated instances.
caseT :: forall dt out inp clauses. CaseTC dt out inp clauses => IsoRecTuple clauses -> (dt : inp) :-> out

-- | Unwrap a constructor with the given name. Useful for sum types.
unsafeUnwrap_ :: forall dt name st. InstrUnwrapC dt name => Label name -> (dt : st) :-> (CtorOnlyField name dt : st)

-- | Version of <a>HasNamedVar</a> for multiple variables.
--   
--   <pre>
--   type HasContext = HasNamedVars s ["x" := Integer, "f" := Lambda MText MText]
--   </pre>
type family HasNamedVars (s :: [Type]) (vs :: [NamedField]) :: Constraint

-- | Indicates that stack <tt>s</tt> contains a <tt>name :! var</tt> or
--   <tt>name :? var</tt> value.
class HasNamedVar (s :: [Type]) (name :: Symbol) (var :: Type) | s name -> var

-- | Requires type <tt>x</tt> to be an unnamed variable.
--   
--   When e.g. <a>dupL</a> sees a polymorphic variable, it can't judge
--   whether is it a variable we are seeking for or not;
--   <tt>VarIsUnnamed</tt> helps to assure the type system that given
--   variable won't be named.
type VarIsUnnamed x = VarName x ~ 'VarUnnamed

-- | Version of <a>dupL</a> that leaves a named variable on stack.
dupLNamed :: forall var name s. (HasNamedVar s name var, Dupable var) => Label name -> s :-> ((name :! var) : s)

-- | Take the element with given label on stack and copy it on top.
--   
--   If there are multiple variables with given label, the one closest to
--   the top of the stack is picked.
dupL :: forall var name s. (HasNamedVar s name var, Dupable var) => Label name -> s :-> (var : s)
class NonZero t

-- | Retain the value only if it is not zero.
nonZero :: NonZero t => (t : s) :-> (Maybe t : s)

-- | Newtype over void result type used in tests to distinguish successful
--   void result from other errors.
--   
--   Usage example: lExpectFailWith (== VoidResult roleMaster)`
--   
--   This error is special - it can contain arguments of different types
--   depending on entrypoint which raises it.
newtype VoidResult r
VoidResult :: r -> VoidResult r
[unVoidResult] :: VoidResult r -> r

-- | <tt>void</tt> type synonym as described in A1.
data Void_ (a :: Type) (b :: Type)
Void_ :: a -> Lambda b b -> Void_ (a :: Type) (b :: Type)

-- | Entry point argument.
[voidParam] :: Void_ (a :: Type) (b :: Type) -> a

-- | Type of result reported via <a>failWith</a>.
[voidResProxy] :: Void_ (a :: Type) (b :: Type) -> Lambda b b

-- | <tt>view</tt> type synonym as described in A1.
data View_ (a :: Type) (r :: Type)
View_ :: a -> ContractRef r -> View_ (a :: Type) (r :: Type)
[viewParam] :: View_ (a :: Type) (r :: Type) -> a
[viewCallbackTo] :: View_ (a :: Type) (r :: Type) -> ContractRef r
class UpdateN (n :: Peano) (s :: [Type]) (a :: Type) (b :: Type) mid tail
updateNImpl :: UpdateN n s a b mid tail => ('[a, b] :-> '[b]) -> (a : s) :-> s

-- | Constraint for updateN that combines kind-agnostic constraint for
--   Lorentz (Haskell) types and for our typed Michelson.
type ConstraintUpdateNLorentz (n :: Peano) (s :: [Type]) (a :: Type) (b :: Type) (mid :: [Type]) (tail :: [Type]) = (UpdateNConstraint' T n (ToTs s) (ToT a) (ToT b) (ToTs mid) (ToTs tail), UpdateNConstraint' Type n s a b mid tail)
class ReplaceN (n :: Peano) (s :: [Type]) (a :: Type) mid tail
replaceNImpl :: ReplaceN n s a mid tail => (a : s) :-> s

-- | Constraint for replaceN that combines kind-agnostic constraint for
--   Lorentz (Haskell) types and for our typed Michelson.
type ConstraintReplaceNLorentz (n :: Peano) (s :: [Type]) (a :: Type) (mid :: [Type]) (tail :: [Type]) = (ReplaceNConstraint' T n (ToTs s) (ToT a) (ToTs mid) (ToTs tail), ReplaceNConstraint' Type n s a mid tail)

-- | Delete element from the map.
deleteMap :: forall k v s. (MapInstrs map, NiceComparable k, KnownValue v) => (k : (map k v : s)) :-> (map k v : s)

-- | Insert given element into map.
mapInsert :: (MapInstrs map, NiceComparable k) => (k : (v : (map k v : s))) :-> (map k v : s)

-- | Insert given element into map, ensuring that it does not overwrite any
--   existing entry.
--   
--   As first argument accepts container name (for error message).
mapInsertNew :: (MapInstrs map, IsoValue (map k v), NiceComparable k, NiceConstant e, Dupable k, KnownValue v) => (forall s0. (k : s0) :-> (e : s0)) -> (k : (v : (map k v : s))) :-> (map k v : s)

-- | An instruction that always fails.
type ErrInstr s = forall serr. s :-> serr
eq :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
neq :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
gt :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
le :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
ge :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
lt :: NiceComparable n => (n : (n : s)) :-> (Bool : s)
ifEq0 :: IfCmp0Constraints a Eq' => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifNeq0 :: IfCmp0Constraints a Neq => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifLt0 :: IfCmp0Constraints a Lt => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifGt0 :: IfCmp0Constraints a Gt => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifLe0 :: IfCmp0Constraints a Le => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifGe0 :: IfCmp0Constraints a Ge => (s :-> s') -> (s :-> s') -> (a : s) :-> s'
ifEq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifNeq :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifLt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifGt :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifLe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'
ifGe :: NiceComparable a => (s :-> s') -> (s :-> s') -> (a : (a : s)) :-> s'

-- | Analog of the FAIL macro in Michelson. Its usage is discouraged
--   because it doesn't carry any information about failure.

-- | <i>Warning: <a>fail_</a> remains in code</i>
fail_ :: a :-> c
assert :: IsError err => err -> (Bool : s) :-> s
assertEq0 :: (IfCmp0Constraints a Eq', IsError err) => err -> (a : s) :-> s
assertNeq0 :: (IfCmp0Constraints a Neq, IsError err) => err -> (a : s) :-> s
assertLt0 :: (IfCmp0Constraints a Lt, IsError err) => err -> (a : s) :-> s
assertGt0 :: (IfCmp0Constraints a Gt, IsError err) => err -> (a : s) :-> s
assertLe0 :: (IfCmp0Constraints a Le, IsError err) => err -> (a : s) :-> s
assertGe0 :: (IfCmp0Constraints a Ge, IsError err) => err -> (a : s) :-> s
assertEq :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertNeq :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertLt :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertGt :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertLe :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertGe :: (NiceComparable a, IsError err) => err -> (a : (a : s)) :-> s
assertNone :: IsError err => err -> (Maybe a : s) :-> s
assertSome :: IsError err => err -> (Maybe a : s) :-> (a : s)
assertLeft :: IsError err => err -> (Either a b : s) :-> (a : s)
assertRight :: IsError err => err -> (Either a b : s) :-> (b : s)
assertUsing :: IsError a => a -> (Bool : s) :-> s

-- | Custom Lorentz macro that drops element with given index (starting
--   from 0) from the stack.
dropX :: forall (n :: Nat) a inp out s s'. (ConstraintDIPNLorentz (ToPeano n) inp out s s', s ~ (a : s'), SingI (ToPeano n)) => inp :-> out

-- | Duplicate the top of the stack <tt>n</tt> times.
--   
--   For example, `cloneX @3` has type `a : s :-&gt; a : a : a : a : s`.
cloneX :: forall (n :: Nat) a s. CloneX (ToPeano n) a s => (a : s) :-> (a : CloneXT (ToPeano n) a s)

-- | <tt>DUU+P</tt> macro. For example, <tt>duupX </tt>3<tt> is
--   </tt>DUUUP@, it puts the 3-rd (starting from 1) element to the top of
--   the stack.
--   
--   Note that <tt>DUU+P</tt> has since been added as the <tt>DUP n</tt>
--   instruction and so this macro is defined simply as follows:
--   
--   <pre>
--   duupX = dupN @n
--   </pre>
duupX :: forall (n :: Nat) a s s'. (ConstraintDUPNLorentz (ToPeano n) s s' a, Dupable a) => s :-> (a : s)

-- | Version of <a>framed</a> which accepts number of elements on input
--   stack which should be preserved.
--   
--   You can treat this macro as calling a Michelson function with given
--   number of arguments.
framedN :: forall n nNat s i i' o o'. (nNat ~ ToPeano n, i' ~ Take nNat i, s ~ Drop nNat i, i ~ (i' ++ s), o ~ (o' ++ s), KnownList i', KnownList o') => (i' :-> o') -> i :-> o
carN :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz ((2 * n) + 1) pair => (pair : s) :-> (PairGetHs (ToPeano ((2 * n) + 1)) pair : s)
cdrN :: forall (n :: Nat) (pair :: Type) (s :: [Type]). ConstraintPairGetLorentz (2 * n) pair => (pair : s) :-> (PairGetHs (ToPeano (2 * n)) pair : s)
papair :: (a : (b : (c : s))) :-> (((a, b), c) : s)
ppaiir :: (a : (b : (c : s))) :-> ((a, (b, c)) : s)
cdar :: ((a1, (a2, b)) : s) :-> (a2 : s)
cddr :: ((a1, (a2, b)) : s) :-> (b : s)
caar :: (((a, b1), b2) : s) :-> (a : s)
cadr :: (((a, b1), b2) : s) :-> (b1 : s)
setCar :: ((a, b1) : (b2 : s)) :-> ((b2, b1) : s)
setCdr :: ((a, b1) : (b2 : s)) :-> ((a, b2) : s)
mapCar :: (forall s0. (a : s0) :-> (a1 : s0)) -> ((a, b) : s) :-> ((a1, b) : s)
mapCdr :: (forall s0. (b : s0) :-> (b1 : s0)) -> ((a, b) : s) :-> ((a, b1) : s)
ifRight :: ((b : s) :-> s') -> ((a : s) :-> s') -> (Either a b : s) :-> s'
ifSome :: ((a : s) :-> s') -> (s :-> s') -> (Maybe a : s) :-> s'
when_ :: (s :-> s) -> (Bool : s) :-> s
unless_ :: (s :-> s) -> (Bool : s) :-> s
whenSome :: ((a : s) :-> s) -> (Maybe a : s) :-> s
whenNone :: (s :-> (a : s)) -> (Maybe a : s) :-> (a : s)

-- | Insert given element into set.
--   
--   This is a separate function from <a>mapUpdate</a> because stacks they
--   operate with differ in length.
setInsert :: NiceComparable e => (e : (Set e : s)) :-> (Set e : s)

-- | Insert given element into set, ensuring that it does not overwrite any
--   existing entry.
--   
--   As first argument accepts container name.
setInsertNew :: (NiceConstant err, NiceComparable e, Dupable e, Dupable (Set e)) => (forall s0. (e : s0) :-> (err : s0)) -> (e : (Set e : s)) :-> (Set e : s)

-- | Delete given element from the set.
setDelete :: NiceComparable e => (e : (Set e : s)) :-> (Set e : s)

-- | Replace nth element (0-indexed) with the one on the top of the stack.
--   For example, `replaceN <tt>3` replaces the 3rd element with the 0th
--   one. `replaceN </tt>0` is not a valid operation (and it is not
--   implemented). `replaceN <tt>1` is equivalent to `swap # drop` (and is
--   the only one implemented like this). In all other cases `replaceN
--   </tt>n` will drop the nth element (`dipN <tt>n drop`) and then put the
--   0th one in its place (`dug </tt>(n-1)`).
replaceN :: forall (n :: Nat) a (s :: [Type]) (s1 :: [Type]) (tail :: [Type]). (ConstraintReplaceNLorentz (ToPeano (n - 1)) s a s1 tail, ReplaceN (ToPeano n) s a s1 tail) => (a : s) :-> s

-- | Replaces the nth element (0-indexed) with the result of the given
--   "updating" instruction (binary with the return type equal to the
--   second argument) applied to the 0th element and the nth element
--   itself. For example, <tt>updateN @3 cons</tt> replaces the 3rd element
--   with the result of <tt>cons</tt> applied to the topmost element and
--   the 3rd one. <tt>updateN @0 instr</tt> is not a valid operation (and
--   it is not implemented). <tt>updateN @1 instr</tt> is equivalent to
--   <tt>instr</tt> (and so is implemented). <tt>updateN @2 instr</tt> is
--   equivalent to <tt>swap # dip instr</tt> (and so is implemented). In
--   all other cases <tt>updateN @n instr</tt> will put the topmost element
--   right above the nth one (<tt>dug @(n-1)</tt>) and then apply the
--   function to them in place (<tt>dipN @(n-1) instr</tt>).
updateN :: forall (n :: Nat) a b (s :: [Type]) (mid :: [Type]) (tail :: [Type]). (ConstraintUpdateNLorentz (ToPeano (n - 1)) s a b mid tail, UpdateN (ToPeano n) s a b mid tail) => ('[a, b] :-> '[b]) -> (a : s) :-> s
buildViewTuple_ :: (HasNoOpToT r, WellTypedIsoValue r, TupleF a) => View_ a r -> Builder
buildView_ :: (WellTypedIsoValue r, HasNoOpToT r) => (a -> Builder) -> View_ a r -> Builder

-- | Polymorphic version of <a>View_</a> constructor.
mkView_ :: ToContractRef r contract => a -> contract -> View_ a r

-- | Wrap internal representation of view into <a>View_</a> itself.
--   
--   <a>View_</a> is part of public standard and should not change often.
wrapView_ :: ((a, ContractRef r) : s) :-> (View_ a r : s)

-- | Unwrap <a>View_</a> into its internal representation.
--   
--   <a>View_</a> is part of public standard and should not change often.
unwrapView_ :: (View_ a r : s) :-> ((a, ContractRef r) : s)
view_ :: (NiceParameter r, Dupable storage) => (forall s0. (a : (storage : s0)) :-> (r : s0)) -> (View_ a r : (storage : s)) :-> ((List Operation, storage) : s)
voidResultTag :: MText
mkVoid :: forall b a. a -> Void_ a b
void_ :: forall a b s s' anything. (IsError (VoidResult b), NiceConstant b) => ((a : s) :-> (b : s')) -> (Void_ a b : s) :-> anything

-- | Wrap internal representation of void into <a>Void_</a> itself.
--   
--   <a>Void_</a> is part of public standard and should not change often.
wrapVoid :: ((a, Lambda b b) : s) :-> (Void_ a b : s)

-- | Unwrap <a>Void_</a> into its internal representation.
--   
--   <a>Void_</a> is part of public standard and should not change often.
unwrapVoid :: (Void_ a b : s) :-> ((a, Lambda b b) : s)
addressToEpAddress :: (Address : s) :-> (EpAddress : s)

-- | Push a value of <tt>contract</tt> type.
--   
--   Doing this via <a>push</a> instruction is not possible, so we need to
--   perform extra actions here.
--   
--   Aside from <tt>contract</tt> value itself you will need to specify
--   which error to throw in case this value is not valid.
pushContractRef :: NiceParameter arg => (forall s0. (FutureContract arg : s) :-> s0) -> ContractRef arg -> s :-> (ContractRef arg : s)

-- | Duplicate two topmost items on top of the stack.
dupTop2 :: forall (a :: Type) (b :: Type) (s :: [Type]). (Dupable a, Dupable b) => (a : (b : s)) :-> (a : (b : (a : (b : s))))
fromOption :: NiceConstant a => a -> (Maybe a : s) :-> (a : s)
isSome :: (Maybe a : s) :-> (Bool : s)

-- | Retain the value if it is not equal to the given one.
--   
--   <pre>
--   &gt;&gt;&gt; non 0 -$ 5
--   Just 5
--   
--   &gt;&gt;&gt; non 0 -$ 0
--   Nothing
--   </pre>
non :: (NiceConstant a, NiceComparable a) => a -> (a : s) :-> (Maybe a : s)

-- | Version of <a>non</a> with a custom predicate.
--   
--   <pre>
--   &gt;&gt;&gt; non' eq0 -$ 5
--   Just 5
--   
--   &gt;&gt;&gt; non' eq0 -$ 0
--   Nothing
--   </pre>
non' :: NiceConstant a => Lambda a Bool -> (a : s) :-> (Maybe a : s)

-- | Check whether container is empty.
isEmpty :: SizeOpHs c => (c : s) :-> (Bool : s)

-- | Call a view.
--   
--   Accepts the view name via a type annotation. This internally asserts
--   the view to be present, as if the supplied <tt>TAddress</tt> argument
--   is valid, the view is guaranteed to be called successfully.
view :: forall name arg ret p vd s. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret, HasView vd name arg ret) => (arg : (TAddress p vd : s)) :-> (ret : s)

-- | Everything that can be put after <tt>if</tt> keyword.
--   
--   The first type argument stands for the condition type, and all other
--   type arguments define stack types around/within the <tt>if then
--   else</tt> construction. For semantics of each type argument see
--   <a>Condition</a>.
class IsCondition cond arg argl argr outb out

-- | Defines semantics of <tt>if ... then ... else ...</tt> construction.
ifThenElse :: IsCondition cond arg argl argr outb out => cond -> (argl :-> outb) -> (argr :-> outb) -> arg :-> out

-- | The most basic predicate for <tt>if ... then .. else ...</tt>
--   construction, defines a kind of operation applied to the top elements
--   of the current stack.
--   
--   Type arguments mean: 1. Input of <tt>if</tt> 2. Left branch input 3.
--   Right branch input 4. Output of branches 5. Output of <tt>if</tt>
data Condition arg argl argr outb out
[Holds] :: Condition (Bool : s) s s o o
[IsSome] :: Condition (Maybe a : s) (a : s) s o o
[IsNone] :: Condition (Maybe a : s) s (a : s) o o
[IsLeft] :: Condition (Either l r : s) (l : s) (r : s) o o
[IsRight] :: Condition (Either l r : s) (r : s) (l : s) o o
[IsCons] :: Condition ([a] : s) (a : ([a] : s)) s o o
[IsNil] :: Condition ([a] : s) s (a : ([a] : s)) o o
[Not] :: Condition s s1 s2 ob o -> Condition s s2 s1 ob o
[IsZero] :: (UnaryArithOpHs Eq' a, UnaryArithResHs Eq' a ~ Bool) => Condition (a : s) s s o o

-- | <i>Deprecated: Use `Not IsZero` instead</i>
[IsNotZero] :: (UnaryArithOpHs Eq' a, UnaryArithResHs Eq' a ~ Bool) => Condition (a : s) s s o o
[IsEq] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsNeq] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsLt] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsGt] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsLe] :: NiceComparable a => Condition (a : (a : s)) s s o o
[IsGe] :: NiceComparable a => Condition (a : (a : s)) s s o o

-- | Explicitly named binary condition, to ensure proper order of stack
--   arguments.
[NamedBinCondition] :: Condition (a : (a : s)) s s o o -> Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o

-- | Provide the compared arguments to <tt>if</tt> branches.
[PreserveArgsBinCondition] :: (Dupable a, Dupable b) => (forall st o. Condition (a : (b : st)) st st o o) -> Condition (a : (b : s)) (a : (b : s)) (a : (b : s)) (a : (b : s)) s

-- | Aliases for <a>(#)</a> used by do-blocks.
(>>) :: (a :-> b) -> (b :-> c) -> a :-> c

-- | Named version of <a>IsLt</a>.
--   
--   In this and similar operators you provide names of accepted stack
--   operands as a safety measure of that they go in the expected order.
(<.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 <.

-- | Named version of <a>IsGt</a>.
(>.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 >.

-- | Named version of <a>IsLe</a>.
(<=.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 <=.

-- | Named version of <a>IsGe</a>.
(>=.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 >=.

-- | Named version of <a>IsEq</a>.
(==.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 ==.

-- | Named version of <a>IsNeq</a>.
(/=.) :: NiceComparable a => Label n1 -> Label n2 -> Condition ((n1 :! a) : ((n2 :! a) : s)) s s o o
infix 4 /=.

-- | Condition modifier, makes stack operands of binary comparison to be
--   available within <tt>if</tt> branches.
keepIfArgs :: (Dupable a, Dupable b) => (forall st o. Condition (a : (b : st)) st st o o) -> Condition (a : (b : s)) (a : (b : s)) (a : (b : s)) (a : (b : s)) s

-- | Class that allows casting <tt>Fixed</tt> values to Integer in vice
--   versa
class LorentzFixedCast a
fromFixed :: LorentzFixedCast a => (a : s) :-> (Integer : s)
toFixed :: LorentzFixedCast a => (Integer : s) :-> (a : s)

-- | Class that enables support of rounding operations for Lorentz
--   non-integer values Note: Round is implemented using "banker's
--   rounding" strategy, rounding half-way values towards nearest even
--   value
class LorentzRounding a b
round_ :: LorentzRounding a b => (a : s) :-> (b : s)
ceil_ :: LorentzRounding a b => (a : s) :-> (b : s)
floor_ :: LorentzRounding a b => (a : s) :-> (b : s)

-- | Operation that represents division of two values with a given result
div :: forall r n m s. ArithOpHs Div n m r => (n : (m : s)) :-> (r : s)
castNFixedToFixed :: (NFixed p : s) :-> (Fixed p : s)
castFixedToNFixed :: (Fixed p : s) :-> (Maybe (NFixed p) : s)

-- | Expression is just an instruction accepting stack <tt>inp</tt> and
--   producing stack <tt>out</tt> with evaluation result <tt>res</tt> at
--   the top.
type Expr inp out res = inp :-> res : out

-- | Consume an element at the top of stack. This is just an alias for
--   <tt>nop</tt>.
take :: Expr (a : s) s a

-- | Lift an instruction to an unary operation on expressions.
unaryExpr :: (forall s. (a : s) :-> (r : s)) -> Expr s0 s1 a -> Expr s0 s1 r

-- | An alias for <a>unaryExpr</a>.
($:) :: (forall s. (a : s) :-> (r : s)) -> Expr s0 s1 a -> Expr s0 s1 r
infixr 9 $:

-- | Lift an instruction to a binary operation on expressions.
binaryExpr :: (forall s. (a : (b : s)) :-> (r : s)) -> Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r

-- | Expressions addition.
(|+|) :: ArithOpHs Add a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 6 |+|

-- | Expressions subtraction.
(|-|) :: ArithOpHs Sub a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 6 |-|

-- | Expressions multiplication.
(|*|) :: ArithOpHs Mul a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 7 |*|

-- | Expressions comparison.
(|==|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |==|

-- | Expressions comparison.
(|/=|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |/=|

-- | Expressions comparison.
(|<|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |<|

-- | Expressions comparison.
(|>|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |>|

-- | Expressions comparison.
(|<=|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |<=|

-- | Expressions comparison.
(|>=|) :: NiceComparable a => Expr s0 s1 a -> Expr s1 s2 a -> Expr s0 s2 Bool
infix 4 |>=|

-- | Bitwise/logical <tt>AND</tt> on expressions.
(|&|) :: ArithOpHs And a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 2 |&|

-- | Bitwise/logical <tt>OR</tt> on expressions.
--   
--   In case you find this operator looking weird, see <a>|.|.|</a>
(|||) :: ArithOpHs Or a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 1 |||

-- | An alias for <a>|||</a>.
(|.|.|) :: ArithOpHs Or a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 1 |.|.|

-- | Bitwise/logical <tt>XOR</tt> on expressions.
(|^|) :: ArithOpHs Xor a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infixl 3 |^|

-- | Left shift on expressions.
(|<<|) :: ArithOpHs Lsl a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infix 8 |<<|

-- | Right shift on expressions.
(|>>|) :: ArithOpHs Lsr a b r => Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 r
infix 8 |>>|

-- | <a>cons</a> on expressions.
--   
--   <pre>
--   one :: a : s :-&gt; [a] : s
--   one = take |:| nil
--   </pre>
(|:|) :: Expr s0 s1 a -> Expr s1 s2 [a] -> Expr s0 s2 [a]
infixr 1 |:|

-- | Construct a simple pair.
--   
--   <pre>
--   trivialContract :: ((), storage) :-&gt; ([Operation], Storage)
--   trivialContract = nil |@| cdr
--   </pre>
--   
--   This is useful as pair appears even in simple contracts. For more
--   advanced types, use <a>constructT</a>.
(|@|) :: Expr s0 s1 a -> Expr s1 s2 b -> Expr s0 s2 (a, b)
infixr 0 |@|

-- | An alias for <a>|@|</a>.
--   
--   <pre>
--   trivialContract :: ((), storage) :-&gt; ([Operation], Storage)
--   trivialContract =
--     pairE
--       ( nil
--       , cdr
--       )
--   </pre>
pairE :: (Expr s0 s1 a, Expr s1 s2 b) -> Expr s0 s2 (a, b)

-- | Construct a list given the constructor for each element.
listE :: KnownValue a => [Expr s s a] -> Expr s s [a]

-- | Version of <a>transferTokens</a> instruction that accepts all the
--   arguments as expressions.
--   
--   <pre>
--   transferTokensE
--     ! #arg L.unit
--     ! #amount (push zeroMutez)
--     ! #contract take
--     |:| nil
--   </pre>
--   
--   You can provide arguments in arbitrary order, but direction of stack
--   changes flow is fixed: stack change in <tt>arg</tt> expression affects
--   stack available in <tt>amount</tt> expression, and stack changes in
--   <tt>amount</tt> expression affect stack changes in <tt>contract</tt>
--   expression.
transferTokensE :: NiceParameter p => ("arg" :! Expr s0 s1 p) -> ("amount" :! Expr s1 s2 Mutez) -> ("contract" :! Expr s2 s3 (ContractRef p)) -> Expr s0 s3 Operation

-- | Version of <a>createContract</a> instruction that accepts all the
--   arguments as expressions.
--   
--   <pre>
--   createContractE
--     ! #delegate none
--     ! #balance (push zeroMutez)
--     ! #storage unit
--     ! #contract myContract
--   </pre>
--   
--   Note that this returns an operation, and pushes the address of the
--   newly created contract as a side-effect.
createContractE :: ("delegate" :! Expr s0 s1 (Maybe KeyHash)) -> ("balance" :! Expr s1 s2 Mutez) -> ("storage" :! Expr s2 s3 st) -> ("contract" :! Contract p st vd) -> Expr s0 (TAddress p vd : s3) Operation

-- | Version of <a>view</a> instruction that accepts all the arguments as
--   expressions.
--   
--   <pre>
--   viewE @"myview"
--     ! #arg (push zeroMutez)
--     ! #address (push addr)
--   </pre>
viewE :: forall name arg ret p vd s0 s1 s2. (HasCallStack, KnownSymbol name, KnownValue arg, NiceViewable ret, HasView vd name arg ret) => ("arg" :! Expr s0 s1 arg) -> ("address" :! Expr s1 s2 (TAddress p vd)) -> Expr s0 s2 ret

-- | Some error with a numeric tag attached.
data NumericErrorWrapper (numTag :: Nat) (err :: Type)

-- | Handler which changes documentation for one particular error type.
data NumericErrorDocHandler

-- | Errors for <a>NumericErrorDocHandler</a>
data NumericErrorDocHandlerError

-- | Adds a section which explains error tag mapping.
data DDescribeErrorTagMap
DDescribeErrorTagMap :: Text -> DDescribeErrorTagMap

-- | Describes where the error tag map is defined in Haskell code.
[detmSrcLoc] :: DDescribeErrorTagMap -> Text

-- | Modify documentation generated for given code so that all
--   <a>CustomError</a> mention not their textual error tag rather
--   respective numeric one from the given map.
--   
--   If some documented error is not present in the map, it remains
--   unmodified. This function may fail with <a>error</a> if contract uses
--   some uncommon errors, see <a>applyErrorTagToErrorsDocWith</a> for
--   details.
applyErrorTagToErrorsDoc :: HasCallStack => ErrorTagMap -> (inp :-> out) -> inp :-> out

-- | Extended version of <a>applyErrorTagToErrorsDoc</a> which accepts
--   error handlers.
--   
--   In most cases that function should be enough for your purposes, but it
--   uses a fixed set of base handlers which may be not enough in case when
--   you define your own errors. In this case define and pass all the
--   necessary handlers to this function.
--   
--   It fails with <a>error</a> if some of the errors used in the contract
--   cannot be handled with given handlers.
applyErrorTagToErrorsDocWith :: HasCallStack => [NumericErrorDocHandler] -> ErrorTagMap -> (inp :-> out) -> inp :-> out

-- | Handler for all <a>CustomError</a>s.
customErrorDocHandler :: NumericErrorDocHandler

-- | Handler for <a>VoidResult</a>.
voidResultDocHandler :: NumericErrorDocHandler

-- | Handlers for most common errors defined in Lorentz.
baseErrorDocHandlers :: [NumericErrorDocHandler]

-- | Lorentz version of <a>Control.Lens.Iso</a>.
data LIso a b
LIso :: (forall s. (a : s) :-> (b : s)) -> (forall s. (b : s) :-> (a : s)) -> LIso a b
[liTo] :: LIso a b -> forall s. (a : s) :-> (b : s)
[liFrom] :: LIso a b -> forall s. (b : s) :-> (a : s)

-- | Invert an isomorphism.
invertIso :: LIso a b -> LIso b a

-- | Given a function that is its own inverse, make an <a>LIso</a> using it
--   in both directions.
involutedIso :: Lambda a a -> LIso a a

-- | The isomorphism between two values with identical representation and
--   semantics.
checkedCoerceIso :: Coercible_ a b => LIso a b

-- | The isomorphism between two values with identical representation.
--   
--   The same precautions as for <a>forcedCoerce</a> apply here.
forcedCoerceIso :: MichelsonCoercible a b => LIso a b

-- | The isomorphism between raw and named value.
namedIso :: Label n -> LIso a (n :! a)

-- | Absence of value on the left hand side is associated with the given
--   value on the right hand side.
nonIso :: (NiceConstant a, NiceComparable a) => a -> LIso (Maybe a) a

-- | Absence of value on the left hand side is associated with the default
--   value on the right hand side.
--   
--   This is more general version of <tt>nonIso ldef</tt> since it can work
--   with e.g. containers.
nonDefIso :: (LDefault a, NiceConstant a) => LIso (Maybe a) a

-- | Concise way to write down constraints with expected content of a
--   storage.
--   
--   Use it like follows:
--   
--   <pre>
--   type StorageConstraint store = StorageContains store
--     [ "fieldInt" := Int
--     , "fieldNat" := Nat
--     , "epsToNat" := Int ::-&gt; Nat
--     , "balances" := Address ~&gt; Int
--     ]
--   </pre>
--   
--   Note that this won't work with complex field references, they have to
--   be included using e.g. <a>StoreHasField</a> manually.
type family StorageContains store (content :: [NamedField]) :: Constraint

-- | Indicates a stored entrypoint with the given <tt>param</tt> and
--   <tt>store</tt> types.
data param ::-> store
infix 9 ::->

-- | Indicates a submap with given key and value types.
data k ~> v
infix 9 ~>

-- | Kind-restricted version of <a>FieldAlias</a> to work solely with
--   string labels.
type FieldNickname alias = FieldAlias (alias :: Symbol)

-- | Alias for a field reference.
--   
--   This allows creating _custom_ field references; you will have to
--   define the respective <a>StoreHasField</a> and <a>StoreHasSubmap</a>
--   instances manually. Since this type occupies a different "namespace"
--   than string labels and <a>:-|</a>, no overlappable instances will be
--   necessary.
--   
--   Example:
--   
--   <pre>
--   -- Shortcut for a deeply nested field X
--   data FieldX
--   
--   instance StoreHasField Storage (FieldAlias FieldX) Integer where
--     ...
--   
--   accessX = stToField (stAlias @FieldX)
--   </pre>
--   
--   Note that <tt>alias</tt> type argument allows instantiations of any
--   kind.
data FieldAlias (alias :: k) (p :: FieldRefTag)

-- | Refer to no particular field, access itself.
data SelfRef (p :: FieldRefTag)
SelfRef :: SelfRef (p :: FieldRefTag)

-- | Refer to a nested entry in storage.
--   
--   Example: <tt>stToField (#a :-| #b)</tt> fetches field <tt>b</tt> in
--   the type under field <tt>a</tt>.
--   
--   If not favouring this name much, you can try an alias from
--   <a>Lorentz.StoreClass.Extra</a>.
data (:-|) (l :: k1) (r :: k2) (p :: FieldRefTag)
(:-|) :: FieldRef l -> FieldRef r -> (:-|) (l :: k1) (r :: k2) (p :: FieldRefTag)
infixr 8 :-|
infixr 8 :-|

-- | Provides operations on stored entrypoints.
--   
--   <tt>store</tt> is the storage containing both the entrypoint
--   <tt>epName</tt> (note: it has to be in a <a>BigMap</a> to take
--   advantage of lazy evaluation) and the <tt>epStore</tt> field this
--   operates on.
class StoreHasEntrypoint store epName epParam epStore | store epName -> epParam epStore
storeEpOps :: StoreHasEntrypoint store epName epParam epStore => StoreEntrypointOps store epName epParam epStore

-- | Datatype containing the full implementation of
--   <a>StoreHasEntrypoint</a> 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 <tt>DerivingVia</tt> extension.)
data StoreEntrypointOps store epName epParam epStore
StoreEntrypointOps :: (forall s. Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : s)) -> (forall s. Label epName -> (EntrypointLambda epParam epStore : (store : s)) :-> (store : s)) -> (forall s. Label epName -> (store : s) :-> (epStore : s)) -> (forall s. Label epName -> (epStore : (store : s)) :-> (store : s)) -> StoreEntrypointOps store epName epParam epStore
[sopToEpLambda] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : s)
[sopSetEpLambda] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (EntrypointLambda epParam epStore : (store : s)) :-> (store : s)
[sopToEpStore] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (store : s) :-> (epStore : s)
[sopSetEpStore] :: StoreEntrypointOps store epName epParam epStore -> forall s. Label epName -> (epStore : (store : s)) :-> (store : s)

-- | Type synonym of a <a>BigMap</a> mapping <a>MText</a> (entrypoint
--   names) to <a>EntrypointLambda</a>.
--   
--   This is useful when defining instances of <a>StoreHasEntrypoint</a> as
--   a storage field containing one or more entrypoints (lambdas) of the
--   same type.
type EntrypointsField param store = BigMap MText (EntrypointLambda param store)

-- | Type synonym for a <a>Lambda</a> that can be used as an entrypoint
type EntrypointLambda param store = Lambda (param, store) ([Operation], store)

-- | Provides operations on submaps of storage.
class StoreHasSubmap store mname key value | store mname -> key value
storeSubmapOps :: StoreHasSubmap store mname key value => StoreSubmapOps store mname key value

-- | Datatype containing the full implementation of <a>StoreHasSubmap</a>
--   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 <tt>DerivingVia</tt> extension.)
data StoreSubmapOps store mname key value
StoreSubmapOps :: (forall s. FieldRef mname -> (key : (store : s)) :-> (Bool : s)) -> (forall s. KnownValue value => FieldRef mname -> (key : (store : s)) :-> (Maybe value : s)) -> (forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (store : s)) -> (forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (Maybe value : (store : s))) -> (forall s. FieldRef mname -> (key : (store : s)) :-> (store : s)) -> (forall s. FieldRef mname -> (key : (value : (store : s))) :-> (store : s)) -> StoreSubmapOps store mname key value
[sopMem] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (store : s)) :-> (Bool : s)
[sopGet] :: StoreSubmapOps store mname key value -> forall s. KnownValue value => FieldRef mname -> (key : (store : s)) :-> (Maybe value : s)
[sopUpdate] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (store : s)
[sopGetAndUpdate] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (Maybe value : (store : s))) :-> (Maybe value : (store : s))
[sopDelete] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (store : s)) :-> (store : s)
[sopInsert] :: StoreSubmapOps store mname key value -> forall s. FieldRef mname -> (key : (value : (store : s))) :-> (store : s)

-- | Provides operations on fields for storage.
class StoreHasField store fname ftype | store fname -> ftype
storeFieldOps :: StoreHasField store fname ftype => StoreFieldOps store fname ftype

-- | Datatype containing the full implementation of <a>StoreHasField</a>
--   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 <tt>DerivingVia</tt> extension.)
data StoreFieldOps store fname ftype
StoreFieldOps :: (forall s. FieldRef fname -> (store : s) :-> (ftype : s)) -> (forall s. Dupable store => FieldRef fname -> (store : s) :-> (ftype : (store : s))) -> (forall s. FieldRef fname -> (ftype : (store : s)) :-> (store : s)) -> StoreFieldOps store fname ftype
[sopToField] :: StoreFieldOps store fname ftype -> forall s. FieldRef fname -> (store : s) :-> (ftype : s)
[sopGetField] :: StoreFieldOps store fname ftype -> forall s. Dupable store => FieldRef fname -> (store : s) :-> (ftype : (store : s))
[sopSetField] :: StoreFieldOps store fname ftype -> forall s. FieldRef fname -> (ftype : (store : s)) :-> (store : s)

-- | Provides access to the direct name of the referred field.
--   
--   This is used in <a>stToFieldNamed</a>.
class FieldRefHasFinalName fr where {
    type family FieldRefFinalName fr :: Symbol;
}
fieldRefFinalName :: FieldRefHasFinalName fr => FieldRef fr -> Label (FieldRefFinalName fr)

-- | Version of <a>FieldRef</a> restricted to symbolic labels.
--   
--   <pre>
--   FieldSymRef name ≡ FieldName name 'FieldRefTag
--   </pre>
type FieldSymRef name = FieldRef (name :: Symbol)

-- | The simplest field reference - just a name. Behaves similarly to
--   <a>Label</a>.
data FieldName (n :: Symbol) (p :: FieldRefTag)

-- | Some kind of reference to a field.
--   
--   The idea behind this type is that in trivial case (<tt>name ::
--   Symbol</tt>) it can be instantiated with a mere label, but it is
--   generic enough to allow complex field references as well.
type FieldRef name = FieldRefObject name 'FieldRefTag

-- | For a type-level field reference - an associated term-level
--   representation.
--   
--   This is similar to <tt>singletons</tt> <tt>Sing</tt> + <tt>SingI</tt>
--   pair but has small differences:
--   
--   <ul>
--   <li>Dedicated to field references, thus term-level thing has
--   <a>FieldRefKind</a> kind.</li>
--   <li>The type of term-level value (<tt>FieldRefObject ty</tt>)
--   determines the kind of the reference type.</li>
--   </ul>
class KnownFieldRef (ty :: k) where {
    type family FieldRefObject ty = (fr :: FieldRefKind) | fr -> ty;
}
mkFieldRef :: KnownFieldRef ty => FieldRefObject ty p
data FieldRefTag

-- | Open kind for various field references.
--   
--   The simplest field reference could be <a>Label</a>, pointing to a
--   field by its name, but we also support more complex scenarios like
--   deep fields identifiers.
type FieldRefKind = FieldRefTag -> Type

-- | Convert a symbolic <a>FieldRef</a> to a label, useful for
--   compatibility with other interfaces.
fieldNameToLabel :: FieldSymRef n -> Label n

-- | Convert a label to <a>FieldRef</a>, useful for compatibility with
--   other interfaces.
fieldNameFromLabel :: Label n -> FieldSymRef n

-- | Pick storage field.
stToField :: StoreHasField store fname ftype => FieldRef fname -> (store : s) :-> (ftype : s)

-- | Get storage field, preserving the storage itself on stack.
stGetField :: (StoreHasField store fname ftype, Dupable store) => FieldRef fname -> (store : s) :-> (ftype : (store : s))

-- | Pick storage field retaining a name label attached.
--   
--   For complex refs this tries to attach the immediate name of the
--   referred field.
stToFieldNamed :: (StoreHasField store fname ftype, FieldRefHasFinalName fname) => FieldRef fname -> (store : s) :-> ((FieldRefFinalName fname :! ftype) : s)

-- | Version of <a>stToFieldNamed</a> that preserves the storage on stack.
stGetFieldNamed :: (StoreHasField store fname ftype, FieldRefHasFinalName fname, Dupable ftype) => FieldRef fname -> (store : s) :-> ((FieldRefFinalName fname :! ftype) : (store : s))

-- | Update storage field.
stSetField :: StoreHasField store fname ftype => FieldRef fname -> (ftype : (store : s)) :-> (store : s)

-- | Check value presence in storage.
stMem :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (store : s)) :-> (Bool : s)

-- | Get value in storage.
stGet :: (StoreHasSubmap store mname key value, KnownValue value) => FieldRef mname -> (key : (store : s)) :-> (Maybe value : s)

-- | Update a value in storage.
stUpdate :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (Maybe value : (store : s))) :-> (store : s)

-- | Atomically get and update a value in storage.
stGetAndUpdate :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (Maybe value : (store : s))) :-> (Maybe value : (store : s))

-- | Delete a value in storage.
stDelete :: forall store mname key value s. StoreHasSubmap store mname key value => FieldRef mname -> (key : (store : s)) :-> (store : s)

-- | Add a value in storage.
stInsert :: StoreHasSubmap store mname key value => FieldRef mname -> (key : (value : (store : s))) :-> (store : s)

-- | Add a value in storage, but fail if it will overwrite some existing
--   entry.
stInsertNew :: (StoreHasSubmap store mname key value, Dupable key) => FieldRef mname -> (forall s0 any. (key : s0) :-> any) -> (key : (value : (store : s))) :-> (store : s)

-- | Extracts and executes the <tt>epName</tt> entrypoint lambda from
--   storage, returing the updated full storage (<tt>store</tt>) and the
--   produced <a>Operation</a>s.
stEntrypoint :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (epParam : (store : s)) :-> (([Operation], store) : s)

-- | Pick stored entrypoint lambda.
stToEpLambda :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : s)

-- | Get stored entrypoint lambda, preserving the storage itself on the
--   stack.
stGetEpLambda :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store : s) :-> (EntrypointLambda epParam epStore : (store : s))

-- | Stores the entrypoint lambda in the storage. Fails if already set.
stSetEpLambda :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (EntrypointLambda epParam epStore : (store : s)) :-> (store : s)

-- | Pick the sub-storage that the entrypoint operates on.
stToEpStore :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (store : s) :-> (epStore : s)

-- | Get the sub-storage that the entrypoint operates on, preserving the
--   storage itself on the stack.
stGetEpStore :: (StoreHasEntrypoint store epName epParam epStore, Dupable store) => Label epName -> (store : s) :-> (epStore : (store : s))

-- | Update the sub-storage that the entrypoint operates on.
stSetEpStore :: StoreHasEntrypoint store epName epParam epStore => Label epName -> (epStore : (store : s)) :-> (store : s)

-- | Implementation of <a>StoreHasField</a> for case of datatype keeping a
--   pack of fields.
storeFieldOpsADT :: HasFieldOfType dt fname ftype => StoreFieldOps dt (fname :: Symbol) ftype

-- | Implementation of <a>StoreHasEntrypoint</a> for a datatype keeping a
--   pack of fields, among which one contains the entrypoint and another is
--   what such entrypoint operates on.
storeEntrypointOpsADT :: (HasFieldOfType store epmName (EntrypointsField epParam epStore), HasFieldOfType store epsName epStore, KnownValue epParam, KnownValue epStore, Dupable store) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

-- | Implementation of <a>StoreHasEntrypoint</a> for a datatype that has a
--   <a>StoreHasField</a> for an <a>EntrypointsField</a> that contains the
--   entrypoint and a <a>StoreHasField</a> for the field such entrypoint
--   operates on.
storeEntrypointOpsFields :: (StoreHasField store epmName (EntrypointsField epParam epStore), StoreHasField store epsName epStore, KnownValue epParam, KnownValue epStore, Dupable store) => Label epmName -> Label epsName -> StoreEntrypointOps store epName epParam epStore

-- | Implementation of <a>StoreHasEntrypoint</a> for a datatype that has a
--   <a>StoreHasSubmap</a> that contains the entrypoint and a
--   <a>StoreHasField</a> 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 <a>StoreHasField</a> for a data type which has an
--   instance of <a>StoreHasField</a> inside. For instance, it can be used
--   for top-level storage.
storeFieldOpsDeeper :: (HasFieldOfType storage fieldsPartName fields, StoreHasField fields fname ftype, Dupable storage) => FieldRef fieldsPartName -> StoreFieldOps storage fname ftype

-- | Implementation of <a>StoreHasSubmap</a> for a data type which has an
--   instance of <a>StoreHasSubmap</a> inside. For instance, it can be used
--   for top-level storage.
storeSubmapOpsDeeper :: (HasFieldOfType storage bigMapPartName fields, StoreHasSubmap fields SelfRef key value, Dupable storage) => FieldRef bigMapPartName -> StoreSubmapOps storage mname key value

-- | Implementation of <a>StoreHasEntrypoint</a> for a data type which has
--   an instance of <a>StoreHasEntrypoint</a> inside. For instance, it can
--   be used for top-level storage.
storeEntrypointOpsDeeper :: (HasFieldOfType store nameInStore substore, StoreHasEntrypoint substore epName epParam epStore, Dupable store) => FieldRef nameInStore -> StoreEntrypointOps store epName epParam epStore

-- | Pretend that given <a>StoreSubmapOps</a> implementation is made up for
--   submap with name <tt>desiredName</tt>, not its actual name. Logic of
--   the implementation remains the same.
--   
--   Use case: imagine that your code requires access to submap named
--   <tt>X</tt>, but in your storage that submap is called <tt>Y</tt>. Then
--   you implement the instance which makes <tt>X</tt> refer to <tt>Y</tt>:
--   
--   <pre>
--   instance StoreHasSubmap Store X Key Value where
--     storeSubmapOps = storeSubmapOpsReferTo #Y storeSubmapOpsForY
--   </pre>
storeSubmapOpsReferTo :: FieldRef name -> StoreSubmapOps storage name key value -> StoreSubmapOps storage desiredName key value

-- | Pretend that given <a>StoreFieldOps</a> implementation is made up for
--   field with name <tt>desiredName</tt>, not its actual name. Logic of
--   the implementation remains the same.
--   
--   See also <a>storeSubmapOpsReferTo</a>.
storeFieldOpsReferTo :: FieldRef name -> StoreFieldOps storage name field -> StoreFieldOps storage desiredName field

-- | Pretend that given <a>StoreEntrypointOps</a> implementation is made up
--   for entrypoint with name <tt>desiredName</tt>, not its actual name.
--   Logic of the implementation remains the same.
--   
--   See also <a>storeSubmapOpsReferTo</a>.
storeEntrypointOpsReferTo :: Label epName -> StoreEntrypointOps store epName epParam epStore -> StoreEntrypointOps store desiredName epParam epStore

-- | Change field operations so that they work on a modified field.
--   
--   For instance, to go from <tt>StoreFieldOps Storage "name" Integer</tt>
--   to <tt>StoreFieldOps Storage "name" (value :! Integer)</tt> you can
--   use <tt>mapStoreFieldOps (namedIso #value)</tt>
mapStoreFieldOps :: LIso field1 field2 -> StoreFieldOps store name field1 -> StoreFieldOps store name field2

-- | Change submap operations so that they work on a modified key.
mapStoreSubmapOpsKey :: Lambda key2 key1 -> StoreSubmapOps store name key1 value -> StoreSubmapOps store name key2 value

-- | Change submap operations so that they work on a modified value.
mapStoreSubmapOpsValue :: (KnownValue value1, KnownValue value2) => LIso value1 value2 -> StoreSubmapOps store name key value1 -> StoreSubmapOps store name key value2

-- | Chain two implementations of field operations.
--   
--   Suits for a case when your store does not contain its fields directly
--   rather has a nested structure.
composeStoreFieldOps :: Dupable store => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreFieldOps substore nameInSubstore field -> StoreFieldOps store nameInSubstore field

-- | Chain implementations of field and submap operations.
composeStoreSubmapOps :: Dupable store => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreSubmapOps substore mname key value -> StoreSubmapOps store mname key 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.
--   
--   <tt>LIso (Maybe substore) substore</tt> argument describes how to get
--   <tt>substore</tt> value if it was absent in map and how to detect when
--   it can be safely removed.
--   
--   Example of use: <tt>sequenceStoreSubmapOps #mySubmap nonDefIso
--   storeSubmapOps storeSubmapOps</tt>
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
composeStoreEntrypointOps :: Dupable store => FieldRef nameInStore -> StoreFieldOps store nameInStore substore -> StoreEntrypointOps substore epName epParam epStore -> StoreEntrypointOps store epName epParam epStore

-- | 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 <tt>value ==
--   Nothing</tt> and <tt>value == Just defValue</tt> cases. Getters, when
--   notice a value equal to the default value, report its absence. Setters
--   tend to remove the value from submap when possible.
--   
--   <tt>LIso (Maybe value) value</tt> and <tt>LIso (Maybe subvalue)
--   subvalue</tt> 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: <tt>zoomStoreSubmapOps #mySubmap nonDefIso nonDefIso
--   storeSubmapOps storeFieldOpsADT</tt>
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

-- | Utility to create <a>EntrypointsField</a>s from an entrypoint name
--   (<tt>epName</tt>) and an <a>EntrypointLambda</a> implementation. Note
--   that you need to merge multiple of these (with <a>&lt;&gt;</a>) if
--   your field contains more than one entrypoint lambda.
mkStoreEp :: Label epName -> EntrypointLambda epParam epStore -> EntrypointsField epParam epStore

-- | An alias for <a>SelfRef</a>.
--   
--   Examples:
--   
--   <pre>
--   &gt;&gt;&gt; push 5 # stMem this -$ (mempty :: Map Integer MText)
--   False
--   </pre>
--   
--   <pre>
--   &gt;&gt;&gt; stGetField this # pair -$ (5 :: Integer)
--   (5,5)
--   </pre>
this :: SelfRef p

-- | Provides alternative variadic interface for deep entries access.
--   
--   Example: <tt>stToField (stNested #a #b #c)</tt>
stNested :: StNestedImpl f SelfRef => f

-- | Construct an alias at term level.
--   
--   This requires passing the alias via type annotation.
stAlias :: forall alias. FieldRef (FieldAlias alias)

-- | Version of <a>stAlias</a> adopted to labels.
stNickname :: Label name -> FieldRef (FieldAlias name)
type family RequireFlatEpDerivation cp deriv :: Constraint
type family RequireFlatParamEps cp :: Constraint

-- | Provides arror for convenient entrypoint documentation
class EntryArrow kind name body

-- | Lift entrypoint implementation.
--   
--   Entrypoint names should go with "e" prefix.
(#->) :: EntryArrow kind name body => (Label name, Proxy kind) -> body -> body

-- | Constraint for <a>documentEntrypoints</a>.
type DocumentEntrypoints kind a = (Generic a, GDocumentEntrypoints kind (Rep a))

-- | Pick a type documentation from <a>CtorField</a>.
class (KnownSymbol con) => DeriveCtorFieldDoc con (cf :: CtorField)
deriveCtorFieldDoc :: DeriveCtorFieldDoc con cf => DEntrypointArg

-- | Describes argument of an entrypoint.
data DEntrypointArg
DEntrypointArg :: Maybe SomeEntrypointArg -> [ParamBuildingStep] -> DEntrypointArg

-- | Argument of the entrypoint. Pass <a>Nothing</a> if no argument is
--   required.
[epaArg] :: DEntrypointArg -> Maybe SomeEntrypointArg

-- | Describes a way to lift an entrypoint argument into full parameter
--   which can be passed to the contract.
--   
--   Steps are supposed to be applied in the order opposite to one in which
--   they are given. E.g. suppose that an entrypoint is called as <tt>Run
--   (Service1 arg)</tt>; then the first step (actual last) should describe
--   wrapping into <tt>Run</tt> constructor, and the second step (actual
--   first) should be about wrapping into <tt>Service1</tt> constructor.
[epaBuilding] :: DEntrypointArg -> [ParamBuildingStep]

-- | Entrypoint argument type in typed representation.
data SomeEntrypointArg
SomeEntrypointArg :: Proxy a -> SomeEntrypointArg

-- | Describes a parameter building step.
--   
--   This can be wrapping into (Haskell) constructor, or a more complex
--   transformation.
data ParamBuildingStep

-- | Wraps something into constructor with given name. Constructor should
--   be the one which corresponds to an entrypoint defined via field
--   annotation, for more complex cases use <a>PbsCustom</a>.
PbsWrapIn :: Text -> ParamBuildingDesc -> ParamBuildingStep

-- | Directly call an entrypoint marked with a field annotation.
PbsCallEntrypoint :: EpName -> ParamBuildingStep

-- | Other action.
PbsCustom :: ParamBuildingDesc -> ParamBuildingStep

-- | This entrypoint cannot be called, which is possible when an explicit
--   default entrypoint is present. This is not a true entrypoint but just
--   some intermediate node in <tt>or</tt> tree and neither it nor any of
--   its parents are marked with a field annotation.
--   
--   It contains dummy <a>ParamBuildingStep</a>s which were assigned before
--   entrypoints were taken into account.
PbsUncallable :: [ParamBuildingStep] -> ParamBuildingStep
data ParamBuildingDesc
ParamBuildingDesc :: Markdown -> ParamBuilder -> ParamBuilder -> ParamBuildingDesc

-- | Plain english description of this step.
[pbdEnglish] :: ParamBuildingDesc -> Markdown

-- | How to construct parameter in Haskell code.
[pbdHaskell] :: ParamBuildingDesc -> ParamBuilder

-- | How to construct parameter working on raw Michelson.
[pbdMichelson] :: ParamBuildingDesc -> ParamBuilder

-- | When describing the way of parameter construction - piece of
--   incremental builder for this description.
newtype ParamBuilder
ParamBuilder :: (Markdown -> Markdown) -> ParamBuilder

-- | Argument stands for previously constructed parameter piece, and
--   returned value - a piece constructed after our step.
[unParamBuilder] :: ParamBuilder -> Markdown -> Markdown

-- | Inserts a reference to an existing entrypoint.
--   
--   This helps to avoid duplication in the generated documentation, in
--   order not to overwhelm the reader.
data DEntrypointReference
DEntrypointReference :: Text -> Anchor -> DEntrypointReference

-- | Describes the behaviour common for entrypoints of given kind.
--   
--   This has very special use cases, like contracts with mix of
--   upgradeable and permanent entrypoints.
data CommonEntrypointsBehaviourKind kind

-- | Describes the behaviour common for all entrypoints.
--   
--   For instance, if your contract runs some checks before calling any
--   entrypoint, you probably want to wrap those checks into
--   <tt>entrypointSection "Prior checks" (Proxy
--   @CommonContractBehaviourKind)</tt>.
data CommonContractBehaviourKind

-- | Default value for <a>DEntrypoint</a> type argument.
data PlainEntrypointsKind

-- | Describes location of entrypoints of the given kind.
--   
--   All such entrypoints will be placed under the same "entrypoints"
--   section, and this instance defines characteristics of this section.
class Typeable ep => EntrypointKindHasDoc (ep :: Type)

-- | Position of the respective entrypoints section in the doc. This shares
--   the same positions space with all other doc items.
entrypointKindPos :: EntrypointKindHasDoc ep => Natural

-- | Name of the respective entrypoints section.
entrypointKindSectionName :: EntrypointKindHasDoc ep => Text

-- | Description in the respective entrypoints section.
entrypointKindSectionDescription :: EntrypointKindHasDoc ep => Maybe Markdown

-- | Gathers information about single entrypoint.
--   
--   We assume that entry points might be of different kinds, which is
--   designated by phantom type parameter. For instance, you may want to
--   have several groups of entry points corresponding to various parts of
--   a contract - specifying different <tt>kind</tt> type argument for each
--   of those groups will allow you defining different <a>DocItem</a>
--   instances with appropriate custom descriptions for them.
data DEntrypoint (kind :: Type)
DEntrypoint :: Text -> SubDoc -> DEntrypoint (kind :: Type)
[depName] :: DEntrypoint (kind :: Type) -> Text
[depSub] :: DEntrypoint (kind :: Type) -> SubDoc

-- | Pattern that checks whether given <a>SomeDocItem</a> hides
--   <a>DEntrypoint</a> inside (of any entrypoint kind).
--   
--   In case a specific kind is necessary, use plain <tt>(cast -&gt; Just
--   DEntrypoint{..})</tt> construction instead.
pattern DEntrypointDocItem :: DEntrypoint kind -> SomeDocItem

-- | Default implementation of <a>docItemToMarkdown</a> for entrypoints.
diEntrypointToMarkdown :: HeaderLevel -> DEntrypoint level -> Markdown

-- | Mark code as part of entrypoint with given name.
--   
--   This is automatically called at most of the appropriate situations,
--   like <a>entryCase</a> calls.
entrypointSection :: EntrypointKindHasDoc kind => Text -> Proxy kind -> (i :-> o) -> i :-> o

-- | Make a <a>ParamBuildingStep</a> that tells about wrapping an argument
--   into a constructor with given name and uses given <a>ParamBuilder</a>
--   as description of Michelson part.
mkPbsWrapIn :: Text -> ParamBuilder -> ParamBuildingStep
constructDEpArg :: forall arg. (NiceParameter arg, TypeHasDoc arg) => DEntrypointArg
emptyDEpArg :: DEntrypointArg
mkDEpUType :: forall t. (KnownValue t, HasAnnotation t) => Ty
mkDEntrypointArgSimple :: forall t. (NiceParameter t, TypeHasDoc t) => DEntrypointArg

-- | Go over contract code and update every occurrence of
--   <a>DEntrypointArg</a> documentation item, adding the given step to its
--   "how to build parameter" description.
clarifyParamBuildingSteps :: ParamBuildingStep -> (inp :-> out) -> inp :-> out

-- | Like <a>case_</a>, to be used for pattern-matching on a parameter or
--   its part.
--   
--   Modifies documentation accordingly. Including description of
--   entrypoints' arguments, thus for them you will need to supply
--   <a>TypeHasDoc</a> instance.
entryCase_ :: forall dt entrypointKind out inp. (InstrCaseC dt, RMap (CaseClauses dt), DocumentEntrypoints entrypointKind dt) => Proxy entrypointKind -> Rec (CaseClauseL inp out) (CaseClauses dt) -> (dt : inp) :-> out

-- | Version of <a>entryCase_</a> for tuples.
entryCase :: forall dt entrypointKind out inp clauses. (CaseTC dt out inp clauses, DocumentEntrypoints entrypointKind dt) => Proxy entrypointKind -> IsoRecTuple clauses -> (dt : inp) :-> out

-- | Wrapper for documenting single entrypoint which parameter isn't going
--   to be unwrapped from some datatype.
--   
--   <tt>entryCase</tt> unwraps a datatype, however, sometimes we want to
--   have entrypoint parameter to be not wrapped into some datatype.
documentEntrypoint :: forall kind epName param s out. (KnownSymbol epName, DocItem (DEntrypoint kind), NiceParameter param, TypeHasDoc param) => ((param : s) :-> out) -> (param : s) :-> out

-- | Modify param building steps with respect to entrypoints that given
--   parameter declares.
--   
--   Each contract with entrypoints should eventually call this function,
--   otherwise, in case if contract uses built-in entrypoints feature, the
--   resulting parameter building steps in the generated documentation will
--   not consider entrypoints and thus may be incorrect.
--   
--   Calling this twice over the same code is also prohibited.
--   
--   This method is for internal use, if you want to apply it to a contract
--   manually, use <a>finalizeParamCallingDoc</a>.
finalizeParamCallingDoc' :: forall cp inp out. (NiceParameterFull cp, HasCallStack) => Proxy cp -> (inp :-> out) -> inp :-> out

-- | Version of 'finalizeParamCallingDoc'' more convenient for manual call
--   in a contract.
finalizeParamCallingDoc :: forall cp inp out. (NiceParameterFull cp, RequireSumType cp, HasCallStack) => ((cp : inp) :-> out) -> (cp : inp) :-> out

-- | Whether <a>finalizeParamCallingDoc</a> has already been applied to
--   these steps.
areFinalizedParamBuildingSteps :: [ParamBuildingStep] -> Bool
entryCaseSimple_ :: forall cp out inp. (InstrCaseC cp, RMap (CaseClauses cp), DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => Rec (CaseClauseL inp out) (CaseClauses cp) -> (cp : inp) :-> out

-- | Version of <a>entryCase</a> for contracts with flat parameter, use it
--   when you need only one <a>entryCase</a> all over the contract
--   implementation.
entryCaseSimple :: forall cp out inp clauses. (CaseTC cp out inp clauses, DocumentEntrypoints PlainEntrypointsKind cp, RequireFlatParamEps cp) => IsoRecTuple clauses -> (cp : inp) :-> out

-- | Entry points template derived from given ADT sum.
type UParamLinearized p = GUParamLinearized (Rep p)

-- | Constraint required by <a>uparamFromAdt</a>.
type UParamLinearize p = (Generic p, GUParamLinearize (Rep p))

-- | Make up a "case" over entry points.
class CaseUParam (entries :: [EntrypointKind])

-- | An action invoked when user-provided entrypoint is not found.
type UParamFallback inp out = ((MText, ByteString) : inp) :-> out

-- | Implementations of some entry points.
--   
--   Note that this thing inherits properties of <a>Rec</a>, e.g. you can
--   <tt>Data.Vinyl.Core.rappend</tt> implementations for two entrypoint
--   sets when assembling scattered parts of a contract.
type EntrypointsImpl inp out entries = Rec (CaseClauseU inp out) entries
data EntrypointLookupError
NoSuchEntrypoint :: MText -> EntrypointLookupError
ArgumentUnpackFailed :: EntrypointLookupError

-- | This class is needed to implement <a>unpackUParam</a>.
class UnpackUParam (c :: Type -> Constraint) entries

-- | Turn <a>UParam</a> into a Haskell value. Since we don't know its type
--   in compile time, we have to erase it using <a>ConstrainedSome</a>. The
--   user of this function can require arbitrary constraint to hold
--   (depending on how they want to use the result).
unpackUParam :: UnpackUParam c entries => UParam entries -> Either EntrypointLookupError (MText, ConstrainedSome c)

-- | This type can store any value that satisfies a certain constraint.
data ConstrainedSome (c :: Type -> Constraint)
[ConstrainedSome] :: c a => a -> ConstrainedSome c

-- | Ensure that given entry points do no contain duplicated names.
type family RequireUniqueEntrypoints (entries :: [EntrypointKind]) :: Constraint

-- | Get type of entrypoint argument by its name.
type family LookupEntrypoint (name :: Symbol) (entries :: [EntrypointKind]) :: Type

-- | Homomorphic version of <a>UParam</a>, forgets the exact interface.
type UParam_ = UParam SomeInterface

-- | Pseudo value for <a>UParam</a> type variable.
type SomeInterface = '[ '("SomeEntrypoints", Void)]

-- | Encapsulates parameter for one of entry points. It keeps entrypoint
--   name and corresponding argument serialized.
--   
--   In Haskell world, we keep an invariant of that contained value relates
--   to one of entry points from <tt>entries</tt> list.
newtype UParam (entries :: [EntrypointKind])
UnsafeUParam :: (MText, ByteString) -> UParam (entries :: [EntrypointKind])

-- | A convenient alias for type-level name-something pair.
type (n :: Symbol) ?: (a :: k) = '(n, a)

-- | An entrypoint is described by two types: its name and type of
--   argument.
type EntrypointKind = (Symbol, Type)

-- | Construct a <a>UParam</a> safely.
mkUParam :: (NicePackedValue a, LookupEntrypoint name entries ~ a, RequireUniqueEntrypoints entries) => Label name -> a -> UParam entries

-- | Helper instruction which extracts content of <a>UParam</a>.
unwrapUParam :: (UParam entries : s) :-> ((MText, ByteString) : s)

-- | Default implementation for <a>UParamFallback</a>, simply reports an
--   error.
uparamFallbackFail :: UParamFallback inp out

-- | Pattern-match on given <tt>UParam entries</tt>.
--   
--   You have to provide all case branches and a fallback action on case
--   when entrypoint is not found.
caseUParam :: (CaseUParam entries, RequireUniqueEntrypoints entries) => Rec (CaseClauseU inp out) entries -> UParamFallback inp out -> (UParam entries : inp) :-> out

-- | Like <a>caseUParam</a>, but accepts a tuple of clauses, not a
--   <a>Rec</a>.
caseUParamT :: forall entries inp out clauses. (clauses ~ Rec (CaseClauseU inp out) entries, RecFromTuple clauses, CaseUParam entries) => IsoRecTuple clauses -> UParamFallback inp out -> (UParam entries : inp) :-> out

-- | Make up <a>UParam</a> from ADT sum.
--   
--   Entry points template will consist of <tt>(constructorName,
--   constructorFieldType)</tt> pairs. Each constructor is expected to have
--   exactly one field.
uparamFromAdt :: UParamLinearize up => up -> UParam (UParamLinearized up)

-- | Note that calling given entrypoints involves constructing
--   <a>UParam</a>.
pbsUParam :: forall ctorName. KnownSymbol ctorName => ParamBuildingStep

-- | Single contract view.
data ContractView st (v :: ViewTyInfo)
[ContractView] :: (KnownSymbol name, NiceViewable arg, NiceViewable ret, HasAnnotation arg, HasAnnotation ret) => ViewCode arg st ret -> ContractView st ('ViewTyInfo name arg ret)

-- | Code for a contract along with compilation options for the Lorentz
--   compiler.
--   
--   It is expected that a <a>Contract</a> is one packaged entity, wholly
--   controlled by its author. Therefore the author should be able to set
--   all options that control contract's behavior.
--   
--   This helps ensure that a given contract will be interpreted in the
--   same way in all environments, like production and testing.
--   
--   Raw <a>ContractCode</a> should not be used for distribution of
--   contracts.
data ContractData cp st vd
ContractData :: ContractCode cp st -> Rec (ContractView st) (RevealViews vd) -> CompilationOptions -> ContractData cp st vd

-- | The contract itself.
[cdCode] :: ContractData cp st vd -> ContractCode cp st

-- | Contract views.
[cdViews] :: ContractData cp st vd -> Rec (ContractView st) (RevealViews vd)

-- | General compilation options for the Lorentz compiler.
[cdCompilationOptions] :: ContractData cp st vd -> CompilationOptions

-- | Options to control Lorentz to Michelson compilation.
data CompilationOptions
CompilationOptions :: Maybe OptimizerConf -> (Bool, MText -> MText) -> (Bool, ByteString -> ByteString) -> Bool -> CompilationOptions

-- | Config for Michelson optimizer.
[coOptimizerConf] :: CompilationOptions -> Maybe OptimizerConf

-- | Function to transform strings with. See
--   <a>transformStringsLorentz</a>.
[coStringTransformer] :: CompilationOptions -> (Bool, MText -> MText)

-- | Function to transform byte strings with. See
--   <a>transformBytesLorentz</a>.
[coBytesTransformer] :: CompilationOptions -> (Bool, ByteString -> ByteString)

-- | Flag which defines whether compiled Michelson contract will have
--   <tt>CAST</tt> (which drops parameter annotations) as a first
--   instruction. Note that when flag is false, there still may be no
--   <tt>CAST</tt> (in case when parameter type has no annotations).
[coDisableInitialCast] :: CompilationOptions -> Bool

-- | Runs Michelson optimizer with default config and does not touch
--   strings and bytes.
defaultCompilationOptions :: CompilationOptions

-- | Leave contract without any modifications. For testing purposes.
intactCompilationOptions :: CompilationOptions

-- | For use outside of Lorentz. Will use <a>defaultCompilationOptions</a>.
compileLorentz :: (inp :-> out) -> Instr (ToTs inp) (ToTs out)

-- | Compile Lorentz code, optionally running the optimizer, string and
--   byte transformers.
compileLorentzWithOptions :: CompilationOptions -> (inp :-> out) -> Instr (ToTs inp) (ToTs out)

-- | Construct and compile Lorentz contract.
--   
--   This is an alias for <a>mkContract</a>.
defaultContract :: (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> Contract cp st ()

-- | Construct and compile Lorentz contract.
--   
--   Note that this accepts code with initial and final stacks unpaired for
--   simplicity.
mkContract :: (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> Contract cp st ()

-- | Version of <a>mkContract</a> that accepts custom compilation options.
mkContractWith :: (NiceParameterFull cp, NiceStorage st) => CompilationOptions -> ContractCode cp st -> Contract cp st ()

-- | Construct a view.
--   
--   <pre>
--   mkView @"add" @(Integer, Integer) do
--    car; unpair; add
--   </pre>
mkView :: forall name 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)

-- | Compile contract with <a>defaultCompilationOptions</a>.
defaultContractData :: forall cp st. (NiceParameterFull cp, NiceStorage st) => ContractCode cp st -> ContractData cp st ()

-- | Compile a whole contract to Michelson.
--   
--   Note that compiled contract can be ill-typed in terms of Michelson
--   code when some of the compilation options are used (e.g. when
--   <a>coDisableInitialCast</a> is <tt>True</tt>, resulted contract can be
--   ill-typed). However, compilation with <a>defaultCompilationOptions</a>
--   should be valid.
compileLorentzContract :: forall cp st vd. ContractData cp st vd -> Contract cp st vd

-- | Set all the contract's views.
--   
--   <pre>
--   compileLorentzContract $
--     defaultContractData do
--       ...
--     &amp; setViews
--       ( mkView <tt>"myView" </tt>() do
--           ...
--       , mkView <tt>"anotherView" </tt>Integer do
--           ...
--       )
--   </pre>
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

-- | Version of <a>setViews</a> that accepts a <a>Rec</a>.
--   
--   May be useful if you have too many views or want to combine views
--   sets.
setViewsRec :: forall vd cp st. NiceViewsDescriptor vd => Rec (ContractView st) (RevealViews vd) -> ContractData cp st () -> ContractData cp st vd

-- | Restrict type of <a>Contract</a>, <a>ContractData</a> or other similar
--   type to have no views.
noViews :: contract cp st () -> contract cp st ()

-- | Interpret a Lorentz instruction, for test purposes. Note that this
--   does not run the optimizer.
interpretLorentzInstr :: (IsoValuesStack inp, IsoValuesStack out) => ContractEnv -> (inp :-> out) -> Rec Identity inp -> Either MichelsonFailureWithStack (Rec Identity out)

-- | Like <a>interpretLorentzInstr</a>, but works on lambda rather than
--   arbitrary instruction.
interpretLorentzLambda :: (IsoValue inp, IsoValue out) => ContractEnv -> Lambda inp out -> inp -> Either MichelsonFailureWithStack out

-- | Lorentz version of analyzer.
analyzeLorentz :: (inp :-> out) -> AnalyzerRes
coBytesTransformerL :: Lens' CompilationOptions (Bool, ByteString -> ByteString)
coDisableInitialCastL :: Lens' CompilationOptions Bool
coOptimizerConfL :: Lens' CompilationOptions (Maybe OptimizerConf)
coStringTransformerL :: Lens' CompilationOptions (Bool, MText -> MText)
cdCodeL :: forall cp st vd cp1. (NiceParameterFull cp1, NiceStorage st) => Lens (ContractData cp st vd) (ContractData cp1 st vd) (ContractCode cp st) (ContractCode cp1 st)
cdCompilationOptionsL :: forall cp st vd. Lens' (ContractData cp st vd) CompilationOptions

-- | Run a lambda with given input.
--   
--   Note that this always returns one value, but can accept multiple input
--   values (in such case they are grouped into nested pairs).
--   
--   For testing and demonstration purposes.
(-$?) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out) => (inps :-> '[out]) -> ZippedStack inps -> Either MichelsonFailureWithStack out
infixr 2 -$?

-- | Like <tt><a>-$?</a></tt>, assumes that no failure is possible.
--   
--   For testing and demonstration purposes. Note, that here types of
--   variables are specified, because the result type of arithmetic
--   operations depends on them.
--   
--   <pre>
--   &gt;&gt;&gt; nop -$ 5
--   5
--   
--   &gt;&gt;&gt; sub -$ ((3 :: Integer), (2 :: Integer))
--   1
--   
--   &gt;&gt;&gt; push 9 -$ ()
--   9
--   
--   &gt;&gt;&gt; add # add -$ ((1 :: Integer), ((2 :: Integer), (3 :: Integer)))
--   6
--   </pre>
(-$) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out, HasCallStack) => (inps :-> '[out]) -> ZippedStack inps -> out
infixr 2 -$

-- | Version of (-$?) with arguments flipped.
(&?-) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out) => ZippedStack inps -> (inps :-> '[out]) -> Either MichelsonFailureWithStack out
infixl 2 &?-

-- | Version of (-$) with arguments flipped.
(&-) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out, HasCallStack) => ZippedStack inps -> (inps :-> '[out]) -> out
infixl 2 &-

-- | Version of (-$) applicable to a series of values.
(<-$>) :: (ZipInstr inps, IsoValue (ZippedStack inps), IsoValue out, HasCallStack) => (inps :-> '[out]) -> [ZippedStack inps] -> [out]
infixl 2 <-$>

-- | Pretty-print a Haskell value as Michelson one.
printLorentzValue :: forall v. NiceUntypedValue v => Bool -> v -> LText

-- | Pretty-print a Lorentz contract into Michelson code.
printLorentzContract :: Bool -> Contract cp st vd -> LText

-- | Estimate code operation size.
contractOpSize :: Contract cp st vd -> OpSize

-- | Estimate value operation size.
valueOpSize :: forall a. NiceUntypedValue a => a -> OpSize