module Indigo.Frontend.Language
(
new
, setVar
, setField
, (+=)
, (-=)
, (*=)
, (<<<=)
, (>>>=)
, (&&=)
, (||=)
, (^=)
, (=:)
, getStorageField
, setStorageField
, updateStorageField
, if_
, when
, unless
, ifSome
, ifNone
, whenSome
, whenNone
, ifRight
, ifLeft
, whenRight
, whenLeft
, ifCons
, case_
, caseRec
, entryCase
, entryCaseRec
, entryCaseSimple
, (//->)
, scope
, defFunction
, defContract
, defNamedPureLambda1
, defNamedLambda1
, defNamedLambda0
, defNamedEffLambda1
, while
, whileLeft
, forEach
, selfCalling
, contractCalling
, doc
, docGroup
, docStorage
, contractName
, contractGeneral
, contractGeneralDefault
, finalizeParamCallingDoc
, transferTokens
, setDelegate
, createContract
, createLorentzContract
, failWith
, assert
, failCustom
, failCustom_
, failUnexpected_
, assertCustom
, assertCustom_
, comment
, justComment
, commentAroundFun
, commentAroundStmt
, IndigoFunction
, IndigoProcedure
, IndigoEntrypoint
, liftIndigoState
) where
import qualified Indigo.Backend as B
import Indigo.Backend.Case hiding (caseRec, entryCaseRec)
import Indigo.Backend.Lambda
import Indigo.Backend.Scope
import Indigo.Compilation (compileIndigoContract)
import Indigo.Frontend.Program
import Indigo.Frontend.Statement
import Indigo.Internal hiding (SetField, return, (>>), (>>=))
import Indigo.Lorentz
import Indigo.Prelude
import Lorentz.EntryPoints.Helpers (RequireSumType)
import qualified Lorentz.Instr as L
import qualified Lorentz.Run as L
import qualified Michelson.Typed as MT
import qualified Michelson.Typed.Arith as M
import Michelson.Typed.Haskell.Instr.Sum (CaseClauseParam(..), CtorField(..))
import Util.TypeLits (AppendSymbol)
import Util.TypeTuple.Class
oneIndigoM :: StatementF IndigoM a -> IndigoM a
oneIndigoM :: StatementF IndigoM a -> IndigoM a
oneIndigoM st :: StatementF IndigoM a
st = Program (StatementF IndigoM) a -> IndigoM a
forall a. Program (StatementF IndigoM) a -> IndigoM a
IndigoM (StatementF IndigoM a -> Program (StatementF IndigoM) a
forall (instr :: * -> *) a. instr a -> Program instr a
Instr StatementF IndigoM a
st)
liftIndigoState :: (forall inp. SomeIndigoState inp a) -> IndigoM a
liftIndigoState :: (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState code :: forall (inp :: [*]). SomeIndigoState inp a
code = Program (StatementF IndigoM) a -> IndigoM a
forall a. Program (StatementF IndigoM) a -> IndigoM a
IndigoM (StatementF IndigoM a -> Program (StatementF IndigoM) a
forall (instr :: * -> *) a. instr a -> Program instr a
Instr (StatementF IndigoM a -> Program (StatementF IndigoM) a)
-> StatementF IndigoM a -> Program (StatementF IndigoM) a
forall a b. (a -> b) -> a -> b
$ (forall (inp :: [*]). SomeIndigoState inp a)
-> StatementF IndigoM a
forall a (freer :: * -> *).
(forall (inp :: [*]). SomeIndigoState inp a) -> StatementF freer a
LiftIndigoState forall (inp :: [*]). SomeIndigoState inp a
code)
varModification
:: (IsExpr ey y, IsObject x)
=> ([y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification :: ('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification act :: '[y, x] :-> '[x]
act v :: Var x
v ex :: ey
ex = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> StatementF IndigoM () -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ ('[y, x] :-> '[x]) -> Var x -> ey -> StatementF IndigoM ()
forall ey y ex (freer :: * -> *).
(ey :~> y, IsObject ex) =>
('[y, ex] :-> '[ex]) -> Var ex -> ey -> StatementF freer ()
VarModification '[y, x] :-> '[x]
act Var x
v ey
ex
new :: IsExpr ex x => ex -> IndigoM (Var x)
new :: ex -> IndigoM (Var x)
new e :: ex
e = StatementF IndigoM (Var x) -> IndigoM (Var x)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (Var x) -> IndigoM (Var x))
-> StatementF IndigoM (Var x) -> IndigoM (Var x)
forall a b. (a -> b) -> a -> b
$ ex -> StatementF IndigoM (Var x)
forall ex x (freer :: * -> *).
(ex :~> x) =>
ex -> StatementF freer (Var x)
NewVar ex
e
setVar :: (IsExpr ex x, IsObject x) => Var x -> ex -> IndigoM ()
setVar :: Var x -> ex -> IndigoM ()
setVar v :: Var x
v e :: ex
e = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> StatementF IndigoM () -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ Var x -> ex -> StatementF IndigoM ()
forall ex x (freer :: * -> *).
(ex :~> x, IsObject x) =>
Var x -> ex -> StatementF freer ()
SetVar Var x
v ex
e
infixr 0 =:
(=:) :: (IsExpr ex x, IsObject x) => Var x -> ex -> IndigoM ()
v :: Var x
v =: :: Var x -> ex -> IndigoM ()
=: e :: ex
e = Var x -> ex -> IndigoM ()
forall ex x. (IsExpr ex x, IsObject x) => Var x -> ex -> IndigoM ()
setVar Var x
v ex
e
setField
:: ( ex :~> ftype
, IsObject dt
, IsObject ftype
, HasField dt fname ftype
)
=> Var dt -> Label fname -> ex -> IndigoM ()
setField :: Var dt -> Label fname -> ex -> IndigoM ()
setField v :: Var dt
v fName :: Label fname
fName e :: ex
e = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> StatementF IndigoM () -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ Var dt -> Label fname -> ex -> StatementF IndigoM ()
forall ex ftype dt (fname :: Symbol) (cont :: * -> *).
(ex :~> ftype, IsObject dt, IsObject ftype,
HasField dt fname ftype) =>
Var dt -> Label fname -> ex -> StatementF cont ()
SetField Var dt
v Label fname
fName ex
e
(+=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Add n m, ArithResHs M.Add n m ~ m
) => Var m -> ex1 -> IndigoM ()
+= :: Var m -> ex1 -> IndigoM ()
(+=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Add n m =>
(n & (m & s)) :-> (ArithResHs Add n m & s)
L.add
(-=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Sub n m, ArithResHs M.Sub n m ~ m
) => Var m -> ex1 -> IndigoM ()
-= :: Var m -> ex1 -> IndigoM ()
(-=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Sub n m =>
(n & (m & s)) :-> (ArithResHs Sub n m & s)
L.sub
(*=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Mul n m, ArithResHs M.Mul n m ~ m
) => Var m -> ex1 -> IndigoM ()
*= :: Var m -> ex1 -> IndigoM ()
(*=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Mul n m =>
(n & (m & s)) :-> (ArithResHs Mul n m & s)
L.mul
(||=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Or n m, ArithResHs M.Or n m ~ m
) => Var m -> ex1 -> IndigoM ()
||= :: Var m -> ex1 -> IndigoM ()
(||=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Or n m =>
(n & (m & s)) :-> (ArithResHs Or n m & s)
L.or
(&&=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.And n m, ArithResHs M.And n m ~ m
) => Var m -> ex1 -> IndigoM ()
&&= :: Var m -> ex1 -> IndigoM ()
(&&=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs And n m =>
(n & (m & s)) :-> (ArithResHs And n m & s)
L.and
(^=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Xor n m, ArithResHs M.Xor n m ~ m
) => Var m -> ex1 -> IndigoM ()
^= :: Var m -> ex1 -> IndigoM ()
(^=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Xor n m =>
(n & (m & s)) :-> (ArithResHs Xor n m & s)
L.xor
(<<<=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Lsl n m, ArithResHs M.Lsl n m ~ m
) => Var m -> ex1 -> IndigoM ()
<<<= :: Var m -> ex1 -> IndigoM ()
(<<<=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Lsl n m =>
(n & (m & s)) :-> (ArithResHs Lsl n m & s)
L.lsl
(>>>=)
:: ( IsExpr ex1 n, IsObject m
, ArithOpHs M.Lsr n m, ArithResHs M.Lsr n m ~ m
) => Var m -> ex1 -> IndigoM ()
>>>= :: Var m -> ex1 -> IndigoM ()
(>>>=) = ('[n, m] :-> '[m]) -> Var m -> ex1 -> IndigoM ()
forall ey y x.
(IsExpr ey y, IsObject x) =>
('[y, x] :-> '[x]) -> Var x -> ey -> IndigoM ()
varModification '[n, m] :-> '[m]
forall n m (s :: [*]).
ArithOpHs Lsr n m =>
(n & (m & s)) :-> (ArithResHs Lsr n m & s)
L.lsr
setStorageField
:: forall store name ftype ex.
( HasStorage store
, ex :~> ftype
, IsObject store
, IsObject ftype
, HasField store name ftype
)
=> Label name -> ex -> IndigoM ()
setStorageField :: Label name -> ex -> IndigoM ()
setStorageField field :: Label name
field expr :: ex
expr = Var store -> Label name -> ex -> IndigoM ()
forall ex ftype dt (fname :: Symbol).
(ex :~> ftype, IsObject dt, IsObject ftype,
HasField dt fname ftype) =>
Var dt -> Label fname -> ex -> IndigoM ()
setField (HasStorage store => Var store
forall st. HasStorage st => Var st
storageVar @store) Label name
field ex
expr
updateStorageField
:: forall store ftype fname fex.
( HasStorage store
, fex :~> ftype
, HasField store fname ftype
, IsObject store
, IsObject ftype
)
=> Label fname
-> (Var ftype -> IndigoM fex)
-> IndigoM ()
updateStorageField :: Label fname -> (Var ftype -> IndigoM fex) -> IndigoM ()
updateStorageField field :: Label fname
field upd :: Var ftype -> IndigoM fex
upd = IndigoM () -> IndigoM ()
forall a. ScopeCodeGen a => IndigoM a -> IndigoFunction a
scope (IndigoM () -> IndigoM ()) -> IndigoM () -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ do
let storage :: Var store
storage = HasStorage store => Var store
forall st. HasStorage st => Var st
storageVar @store
Var ftype
fieldVar <- Expr ftype -> IndigoM (Var ftype)
forall ex x. IsExpr ex x => ex -> IndigoM (Var x)
new(Expr ftype -> IndigoM (Var ftype))
-> Expr ftype -> IndigoM (Var ftype)
forall a b. (a -> b) -> a -> b
$ Var store
storage Var store -> Label fname -> Expr ftype
forall dt (name :: Symbol) ftype exDt.
(HasField dt name ftype, exDt :~> dt) =>
exDt -> Label name -> Expr ftype
#! Label fname
field
fex
expr <- Var ftype -> IndigoM fex
upd Var ftype
fieldVar
Var store -> Label fname -> fex -> IndigoM ()
forall ex ftype dt (fname :: Symbol).
(ex :~> ftype, IsObject dt, IsObject ftype,
HasField dt fname ftype) =>
Var dt -> Label fname -> ex -> IndigoM ()
setField Var store
storage Label fname
field fex
expr
getStorageField
:: forall store ftype fname .
( HasStorage store
, HasField store fname ftype
)
=> Label fname -> IndigoM (Var ftype)
getStorageField :: Label fname -> IndigoM (Var ftype)
getStorageField field :: Label fname
field = Expr ftype -> IndigoM (Var ftype)
forall ex x. IsExpr ex x => ex -> IndigoM (Var x)
new(Expr ftype -> IndigoM (Var ftype))
-> Expr ftype -> IndigoM (Var ftype)
forall a b. (a -> b) -> a -> b
$ HasStorage store => Var store
forall st. HasStorage st => Var st
storageVar @store Var store -> Label fname -> Expr ftype
forall dt (name :: Symbol) ftype exDt.
(HasField dt name ftype, exDt :~> dt) =>
exDt -> Label name -> Expr ftype
#! Label fname
field
if_
:: forall a b ex . (IfConstraint a b, ex :~> Bool)
=> ex
-> IndigoM a
-> IndigoM b
-> IndigoM (RetVars a)
if_ :: ex -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
if_ ex :: ex
ex tb :: IndigoM a
tb fb :: IndigoM b
fb = StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a))
-> StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a b. (a -> b) -> a -> b
$ ex -> IndigoM a -> IndigoM b -> StatementF IndigoM (RetVars a)
forall a b a (freer :: * -> *).
(IfConstraint a b, a :~> Bool) =>
a -> freer a -> freer b -> StatementF freer (RetVars a)
If ex
ex IndigoM a
tb IndigoM b
fb
when :: (exc :~> Bool) => exc -> IndigoM () -> IndigoM ()
when :: exc -> IndigoM () -> IndigoM ()
when cond :: exc
cond expr :: IndigoM ()
expr = exc -> IndigoM () -> IndigoM () -> IndigoM (RetVars ())
forall a b ex.
(IfConstraint a b, ex :~> Bool) =>
ex -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
if_ exc
cond IndigoM ()
expr (() -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())
unless :: (exc :~> Bool) => exc -> IndigoM () -> IndigoM ()
unless :: exc -> IndigoM () -> IndigoM ()
unless cond :: exc
cond expr :: IndigoM ()
expr = exc -> IndigoM () -> IndigoM () -> IndigoM (RetVars ())
forall a b ex.
(IfConstraint a b, ex :~> Bool) =>
ex -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
if_ exc
cond (() -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) IndigoM ()
expr
ifSome
:: forall x a b ex . (KnownValue x, ex :~> Maybe x, IfConstraint a b)
=> ex
-> (Var x -> IndigoM a)
-> IndigoM b
-> IndigoM (RetVars a)
ifSome :: ex -> (Var x -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
ifSome ex :: ex
ex tb :: Var x -> IndigoM a
tb fb :: IndigoM b
fb = StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a))
-> StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a b. (a -> b) -> a -> b
$ ex
-> (Var x -> IndigoM a)
-> IndigoM b
-> StatementF IndigoM (RetVars a)
forall a b x ex (freer :: * -> *).
(IfConstraint a b, KnownValue x, ex :~> Maybe x) =>
ex -> (Var x -> freer a) -> freer b -> StatementF freer (RetVars a)
IfSome ex
ex Var x -> IndigoM a
tb IndigoM b
fb
ifNone
:: forall x a b ex . (KnownValue x, ex :~> Maybe x, IfConstraint a b)
=> ex
-> IndigoM b
-> (Var x -> IndigoM a)
-> IndigoM (RetVars a)
ifNone :: ex -> IndigoM b -> (Var x -> IndigoM a) -> IndigoM (RetVars a)
ifNone ex :: ex
ex fb :: IndigoM b
fb tb :: Var x -> IndigoM a
tb = ex -> (Var x -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
forall x a b ex.
(KnownValue x, ex :~> Maybe x, IfConstraint a b) =>
ex -> (Var x -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
ifSome ex
ex Var x -> IndigoM a
tb IndigoM b
fb
whenSome
:: forall x exa .
( KnownValue x
, exa :~> Maybe x
)
=> exa
-> (Var x -> IndigoM ())
-> IndigoM ()
whenSome :: exa -> (Var x -> IndigoM ()) -> IndigoM ()
whenSome c :: exa
c f :: Var x -> IndigoM ()
f = exa -> (Var x -> IndigoM ()) -> IndigoM () -> IndigoM (RetVars ())
forall x a b ex.
(KnownValue x, ex :~> Maybe x, IfConstraint a b) =>
ex -> (Var x -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
ifSome exa
c Var x -> IndigoM ()
f (() -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())
whenNone
:: forall x exa .
( KnownValue x
, exa :~> Maybe x
)
=> exa
-> IndigoM ()
-> IndigoM ()
whenNone :: exa -> IndigoM () -> IndigoM ()
whenNone c :: exa
c f :: IndigoM ()
f = exa -> (Var x -> IndigoM ()) -> IndigoM () -> IndigoM (RetVars ())
forall x a b ex.
(KnownValue x, ex :~> Maybe x, IfConstraint a b) =>
ex -> (Var x -> IndigoM a) -> IndigoM b -> IndigoM (RetVars a)
ifSome exa
c (\_ -> () -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) IndigoM ()
f
ifRight
:: forall x y a b ex .
( KnownValue x
, KnownValue y
, ex :~> Either y x
, IfConstraint a b
)
=> ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> IndigoM (RetVars a)
ifRight :: ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> IndigoM (RetVars a)
ifRight ex :: ex
ex rb :: Var x -> IndigoM a
rb lb :: Var y -> IndigoM b
lb = StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a))
-> StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a b. (a -> b) -> a -> b
$ ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> StatementF IndigoM (RetVars a)
forall a b x a b (freer :: * -> *).
(IfConstraint a b, KnownValue x, KnownValue a, b :~> Either a x) =>
b
-> (Var x -> freer a)
-> (Var a -> freer b)
-> StatementF freer (RetVars a)
IfRight ex
ex Var x -> IndigoM a
rb Var y -> IndigoM b
lb
ifLeft
:: forall x y a b ex .
( KnownValue x
, KnownValue y
, ex :~> Either y x
, IfConstraint a b
)
=> ex
-> (Var y -> IndigoM b)
-> (Var x -> IndigoM a)
-> IndigoM (RetVars a)
ifLeft :: ex
-> (Var y -> IndigoM b)
-> (Var x -> IndigoM a)
-> IndigoM (RetVars a)
ifLeft ex :: ex
ex lb :: Var y -> IndigoM b
lb rb :: Var x -> IndigoM a
rb = ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> IndigoM (RetVars a)
forall x y a b ex.
(KnownValue x, KnownValue y, ex :~> Either y x,
IfConstraint a b) =>
ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> IndigoM (RetVars a)
ifRight ex
ex Var x -> IndigoM a
rb Var y -> IndigoM b
lb
whenRight
:: forall x y ex .
( KnownValue x
, KnownValue y
, ex :~> Either y x
)
=> ex
-> (Var x -> IndigoM ())
-> IndigoM ()
whenRight :: ex -> (Var x -> IndigoM ()) -> IndigoM ()
whenRight c :: ex
c f :: Var x -> IndigoM ()
f = ex
-> (Var x -> IndigoM ())
-> (Var y -> IndigoM ())
-> IndigoM (RetVars ())
forall x y a b ex.
(KnownValue x, KnownValue y, ex :~> Either y x,
IfConstraint a b) =>
ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> IndigoM (RetVars a)
ifRight ex
c Var x -> IndigoM ()
f (\_ -> () -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ())
whenLeft
:: forall x y ex .
( KnownValue x
, KnownValue y
, ex :~> Either y x
)
=> ex
-> (Var y -> IndigoM ())
-> IndigoM ()
whenLeft :: ex -> (Var y -> IndigoM ()) -> IndigoM ()
whenLeft c :: ex
c f :: Var y -> IndigoM ()
f = ex
-> (Var x -> IndigoM ())
-> (Var y -> IndigoM ())
-> IndigoM (RetVars ())
forall x y a b ex.
(KnownValue x, KnownValue y, ex :~> Either y x,
IfConstraint a b) =>
ex
-> (Var x -> IndigoM a)
-> (Var y -> IndigoM b)
-> IndigoM (RetVars a)
ifRight ex
c (\_ -> () -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) Var y -> IndigoM ()
f
ifCons
:: forall x a b ex . (KnownValue x, ex :~> List x, IfConstraint a b)
=> ex
-> (Var x -> Var (List x) -> IndigoM a)
-> IndigoM b
-> IndigoM (RetVars a)
ifCons :: ex
-> (Var x -> Var (List x) -> IndigoM a)
-> IndigoM b
-> IndigoM (RetVars a)
ifCons ex :: ex
ex tb :: Var x -> Var (List x) -> IndigoM a
tb fb :: IndigoM b
fb = StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a))
-> StatementF IndigoM (RetVars' (ClassifyReturnValue b) b)
-> IndigoM (RetVars a)
forall a b. (a -> b) -> a -> b
$ ex
-> (Var x -> Var (List x) -> IndigoM a)
-> IndigoM b
-> StatementF IndigoM (RetVars a)
forall a b x dt (freer :: * -> *).
(IfConstraint a b, KnownValue x, dt :~> List x) =>
dt
-> (Var x -> Var (List x) -> freer a)
-> freer b
-> StatementF freer (RetVars a)
IfCons ex
ex Var x -> Var (List x) -> IndigoM a
tb IndigoM b
fb
caseRec
:: forall dt guard ret clauses .
CaseCommonF (IndigoMCaseClauseL IndigoM) dt guard ret clauses
=> guard
-> clauses
-> IndigoM (RetVars ret)
caseRec :: guard -> clauses -> IndigoM (RetVars ret)
caseRec = StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret))
-> (guard
-> Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt))
-> StatementF IndigoM (RetVars ret))
-> guard
-> Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt))
-> IndigoM (RetVars ret)
forall a b c. SuperComposition a b c => a -> b -> c
... guard
-> Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt))
-> StatementF IndigoM (RetVars ret)
forall (freer :: * -> *) dt guard ret clauses.
CaseCommonF (IndigoMCaseClauseL freer) dt guard ret clauses =>
guard -> clauses -> StatementF freer (RetVars ret)
Case
case_
:: forall dt guard ret clauses.
( CaseCommonF (IndigoMCaseClauseL IndigoM) dt guard ret clauses
, RecFromTuple clauses
)
=> guard
-> IsoRecTuple clauses
-> IndigoM (RetVars ret)
case_ :: guard -> IsoRecTuple clauses -> IndigoM (RetVars ret)
case_ g :: guard
g = guard -> clauses -> IndigoM (RetVars ret)
forall dt guard ret clauses.
CaseCommonF (IndigoMCaseClauseL IndigoM) dt guard ret clauses =>
guard -> clauses -> IndigoM (RetVars ret)
caseRec guard
g (clauses -> IndigoM (RetVars ret))
-> (IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt)))
-> clauses)
-> IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt)))
-> IndigoM (RetVars ret)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RecFromTuple clauses => IsoRecTuple clauses -> clauses
forall r. RecFromTuple r => IsoRecTuple r -> r
recFromTuple @clauses
entryCaseRec
:: forall dt entryPointKind guard ret clauses .
( CaseCommonF (IndigoMCaseClauseL IndigoM) dt guard ret clauses
, DocumentEntryPoints entryPointKind dt
)
=> Proxy entryPointKind
-> guard
-> clauses
-> IndigoM (RetVars ret)
entryCaseRec :: Proxy entryPointKind -> guard -> clauses -> IndigoM (RetVars ret)
entryCaseRec proxy :: Proxy entryPointKind
proxy g :: guard
g cls :: clauses
cls = StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret))
-> StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret)
forall a b. (a -> b) -> a -> b
$ Proxy entryPointKind
-> guard -> clauses -> StatementF IndigoM (RetVars ret)
forall (freer :: * -> *) dt guard ret cp guard.
(CaseCommonF (IndigoMCaseClauseL freer) dt guard ret cp,
DocumentEntryPoints guard dt) =>
Proxy guard -> guard -> cp -> StatementF freer (RetVars ret)
EntryCase Proxy entryPointKind
proxy guard
g clauses
cls
entryCase
:: forall dt entryPointKind guard ret clauses .
( CaseCommonF (IndigoMCaseClauseL IndigoM) dt guard ret clauses
, RecFromTuple clauses
, DocumentEntryPoints entryPointKind dt
)
=> Proxy entryPointKind
-> guard
-> IsoRecTuple clauses
-> IndigoM (RetVars ret)
entryCase :: Proxy entryPointKind
-> guard -> IsoRecTuple clauses -> IndigoM (RetVars ret)
entryCase proxy :: Proxy entryPointKind
proxy g :: guard
g = Proxy entryPointKind -> guard -> clauses -> IndigoM (RetVars ret)
forall dt entryPointKind guard ret clauses.
(CaseCommonF (IndigoMCaseClauseL IndigoM) dt guard ret clauses,
DocumentEntryPoints entryPointKind dt) =>
Proxy entryPointKind -> guard -> clauses -> IndigoM (RetVars ret)
entryCaseRec Proxy entryPointKind
proxy guard
g (clauses -> IndigoM (RetVars ret))
-> (IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt)))
-> clauses)
-> IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep dt)))
-> IndigoM (RetVars ret)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RecFromTuple clauses => IsoRecTuple clauses -> clauses
forall r. RecFromTuple r => IsoRecTuple r -> r
recFromTuple @clauses
entryCaseSimple
:: forall cp guard ret clauses .
( CaseCommonF (IndigoMCaseClauseL IndigoM) cp guard ret clauses
, RecFromTuple clauses
, DocumentEntryPoints PlainEntryPointsKind cp
, NiceParameterFull cp
, RequireFlatParamEps cp
)
=> guard
-> IsoRecTuple clauses
-> IndigoM (RetVars ret)
entryCaseSimple :: guard -> IsoRecTuple clauses -> IndigoM (RetVars ret)
entryCaseSimple g :: guard
g = StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars ret) -> IndigoM (RetVars ret))
-> (IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep cp)))
-> StatementF IndigoM (RetVars ret))
-> IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep cp)))
-> IndigoM (RetVars ret)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. guard -> clauses -> StatementF IndigoM (RetVars ret)
forall (freer :: * -> *) cp guard ex x.
(CaseCommonF (IndigoMCaseClauseL freer) cp guard ex x,
DocumentEntryPoints PlainEntryPointsKind cp, NiceParameterFull cp,
RequireFlatParamEps cp) =>
guard -> x -> StatementF freer (RetVars ex)
EntryCaseSimple guard
g (clauses -> StatementF IndigoM (RetVars ret))
-> (IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep cp)))
-> clauses)
-> IsoRecTuple
(Rec (IndigoMCaseClauseL IndigoM ret) (GCaseClauses (Rep cp)))
-> StatementF IndigoM (RetVars ret)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. RecFromTuple clauses => IsoRecTuple clauses -> clauses
forall r. RecFromTuple r => IsoRecTuple r -> r
recFromTuple @clauses
(//->)
:: ( CaseArrow name (Var x -> IndigoAnyOut x ret)
(IndigoCaseClauseL ret ('CaseClauseParam ctor ('OneField x)))
, ScopeCodeGen retBr
, ret ~ RetExprs retBr
, RetOutStack ret ~ RetOutStack retBr
, KnownValue x
, name ~ (AppendSymbol "c" ctor)
)
=> Label name
-> (Var x -> IndigoM retBr)
-> IndigoMCaseClauseL IndigoM ret ('CaseClauseParam ctor ('OneField x))
//-> :: Label name
-> (Var x -> IndigoM retBr)
-> IndigoMCaseClauseL
IndigoM ret ('CaseClauseParam ctor ('OneField x))
(//->) cName :: Label name
cName b :: Var x -> IndigoM retBr
b = Label name
-> (Var x -> IndigoM retBr)
-> IndigoMCaseClauseL
IndigoM ret ('CaseClauseParam ctor ('OneField x))
forall (name :: Symbol) x ret (ctor :: Symbol) retBr
(freer :: * -> *).
(CaseArrow
name
(Var x -> IndigoAnyOut x ret)
(IndigoCaseClauseL ret ('CaseClauseParam ctor ('OneField x))),
name ~ AppendSymbol "c" ctor, KnownValue x, ScopeCodeGen retBr,
ret ~ RetExprs retBr, RetOutStack ret ~ RetOutStack retBr) =>
Label name
-> (Var x -> freer retBr)
-> IndigoMCaseClauseL
freer ret ('CaseClauseParam ctor ('OneField x))
OneFieldIndigoMCaseClauseL Label name
cName Var x -> IndigoM retBr
b
infixr 0 //->
type IndigoFunction ret = IndigoM (RetVars ret)
type IndigoProcedure = IndigoM ()
type IndigoEntrypoint param = param -> IndigoProcedure
scope
:: forall a . ScopeCodeGen a
=> IndigoM a
-> IndigoFunction a
scope :: IndigoM a -> IndigoFunction a
scope = StatementF IndigoM (RetVars' (ClassifyReturnValue a) a)
-> IndigoFunction a
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars' (ClassifyReturnValue a) a)
-> IndigoFunction a)
-> (IndigoM a
-> StatementF IndigoM (RetVars' (ClassifyReturnValue a) a))
-> IndigoM a
-> IndigoFunction a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndigoM a
-> StatementF IndigoM (RetVars' (ClassifyReturnValue a) a)
forall res (freer :: * -> *).
ScopeCodeGen res =>
freer res -> StatementF freer (RetVars res)
Scope
defFunction
:: forall a . ScopeCodeGen a
=> IndigoM a
-> IndigoFunction a
defFunction :: IndigoM a -> IndigoFunction a
defFunction = IndigoM a -> IndigoFunction a
forall a. ScopeCodeGen a => IndigoM a -> IndigoFunction a
scope
defContract
:: (HasSideEffects => IndigoM ())
-> (HasSideEffects => IndigoProcedure)
defContract :: (HasSideEffects => IndigoM ()) -> HasSideEffects => IndigoM ()
defContract = (HasSideEffects => IndigoM ()) -> IndigoM ()
forall a. ScopeCodeGen a => IndigoM a -> IndigoFunction a
scope
defNamedEffLambda1
:: forall st argExpr res .
( ToExpr argExpr
, Typeable res
, ExecuteLambdaEff1C st (ExprType argExpr) res
, CreateLambdaEff1C st (ExprType argExpr) res)
=> String
-> (Var (ExprType argExpr) -> IndigoM res)
-> (argExpr -> IndigoM (RetVars res))
defNamedEffLambda1 :: String
-> (Var (ExprType argExpr) -> IndigoM res)
-> argExpr
-> IndigoM (RetVars res)
defNamedEffLambda1 lName :: String
lName body :: Var (ExprType argExpr) -> IndigoM res
body = \ex :: argExpr
ex ->
StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars res) -> IndigoM (RetVars res))
-> StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a b. (a -> b) -> a -> b
$ Proxy st
-> String
-> (Var (ExprType argExpr) -> IndigoM res)
-> Expr (ExprType argExpr)
-> StatementF IndigoM (RetVars res)
forall res arg res (freer :: * -> *).
(ExecuteLambdaEff1C res arg res, CreateLambdaEff1C res arg res,
Typeable res) =>
Proxy res
-> String
-> (Var arg -> freer res)
-> Expr arg
-> StatementF freer (RetVars res)
LambdaEff1Call (Proxy st
forall k (t :: k). Proxy t
Proxy @st) String
lName Var (ExprType argExpr) -> IndigoM res
body (argExpr -> Expr (ExprType argExpr)
forall a. ToExpr a => a -> Expr (ExprType a)
toExpr argExpr
ex)
defNamedLambda1
:: forall st argExpr res .
( ToExpr argExpr
, Typeable res
, ExecuteLambda1C st (ExprType argExpr) res
, CreateLambda1C st (ExprType argExpr) res)
=> String
-> (Var (ExprType argExpr) -> IndigoM res)
-> (argExpr -> IndigoM (RetVars res))
defNamedLambda1 :: String
-> (Var (ExprType argExpr) -> IndigoM res)
-> argExpr
-> IndigoM (RetVars res)
defNamedLambda1 lName :: String
lName body :: Var (ExprType argExpr) -> IndigoM res
body = \ex :: argExpr
ex ->
StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars res) -> IndigoM (RetVars res))
-> StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a b. (a -> b) -> a -> b
$ Proxy st
-> String
-> (Var (ExprType argExpr) -> IndigoM res)
-> Expr (ExprType argExpr)
-> StatementF IndigoM (RetVars res)
forall st arg res (freer :: * -> *).
(ExecuteLambda1C st arg res, CreateLambda1C st arg res,
Typeable res) =>
Proxy st
-> String
-> (Var arg -> freer res)
-> Expr arg
-> StatementF freer (RetVars res)
Lambda1Call (Proxy st
forall k (t :: k). Proxy t
Proxy @st) String
lName Var (ExprType argExpr) -> IndigoM res
body (argExpr -> Expr (ExprType argExpr)
forall a. ToExpr a => a -> Expr (ExprType a)
toExpr argExpr
ex)
defNamedLambda0
:: forall st res .
( Typeable res
, ExecuteLambda1C st () res
, CreateLambda1C st () res)
=> String
-> IndigoM res
-> IndigoM (RetVars res)
defNamedLambda0 :: String -> IndigoM res -> IndigoM (RetVars res)
defNamedLambda0 lName :: String
lName body :: IndigoM res
body = StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars res) -> IndigoM (RetVars res))
-> StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a b. (a -> b) -> a -> b
$ Proxy st
-> String
-> (Var () -> IndigoM res)
-> Expr ()
-> StatementF IndigoM (RetVars res)
forall st arg res (freer :: * -> *).
(ExecuteLambda1C st arg res, CreateLambda1C st arg res,
Typeable res) =>
Proxy st
-> String
-> (Var arg -> freer res)
-> Expr arg
-> StatementF freer (RetVars res)
Lambda1Call (Proxy st
forall k (t :: k). Proxy t
Proxy @st) String
lName (\(Var ()
_ :: Var ()) -> IndigoM res
body) (() -> Expr ()
forall a. NiceConstant a => a -> Expr a
C ())
defNamedPureLambda1
:: forall argExpr res .
( ToExpr argExpr
, Typeable res
, ExecuteLambdaPure1C (ExprType argExpr) res
, CreateLambdaPure1C (ExprType argExpr) res)
=> String
-> (Var (ExprType argExpr) -> IndigoM res)
-> (argExpr -> IndigoM (RetVars res))
defNamedPureLambda1 :: String
-> (Var (ExprType argExpr) -> IndigoM res)
-> argExpr
-> IndigoM (RetVars res)
defNamedPureLambda1 lName :: String
lName body :: Var (ExprType argExpr) -> IndigoM res
body = \ex :: argExpr
ex ->
StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (RetVars res) -> IndigoM (RetVars res))
-> StatementF IndigoM (RetVars res) -> IndigoM (RetVars res)
forall a b. (a -> b) -> a -> b
$ String
-> (Var (ExprType argExpr) -> IndigoM res)
-> Expr (ExprType argExpr)
-> StatementF IndigoM (RetVars res)
forall arg res (freer :: * -> *).
(ExecuteLambdaPure1C arg res, CreateLambdaPure1C arg res,
Typeable res) =>
String
-> (Var arg -> freer res)
-> Expr arg
-> StatementF freer (RetVars res)
LambdaPure1Call String
lName Var (ExprType argExpr) -> IndigoM res
body (argExpr -> Expr (ExprType argExpr)
forall a. ToExpr a => a -> Expr (ExprType a)
toExpr argExpr
ex)
while :: forall ex . ex :~> Bool => ex -> IndigoM () -> IndigoM ()
while :: ex -> IndigoM () -> IndigoM ()
while e :: ex
e body :: IndigoM ()
body = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> StatementF IndigoM () -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ ex -> IndigoM () -> StatementF IndigoM ()
forall ex (freer :: * -> *).
(ex :~> Bool) =>
ex -> freer () -> StatementF freer ()
While ex
e IndigoM ()
body
whileLeft
:: forall x y ex .
( ex :~> Either y x
, KnownValue y
, KnownValue x
)
=> ex
-> (Var y -> IndigoM ())
-> IndigoM (Var x)
whileLeft :: ex -> (Var y -> IndigoM ()) -> IndigoM (Var x)
whileLeft e :: ex
e body :: Var y -> IndigoM ()
body = StatementF IndigoM (Var x) -> IndigoM (Var x)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (Var x) -> IndigoM (Var x))
-> StatementF IndigoM (Var x) -> IndigoM (Var x)
forall a b. (a -> b) -> a -> b
$ ex -> (Var y -> IndigoM ()) -> StatementF IndigoM (Var x)
forall x y a (freer :: * -> *).
(KnownValue x, KnownValue y, a :~> Either y x) =>
a -> (Var y -> freer ()) -> StatementF freer (Var x)
WhileLeft ex
e Var y -> IndigoM ()
body
forEach
:: forall a e . (IterOpHs a, KnownValue (IterOpElHs a), e :~> a)
=> e -> (Var (IterOpElHs a) -> IndigoM ())
-> IndigoM ()
forEach :: e -> (Var (IterOpElHs a) -> IndigoM ()) -> IndigoM ()
forEach container :: e
container body :: Var (IterOpElHs a) -> IndigoM ()
body = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> StatementF IndigoM () -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ e -> (Var (IterOpElHs a) -> IndigoM ()) -> StatementF IndigoM ()
forall a e (freer :: * -> *).
(IterOpHs a, KnownValue (IterOpElHs a), e :~> a) =>
e -> (Var (IterOpElHs a) -> freer ()) -> StatementF freer ()
ForEach e
container Var (IterOpElHs a) -> IndigoM ()
body
doc :: DocItem di => di -> IndigoM ()
doc :: di -> IndigoM ()
doc di :: di
di = (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ())
-> (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ IndigoState inp inp () -> SomeIndigoState inp ()
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (IndigoState inp inp () -> SomeIndigoState inp ())
-> IndigoState inp inp () -> SomeIndigoState inp ()
forall a b. (a -> b) -> a -> b
$ di -> IndigoState inp inp ()
forall di (s :: [*]). DocItem di => di -> IndigoState s s ()
B.doc di
di
docGroup :: DocGrouping -> IndigoM () -> IndigoM ()
docGroup :: DocGrouping -> IndigoM () -> IndigoM ()
docGroup = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> (DocGrouping -> IndigoM () -> StatementF IndigoM ())
-> DocGrouping
-> IndigoM ()
-> IndigoM ()
forall a b c. SuperComposition a b c => a -> b -> c
... DocGrouping -> IndigoM () -> StatementF IndigoM ()
forall (freer :: * -> *).
DocGrouping -> freer () -> StatementF freer ()
DocGroup
docStorage :: forall storage. TypeHasDoc storage => IndigoM ()
docStorage :: IndigoM ()
docStorage = (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ())
-> (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ IndigoState inp inp () -> SomeIndigoState inp ()
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (IndigoState inp inp () -> SomeIndigoState inp ())
-> IndigoState inp inp () -> SomeIndigoState inp ()
forall a b. (a -> b) -> a -> b
$ forall (s :: [*]). TypeHasDoc storage => IndigoState s s ()
forall storage (s :: [*]). TypeHasDoc storage => IndigoState s s ()
B.docStorage @storage
contractName :: Text -> IndigoM () -> IndigoM ()
contractName :: Text -> IndigoM () -> IndigoM ()
contractName = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> (Text -> IndigoM () -> StatementF IndigoM ())
-> Text
-> IndigoM ()
-> IndigoM ()
forall a b c. SuperComposition a b c => a -> b -> c
... Text -> IndigoM () -> StatementF IndigoM ()
forall (freer :: * -> *). Text -> freer () -> StatementF freer ()
ContractName
contractGeneral :: IndigoM () -> IndigoM ()
contractGeneral :: IndigoM () -> IndigoM ()
contractGeneral = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> (IndigoM () -> StatementF IndigoM ())
-> IndigoM ()
-> IndigoM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndigoM () -> StatementF IndigoM ()
forall (freer :: * -> *). freer () -> StatementF freer ()
ContractGeneral
contractGeneralDefault :: IndigoM ()
contractGeneralDefault :: IndigoM ()
contractGeneralDefault = (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ())
-> (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ IndigoState inp inp () -> SomeIndigoState inp ()
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (IndigoState inp inp () -> SomeIndigoState inp ())
-> IndigoState inp inp () -> SomeIndigoState inp ()
forall a b. (a -> b) -> a -> b
$ IndigoState inp inp ()
forall (s :: [*]). IndigoState s s ()
B.contractGeneralDefault
finalizeParamCallingDoc
:: forall param x.
( ToExpr param
, NiceParameterFull (ExprType param)
, RequireSumType (ExprType param)
, HasCallStack
)
=> (Var (ExprType param) -> IndigoM x) -> (param -> IndigoM x)
finalizeParamCallingDoc :: (Var (ExprType param) -> IndigoM x) -> param -> IndigoM x
finalizeParamCallingDoc = StatementF IndigoM x -> IndigoM x
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM x -> IndigoM x)
-> ((Var (ExprType param) -> IndigoM x)
-> param -> StatementF IndigoM x)
-> (Var (ExprType param) -> IndigoM x)
-> param
-> IndigoM x
forall a b c. SuperComposition a b c => a -> b -> c
... (Var (ExprType param) -> IndigoM x)
-> param -> StatementF IndigoM x
forall param (freer :: * -> *) x.
(ToExpr param, NiceParameterFull (ExprType param),
RequireSumType (ExprType param), HasCallStack) =>
(Var (ExprType param) -> freer x) -> param -> StatementF freer x
FinalizeParamCallingDoc
selfCalling
:: forall p mname.
( NiceParameterFull p
, KnownValue (GetEntryPointArgCustom p mname)
)
=> EntryPointRef mname
-> IndigoM (Var (ContractRef (GetEntryPointArgCustom p mname)))
selfCalling :: EntryPointRef mname
-> IndigoM (Var (ContractRef (GetEntryPointArgCustom p mname)))
selfCalling ep :: EntryPointRef mname
ep = (forall (inp :: [*]).
SomeIndigoState
inp (Var (ContractRef (GetEntryPointArgCustom p mname))))
-> IndigoM (Var (ContractRef (GetEntryPointArgCustom p mname)))
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]).
SomeIndigoState
inp (Var (ContractRef (GetEntryPointArgCustom p mname))))
-> IndigoM (Var (ContractRef (GetEntryPointArgCustom p mname))))
-> (forall (inp :: [*]).
SomeIndigoState
inp (Var (ContractRef (GetEntryPointArgCustom p mname))))
-> IndigoM (Var (ContractRef (GetEntryPointArgCustom p mname)))
forall a b. (a -> b) -> a -> b
$ IndigoState
inp
(ContractRef (GetEntryPointArgCustom p mname) & inp)
(Var (ContractRef (GetEntryPointArgCustom p mname)))
-> SomeIndigoState
inp (Var (ContractRef (GetEntryPointArgCustom p mname)))
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (IndigoState
inp
(ContractRef (GetEntryPointArgCustom p mname) & inp)
(Var (ContractRef (GetEntryPointArgCustom p mname)))
-> SomeIndigoState
inp (Var (ContractRef (GetEntryPointArgCustom p mname))))
-> IndigoState
inp
(ContractRef (GetEntryPointArgCustom p mname) & inp)
(Var (ContractRef (GetEntryPointArgCustom p mname)))
-> SomeIndigoState
inp (Var (ContractRef (GetEntryPointArgCustom p mname)))
forall a b. (a -> b) -> a -> b
$ EntryPointRef mname
-> IndigoState
inp
(ContractRef (GetEntryPointArgCustom p mname) & inp)
(Var (ContractRef (GetEntryPointArgCustom p mname)))
forall p (inp :: [*]) (mname :: Maybe Symbol).
(NiceParameterFull p,
KnownValue (GetEntryPointArgCustom p mname)) =>
EntryPointRef mname
-> IndigoState
inp
(ContractRef (GetEntryPointArgCustom p mname) & inp)
(Var (ContractRef (GetEntryPointArgCustom p mname)))
B.selfCalling @p EntryPointRef mname
ep
contractCalling
:: forall cp epRef epArg addr exAddr.
( HasEntryPointArg cp epRef epArg
, ToTAddress cp addr
, ToT addr ~ ToT Address
, exAddr :~> addr
, KnownValue epArg
)
=> epRef -> exAddr -> IndigoM (Var (Maybe (ContractRef epArg)))
contractCalling :: epRef -> exAddr -> IndigoM (Var (Maybe (ContractRef epArg)))
contractCalling = StatementF IndigoM (Var (Maybe (ContractRef epArg)))
-> IndigoM (Var (Maybe (ContractRef epArg)))
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (Var (Maybe (ContractRef epArg)))
-> IndigoM (Var (Maybe (ContractRef epArg))))
-> (epRef
-> exAddr -> StatementF IndigoM (Var (Maybe (ContractRef epArg))))
-> epRef
-> exAddr
-> IndigoM (Var (Maybe (ContractRef epArg)))
forall a b c. SuperComposition a b c => a -> b -> c
... Proxy cp
-> epRef
-> exAddr
-> StatementF IndigoM (Var (Maybe (ContractRef epArg)))
forall exs param epArg ex a (freer :: * -> *).
(HasEntryPointArg exs param epArg, ToTAddress exs ex,
ToT ex ~ ToT Address, a :~> ex, KnownValue epArg) =>
Proxy exs
-> param -> a -> StatementF freer (Var (Maybe (ContractRef epArg)))
ContractCalling (Proxy cp
forall k (t :: k). Proxy t
Proxy @cp)
transferTokens
:: (IsExpr exp p, IsExpr exm Mutez, IsExpr exc (ContractRef p), NiceParameter p, HasSideEffects)
=> exp -> exm -> exc -> IndigoM ()
transferTokens :: exp -> exm -> exc -> IndigoM ()
transferTokens = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> (exp -> exm -> exc -> StatementF IndigoM ())
-> exp
-> exm
-> exc
-> IndigoM ()
forall a b c. SuperComposition a b c => a -> b -> c
... exp -> exm -> exc -> StatementF IndigoM ()
forall exp p exm exc (freer :: * -> *).
(exp :~> p, exm :~> Mutez, exc :~> ContractRef p, NiceParameter p,
HasSideEffects) =>
exp -> exm -> exc -> StatementF freer ()
TransferTokens
setDelegate :: (HasSideEffects, IsExpr ex (Maybe KeyHash)) => ex -> IndigoM ()
setDelegate :: ex -> IndigoM ()
setDelegate = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> (ex -> StatementF IndigoM ()) -> ex -> IndigoM ()
forall a b c. SuperComposition a b c => a -> b -> c
... ex -> StatementF IndigoM ()
forall ex (freer :: * -> *).
(HasSideEffects, ex :~> Maybe KeyHash) =>
ex -> StatementF freer ()
SetDelegate
createContract
:: ( IsObject st
, IsExpr exk (Maybe KeyHash), IsExpr exm Mutez, IsExpr exs st
, NiceStorage st, NiceParameterFull param
, HasSideEffects
)
=> (HasStorage st => Var param -> IndigoM ())
-> exk
-> exm
-> exs
-> IndigoM (Var Address)
createContract :: (HasStorage st => Var param -> IndigoM ())
-> exk -> exm -> exs -> IndigoM (Var Address)
createContract iCtr :: HasStorage st => Var param -> IndigoM ()
iCtr ek :: exk
ek em :: exm
em es :: exs
es = StatementF IndigoM (Var Address) -> IndigoM (Var Address)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (Var Address) -> IndigoM (Var Address))
-> StatementF IndigoM (Var Address) -> IndigoM (Var Address)
forall a b. (a -> b) -> a -> b
$ Contract param st
-> exk -> exm -> exs -> StatementF IndigoM (Var Address)
forall st exk exm exs param (freer :: * -> *).
(IsObject st, exk :~> Maybe KeyHash, exm :~> Mutez, exs :~> st,
NiceStorage st, NiceParameterFull param, HasSideEffects) =>
Contract param st
-> exk -> exm -> exs -> StatementF freer (Var Address)
CreateContract (ContractCode param st -> Contract param st
forall cp st. ContractCode cp st -> Contract cp st
defaultContract (ContractCode param st -> Contract param st)
-> ContractCode param st -> Contract param st
forall a b. (a -> b) -> a -> b
$ IndigoContract param st -> ContractCode param st
forall param st.
(KnownValue param, IsObject st) =>
IndigoContract param st -> ContractCode param st
compileIndigoContract IndigoContract param st
HasStorage st => Var param -> IndigoM ()
iCtr) exk
ek exm
em exs
es
createLorentzContract
:: ( IsObject st
, IsExpr exk (Maybe KeyHash), IsExpr exm Mutez, IsExpr exs st
, NiceStorage st, NiceParameterFull param
, HasSideEffects
)
=> L.Contract param st
-> exk
-> exm
-> exs
-> IndigoM (Var Address)
createLorentzContract :: Contract param st -> exk -> exm -> exs -> IndigoM (Var Address)
createLorentzContract lCtr :: Contract param st
lCtr ek :: exk
ek em :: exm
em es :: exs
es = StatementF IndigoM (Var Address) -> IndigoM (Var Address)
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM (Var Address) -> IndigoM (Var Address))
-> StatementF IndigoM (Var Address) -> IndigoM (Var Address)
forall a b. (a -> b) -> a -> b
$ Contract param st
-> exk -> exm -> exs -> StatementF IndigoM (Var Address)
forall st exk exm exs param (freer :: * -> *).
(IsObject st, exk :~> Maybe KeyHash, exm :~> Mutez, exs :~> st,
NiceStorage st, NiceParameterFull param, HasSideEffects) =>
Contract param st
-> exk -> exm -> exs -> StatementF freer (Var Address)
CreateContract Contract param st
lCtr exk
ek exm
em exs
es
assert
:: forall x ex.
( IsError x
, IsExpr ex Bool
)
=> x -> ex -> IndigoM ()
assert :: x -> ex -> IndigoM ()
assert = StatementF IndigoM () -> IndigoM ()
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM () -> IndigoM ())
-> (x -> ex -> StatementF IndigoM ()) -> x -> ex -> IndigoM ()
forall a b c. SuperComposition a b c => a -> b -> c
... x -> ex -> StatementF IndigoM ()
forall x ex (freer :: * -> *).
(IsError x, ex :~> Bool) =>
x -> ex -> StatementF freer ()
Assert
failWith
:: forall r a ex . IsExpr ex a
=> ex -> IndigoM r
failWith :: ex -> IndigoM r
failWith = StatementF IndigoM r -> IndigoM r
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM r -> IndigoM r)
-> (ex -> StatementF IndigoM r) -> ex -> IndigoM r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ex -> StatementF IndigoM r
forall ex a (freer :: * -> *) r.
(ex :~> a) =>
ex -> StatementF freer r
FailWith
failCustom
:: forall r tag err ex.
( err ~ ErrorArg tag
, CustomErrorHasDoc tag
, NiceConstant err
, ex :~> err
)
=> Label tag -> ex -> IndigoM r
failCustom :: Label tag -> ex -> IndigoM r
failCustom l :: Label tag
l errEx :: ex
errEx = StatementF IndigoM r -> IndigoM r
forall a. StatementF IndigoM a -> IndigoM a
oneIndigoM (StatementF IndigoM r -> IndigoM r)
-> StatementF IndigoM r -> IndigoM r
forall a b. (a -> b) -> a -> b
$ Label tag -> ex -> StatementF IndigoM r
forall err (tag :: Symbol) ex (freer :: * -> *) r.
(err ~ ErrorArg tag, CustomErrorHasDoc tag, NiceConstant err,
ex :~> err) =>
Label tag -> ex -> StatementF freer r
FailCustom Label tag
l ex
errEx
failCustom_
:: forall r tag notVoidErrorMsg.
( RequireNoArgError tag notVoidErrorMsg
, CustomErrorHasDoc tag
)
=> Label tag -> IndigoM r
failCustom_ :: Label tag -> IndigoM r
failCustom_ lab :: Label tag
lab = (forall (inp :: [*]). SomeIndigoState inp r) -> IndigoM r
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]). SomeIndigoState inp r) -> IndigoM r)
-> (forall (inp :: [*]). SomeIndigoState inp r) -> IndigoM r
forall a b. (a -> b) -> a -> b
$ IndigoState inp Any r -> SomeIndigoState inp r
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (IndigoState inp Any r -> SomeIndigoState inp r)
-> IndigoState inp Any r -> SomeIndigoState inp r
forall a b. (a -> b) -> a -> b
$ Label tag -> IndigoState inp Any r
forall (tag :: Symbol) (s :: [*]) (t :: [*]) r
(notVoidErrorMsg :: ErrorMessage).
(RequireNoArgError tag notVoidErrorMsg, CustomErrorHasDoc tag) =>
Label tag -> IndigoState s t r
B.failCustom_ Label tag
lab
failUnexpected_ :: MText -> IndigoM r
failUnexpected_ :: MText -> IndigoM r
failUnexpected_ tx :: MText
tx = (forall (inp :: [*]). SomeIndigoState inp r) -> IndigoM r
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]). SomeIndigoState inp r) -> IndigoM r)
-> (forall (inp :: [*]). SomeIndigoState inp r) -> IndigoM r
forall a b. (a -> b) -> a -> b
$ IndigoState inp Any r -> SomeIndigoState inp r
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (IndigoState inp Any r -> SomeIndigoState inp r)
-> IndigoState inp Any r -> SomeIndigoState inp r
forall a b. (a -> b) -> a -> b
$ MText -> IndigoState inp Any r
forall (s :: [*]) (t :: [*]) r. MText -> IndigoState s t r
B.failUnexpected_ MText
tx
assertCustom
:: forall tag err errEx ex .
( err ~ ErrorArg tag
, CustomErrorHasDoc tag
, NiceConstant err
, IsExpr errEx err
, IsExpr ex Bool
)
=> Label tag -> errEx -> ex -> IndigoM ()
assertCustom :: Label tag -> errEx -> ex -> IndigoM ()
assertCustom tag :: Label tag
tag errEx :: errEx
errEx e :: ex
e = Expr Bool -> IndigoM () -> IndigoM () -> IndigoM (RetVars ())
forall a b ex.
(IfConstraint a b, ex :~> Bool) =>
ex -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
if_ (ex -> Expr (ExprType ex)
forall a. ToExpr a => a -> Expr (ExprType a)
toExpr ex
e) (() -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (Label tag -> errEx -> IndigoM ()
forall r (tag :: Symbol) err ex.
(err ~ ErrorArg tag, CustomErrorHasDoc tag, NiceConstant err,
ex :~> err) =>
Label tag -> ex -> IndigoM r
failCustom Label tag
tag errEx
errEx :: IndigoM ())
assertCustom_
:: forall tag notVoidErrorMsg ex.
( RequireNoArgError tag notVoidErrorMsg
, CustomErrorHasDoc tag
, IsExpr ex Bool
)
=> Label tag -> ex -> IndigoM ()
assertCustom_ :: Label tag -> ex -> IndigoM ()
assertCustom_ tag :: Label tag
tag e :: ex
e = Expr Bool -> IndigoM () -> IndigoM () -> IndigoM (RetVars ())
forall a b ex.
(IfConstraint a b, ex :~> Bool) =>
ex -> IndigoM a -> IndigoM b -> IndigoM (RetVars a)
if_ (ex -> Expr (ExprType ex)
forall a. ToExpr a => a -> Expr (ExprType a)
toExpr ex
e) (() -> IndigoM ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()) (Label tag -> IndigoM ()
forall r (tag :: Symbol) (notVoidErrorMsg :: ErrorMessage).
(RequireNoArgError tag notVoidErrorMsg, CustomErrorHasDoc tag) =>
Label tag -> IndigoM r
failCustom_ Label tag
tag :: IndigoM ())
justComment :: Text -> IndigoM ()
= CommentType -> IndigoM ()
comment (CommentType -> IndigoM ())
-> (Text -> CommentType) -> Text -> IndigoM ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> CommentType
MT.JustComment
comment :: MT.CommentType -> IndigoM ()
t :: CommentType
t = (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a. (forall (inp :: [*]). SomeIndigoState inp a) -> IndigoM a
liftIndigoState ((forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ())
-> (forall (inp :: [*]). SomeIndigoState inp ()) -> IndigoM ()
forall a b. (a -> b) -> a -> b
$ IndigoState inp inp () -> SomeIndigoState inp ()
forall (inp :: [*]) (out :: [*]) a.
IndigoState inp out a -> SomeIndigoState inp a
toSIS (CommentType -> IndigoState inp inp ()
forall (i :: [*]). CommentType -> IndigoState i i ()
B.comment CommentType
t)
commentAroundFun :: Text -> IndigoM a -> IndigoM a
fName :: Text
fName body :: IndigoM a
body =
CommentType -> IndigoM ()
comment (Text -> CommentType
MT.FunctionStarts Text
fName) IndigoM () -> IndigoM a -> IndigoM a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
IndigoM a
body IndigoM a -> (a -> IndigoM a) -> IndigoM a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
\res :: a
res -> a
res a -> IndigoM () -> IndigoM a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ CommentType -> IndigoM ()
comment (Text -> CommentType
MT.FunctionEnds Text
fName)
commentAroundStmt :: Text -> IndigoM a -> IndigoM a
sName :: Text
sName body :: IndigoM a
body =
CommentType -> IndigoM ()
comment (Text -> CommentType
MT.StatementStarts Text
sName) IndigoM () -> IndigoM a -> IndigoM a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
IndigoM a
body IndigoM a -> (a -> IndigoM a) -> IndigoM a
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
\res :: a
res -> a
res a -> IndigoM () -> IndigoM a
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ CommentType -> IndigoM ()
comment (Text -> CommentType
MT.StatementEnds Text
sName)