Indigo.Compilation.Sequential

Instruction datatype and its compilations.

The idea behind this module is to provide an intermediate representation that can:

• be generated from the frontend freer monad
• be compiled to the backend IndigoState
• be easy to analyze, manipulate and modify

This is meant to be the common ground for modular optimizations on the code before this is handed off to the backend and eventually translated to Michelson.

Documentation

type Block = [Instruction]

Simple synonym for a list of Instruction

data Instruction where

Data type representing an instruction.

Differently from the frontend this is not used to build a Monad of some kind, it is instead based on having as argument the variable to associate with the resulting value (if any).

This is combined in simple lists, named Block, and it is intended to be easily altered, this is because these are used as the intermediate representation between the frontend and the backend, where optimizations can occur.

Constructors

LiftIndigoState :: (forall inp. SomeIndigoState inp) -> Instruction

Comment :: Text -> Instruction

AssignVar :: KnownValue x => Var x -> Expr x -> Instruction

SetVar :: KnownValue x => Var x -> Expr x -> Instruction

VarModification :: (IsObject x, KnownValue y) => ([y, x] :-> '[x]) -> Var x -> Expr y -> Instruction

SetField :: (HasField store fname ftype, IsObject store, IsObject ftype) => Var store -> Label fname -> Expr ftype -> Instruction

LambdaCall1

Fields

• :: LambdaKind st arg ret extra

  Kind of lambda (pure, storage modification, fully functional lambda with effects)

• -> String

  Name of the lambda

• -> Expr arg

  Expression for the lambda argument

• -> Var arg

  Variable for the argument value (available to the lambda code block)

• -> Block

  Code block for the lambda

• -> ret

  Return value(s) of the lambda

• -> RetVars ret

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

CreateLambda1

Fields

• :: CreateLambda1CGeneric extra arg ret
• => StackVars (arg ': extra)

  Initial StackVars to be used in the lambda code

• -> Var arg

  Variable for the argument value (available to the lambda code block)

• -> Block

  Code block for the lambda

• -> ret

  Return value(s) of the lambda

• -> Var (Lambda1Generic extra arg ret)

  Variable that will be assigned to the resulting lambda

• -> Instruction

ExecLambda1

Fields

• :: LambdaKind st arg ret extra
• -> Proxy ret
• -> Expr arg

  Expression for the lambda argument

• -> Var (Lambda1Generic extra arg ret)

  Variable of the lambda to be executed

• -> RetVars ret

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

Scope

Fields

• :: ScopeCodeGen ret
• => Block

  Code block to execute inside the scope

• -> ret

  Return value(s) of the scoped code block

• -> RetVars ret

  Variable that will be assigned to the resulting value(s)

• -> Instruction

If

Fields

• :: IfConstraint a b
• => Expr Bool

  Expression for the control flow

• -> Block

  Code block for the positive branch

• -> a

  Return value(s) of the positive branch

• -> Block

  Code block for the negative branch

• -> b

  Return value(s) of the negative branch

• -> RetVars a

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

IfSome

Fields

• :: (IfConstraint a b, KnownValue x)
• => Expr (Maybe x)

  Expression for the control flow

• -> Var x

  Variable for the Just value (available to the next code block)

• -> Block

  Code block for the Just branch

• -> a

  Return value(s) of the Just branch

• -> Block

  Code block for the Nothing branch

• -> b

  Return value(s) of the Nothing branch

• -> RetVars a

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

IfRight

Fields

• :: (IfConstraint a b, KnownValue r, KnownValue l)
• => Expr (Either l r)

  Expression for the control flow

• -> Var r

  Variable for the Right value (available to the next code block)

• -> Block

  Code block for the Right branch

• -> a

  Return value(s) of the Right branch

• -> Var l

  Variable for the Left value (available to the next code block)

• -> Block

  Code block for the Left branch

• -> b

  Return value(s) of the Left branch

• -> RetVars a

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

IfCons

Fields

• :: (IfConstraint a b, KnownValue x)
• => Expr (List x)

  Expression for the control flow

• -> Var x

  Variable for the "head" value (available to the next code block)

• -> Var (List x)

  Variable for the "tail" value (available to the next code block)

• -> Block

  Code block for the non-empty list branch

• -> a

  Return value(s) of the non-empty list branch

• -> Block

  Code block for the empty list branch

• -> b

  Return value(s) of the empty list branch

• -> RetVars a

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

Case

Fields

• :: CaseCommon dt ret clauses
• => Expr dt
• -> clauses
• -> RetVars ret

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

EntryCase

Fields

• :: (CaseCommon dt ret clauses, DocumentEntrypoints entryPointKind dt)
• => Proxy entryPointKind
• -> Expr dt
• -> clauses
• -> RetVars ret

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

EntryCaseSimple

Fields

• :: (CaseCommon dt ret clauses, DocumentEntrypoints PlainEntrypointsKind dt, NiceParameterFull dt, RequireFlatParamEps dt)
• => Expr dt
• -> clauses
• -> RetVars ret

  Variable(s) that will be assigned to the resulting value(s)

• -> Instruction

While

Fields

• :: Expr Bool

  Expression for the control flow

• -> Block

  Block of code to execute, as long as the expression holds True

• -> Instruction

WhileLeft

Fields

• :: (KnownValue l, KnownValue r)
• => Expr (Either l r)

  Expression for the control flow value

• -> Var l

  Variable for the Left value (available to the code block)

• -> Block

  Code block to execute while the value is Left

• -> Var r

  Variable that will be assigned to the resulting value

• -> Instruction

ForEach

Fields

• :: (IterOpHs a, KnownValue (IterOpElHs a))
• => Expr a

  Expression for the container to traverse

• -> Var (IterOpElHs a)

  Variable for the current item (available to the code block)

• -> Block

  Code block to execute over each element of the container

• -> Instruction

ContractName :: Text -> Block -> Instruction

DocGroup :: forall di. DocItem di => (SubDoc -> di) -> Block -> Instruction

ContractGeneral :: Block -> Instruction

FinalizeParamCallingDoc :: (NiceParameterFull cp, RequireSumType cp) => Var cp -> Block -> Expr cp -> Instruction

TransferTokens :: (NiceParameter p, HasSideEffects, IsNotInView) => Expr p -> Expr Mutez -> Expr (ContractRef p) -> Instruction

SetDelegate :: (HasSideEffects, IsNotInView) => Expr (Maybe KeyHash) -> Instruction

CreateContract

Fields

• :: (HasSideEffects, NiceStorage s, NiceParameterFull p, NiceViewsDescriptor vd, Typeable vd, IsNotInView)
• => Contract p s vd
• -> Expr (Maybe KeyHash)
• -> Expr Mutez
• -> Expr s
• -> Var Address

  Variable that will be assigned to the resulting Address

• -> Instruction

SelfCalling

Fields

• :: (NiceParameterFull p, KnownValue (GetEntrypointArgCustom p mname), IsoValue (ContractRef (GetEntrypointArgCustom p mname)), IsNotInView)
• => Proxy p
• -> EntrypointRef mname
• -> Var (ContractRef (GetEntrypointArgCustom p mname))

  Variable that will be assigned to the resulting ContractRef

• -> Instruction

ContractCalling

Fields

• :: (HasEntrypointArg cp epRef epArg, ToTAddress cp vd addr, ToT addr ~ ToT Address, KnownValue epArg, IsoValue (ContractRef epArg))
• => Proxy (cp, vd)
• -> epRef
• -> Expr addr
• -> Var (Maybe (ContractRef epArg))

  Variable that will be assigned to the resulting ContractRef

• -> Instruction

Emit :: (HasSideEffects, NicePackedValue a, HasAnnotation a) => FieldAnn -> Expr a -> Instruction

Fail :: (forall inp. SomeIndigoState inp) -> Instruction

FailOver :: (forall inp. Expr a -> SomeIndigoState inp) -> Expr a -> Instruction

data IndigoSeqCaseClause ret (param :: CaseClauseParam) where

Analogous datatype as IndigoCaseClauseL and IndigoMCaseClauseL.

Constructors

OneFieldIndigoSeqCaseClause :: AppendSymbol "c" ctor ~ name => Label name -> CaseBranch x ret -> IndigoSeqCaseClause ret ('CaseClauseParam ctor ('OneField x))

data CaseBranch x ret where

Representation of a branch of a generic case-like Instruction.

Constructors

CaseBranch

Fields

• :: (KnownValue x, ScopeCodeGen retBr, ret ~ RetExprs retBr, RetOutStack ret ~ RetOutStack retBr)
• => Var x

  Input variable (accessible to the branch's code block)

• -> Block

  Code block for this branch

• -> retBr

  Return value of this branch

• -> CaseBranch x ret

Translations

newtype SequentialHooks

Constructors

SequentialHooks

Fields

• shStmtHook :: CallStack -> Block -> State InstrCollector ()

Instances

Monoid SequentialHooks

Defined in Indigo.Compilation.Sequential.Types

Methods

mempty :: SequentialHooks

mappend :: SequentialHooks -> SequentialHooks -> SequentialHooks

mconcat :: [SequentialHooks] -> SequentialHooks

Semigroup SequentialHooks

Defined in Indigo.Compilation.Sequential.Types

Methods

(<>) :: SequentialHooks -> SequentialHooks -> SequentialHooks

sconcat :: NonEmpty SequentialHooks -> SequentialHooks

stimes :: Integral b => b -> SequentialHooks -> SequentialHooks

stmtHookL :: Lens' SequentialHooks (CallStack -> Block -> State InstrCollector ())

data InstrCollector

Data type internally used to collect Instructions from IndigoM

Constructors

InstrCollector

Fields

• nextRef :: RefId
• instrList :: Block
• seqHooks :: SequentialHooks

indigoMtoSequential :: RefId -> SequentialHooks -> IndigoM a -> (Block, RefId)

Transformation from IndigoM to a Block of Instructions.

Requires the first non-used RefId and returns the next one.

sequentialToLorentz :: MetaData inp -> (Block, RefId) -> inp :-> inp

Translation from a Block and an initial MetaData to Lorentz.

Case machinery

updateClauses :: (Block -> Block) -> Rec (IndigoSeqCaseClause ret) dt -> Rec (IndigoSeqCaseClause ret) dt

Applies the given Block to Block transformation to the inner code block of every case clause.

mapMClauses :: Monad m => (Block -> m ()) -> Rec (IndigoSeqCaseClause ret) dt -> m ()

Applies the given monadic function giving it the inner code block of each case clause, in order.