Lorentz.Base

Foundation of Lorentz development.

Documentation

newtype (inp :: [Type]) :-> (out :: [Type]) infixr 1

Alias for instruction which hides inner types representation via T.

Constructors

LorentzInstr

Fields

• unLorentzInstr :: RemFail Instr (ToTs inp) (ToTs out)

Instances

(CanCastTo (ZippedStack i1) (ZippedStack i2), CanCastTo (ZippedStack o1) (ZippedStack o2)) => CanCastTo (i1 :-> o1 :: Type) (i2 :-> o2 :: Type)

Defined in Lorentz.Coercions

Methods

castDummy :: Proxy (i1 :-> o1) -> Proxy (i2 :-> o2) -> ()

Monoid (s :-> s)

Defined in Lorentz.Base

Methods

mempty :: s :-> s

mappend :: (s :-> s) -> (s :-> s) -> s :-> s

mconcat :: [s :-> s] -> s :-> s

Semigroup (s :-> s)

Defined in Lorentz.Base

Methods

(<>) :: (s :-> s) -> (s :-> s) -> s :-> s

sconcat :: NonEmpty (s :-> s) -> s :-> s

stimes :: Integral b => b -> (s :-> s) -> s :-> s

Show (inp :-> out)

Defined in Lorentz.Base

Methods

showsPrec :: Int -> (inp :-> out) -> ShowS

show :: (inp :-> out) -> String

showList :: [inp :-> out] -> ShowS

NFData (i :-> o)

Defined in Lorentz.Base

Methods

rnf :: (i :-> o) -> ()

Buildable (inp :-> out)

Defined in Lorentz.Base

Methods

build :: (inp :-> out) -> Builder

Eq (inp :-> out)

Defined in Lorentz.Base

Methods

(==) :: (inp :-> out) -> (inp :-> out) -> Bool

(/=) :: (inp :-> out) -> (inp :-> out) -> Bool

(HasAnnotation (ZippedStack i), HasAnnotation (ZippedStack o)) => HasAnnotation (i :-> o)

Defined in Lorentz.Zip

Methods

getAnnotation :: FollowEntrypointFlag -> Notes (ToT (i :-> o))

annOptions :: AnnOptions

MapLorentzInstr (i :-> o)

Defined in Lorentz.Base

Methods

mapLorentzInstr :: (forall (i0 :: [Type]) (o0 :: [Type]). (i0 :-> o0) -> i0 :-> o0) -> (i :-> o) -> i :-> o

HasRPCRepr (inp :-> out)

Defined in Lorentz.Zip

Associated Types

type AsRPC (inp :-> out)

ContainsDoc (i :-> o)

Defined in Lorentz.Doc

Methods

buildDocUnfinalized :: (i :-> o) -> ContractDoc

ContainsUpdateableDoc (i :-> o)

Defined in Lorentz.Doc

Methods

modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> (i :-> o) -> i :-> o

RenderDoc (inp :-> out)

Defined in Lorentz.Base

Methods

renderDoc :: RenderContext -> (inp :-> out) -> Doc

isRenderable :: (inp :-> out) -> Bool

(WellTypedToT (ZippedStack inp), WellTypedToT (ZippedStack out), ZipInstr inp, ZipInstr out) => IsoValue (inp :-> out)

Defined in Lorentz.Zip

Associated Types

type ToT (inp :-> out) :: T

Methods

toVal :: (inp :-> out) -> Value (ToT (inp :-> out))

fromVal :: Value (ToT (inp :-> out)) -> inp :-> out

(i ~ arg, o ~ argl, o ~ argr, r ~ Bool, outb ~ out) => IsCondition (Expr i o r) arg argl argr outb out

An expression producing Bool can be placed as condition to 'if'.

Defined in Lorentz.Expr

Methods

ifThenElse :: Expr i o r -> (argl :-> outb) -> (argr :-> outb) -> arg :-> out

type AsRPC (inp :-> out)

Defined in Lorentz.Zip

type AsRPC (inp :-> out) = inp :-> out

type ToT (inp :-> out)

Defined in Lorentz.Zip

type ToT (inp :-> out) = 'TLambda (ToT (ZippedStack inp)) (ToT (ZippedStack out))

type (%>) = (:->) infixr 1

Alias for :->, seems to make signatures more readable sometimes.

Let's someday decide which one of these two should remain.

type (&) (a :: Type) (b :: [Type]) = a ': b infixr 2

An alias for ':.

We discourage its use as this hinders reading error messages (the compiler inserts unnecessary parentheses and indentation).

(#) :: (a :-> b) -> (b :-> c) -> a :-> c infixl 8

Function composition for instructions.

Note that, unlike Morley's :# operator, (#) is left-associative.

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

parseLorentzValue :: forall v. KnownValue v => MichelsonSource -> Text -> Either ParseLorentzError v

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).

transformStringsLorentz :: Bool -> (MText -> MText) -> (inp :-> out) -> inp :-> out

Lorentz version of transformStrings.

transformBytesLorentz :: Bool -> (ByteString -> ByteString) -> (inp :-> out) -> inp :-> out

Lorentz version of transformBytes.

optimizeLorentz :: (inp :-> out) -> inp :-> out

optimizeLorentzWithConf :: OptimizerConf -> (inp :-> out) -> inp :-> out

class MapLorentzInstr instr where

Applicable for wrappers over Lorentz code.

Methods

mapLorentzInstr :: (forall i o. (i :-> o) -> i :-> o) -> instr -> instr

Modify all the code under given entity.

Instances

MapLorentzInstr (i :-> o)

Defined in Lorentz.Base

Methods

mapLorentzInstr :: (forall (i0 :: [Type]) (o0 :: [Type]). (i0 :-> o0) -> i0 :-> o0) -> (i :-> o) -> i :-> o

type ContractOut st = '[([Operation], st)]

newtype ContractCode cp st

Wrap contract code capturing the constraint that the code is not inside a view.

Constructors

ContractCode

Fields

• unContractCode :: '[(cp, st)] :-> ContractOut st

Instances

Show (ContractCode cp st)

Defined in Lorentz.Base

Methods

showsPrec :: Int -> ContractCode cp st -> ShowS

show :: ContractCode cp st -> String

showList :: [ContractCode cp st] -> ShowS

NFData (ContractCode cp st)

Defined in Lorentz.Base

Methods

rnf :: ContractCode cp st -> ()

Eq (ContractCode cp st)

Defined in Lorentz.Base

Methods

(==) :: ContractCode cp st -> ContractCode cp st -> Bool

(/=) :: ContractCode cp st -> ContractCode cp st -> Bool

ContainsDoc (ContractCode i o)

Defined in Lorentz.Doc

Methods

buildDocUnfinalized :: ContractCode i o -> ContractDoc

ContainsUpdateableDoc (ContractCode i o)

Defined in Lorentz.Doc

Methods

modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> ContractCode i o -> ContractCode i o

mkContractCode :: (IsNotInView => '[(cp, st)] :-> ContractOut st) -> ContractCode cp st

A helper to construct ContractCode that provides IsNotInView constraint.

class IsNotInView

Instances

(TypeError ('Text "Not allowed on the top level of a view") :: Constraint) => IsNotInView

Defined in Morley.Michelson.Typed.Contract

data SomeContractCode where

Constructors

SomeContractCode :: (NiceParameter cp, NiceStorage st) => ContractCode cp st -> SomeContractCode

type ViewCode arg st ret = '[(arg, st)] :-> '[ret]

data Contract cp st vd

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.

Constructors

(NiceParameter cp, NiceStorage st, NiceViewsDescriptor vd) => Contract

Fields

• cMichelsonContract :: Contract (ToT cp) (ToT st)

  Ready contract code.

• cDocumentedCode :: ~(ContractCode cp st)

  Contract that contains documentation.

  We have to keep it separately, since optimizer is free to destroy documentation blocks. Also, it is not ContractDoc but Lorentz code because the latter is easier to modify.

Instances

Show (Contract cp st vd)

Defined in Lorentz.Base

Methods

showsPrec :: Int -> Contract cp st vd -> ShowS

show :: Contract cp st vd -> String

showList :: [Contract cp st vd] -> ShowS

NFData (Contract cp st vd)

Defined in Lorentz.Base

Methods

rnf :: Contract cp st vd -> ()

Eq (Contract cp st vd)

Defined in Lorentz.Base

Methods

(==) :: Contract cp st vd -> Contract cp st vd -> Bool

(/=) :: Contract cp st vd -> Contract cp st vd -> Bool

ToExpression (Contract cp st vd)

Defined in Lorentz.Base

Methods

toExpression :: Contract cp st vd -> Expression

ContainsDoc (Contract cp st vd)

Defined in Lorentz.Doc

Methods

buildDocUnfinalized :: Contract cp st vd -> ContractDoc

ContainsUpdateableDoc (Contract cp st vd)

Defined in Lorentz.Doc

Methods

modifyDocEntirely :: (SomeDocItem -> SomeDocItem) -> Contract cp st vd -> Contract cp st vd

toMichelsonContract :: Contract cp st vd -> Contract (ToT cp) (ToT st)

Demote Lorentz Contract to Michelson typed Contract.

type Fn a b = '[a] :-> '[b]

An instruction sequence taking one stack element as input and returning one stack element as output. Essentially behaves as a Michelson lambda without any additional semantical meaning.

The reason for this distinction is Michelson lambdas allow instructions inside them that might be forbidden in the outer scope. This type doesn't add any such conditions.