Indigo.Backend.Scope

Machinery that provides the ability to return values from Indigo statements (like if, case, while, etc). You are allowed to return unit, one expression or a tuple of expressions. For instance:

(a, b) <- if flag
          then do
                 anotherFlag <- newVar True
                 return (5 +. var, anotherFlag ||. True)
          else return (0, anotherVar)

is a valid construction. Pay attention to the fact that 5 +. var has the type Expr Integer, but 0 is just an Integer and anotherFlag ||. True has type Expr Bool, but anotherVar has type Var Bool; and this code will compile anyway. This is done intentionally to avoid the burden of manually converting values to expressions (or variables). So you can write the same constructions as in a regular language.

Documentation

data BranchRetKind

To avoid overlapping instances we need to somehow distinguish single values from tuples, because the instances:

  instance Something a
  instance Something (a, b)

overlap and adding {-# OVERLAPPING #-} doesn't rescue in some cases, especially for type families defined in Something.

Constructors

Unit

If value is unit (don't return anything)

SingleVal

If it's a single value (not tuple)

Tuple

If it's tuple (we don't care how many elements are in)

type ScopeCodeGen ret = ScopeCodeGen' (ClassifyReturnValue ret) ret

class ReturnableValue' retKind ret => ScopeCodeGen' (retKind :: BranchRetKind) (ret :: Type) where

Type class which unions all related management of computations in a scope, like in if branch, in case body, etc.

Particularly, it takes care of the computation of expressions returning from a scope to leave it safely. Basically, this type class encapsulates the generation of Lorentz code that looks like:

  branch_code #
    -- we get some arbitrary type of a stack here, lets call it xs
  compute_returning_expressions #
    -- we get type of stack [e1, e2, ... ek] ++ xs
  cleanup_xs_to_inp
    -- we get [e1, e2, e3, ..., ek] ++ inp

Methods

compileScopeReturn' :: ret -> IndigoState xs (RetOutStack' retKind ret ++ xs) ()

Produces an Indigo computation that puts on the stack the evaluated returned expressions from the leaving scope.

liftClear' :: (xs :-> inp) -> (RetOutStack' retKind ret ++ xs) :-> (RetOutStack' retKind ret ++ inp)

Drop the stack cells that were produced in the leaving scope, apart from ones corresponding to the returning expressions.

genGcClear' :: (RetOutStack' retKind ret ++ inp) :-> inp

Generate gcClear for the whole statement

Instances

ScopeCodeGen' 'Unit ()

Defined in Indigo.Backend.Scope

Methods

compileScopeReturn' :: forall (xs :: [Type]). () -> IndigoState xs (RetOutStack' 'Unit () ++ xs) ()

liftClear' :: forall (xs :: [Type]) (inp :: [Type]). (xs :-> inp) -> (RetOutStack' 'Unit () ++ xs) :-> (RetOutStack' 'Unit () ++ inp)

genGcClear' :: forall (inp :: [Type]). (RetOutStack' 'Unit () ++ inp) :-> inp

KnownValueExpr single => ScopeCodeGen' 'SingleVal single

Defined in Indigo.Backend.Scope

Methods

compileScopeReturn' :: forall (xs :: [Type]). single -> IndigoState xs (RetOutStack' 'SingleVal single ++ xs) ()

liftClear' :: forall (xs :: [Type]) (inp :: [Type]). (xs :-> inp) -> (RetOutStack' 'SingleVal single ++ xs) :-> (RetOutStack' 'SingleVal single ++ inp)

genGcClear' :: forall (inp :: [Type]). (RetOutStack' 'SingleVal single ++ inp) :-> inp

(KnownValueExpr x, KnownValueExpr y) => ScopeCodeGen' 'Tuple (x, y)

Defined in Indigo.Backend.Scope

Methods

compileScopeReturn' :: forall (xs :: [Type]). (x, y) -> IndigoState xs (RetOutStack' 'Tuple (x, y) ++ xs) ()

liftClear' :: forall (xs :: [Type]) (inp :: [Type]). (xs :-> inp) -> (RetOutStack' 'Tuple (x, y) ++ xs) :-> (RetOutStack' 'Tuple (x, y) ++ inp)

genGcClear' :: forall (inp :: [Type]). (RetOutStack' 'Tuple (x, y) ++ inp) :-> inp

(KnownValueExpr x, KnownValueExpr y, KnownValueExpr z) => ScopeCodeGen' 'Tuple (x, y, z)

Defined in Indigo.Backend.Scope

Methods

compileScopeReturn' :: forall (xs :: [Type]). (x, y, z) -> IndigoState xs (RetOutStack' 'Tuple (x, y, z) ++ xs) ()

liftClear' :: forall (xs :: [Type]) (inp :: [Type]). (xs :-> inp) -> (RetOutStack' 'Tuple (x, y, z) ++ xs) :-> (RetOutStack' 'Tuple (x, y, z) ++ inp)

genGcClear' :: forall (inp :: [Type]). (RetOutStack' 'Tuple (x, y, z) ++ inp) :-> inp

type ReturnableValue ret = ReturnableValue' (ClassifyReturnValue ret) ret

class ReturnableValue' (retKind :: BranchRetKind) (ret :: Type) where

Class for values that can be returned from Indigo statements. They include () and tuples.

Associated Types

type RetOutStack' retKind ret :: [Type]

Type family reflecting the top elements of stack produced by a statement returning the value.

type RetVars' retKind ret :: Type

Type family reflecting the returning value from a statement.

type RetExprs' retKind ret :: Type

Tuple looking like (Expr x, Expr y, ..) that corresponds to expressions returning from the scope. 'RetVars'' and 'RetExprs'' are twin types because the former just adds Var over each expression of the latter.

Methods

allocateVars'

Arguments

:: (forall inpt x. KnownValue x => MetaData inpt -> (Var x, MetaData (x & inpt)))

Single variable allocator

-> MetaData inp

-> (RetVars' retKind ret, MetaData (RetOutStack' retKind ret ++ inp))

Allocate variables referring to result of the statement.

Instances

ReturnableValue' 'Unit ()

Defined in Indigo.Backend.Scope

Associated Types

type RetOutStack' 'Unit () :: [Type]

type RetVars' 'Unit ()

type RetExprs' 'Unit ()

Methods

allocateVars' :: forall (inp :: [Type]). (forall (inpt :: [Type]) x. KnownValue x => MetaData inpt -> (Var x, MetaData (x & inpt))) -> MetaData inp -> (RetVars' 'Unit (), MetaData (RetOutStack' 'Unit () ++ inp))

KnownValueExpr single => ReturnableValue' 'SingleVal single

Defined in Indigo.Backend.Scope

Associated Types

type RetOutStack' 'SingleVal single :: [Type]

type RetVars' 'SingleVal single

type RetExprs' 'SingleVal single

Methods

allocateVars' :: forall (inp :: [Type]). (forall (inpt :: [Type]) x. KnownValue x => MetaData inpt -> (Var x, MetaData (x & inpt))) -> MetaData inp -> (RetVars' 'SingleVal single, MetaData (RetOutStack' 'SingleVal single ++ inp))

(KnownValueExpr x, KnownValueExpr y) => ReturnableValue' 'Tuple (x, y)

Defined in Indigo.Backend.Scope

Associated Types

type RetOutStack' 'Tuple (x, y) :: [Type]

type RetVars' 'Tuple (x, y)

type RetExprs' 'Tuple (x, y)

Methods

allocateVars' :: forall (inp :: [Type]). (forall (inpt :: [Type]) x0. KnownValue x0 => MetaData inpt -> (Var x0, MetaData (x0 & inpt))) -> MetaData inp -> (RetVars' 'Tuple (x, y), MetaData (RetOutStack' 'Tuple (x, y) ++ inp))

(KnownValueExpr x, KnownValueExpr y, KnownValueExpr z) => ReturnableValue' 'Tuple (x, y, z)

Defined in Indigo.Backend.Scope

Associated Types

type RetOutStack' 'Tuple (x, y, z) :: [Type]

type RetVars' 'Tuple (x, y, z)

type RetExprs' 'Tuple (x, y, z)

Methods

allocateVars' :: forall (inp :: [Type]). (forall (inpt :: [Type]) x0. KnownValue x0 => MetaData inpt -> (Var x0, MetaData (x0 & inpt))) -> MetaData inp -> (RetVars' 'Tuple (x, y, z), MetaData (RetOutStack' 'Tuple (x, y, z) ++ inp))

type RetOutStack ret = RetOutStack' (ClassifyReturnValue ret) ret

type RetVars ret = RetVars' (ClassifyReturnValue ret) ret

type RetExprs ret = RetExprs' (ClassifyReturnValue ret) ret

type family ClassifyReturnValue (ret :: Type) where ...

This type family returns a promoted value of type BranchRetKind or causes a compilation error if a tuple with too many elements is used.

Equations

ClassifyReturnValue () = 'Unit

ClassifyReturnValue (_, _) = 'Tuple

ClassifyReturnValue (_, _, _) = 'Tuple

ClassifyReturnValue (_, _, _, _) = TypeError ('Text "Tuple with 4 elements is not supported yet as returning value")

ClassifyReturnValue (_, _, _, _, _) = TypeError ('Text "Tuple with 5 elements is not supported yet as returning value")

ClassifyReturnValue (_, _, _, _, _, _) = TypeError ('Text "Tuple with 6 elements is not supported yet as returning value")

ClassifyReturnValue _ = 'SingleVal

liftClear :: forall ret inp xs. ScopeCodeGen ret => (xs :-> inp) -> (RetOutStack ret ++ xs) :-> (RetOutStack ret ++ inp)

Specific version of 'liftClear''

compileScope :: forall ret inp xs. ScopeCodeGen ret => GenCode inp xs ret -> inp :-> (RetOutStack ret ++ inp)

Concatenate a scoped code, generation of returning expressions, and clean up of redundant cells from the stack.

allocateVars :: forall ret inp. ReturnableValue ret => (forall inpt x. KnownValue x => MetaData inpt -> (Var x, MetaData (x & inpt))) -> MetaData inp -> (RetVars ret, MetaData (RetOutStack ret ++ inp))

Specific version of 'allocateVars''

finalizeStatement :: forall ret inp. ScopeCodeGen ret => MetaData inp -> (inp :-> (RetOutStack ret ++ inp)) -> GenCode inp (RetOutStack ret ++ inp) (RetVars ret)

Push a variables in MetaData, referring to the generated expressions, and generate gcClear for the whole statement.