{-# OPTIONS_GHC -Wno-redundant-constraints #-}
module Language.Drasil.Code.Imperative.Import (codeType, spaceCodeType,
  publicFunc, publicFuncProc, privateMethod, privateFuncProc, publicInOutFunc,
  publicInOutFuncProc, privateInOutMethod, privateInOutFuncProc, genConstructor,
  mkVar, mkVarProc, mkVal, mkValProc, convExpr, convExprProc, convStmt,
  convStmtProc, genModDef, genModDefProc, genModFuncs, genModFuncsProc,
  genModClasses, readData, readDataProc, renderC
) where

import Prelude hiding (sin, cos, tan, log, exp)
import Control.Lens ((^.))
import qualified Data.Map as Map (lookup)
import Control.Monad (liftM2,liftM3)
import Control.Monad.State (get, modify)
import Data.List ((\\), intersect)

import Drasil.Code.CodeExpr (sy, ($<), ($>), ($<=), ($>=), ($&&), in')
import Drasil.Code.CodeVar (CodeIdea(codeName), CodeVarChunk, obv, quantvar,
  quantfunc, DefiningCodeExpr(..))
import qualified Drasil.Code.CodeExpr.Development as S (CodeExpr(..))
import Drasil.Code.CodeExpr.Development (CodeExpr(..), ArithBinOp(..),
  AssocArithOper(..), AssocBoolOper(..), AssocConcatOper(..), EqBinOp(..),
  LABinOp(..), OrdBinOp(..), UFunc(..), UFuncB(..), UFuncVV(..), UFuncVN(..),
  VVNBinOp(..), VVVBinOp(..), NVVBinOp(..), ESSBinOp(..), ESBBinOp(..))
import Drasil.Database (UID, HasUID(..), IsChunk)
import Language.Drasil (HasSymbol, HasSpace(..),
  Space (Rational, Real), RealInterval(..), Constraint(..), Inclusive (..))
import Language.Drasil.Code.Imperative.Comments (renderTermAndUnit)
import Language.Drasil.Code.Imperative.ConceptMatch (conceptToGOOL)
import Language.Drasil.Code.Imperative.GenerateGOOL (auxClass, fApp, fAppProc,
  ctorCall, genModuleWithImports, genModuleWithImportsProc, primaryClass)
import Language.Drasil.Code.Imperative.Helpers (convScope)
import Language.Drasil.Code.Imperative.Logging (logBody)
import Language.Drasil.Code.Imperative.DrasilState (GenState, DrasilState(..),
  ScopeType(..), genICName, lookupC, HasChoices(..))
import Language.Drasil.Chunk.Code (ccObjVar)
import Language.Drasil.Chunk.Parameter (ParameterChunk(..), PassBy(..), pcAuto)
import Language.Drasil.Code.CodeQuantityDicts (inFileName, inParams, consts)
import Language.Drasil.Choices (Comments(..), ConstantRepr(..),
  ConstantStructure(..), Structure(..), InternalConcept(..))
import Language.Drasil.CodeSpec (HasCodeSpec(..))
import Language.Drasil.Code.DataDesc (DataItem, LinePattern(Repeat, Straight),
  Data(Line, Lines, JunkData, Singleton), DataDesc, isLine, isLines, getInputs,
  getPatternInputs)
import Language.Drasil.Literal.Development
import Language.Drasil.Mod (Func(..), FuncData(..), FuncDef(..), FuncStmt(..),
  Mod(..), Name, Description, StateVariable(..), fstdecl)
import qualified Language.Drasil.Mod as M (Class(..))
import Language.Drasil.Printers (oneLineCodeSymbolDoc)

import Drasil.GOOL (Label, CSStateVar, NamedArgs, Initializers, OOProg, CS, FS,
  MS, VS, AttachmentSym(..), bodyStatements, BlockSym(..), TypeSym(..),
  OOTypeSym(..), VariableSym(..), VariableElim(..), VariableValue(..),
  ScopeSym(..), OOVariableSym(..), SelfSym(..), instanceVarSelf,
  VariableElim(..), ($->), ValueSym(..), Literal(..), VariableValue(..),
  NumericExpression(..), BooleanExpression(..), Comparison(..),
  ValueExpression(..), OOValueExpression(..), objMethodCallMixedArgs,
  Reference(..), Array(..), List(..), ListStatement(..), MultiStatement(..),
  ValueStatement(..), AssignStatement(..), DeclStatement(..), FileHandling(..),
  ReadFile(..), StringStatement(..), ControlStatement(..), ifNoElse,
  VisibilitySym(..), ParameterSym(..), MethodSym(..), OOMethodSym(..), pubDVar,
  privDVar, nonInitConstructor, convType, convTypeOO, VisibilityTag(..),
  CodeType(..), onStateValue, TypeElim, OODeclStatement, MathConstant, Argument,
  PrintFile, BodySym, InternalValueExp)
import qualified Drasil.GOOL as OO (CodeType(List, Array), Set(..), Literal)
import Drasil.GProc (ProcProg, NativeVector(..))
import Drasil.System (systemdb)

-- | Gets a chunk's 'CodeType', by checking which 'CodeType' the user has chosen to
-- match the chunk's 'Space' to.
codeType :: (HasSpace c) => c -> GenState CodeType
codeType :: forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType c
c = Space -> StateT DrasilState Identity CodeType
spaceCodeType (c
c c -> Getting Space c Space -> Space
forall s a. s -> Getting a s a -> a
^. Getting Space c Space
forall c. HasSpace c => Getter c Space
Getter c Space
typ)

-- | Gets the 'CodeType' for a 'Space', based on the user's choice.
spaceCodeType :: Space -> GenState CodeType
spaceCodeType :: Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
s = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  (g ^. spaceMatches) s

-- | If 'UID' for the variable is matched to a concept, call 'conceptToGOOL' to get
-- the GOOL code for the concept, and return.
-- If 'UID' is for a constant and user has chosen 'Inline', convert the constant's
-- defining 'Expr' to a value with 'convExpr'.
-- Otherwise, just a regular variable: construct it by calling the variable, then
-- call 'valueOf' to reference its value.
value
  ::
    ( ValueSym r val typ
    , Argument r val
    , OO.Literal r val typ
    , MathConstant r val
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , SelfSym r var
    , InternalValueExp r var val typ
    , ValueExpression r var val binder typ
    , OOValueExpression r var val typ
    , List r val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => UID -> Name -> VS (r typ) -> GenState (VS (r val))
value :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, Literal r val typ,
 MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, SelfSym r var,
 InternalValueExp r var val typ,
 ValueExpression r var val binder typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
UID -> Name -> VS (r typ) -> GenState (VS (r val))
value UID
u Name
s VS (r typ)
t = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let cs = DrasilState
g
      mm = DrasilState
cs DrasilState
-> Getting ConstantMap DrasilState ConstantMap -> ConstantMap
forall s a. s -> Getting a s a -> a
^. Getting ConstantMap DrasilState ConstantMap
forall c. HasCodeSpec c => Lens' c ConstantMap
Lens' DrasilState ConstantMap
constMap
      constDef = do
        cd <- UID -> ConstantMap -> Maybe CodeDefinition
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup UID
u ConstantMap
mm
        maybeInline (g ^. conStruct) cd
      maybeInline ConstantStructure
Inline a
m = a -> Maybe a
forall a. a -> Maybe a
Just a
m
      maybeInline ConstantStructure
_ a
_ = Maybe a
forall a. Maybe a
Nothing
      cm = DrasilState
g DrasilState
-> Getting MatchedConceptMap DrasilState MatchedConceptMap
-> MatchedConceptMap
forall s a. s -> Getting a s a -> a
^. Getting MatchedConceptMap DrasilState MatchedConceptMap
forall a. HasChoices a => Lens' a MatchedConceptMap
Lens' DrasilState MatchedConceptMap
concMatches
      cdCncpt = UID -> MatchedConceptMap -> Maybe CodeConcept
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup UID
u MatchedConceptMap
cm
  val <- maybe (valueOf <$> variable s t) (convExpr . (^. codeExpr)) constDef
  pure $ maybe val conceptToGOOL cdCncpt

-- | If variable is an input, construct it with 'var' and pass to inputVariable.
-- If variable is a constant and 'Var' constant representation is chosen,
-- construct it with 'var' and pass to 'constVariable'.
-- If variable is a constant and 'Const' constant representation is chosen,
-- construct it with 'classConst' and pass to 'constVariable'.
-- If variable is neither, just construct it with 'var' and return it.
variable
  ::
    ( TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , SelfSym r var
    , VariableElim r var typ
    , VariableValue r var val
    )
  => Name -> VS (r typ) -> GenState (VS (r var))
variable :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Name -> VS (r typ) -> GenState (VS (r var))
variable Name
s VS (r typ)
t = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let cs = DrasilState
g
      defFunc ConstantRepr
Var = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var
      defFunc ConstantRepr
Const = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
Name -> VS (r typ) -> VS (r var)
classConst
  if s `elem` fmap codeName (cs ^. inputs)
    then inputVariable (g ^. inStruct) Var (var s t)
    else if s `elem` fmap codeName (cs ^. constDefns)
      then constVariable (g ^. conStruct) (g ^. conRepr)
              ((defFunc $ g ^. conRepr) s t)
      else pure $ var s t

-- | If 'Unbundled' inputs, just return variable as-is.
-- If 'Bundled' inputs, access variable through object, where the object is self
-- if current module is InputParameters, 'inParams' otherwise.
-- Final case is for when 'constVariable' calls inputVariable, when user chooses
-- WithInputs for constant structure, inputs are 'Bundled', and constant
-- representation is 'Const'. Variable should be accessed through class, so
-- 'classVariable' is called.
inputVariable
  ::
    ( TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , SelfSym r var
    , VariableElim r var typ
    , VariableValue r var val
    )
  => Structure -> ConstantRepr -> VS (r var) -> GenState (VS (r var))
inputVariable :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Structure -> ConstantRepr -> VS (r var) -> GenState (VS (r var))
inputVariable Structure
Unbundled ConstantRepr
_ VS (r var)
v = VS (r var) -> StateT DrasilState Identity (VS (r var))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure VS (r var)
v
inputVariable Structure
Bundled ConstantRepr
Var VS (r var)
v = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  inClsName <- genICName InputParameters
  ip <- mkVar (quantvar inParams)
  pure $ if currentClass g == inClsName then instanceVarSelf v else valueOf ip $-> v
inputVariable Structure
Bundled ConstantRepr
Const VS (r var)
v = do
  ip <- Input -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar (DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar DefinedQuantityDict
inParams)
  classVariable ip v

-- | If 'Unbundled' constants, just return variable as-is.
-- If 'Bundled' constants and 'Var' constant representation, access variable
-- through 'consts' object.
-- If 'Bundled' constants and 'Const' constant representation, access variable
-- through class, so call 'classVariable'.
-- If constants stored 'WithInputs', call 'inputVariable'.
-- If constants are 'Inline'd, the generator should not be attempting to make a
-- variable for one of the constants.
constVariable
  ::
    ( TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , SelfSym r var
    , VariableElim r var typ
    , VariableValue r var val
    )
  => ConstantStructure -> ConstantRepr -> VS (r var) -> GenState (VS (r var))
constVariable :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
ConstantStructure
-> ConstantRepr -> VS (r var) -> GenState (VS (r var))
constVariable (Store Structure
Unbundled) ConstantRepr
_ VS (r var)
v = VS (r var) -> StateT DrasilState Identity (VS (r var))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure VS (r var)
v
constVariable (Store Structure
Bundled) ConstantRepr
Var VS (r var)
v = do
  cs <- Input -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar (DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar DefinedQuantityDict
consts)
  pure $ valueOf cs $-> v
constVariable (Store Structure
Bundled) ConstantRepr
Const VS (r var)
v = do
  cs <- Input -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar (DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar DefinedQuantityDict
consts)
  classVariable cs v
constVariable ConstantStructure
WithInputs ConstantRepr
cr VS (r var)
v = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  inputVariable (g ^. inStruct) cr v
constVariable ConstantStructure
Inline ConstantRepr
_ VS (r var)
_ = Name -> StateT DrasilState Identity (VS (r var))
forall a. HasCallStack => Name -> a
error (Name -> StateT DrasilState Identity (VS (r var)))
-> Name -> StateT DrasilState Identity (VS (r var))
forall a b. (a -> b) -> a -> b
$ Name
"mkVar called on a constant, but user " Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<>
  Name
"chose to Inline constants. Generator has a bug."

-- | For generating GOOL for a variable that is accessed through a class.
-- If the variable is not in the export map, then it is not a public class variable
-- and cannot be accessed, so throw an error.
-- If the variable is exported by the current module, use 'classVarAccess'.
-- If the variable is exported by a different module, use 'extClassVarAccess'.
classVariable
  :: (OOVariableSym r var val typ, VariableElim r var typ)
  => VS (r var) -> VS (r var) -> GenState (VS (r var))
classVariable :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(OOVariableSym r var val typ, VariableElim r var typ) =>
VS (r var) -> VS (r var) -> GenState (VS (r var))
classVariable VS (r var)
c VS (r var)
v = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let checkCurrent Name
m = if DrasilState -> Name
currentModule DrasilState
g Name -> Name -> Bool
forall a. Eq a => a -> a -> Bool
== Name
m then VS (r typ) -> VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r typ) -> VS (r var) -> VS (r var)
classVarAccess else VS (r typ) -> VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r typ) -> VS (r var) -> VS (r var)
extClassVarAccess
  pure $ do
    v' <- v
    let nm = r var -> Name
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> Name
variableName r var
v'
    maybe (error $ "Variable " <> nm <> " missing from export map")
      checkCurrent (Map.lookup nm (eMap g)) (onStateValue variableType c) v

-- | Generates a GOOL Value for a variable represented by a 'CodeVarChunk'.
mkVal
  ::
    ( ValueSym r val typ
    , Argument r val
    , OO.Literal r val typ
    , MathConstant r val
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , SelfSym r var
    , InternalValueExp r var val typ
    , OOValueExpression r var val typ
    , List r val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => CodeVarChunk -> GenState (VS (r val))
mkVal :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, Literal r val typ,
 MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
Input -> GenState (VS (r val))
mkVal Input
v = do
  t <- Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v
  let toGOOLVal Maybe CodeChunk
Nothing = UID -> Name -> VS (r typ) -> GenState (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, Literal r val typ,
 MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, SelfSym r var,
 InternalValueExp r var val typ,
 ValueExpression r var val binder typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
UID -> Name -> VS (r typ) -> GenState (VS (r val))
value (Input
v Input -> Getting UID Input UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID Input UID
forall c. HasUID c => Getter c UID
Getter Input UID
uid) (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t)
      toGOOLVal (Just CodeChunk
o) = do
        ot <- CodeChunk -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType CodeChunk
o
        pure $ valueOf $ instanceVarAccess (valueOf $ var (codeName o) (convTypeOO ot))
          (var (codeName v) (convTypeOO t))
  toGOOLVal (v ^. obv)

-- | Generates a GOOL Variable for a variable represented by a 'CodeVarChunk'.
mkVar
  ::
    ( TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , SelfSym r var
    , VariableElim r var typ
    , VariableValue r var val
    )
  => CodeVarChunk -> GenState (VS (r var))
mkVar :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar Input
v = do
  t <- Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v
  let toGOOLVar Maybe CodeChunk
Nothing = Name -> VS (r typ) -> GenState (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Name -> VS (r typ) -> GenState (VS (r var))
variable (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t)
      toGOOLVar (Just CodeChunk
o) = do
        ot <- CodeChunk -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType CodeChunk
o
        pure $ instanceVarAccess (valueOf $ var (codeName o) (convTypeOO ot))
          (var (codeName v) (convTypeOO t))
  toGOOLVar (v ^. obv)

-- | Generates a GOOL Parameter for a parameter represented by a 'ParameterChunk'.
mkParam
  ::
    ( TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , SelfSym r var
    , ParameterSym r param var
    , VariableElim r var typ
    )
  => ParameterChunk -> GenState (MS (r param))
mkParam :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (param :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 SelfSym r var, ParameterSym r param var, VariableElim r var typ) =>
ParameterChunk -> GenState (MS (r param))
mkParam ParameterChunk
p = do
  v <- Input -> GenState (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar (ParameterChunk -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar ParameterChunk
p)
  pure $ paramFunc (passBy p) v
  where paramFunc :: PassBy -> VS (r var) -> MS (r param)
paramFunc PassBy
Ref = VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
pointerParam
        paramFunc PassBy
Val = VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param

-- | Generates a public function.
publicFunc
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> VS (r typ)
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
publicFunc :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicFunc Name
n VS (r typ)
t Name
desc [ParameterChunk]
ps Maybe Name
r [MS (r block)]
b = do
  (DrasilState -> DrasilState) -> StateT DrasilState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethod (Name
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public VS (r typ)
t) Name
n Name
desc [ParameterChunk]
ps Maybe Name
r [MS (r block)]
b

-- | Generates a public method.
publicMethod
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> VS (r typ)
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
publicMethod :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicMethod Name
n VS (r typ)
t = do
  ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethod (Name
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
Name
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel VS (r typ)
t) Name
n

-- | Generates a private method.
privateMethod
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> VS (r typ)
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
privateMethod :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
privateMethod Name
n VS (r typ)
t = do
  ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethod (Name
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
Name
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel VS (r typ)
t) Name
n

-- | Generates a public function, defined by its inputs and outputs.
publicInOutFunc
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> Description
  -> [CodeVarChunk]
  -> [CodeVarChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
publicInOutFunc :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
publicInOutFunc Name
n = ([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (scope :: k) (stmt :: k) (bod :: k) (block :: k) (mthd :: k).
(Literal r val typ, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, SelfSym r var, ScopeSym r scope,
 MultiStatement r stmt, DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 VariableElim r var typ) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
genInOutFunc (Name
-> r vis
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name -> r vis -> InOutFunc r mthd bod var
inOutFunc Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public) (Name
-> r vis
-> Name
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name -> r vis -> DocInOutFunc r mthd bod var
docInOutFunc Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public) Name
n

-- | Generates a private method, defined by its inputs and outputs.
privateInOutMethod
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> Description
  -> [CodeVarChunk]
  -> [CodeVarChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
privateInOutMethod :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
privateInOutMethod Name
n = ([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (scope :: k) (stmt :: k) (bod :: k) (block :: k) (mthd :: k).
(Literal r val typ, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, SelfSym r var, ScopeSym r scope,
 MultiStatement r stmt, DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 VariableElim r var typ) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
genInOutFunc (Name
-> r vis
-> r attch
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
Name -> r vis -> r attch -> InOutFunc r mthd bod var
inOutMethod Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel)
  (Name
-> r vis
-> r attch
-> Name
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
Name -> r vis -> r attch -> DocInOutFunc r mthd bod var
docInOutMethod Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel) Name
n

-- | Generates a constructor.
genConstructor
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> Description
  -> [ParameterChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
genConstructor :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> Name
-> [ParameterChunk]
-> [MS (r block)]
-> GenState (MS (r mthd))
genConstructor Name
n Name
desc [ParameterChunk]
p = do
  ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethod [MS (r param)] -> MS (r bod) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
[MS (r param)] -> MS (r bod) -> MS (r mthd)
nonInitConstructor Name
n Name
desc [ParameterChunk]
p Maybe Name
forall a. Maybe a
Nothing

-- | Generates a constructor that includes initialization of variables.
genInitConstructor
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> Description
  -> [ParameterChunk]
  -> Initializers r var val
  -> [MS (r block)]
  -> GenState (MS (r mthd))
genInitConstructor :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> Name
-> [ParameterChunk]
-> Initializers r var val
-> [MS (r block)]
-> GenState (MS (r mthd))
genInitConstructor Name
n Name
desc [ParameterChunk]
p Initializers r var val
is = ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethod ([MS (r param)]
-> Initializers r var val -> MS (r bod) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
[MS (r param)]
-> Initializers r var val -> MS (r bod) -> MS (r mthd)
`constructor` Initializers r var val
is) Name
n Name
desc [ParameterChunk]
p
  Maybe Name
forall a. Maybe a
Nothing

-- | Generates a function or method using the passed GOOL constructor. Other
-- parameters are the method's name, description, list of parameters,
-- description of what is returned (if applicable), and body.
genMethod
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => ([MS (r param)] -> MS (r bod) -> MS (r mthd))
  -> Label
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
genMethod :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethod [MS (r param)] -> MS (r bod) -> MS (r mthd)
f Name
n Name
desc [ParameterChunk]
p Maybe Name
r [MS (r block)]
b = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  vars <- mapM (mkVar . quantvar) p
  ps <- mapM mkParam p
  bod <- logBody n vars b
  let fn = [MS (r param)] -> MS (r bod) -> MS (r mthd)
f [MS (r param)]
ps MS (r bod)
bod
  pComms <- mapM renderTermAndUnit p
  pure $ if CommentFunc `elem` g ^. commented
    then docFunc desc pComms r fn else fn

-- | Generates a function or method defined by its inputs and outputs.
-- Parameters are: the GOOL constructor to use, the equivalent GOOL constructor
-- for a documented function/method, the visibility, attachment, name, description,
-- list of inputs, list of outputs, and body.
genInOutFunc
  ::
    ( OO.Literal r val typ
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , SelfSym r var
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , BlockSym r block stmt
    , BodySym r bod block
    , VariableElim r var typ
    )
  => ([VS (r var)] -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
  -> (String -> [(String, VS (r var))] -> [(String, VS (r var))] -> [(String, VS (r var))] -> MS (r bod) -> MS (r mthd))
  -> Label
  -> Description
  -> [CodeVarChunk]
  -> [CodeVarChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
genInOutFunc :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (scope :: k) (stmt :: k) (bod :: k) (block :: k) (mthd :: k).
(Literal r val typ, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, SelfSym r var, ScopeSym r scope,
 MultiStatement r stmt, DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 VariableElim r var typ) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
genInOutFunc [VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f Name
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
docf Name
n Name
desc [Input]
ins' [Input]
outs' [MS (r block)]
b = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  let ins = [Input]
ins' [Input] -> [Input] -> [Input]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Input]
outs'
      outs = [Input]
outs' [Input] -> [Input] -> [Input]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Input]
ins'
      both = [Input]
ins' [Input] -> [Input] -> [Input]
forall a. Eq a => [a] -> [a] -> [a]
`intersect` [Input]
outs'
  inVs <- mapM mkVar ins
  outVs <- mapM mkVar outs
  bothVs <- mapM mkVar both
  bod <- logBody n (bothVs <> inVs) b
  pComms <- mapM renderTermAndUnit ins
  oComms <- mapM renderTermAndUnit outs
  bComms <- mapM renderTermAndUnit both
  pure $ if CommentFunc `elem` g ^. commented
    then docf desc (zip pComms inVs) (zip oComms outVs) (zip
    bComms bothVs) bod else f inVs outVs bothVs bod

-- | Converts an 'Expr' to a GOOL Value.
convExpr
  ::
    ( ValueSym r val typ
    , Argument r val
    , MathConstant r val
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , OO.Literal r val typ
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , SelfSym r var
    , InternalValueExp r var val typ
    , OOValueExpression r var val typ
    , List r val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => CodeExpr -> GenState (VS (r val))
convExpr :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr (Lit (Dbl Double
d)) = do
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
Real
  let getLiteral CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble Double
d
      getLiteral CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Double -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
d)
      getLiteral CodeType
_ = Name -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExpr: Real space matched to invalid CodeType; should be Double or Float"
  pure $ getLiteral sm
convExpr (Lit (ExactDbl Integer
d)) = CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall a b. (a -> b) -> a -> b
$ Literal -> CodeExpr
Lit (Literal -> CodeExpr) -> (Double -> Literal) -> Double -> CodeExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Literal
Dbl (Double -> CodeExpr) -> Double -> CodeExpr
forall a b. (a -> b) -> a -> b
$ Integer -> Double
forall a. Num a => Integer -> a
fromInteger Integer
d
convExpr (Lit (Int Integer
i))      = VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r val) -> StateT DrasilState Identity (VS (r val)))
-> VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a b. (a -> b) -> a -> b
$ Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
i
convExpr (Lit (Str Name
s))      = VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r val) -> StateT DrasilState Identity (VS (r val)))
-> VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a b. (a -> b) -> a -> b
$ Name -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Name -> VS (r val)
litString Name
s
convExpr (Lit (Perc Integer
a Integer
b)) = do
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
Rational
  let getLiteral CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble
      getLiteral CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Float -> VS (r val)) -> (Double -> Float) -> Double -> VS (r val)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac
      getLiteral CodeType
_ = Name -> Double -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExpr: Rational space matched to invalid CodeType; should be Double or Float"
  pure $ getLiteral sm (fromIntegral a / (10 ** fromIntegral b))
convExpr (AssocA AssocArithOper
Add [CodeExpr]
l) = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#+)  ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
convExpr (AssocA AssocArithOper
Mul [CodeExpr]
l) = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#*)  ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
convExpr (AssocB AssocBoolOper
And [CodeExpr]
l) = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?&&) ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
convExpr (AssocB AssocBoolOper
Or [CodeExpr]
l)  = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?||) ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
convExpr (AssocC AssocConcatOper
SUnion [CodeExpr]
l)  = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#+) ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
convExpr (C UID
c)   = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let v = DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
c)
  mkVal v
convExpr (FCall UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns) = UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> StateT DrasilState Identity (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> GenState (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> GenState (VS (r val))
convCall UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, VariableValue r var val,
 SelfSym r var, InternalValueExp r var val typ,
 ValueExpression r var val binder typ, TypeElim r typ) =>
Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
fApp Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
Name -> MixedCall r var val typ
libFuncAppMixedArgs
convExpr (New UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns) = UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> StateT DrasilState Identity (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> GenState (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> GenState (VS (r val))
convCall UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns (\Name
m Name
_ -> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k).
(ValueSym r val typ, Argument r val,
 OOValueExpression r var val typ, TypeElim r typ) =>
Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
ctorCall Name
m)
  (\Name
m Name
_ -> Name
-> VS (r typ) -> [VS (r val)] -> NamedArgs r var val -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
Name -> MixedCtorCall r var val typ
libNewObjMixedArgs Name
m)
convExpr (Message UID
a UID
m [CodeExpr]
x [(UID, CodeExpr)]
ns) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let objCd = DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
a)
  o <- mkVal objCd
  convCall m x ns
    (\Name
_ Name
n VS (r typ)
t [VS (r val)]
ps NamedArgs r var val
nas -> VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r typ)
-> VS (r val)
-> Name
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ)
-> VS (r val)
-> Name
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
objMethodCallMixedArgs VS (r typ)
t VS (r val)
o Name
n [VS (r val)]
ps NamedArgs r var val
nas))
    (\Name
_ Name
n VS (r typ)
t -> VS (r typ)
-> VS (r val)
-> Name
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ)
-> VS (r val)
-> Name
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
objMethodCallMixedArgs VS (r typ)
t VS (r val)
o Name
n)
convExpr (Field UID
o UID
f) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let ob  = DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
o)
      fld = DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
f)
  v <- mkVar (ccObjVar ob fld)
  pure $ valueOf v
convExpr (UnaryOp UFunc
o CodeExpr
u)    = UFunc -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
(NumericExpression r val, Reference r val) =>
UFunc -> VS (r val) -> VS (r val)
unop UFunc
o (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
u
convExpr (UnaryOpB UFuncB
o CodeExpr
u)   = UFuncB -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
UFuncB -> VS (r val) -> VS (r val)
unopB UFuncB
o (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
u
convExpr (UnaryOpVV UFuncVV
o CodeExpr
u)  = UFuncVV -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
UFuncVV -> VS (r val) -> VS (r val)
unopVV UFuncVV
o (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
u
convExpr (UnaryOpVN UFuncVN
o CodeExpr
u)  = UFuncVN -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
UFuncVN -> VS (r val) -> VS (r val)
unopVN UFuncVN
o (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
u
convExpr (ArithBinaryOp ArithBinOp
Frac (Lit (Int Integer
a)) (Lit (Int Integer
b))) = do -- hack to deal with integer division
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
Rational
  let getLiteral CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble (Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
a) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble (Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
b)
      getLiteral CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
a) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
b)
      getLiteral CodeType
_ = Name -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExpr: Rational space matched to invalid CodeType; should be Double or Float"
  pure $ getLiteral sm
convExpr (ArithBinaryOp ArithBinOp
o CodeExpr
a CodeExpr
b) = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (ArithBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
ArithBinOp -> VS (r val) -> VS (r val) -> VS (r val)
arithBfunc ArithBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (LABinaryOp LABinOp
o CodeExpr
a CodeExpr
b)    = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (LABinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
LABinOp -> VS (r val) -> VS (r val) -> VS (r val)
laBfunc LABinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (EqBinaryOp EqBinOp
o CodeExpr
a CodeExpr
b)    = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (EqBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
EqBinOp -> VS (r val) -> VS (r val) -> VS (r val)
eqBfunc EqBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (OrdBinaryOp OrdBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (OrdBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
OrdBinOp -> VS (r val) -> VS (r val) -> VS (r val)
ordBfunc OrdBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (VVVBinaryOp VVVBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (VVVBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
VVVBinOp -> VS (r val) -> VS (r val) -> VS (r val)
vecVecVecBfunc VVVBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (VVNBinaryOp VVNBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (VVNBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
VVNBinOp -> VS (r val) -> VS (r val) -> VS (r val)
vecVecNumBfunc VVNBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (NVVBinaryOp NVVBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (NVVBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NVVBinOp -> VS (r val) -> VS (r val) -> VS (r val)
numVecVecBfunc NVVBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (ESSBinaryOp ESSBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (ESSBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
ESSBinOp -> VS (r val) -> VS (r val) -> VS (r val)
elementSetSetBfunc ESSBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (ESBBinaryOp ESBBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (ESBBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
ESBBinOp -> VS (r val) -> VS (r val) -> VS (r val)
elementSetBoolBfunc ESBBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
b)
convExpr (Case Completeness
c [(CodeExpr, CodeExpr)]
l)            = [(CodeExpr, CodeExpr)] -> StateT DrasilState Identity (VS (r val))
doit [(CodeExpr, CodeExpr)]
l -- FIXME this is sub-optimal
  where
    doit :: [(CodeExpr, CodeExpr)] -> StateT DrasilState Identity (VS (r val))
doit [] = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"should never happen" -- TODO: change error message?
    doit [(CodeExpr
e,CodeExpr
_)] = CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e -- should always be the else clause
    doit ((CodeExpr
e,CodeExpr
cond):[(CodeExpr, CodeExpr)]
xs) = (VS (r val) -> VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
inlineIf (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
cond) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e)
      (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr (Completeness -> [(CodeExpr, CodeExpr)] -> CodeExpr
Case Completeness
c [(CodeExpr, CodeExpr)]
xs))
convExpr (Matrix [[CodeExpr]
l]) = do
  ar <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
                                    -- hd will never fail here
  pure $ litArray (valueType <$> head ar) ar
convExpr Matrix{} = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExpr: Matrix"
convExpr (S.Set Space
s [CodeExpr]
l) = do
  ar <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
l
  sm <- spaceCodeType s
  pure $ litSet (convTypeOO sm) ar
convExpr(Variable Name
s (S.Set Space
l [CodeExpr]
_)) = do
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
l
  let varSet = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
s (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
setType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
sm)
  pure $ valueOf varSet
convExpr(Variable Name
_ CodeExpr
_) = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExpr: Variable"
convExpr Operator{} = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExpr: Operator"
convExpr (RealI UID
c RealInterval CodeExpr CodeExpr
ri)  = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  convExpr $ renderRealInt (lookupC g c) ri

-- | Generates a function/method call, based on the 'UID' of the chunk representing
-- the function, the list of argument 'Expr's, the list of named argument 'Expr's,
-- the function call generator to use, and the library version of the function
-- call generator (used if the function is in the library export map).
convCall
  ::
    ( ValueSym r val typ
    , Argument r val
    , MathConstant r val
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , OO.Literal r val typ
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , SelfSym r var
    , InternalValueExp r var val typ
    , OOValueExpression r var val typ
    , List r val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => UID
  -> [CodeExpr]
  -> [(UID, CodeExpr)]
  -> (Name -> Name -> VS (r typ) -> [VS (r val)] -> NamedArgs r var val -> GenState (VS (r val)))
  -> (Name -> Name -> VS (r typ) -> [VS (r val)] -> NamedArgs r var val -> VS (r val))
  -> GenState (VS (r val))
convCall :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> GenState (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> GenState (VS (r val))
convCall UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
f Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
libf = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let mem = DrasilState -> Map Name Name
eMap DrasilState
g
      lem = DrasilState -> Map Name Name
libEMap DrasilState
g
      funcCd = DefinedQuantityDict -> CodeFuncChunk
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeFuncChunk
quantfunc (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
c)
      funcNm = CodeFuncChunk -> Name
forall c. CodeIdea c => c -> Name
codeName CodeFuncChunk
funcCd
  funcTp <- codeType funcCd
  args <- mapM convExpr x
  nms <- mapM (mkVar . quantvar . lookupC g . fst) ns
  nargs <- mapM (convExpr . snd) ns
  maybe (maybe (error $ "Call to non-existent function " <> funcNm)
      (\Name
m -> VS (r val) -> GenState (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r val) -> GenState (VS (r val)))
-> VS (r val) -> GenState (VS (r val))
forall a b. (a -> b) -> a -> b
$ Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
libf Name
m Name
funcNm (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
funcTp) [VS (r val)]
args ([VS (r var)] -> [VS (r val)] -> NamedArgs r var val
forall a b. [a] -> [b] -> [(a, b)]
zip [VS (r var)]
nms [VS (r val)]
nargs))
      (Map.lookup funcNm lem))
    (\Name
m -> Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
f Name
m Name
funcNm (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
funcTp) [VS (r val)]
args ([VS (r var)] -> [VS (r val)] -> NamedArgs r var val
forall a b. [a] -> [b] -> [(a, b)]
zip [VS (r var)]
nms [VS (r val)]
nargs))
    (Map.lookup funcNm mem)

-- | Converts a 'Constraint' to a 'CodeExpr'.
renderC :: (IsChunk c, HasSymbol c) => c -> Constraint CodeExpr -> CodeExpr
renderC :: forall c.
(IsChunk c, HasSymbol c) =>
c -> Constraint CodeExpr -> CodeExpr
renderC c
s (Range ConstraintReason
_ RealInterval CodeExpr CodeExpr
rr)         = c -> RealInterval CodeExpr CodeExpr -> CodeExpr
forall c.
(IsChunk c, HasSymbol c) =>
c -> RealInterval CodeExpr CodeExpr -> CodeExpr
renderRealInt c
s RealInterval CodeExpr CodeExpr
rr
renderC c
s (Elem ConstraintReason
_ CodeExpr
rr)          = c -> CodeExpr -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr -> CodeExpr
renderSet c
s CodeExpr
rr

-- | Converts an interval ('RealInterval') to a 'CodeExpr'.
renderRealInt :: (IsChunk c, HasSymbol c) => c -> RealInterval CodeExpr CodeExpr -> CodeExpr
renderRealInt :: forall c.
(IsChunk c, HasSymbol c) =>
c -> RealInterval CodeExpr CodeExpr -> CodeExpr
renderRealInt c
s (Bounded (Inclusive
Inc, CodeExpr
a) (Inclusive
Inc, CodeExpr
b)) = (CodeExpr
a CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$&& (c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= CodeExpr
b)
renderRealInt c
s (Bounded (Inclusive
Inc, CodeExpr
a) (Inclusive
Exc, CodeExpr
b)) = (CodeExpr
a CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$&& (c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<  CodeExpr
b)
renderRealInt c
s (Bounded (Inclusive
Exc, CodeExpr
a) (Inclusive
Inc, CodeExpr
b)) = (CodeExpr
a CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<  c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$&& (c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= CodeExpr
b)
renderRealInt c
s (Bounded (Inclusive
Exc, CodeExpr
a) (Inclusive
Exc, CodeExpr
b)) = (CodeExpr
a CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<  c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s) CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$&& (c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<  CodeExpr
b)
renderRealInt c
s (UpTo    (Inclusive
Inc, CodeExpr
a))          = c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<= CodeExpr
a
renderRealInt c
s (UpTo    (Inclusive
Exc, CodeExpr
a))          = c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$<  CodeExpr
a
renderRealInt c
s (UpFrom  (Inclusive
Inc, CodeExpr
a))          = c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$>= CodeExpr
a
renderRealInt c
s (UpFrom  (Inclusive
Exc, CodeExpr
a))          = c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
s CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
$>  CodeExpr
a

renderSet :: (IsChunk c, HasSymbol c) => c -> CodeExpr -> CodeExpr
renderSet :: forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr -> CodeExpr
renderSet c
e CodeExpr
s = CodeExpr -> CodeExpr -> CodeExpr
forall r. ExprC r => r -> r -> r
in' (Name -> CodeExpr -> CodeExpr
Variable (Name
"set_" Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> c -> Name
forall x. HasSymbol x => x -> Name
oneLineCodeSymbolDoc c
e) CodeExpr
s) (c -> CodeExpr
forall c. (IsChunk c, HasSymbol c) => c -> CodeExpr
forall r c. (ExprC r, IsChunk c, HasSymbol c) => c -> r
sy c
e)

-- | Maps a 'UFunc' to the corresponding GOOL unary function.
unop
  :: (NumericExpression r val, Reference r val)
  => UFunc -> (VS (r val) -> VS (r val))
unop :: forall {k} (r :: k -> *) (val :: k).
(NumericExpression r val, Reference r val) =>
UFunc -> VS (r val) -> VS (r val)
unop UFunc
Sqrt = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
(#/^)
unop UFunc
Log  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
log
unop UFunc
Ln   = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
ln
unop UFunc
Abs  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
(#|)
unop UFunc
Exp  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
exp
unop UFunc
Sin  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
sin
unop UFunc
Cos  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
cos
unop UFunc
Tan  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
tan
unop UFunc
Csc  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
csc
unop UFunc
Sec  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
sec
unop UFunc
Cot  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
cot
unop UFunc
Arcsin = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
arcsin
unop UFunc
Arccos = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
arccos
unop UFunc
Arctan = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
arctan
unop UFunc
Neg  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
(#~)
unop UFunc
MakeRef = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Reference r val =>
VS (r val) -> VS (r val)
makeRef

-- | Similar to 'unop', but for the 'Not' constructor.
unopB :: (BooleanExpression r val) => UFuncB -> (VS (r val) -> VS (r val))
unopB :: forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
UFuncB -> VS (r val) -> VS (r val)
unopB UFuncB
Not = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val)
(?!)

-- | Similar to 'unop', but for vectors.
unopVN :: (List r val) => UFuncVN -> (VS (r val) -> VS (r val))
unopVN :: forall {k} (r :: k -> *) (val :: k).
List r val =>
UFuncVN -> VS (r val) -> VS (r val)
unopVN UFuncVN
Dim = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize
unopVN UFuncVN
Norm = Name -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"unop: Norm not implemented" -- TODO

-- | Similar to 'unop', but for vectors.
unopVV :: (ValueSym r val typ) => UFuncVV -> (VS (r val) -> VS (r val))
unopVV :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
UFuncVV -> VS (r val) -> VS (r val)
unopVV UFuncVV
NegV = Name -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"unop: Negation on Vectors not implemented" -- TODO

-- Maps an 'ArithBinOp' to it's corresponding GOOL binary function.
arithBfunc
  :: (NumericExpression r val)
  => ArithBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
arithBfunc :: forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
ArithBinOp -> VS (r val) -> VS (r val) -> VS (r val)
arithBfunc ArithBinOp
Pow  = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#^)
arithBfunc ArithBinOp
Subt = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#-)
arithBfunc ArithBinOp
Frac = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#/)

-- Maps an 'EqBinOp' to it's corresponding GOOL binary function.
eqBfunc
  :: (Comparison r val)
  => EqBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
eqBfunc :: forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
EqBinOp -> VS (r val) -> VS (r val) -> VS (r val)
eqBfunc EqBinOp
Eq  = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?==)
eqBfunc EqBinOp
NEq = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?!=)

-- Maps an 'LABinOp' to it's corresponding GOOL binary function.
laBfunc
  :: (List r val)
  => LABinOp -> (VS (r val) -> VS (r val) -> VS (r val))
laBfunc :: forall {k} (r :: k -> *) (val :: k).
List r val =>
LABinOp -> VS (r val) -> VS (r val) -> VS (r val)
laBfunc LABinOp
Index = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
listAccess
laBfunc LABinOp
IndexOf = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
indexOf

-- Maps an 'OrdBinOp' to it's corresponding GOOL binary function.
ordBfunc
  :: (Comparison r val)
  => OrdBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
ordBfunc :: forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
OrdBinOp -> VS (r val) -> VS (r val) -> VS (r val)
ordBfunc OrdBinOp
Gt  = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?>)
ordBfunc OrdBinOp
Lt  = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?<)
ordBfunc OrdBinOp
LEq = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?<=)
ordBfunc OrdBinOp
GEq = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?>=)

-- Maps a 'VVVBinOp' to it's corresponding GOOL binary function.
vecVecVecBfunc :: VVVBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
vecVecVecBfunc :: forall {k} (r :: k -> *) (val :: k).
VVVBinOp -> VS (r val) -> VS (r val) -> VS (r val)
vecVecVecBfunc VVVBinOp
Cross = Name -> VS (r val) -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"bfunc: Cross not implemented"
vecVecVecBfunc VVVBinOp
VAdd = Name -> VS (r val) -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"bfunc: Vector addition not implemented"
vecVecVecBfunc VVVBinOp
VSub = Name -> VS (r val) -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"bfunc: Vector subtraction not implemented"

-- Maps a 'VVNBinOp' to it's corresponding GOOL binary function.
vecVecNumBfunc :: VVNBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
vecVecNumBfunc :: forall {k} (r :: k -> *) (val :: k).
VVNBinOp -> VS (r val) -> VS (r val) -> VS (r val)
vecVecNumBfunc VVNBinOp
Dot = Name -> VS (r val) -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExpr DotProduct"

-- Maps a 'NVVBinOp' to it's corresponding GOOL binary function.
numVecVecBfunc :: NVVBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
numVecVecBfunc :: forall {k} (r :: k -> *) (val :: k).
NVVBinOp -> VS (r val) -> VS (r val) -> VS (r val)
numVecVecBfunc NVVBinOp
Scale = Name -> VS (r val) -> VS (r val) -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExpr Scaling of Vectors"

-- Maps a 'ESSBinOp' to its corresponding GOOL binary function.
elementSetSetBfunc :: (OO.Set r val) => ESSBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
elementSetSetBfunc :: forall {k} (r :: k -> *) (val :: k).
Set r val =>
ESSBinOp -> VS (r val) -> VS (r val) -> VS (r val)
elementSetSetBfunc ESSBinOp
SAdd = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
OO.setAdd
elementSetSetBfunc ESSBinOp
SRemove = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
OO.setRemove

-- Maps a 'ESSBinOp' to it's corresponding GOOL binary function.
elementSetBoolBfunc :: (OO.Set r val) => ESBBinOp -> (VS (r val) -> VS (r val) -> VS (r val))
elementSetBoolBfunc :: forall {k} (r :: k -> *) (val :: k).
Set r val =>
ESBBinOp -> VS (r val) -> VS (r val) -> VS (r val)
elementSetBoolBfunc ESBBinOp
SContains = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
VS (r val) -> VS (r val) -> VS (r val)
OO.contains

-- medium hacks --

-- | Converts a 'Mod' to GOOL.
genModDef
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Mod -> GenState (FS (r file))
genModDef :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Mod -> GenState (FS (r file))
genModDef (Mod Name
n Name
desc [Name]
is [Class]
cs [Func]
fs) = Name
-> Name
-> [Name]
-> [GenState (Maybe (MS (r mthd)))]
-> [GenState (Maybe (CS (r cls)))]
-> GenState (FS (r file))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> Name
-> [Name]
-> [GenState (Maybe (MS (r mthd)))]
-> [GenState (Maybe (CS (r cls)))]
-> GenState (FS (r file))
genModuleWithImports Name
n Name
desc [Name]
is ((MS (r mthd) -> Maybe (MS (r mthd)))
-> StateT DrasilState Identity (MS (r mthd))
-> GenState (Maybe (MS (r mthd)))
forall a b.
(a -> b)
-> StateT DrasilState Identity a -> StateT DrasilState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
  MS (r mthd) -> Maybe (MS (r mthd))
forall a. a -> Maybe a
Just (StateT DrasilState Identity (MS (r mthd))
 -> GenState (Maybe (MS (r mthd))))
-> (Func -> StateT DrasilState Identity (MS (r mthd)))
-> Func
-> GenState (Maybe (MS (r mthd)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> StateT DrasilState Identity (MS (r mthd)))
-> [StateVariable]
-> Func
-> StateT DrasilState Identity (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
genFunc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> StateT DrasilState Identity (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicFunc [] (Func -> GenState (Maybe (MS (r mthd))))
-> [Func] -> [GenState (Maybe (MS (r mthd)))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Func]
fs)
  (case [Class]
cs of [] -> []
              (Class
cl:[Class]
cls) -> (CS (r cls) -> Maybe (CS (r cls)))
-> StateT DrasilState Identity (CS (r cls))
-> GenState (Maybe (CS (r cls)))
forall a b.
(a -> b)
-> StateT DrasilState Identity a -> StateT DrasilState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CS (r cls) -> Maybe (CS (r cls))
forall a. a -> Maybe a
Just ((Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> StateT DrasilState Identity (CS (r cls)))
-> Class -> StateT DrasilState Identity (CS (r cls))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> GenState (CS (r cls)))
-> Class -> GenState (CS (r cls))
genClass Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> StateT DrasilState Identity (CS (r cls))
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> GenState (CS (r cls))
primaryClass Class
cl) GenState (Maybe (CS (r cls)))
-> [GenState (Maybe (CS (r cls)))]
-> [GenState (Maybe (CS (r cls)))]
forall a. a -> [a] -> [a]
:
                (Class -> GenState (Maybe (CS (r cls))))
-> [Class] -> [GenState (Maybe (CS (r cls)))]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((CS (r cls) -> Maybe (CS (r cls)))
-> StateT DrasilState Identity (CS (r cls))
-> GenState (Maybe (CS (r cls)))
forall a b.
(a -> b)
-> StateT DrasilState Identity a -> StateT DrasilState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap CS (r cls) -> Maybe (CS (r cls))
forall a. a -> Maybe a
Just (StateT DrasilState Identity (CS (r cls))
 -> GenState (Maybe (CS (r cls))))
-> (Class -> StateT DrasilState Identity (CS (r cls)))
-> Class
-> GenState (Maybe (CS (r cls)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> StateT DrasilState Identity (CS (r cls)))
-> Class -> StateT DrasilState Identity (CS (r cls))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> GenState (CS (r cls)))
-> Class -> GenState (CS (r cls))
genClass Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> StateT DrasilState Identity (CS (r cls))
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> GenState (CS (r cls))
auxClass) [Class]
cls)

-- | Converts a 'Mod'\'s functions to GOOL.
genModFuncs
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Mod -> [GenState (MS (r mthd))]
genModFuncs :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Mod -> [GenState (MS (r mthd))]
genModFuncs (Mod Name
_ Name
_ [Name]
_ [Class]
_ [Func]
fs) = (Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
genFunc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicFunc [] (Func -> GenState (MS (r mthd)))
-> [Func] -> [GenState (MS (r mthd))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Func]
fs

-- | Converts a 'Mod'\'s classes to GOOL.
genModClasses
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Mod -> [GenState (CS (r cls))]
genModClasses :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Mod -> [GenState (CS (r cls))]
genModClasses (Mod Name
_ Name
_ [Name]
_ [Class]
cs [Func]
_) = (Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> GenState (CS (r cls)))
-> Class -> GenState (CS (r cls))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> GenState (CS (r cls)))
-> Class -> GenState (CS (r cls))
genClass Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> GenState (CS (r cls))
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> GenState (CS (r cls))
auxClass (Class -> GenState (CS (r cls)))
-> [Class] -> [GenState (CS (r cls))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Class]
cs

-- | Converts a Class (from the Mod AST) to GOOL.
-- The class generator to use is passed as a parameter.
genClass
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => (Name -> Maybe Name -> Description -> [CSStateVar r stvr] -> GenState [MS (r mthd)] -> GenState [MS (r mthd)] -> GenState (CS (r cls)))
  -> M.Class
  -> GenState (CS (r cls))
genClass :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> Maybe Name
 -> Name
 -> [CSStateVar r stvr]
 -> GenState [MS (r mthd)]
 -> GenState [MS (r mthd)]
 -> GenState (CS (r cls)))
-> Class -> GenState (CS (r cls))
genClass Name
-> Maybe Name
-> Name
-> [CSStateVar r stvr]
-> GenState [MS (r mthd)]
-> GenState [MS (r mthd)]
-> GenState (CS (r cls))
f (M.ClassDef Name
n Maybe Name
i Name
desc [StateVariable]
svs [Func]
cs [Func]
ms) = let svar :: VisibilityTag -> VS (r var) -> CSStateVar r stvr
svar VisibilityTag
Pub = VS (r var) -> CSStateVar r stvr
forall {k} (r :: k -> *) (attch :: k) (vis :: k) (stvr :: k)
       (var :: k) (val :: k).
(AttachmentSym r attch, VisibilitySym r vis,
 StateVarSym r stvr attch vis var val) =>
VS (r var) -> CSStateVar r stvr
pubDVar
                                                 svar VisibilityTag
Priv = VS (r var) -> CSStateVar r stvr
forall {k} (r :: k -> *) (attch :: k) (vis :: k) (stvr :: k)
       (var :: k) (val :: k).
(AttachmentSym r attch, VisibilitySym r vis,
 StateVarSym r stvr attch vis var val) =>
VS (r var) -> CSStateVar r stvr
privDVar
  in do
  (DrasilState -> DrasilState) -> StateT DrasilState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  svrs <- (StateVariable -> StateT DrasilState Identity (CSStateVar r stvr))
-> [StateVariable]
-> StateT DrasilState Identity [CSStateVar r stvr]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (\(SV VisibilityTag
s Input
v) -> VisibilityTag -> VS (r var) -> CSStateVar r stvr
forall {k} {r :: k -> *} {vis :: k} {attch :: k} {stvr :: k}
       {var :: k} {val :: k}.
(VisibilitySym r vis, AttachmentSym r attch,
 StateVarSym r stvr attch vis var val) =>
VisibilityTag -> VS (r var) -> CSStateVar r stvr
svar VisibilityTag
s (VS (r var) -> CSStateVar r stvr)
-> (CodeType -> VS (r var)) -> CodeType -> CSStateVar r stvr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (VS (r typ) -> VS (r var))
-> (CodeType -> VS (r typ)) -> CodeType -> VS (r var)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO (CodeType -> CSStateVar r stvr)
-> StateT DrasilState Identity CodeType
-> StateT DrasilState Identity (CSStateVar r stvr)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v) [StateVariable]
svs
  f n i desc svrs (mapM (genFunc publicMethod svs) cs)
                  (mapM (genFunc publicMethod svs) ms)

-- | Converts a 'Func' (from the Mod AST) to GOOL.
-- The function generator to use is passed as a parameter. Automatically adds
-- variable declaration statements for any undeclared variables. For methods,
-- the list of StateVariables is needed so they can be included in the list of
-- declared variables.
genFunc
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => (Name -> VS (r typ) -> Description -> [ParameterChunk] -> Maybe Description -> [MS (r block)] -> GenState (MS (r mthd)))
  -> [StateVariable]
  -> Func
  -> GenState (MS (r mthd))
genFunc :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
(Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
genFunc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
f [StateVariable]
svs (FDef (FuncDef Name
n Name
desc [ParameterChunk]
parms Space
o Maybe Name
rd [FuncStmt]
s)) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  stmts <- mapM convStmt s
  vars <- mapM mkVar (fstdecl (g ^. systemdb) s
    \\ (fmap quantvar parms <> fmap stVar svs))
  t <- spaceCodeType o
  f n (convTypeOO t) desc parms rd [block $ (`varDec` local) <$> vars, block stmts]
genFunc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
_ [StateVariable]
svs (FDef (CtorDef Name
n Name
desc [ParameterChunk]
parms [Initializer]
i [FuncStmt]
s)) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  inits <- mapM (convExpr . snd) i
  initvars <- mapM ((\Input
iv -> Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
iv) (VS (r typ) -> VS (r var))
-> (CodeType -> VS (r typ)) -> CodeType -> VS (r var)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO
    (CodeType -> VS (r var))
-> StateT DrasilState Identity CodeType
-> StateT DrasilState Identity (VS (r var))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
iv) . fst) i
  stmts <- mapM convStmt s
  vars <- mapM mkVar (fstdecl (g ^. systemdb) s
    \\ (fmap quantvar parms <> fmap stVar svs))
  genInitConstructor n desc parms (zip initvars inits)
    [block $ (`varDec` local) <$> vars, block stmts]
genFunc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
_ [StateVariable]
_ (FData (FuncData Name
n Name
desc DataDesc
ddef)) = do
  (DrasilState -> DrasilState) -> StateT DrasilState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  Name -> Name -> DataDesc -> GenState (MS (r mthd))
forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name -> Name -> DataDesc -> GenState (MS (r mthd))
genDataFunc Name
n Name
desc DataDesc
ddef

-- | Converts a 'FuncStmt' to a GOOL Statement.
convStmt
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , ValueSym r val typ
    , Argument r val
    , MathConstant r val
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , OO.Literal r val typ
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , SelfSym r var
    , InternalValueExp r var val typ
    , OOValueExpression r var val typ
    , Array r var val
    , List r val
    , ListStatement r stmt val
    , Reference r val
    , OO.Set r val
    , ScopeSym r scope
    , MultiStatement r stmt
    , ValueStatement r stmt val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , DeclStatement r bod stmt var scope val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => FuncStmt -> GenState (MS (r stmt))
convStmt :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt (FAsg Input
v (Matrix [[CodeExpr]
es])) = do
  els <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
es
  v' <- mkVar v
  t <- codeType v
  let listFunc (OO.List CodeType
_) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litList
      listFunc (OO.Array CodeType
_) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litArray
      listFunc CodeType
_ = Name -> VS (r typ) -> [VS (r val)] -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"Type mismatch between variable and value in assignment FuncStmt"
  pure $ assign v' (listFunc t (innerType $ variableType <$> v') els)
convStmt (FAsg Input
v CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e
  v' <- mkVar v
  pure $ assign v' e'
convStmt (FAsgIndex Input
v Integer
i CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e
  v' <- mkVar v
  t <- codeType v
  let asgFunc (OO.List CodeType
_) = VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
listSet (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
v') (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
i) VS (r val)
e'
      asgFunc (OO.Array CodeType
_) = VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
assign (VS (r val) -> VS (r val) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k).
Array r var val =>
VS (r val) -> VS (r val) -> VS (r var)
arrayElem (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
v') (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
i)) VS (r val)
e'
      asgFunc CodeType
_ = Name -> MS (r stmt)
forall a. HasCallStack => Name -> a
error Name
"FAsgIndex used with non-indexed value"
  pure $ asgFunc t
convStmt (FFor Input
v CodeExpr
start CodeExpr
end CodeExpr
step [FuncStmt]
st) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
st
  vari <- mkVar v
  start' <- convExpr start
  end' <- convExpr end
  step' <- convExpr step
  pure $ forRange vari start' end' step' (bodyStatements stmts)
convStmt (FForEach Input
v CodeExpr
e [FuncStmt]
st) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
st
  vari <- mkVar v
  e' <- convExpr e
  pure $ forEach vari e' (bodyStatements stmts)
convStmt (FWhile CodeExpr
e [FuncStmt]
st) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
st
  e' <- convExpr e
  pure $ while e' (bodyStatements stmts)
convStmt (FCond CodeExpr
e [FuncStmt]
tSt []) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
tSt
  e' <- convExpr e
  pure $ ifNoElse [(e', bodyStatements stmts)]
convStmt (FCond CodeExpr
e [FuncStmt]
tSt [FuncStmt]
eSt) = do
  stmt1 <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
tSt
  stmt2 <- mapM convStmt eSt
  e' <- convExpr e
  pure $ ifCond [(e', bodyStatements stmt1)] (bodyStatements stmt2)
convStmt (FRet CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e
  pure $ returnStmt e'
convStmt (FThrow Name
s) = MS (r stmt) -> StateT DrasilState Identity (MS (r stmt))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MS (r stmt) -> StateT DrasilState Identity (MS (r stmt)))
-> MS (r stmt) -> StateT DrasilState Identity (MS (r stmt))
forall a b. (a -> b) -> a -> b
$ Name -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
Name -> MS (r stmt)
throw Name
s
convStmt (FTry [FuncStmt]
t [FuncStmt]
c) = do
  stmt1 <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
t
  stmt2 <- mapM convStmt c
  pure $ tryCatch (bodyStatements stmt1) (bodyStatements stmt2)
convStmt FuncStmt
FContinue = MS (r stmt) -> StateT DrasilState Identity (MS (r stmt))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
continue
convStmt (FDecDef Input
v (Matrix [[]])) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let scp = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  vari <- mkVar v
  let convDec (OO.List CodeType
_) = Integer -> VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
Integer -> VS (r var) -> r scope -> MS (r stmt)
listDec Integer
0 VS (r var)
vari
      convDec (OO.Array CodeType
_) = Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
arrayDec Integer
0 VS (r val)
forall a. HasCallStack => a
undefined VS (r var)
vari
      convDec CodeType
_ = VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> MS (r stmt)
varDec VS (r var)
vari
  (`convDec` scp) <$> codeType v
convStmt (FDecDef Input
v CodeExpr
e) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let scp = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  v' <- mkVar v
  t <- codeType v
  let convDecDef (Matrix [[CodeExpr]
lst]) = do
        let contDecDef :: CodeType -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
contDecDef (OO.List CodeType
_) = VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef
            contDecDef (OO.Array CodeType
_) = VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
arrayDecDef
            contDecDef CodeType
_ = Name -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall a. HasCallStack => Name -> a
error Name
"Type mismatch between variable and value in declare-define FuncStmt"
        e' <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr [CodeExpr]
lst
        pure $ contDecDef t v' scp e'
      convDecDef CodeExpr
_ = do
        e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e
        pure $ varDecDef v' scp e'
  convDecDef e
convStmt (FFuncDef CodeFuncChunk
f [ParameterChunk]
ps [FuncStmt]
sts) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let scp = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  f' <- mkVar (quantvar f)
  pms <- mapM (mkVar . quantvar) ps
  b <- mapM convStmt sts
  pure $ funcDecDef f' scp pms (bodyStatements b)
convStmt (FVal CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
e
  pure $ valStmt e'
convStmt (FMulti [FuncStmt]
ss) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, MathConstant r val, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, Literal r val typ,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, SelfSym r var,
 InternalValueExp r var val typ, OOValueExpression r var val typ,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, Set r val, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 DeclStatement r bod stmt var scope val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmt [FuncStmt]
ss
  pure $ multi stmts
convStmt (FAppend CodeExpr
a CodeExpr
b) = do
  a' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, MathConstant r val,
 TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, VariableValue r var val,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 SelfSym r var, InternalValueExp r var val typ,
 OOValueExpression r var val typ, List r val, Reference r val,
 Set r val, TypeElim r typ, VariableElim r var typ) =>
CodeExpr -> GenState (VS (r val))
convExpr CodeExpr
a
  b' <- convExpr b
  pure $ listAppend a' b'

-- | Generates a function that reads a file whose format is based on the passed
-- 'DataDesc'.
genDataFunc
  :: (OOProg r prg file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Name -> Description -> DataDesc -> GenState (MS (r mthd))
genDataFunc :: forall (r :: * -> *) prg file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OOProg
  r
  prg
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name -> Name -> DataDesc -> GenState (MS (r mthd))
genDataFunc Name
nameTitle Name
desc DataDesc
ddef = do
  let parms :: [Input]
parms = DataDesc -> [Input]
getInputs DataDesc
ddef
  bod <- DataDesc -> GenState [MS (r block)]
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, Literal r val typ, MathConstant r val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 SelfSym r var, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, InternalValueExp r var val typ,
 ValueExpression r var val binder typ,
 OOValueExpression r var val typ, List r val,
 ListStatement r stmt val, Reference r val, Set r val,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, TypeElim r typ, VariableElim r var typ) =>
DataDesc -> GenState [MS (r block)]
readData DataDesc
ddef
  publicFunc nameTitle void desc (pcAuto <$> quantvar inFileName : parms)
    Nothing bod

-- this is really ugly!!
-- | Read from a data description into an 'MS block' of 'MS Statement's.
readData
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , ValueSym r val typ
    , Argument r val
    , OO.Literal r val typ
    , MathConstant r val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , SelfSym r var
    , TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , VariableValue r var val
    , InternalValueExp r var val typ
    , ValueExpression r var val binder typ
    , OOValueExpression r var val typ
    , List r val
    , ListStatement r stmt val
    , Reference r val
    , OO.Set r val
    , ScopeSym r scope
    , DeclStatement r bod stmt var scope val
    , OODeclStatement r stmt var scope val
    , ControlStatement r bod stmt var val
    , StringStatement r stmt var val
    , FileHandling r stmt var val
    , ReadFile r stmt var val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => DataDesc -> GenState [MS (r block)]
readData :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, ValueSym r val typ,
 Argument r val, Literal r val typ, MathConstant r val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 SelfSym r var, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, InternalValueExp r var val typ,
 ValueExpression r var val binder typ,
 OOValueExpression r var val typ, List r val,
 ListStatement r stmt val, Reference r val, Set r val,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, TypeElim r typ, VariableElim r var typ) =>
DataDesc -> GenState [MS (r block)]
readData DataDesc
ddef = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let localScope = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  inD <- mapM (`inData` localScope) ddef
  v_filename <- mkVal (quantvar inFileName)
  pure [block $
    varDec var_infile localScope :
    (if any (\Data
d -> Data -> Bool
isLine Data
d Bool -> Bool -> Bool
|| Data -> Bool
isLines Data
d) ddef then [varDec var_line localScope,
    listDec 0 var_linetokens localScope ] else []) <>
    [listDec 0 var_lines localScope | any isLines ddef] <> (openFileR var_infile
    v_filename : concat inD <> [closeFile v_infile])]
  where inData
          ::
            ( BlockSym r block stmt
            , BodySym r bod block
            , OO.Literal r val typ
            , SelfSym r var
            , TypeSym r typ
            , OOTypeSym r typ
            , VariableSym r var typ
            , OOVariableSym r var val typ
            , VariableValue r var val
            , List r val
            , ListStatement r stmt val
            , ScopeSym r scope
            , DeclStatement r bod stmt var scope val
            , OODeclStatement r stmt var scope val
            , ControlStatement r bod stmt var val
            , StringStatement r stmt var val
            , ReadFile r stmt var val
            , VariableElim r var typ
            )
          => Data -> r scope -> GenState [MS (r stmt)]
        inData :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (typ :: k) (var :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, Literal r val typ,
 SelfSym r var, TypeSym r typ, OOTypeSym r typ,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, List r val, ListStatement r stmt val,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, ReadFile r stmt var val,
 VariableElim r var typ) =>
Data -> r scope -> GenState [MS (r stmt)]
inData (Singleton Input
v) r scope
_ = do
            vv <- Input -> GenState (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar Input
v
            pure [getFileInput v_infile vv]
        inData Data
JunkData r scope
_ = [MS (r stmt)] -> StateT DrasilState Identity [MS (r stmt)]
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> MS (r stmt)
discardFileLine VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile]
        inData (Line LinePattern
lp Char
d) r scope
scp = do
          lnI <- Maybe Name
-> LinePattern
-> r scope
-> StateT DrasilState Identity [MS (r stmt)]
forall {k} (r :: k -> *) (var :: k) (typ :: k) (scope :: k)
       (val :: k) (stmt :: k) (bod :: k).
(SelfSym r var, TypeSym r typ, OOTypeSym r typ, ScopeSym r scope,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, ListStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val,
 StringStatement r stmt var val, VariableElim r var typ) =>
Maybe Name -> LinePattern -> r scope -> GenState [MS (r stmt)]
lineData Maybe Name
forall a. Maybe a
Nothing LinePattern
lp r scope
scp
          pure $ [getFileInputLine v_infile var_line,
            stringSplit d var_linetokens v_line] <> lnI
        inData (Lines LinePattern
lp Maybe Integer
ls Char
d) r scope
scp = do
          lnV <- Maybe Name
-> LinePattern
-> r scope
-> StateT DrasilState Identity [MS (r stmt)]
forall {k} (r :: k -> *) (var :: k) (typ :: k) (scope :: k)
       (val :: k) (stmt :: k) (bod :: k).
(SelfSym r var, TypeSym r typ, OOTypeSym r typ, ScopeSym r scope,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, ListStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val,
 StringStatement r stmt var val, VariableElim r var typ) =>
Maybe Name -> LinePattern -> r scope -> GenState [MS (r stmt)]
lineData (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"_temp") LinePattern
lp r scope
scp
          let readLines Maybe Integer
Nothing = [VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInputAll VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_lines,
                VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forRange VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_i (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0) (VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_lines) (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1)
                  ([MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements ([MS (r stmt)] -> MS (r bod)) -> [MS (r stmt)] -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ Char -> VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
Char -> VS (r var) -> VS (r val) -> MS (r stmt)
stringSplit Char
d VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_linetokens (
                  VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
listAccess VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_lines VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_i) MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: [MS (r stmt)]
lnV)]
              readLines (Just Integer
numLines) = [VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forRange VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_i (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0)
                (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
numLines) (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1)
                ([MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements ([MS (r stmt)] -> MS (r bod)) -> [MS (r stmt)] -> MS (r bod)
forall a b. (a -> b) -> a -> b
$
                  [VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInputLine VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_line,
                   Char -> VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
Char -> VS (r var) -> VS (r val) -> MS (r stmt)
stringSplit Char
d VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_linetokens VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_line
                  ] [MS (r stmt)] -> [MS (r stmt)] -> [MS (r stmt)]
forall a. Semigroup a => a -> a -> a
<> [MS (r stmt)]
lnV)]
          pure $ readLines ls
        ---------------
        lineData
          ::
            ( SelfSym r var
            , TypeSym r typ
            , OOTypeSym r typ
            , ScopeSym r scope
            , VariableSym r var typ
            , OOVariableSym r var val typ
            , VariableValue r var val
            , ListStatement r stmt val
            , DeclStatement r bod stmt var scope val
            , OODeclStatement r stmt var scope val
            , StringStatement r stmt var val
            , VariableElim r var typ
            )
          => Maybe String -> LinePattern -> r scope -> GenState [MS (r stmt)]
        lineData :: forall {k} (r :: k -> *) (var :: k) (typ :: k) (scope :: k)
       (val :: k) (stmt :: k) (bod :: k).
(SelfSym r var, TypeSym r typ, OOTypeSym r typ, ScopeSym r scope,
 VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val, ListStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val,
 StringStatement r stmt var val, VariableElim r var typ) =>
Maybe Name -> LinePattern -> r scope -> GenState [MS (r stmt)]
lineData Maybe Name
s p :: LinePattern
p@(Straight [Input]
_) r scope
_ = do
          vs <- Maybe Name -> LinePattern -> GenState [VS (r var)]
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Maybe Name -> LinePattern -> GenState [VS (r var)]
getEntryVars Maybe Name
s LinePattern
p
          pure [stringListVals vs v_linetokens]
        lineData Maybe Name
s p :: LinePattern
p@(Repeat [Input]
ds) r scope
scp = do
          vs <- Maybe Name -> LinePattern -> GenState [VS (r var)]
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Maybe Name -> LinePattern -> GenState [VS (r var)]
getEntryVars Maybe Name
s LinePattern
p
          sequence $ clearTemps s ds scp <> (pure
            (stringListLists vs v_linetokens) : appendTemps s ds)
        ---------------
        clearTemps
          ::
            ( TypeSym r typ
            , OOTypeSym r typ
            , ScopeSym r scope
            , VariableSym r var typ
            , DeclStatement r bod stmt var scope val
            , OODeclStatement r stmt var scope val
            )
          => Maybe String -> [DataItem] -> r scope -> [GenState (MS (r stmt))]
        clearTemps :: forall {k} (r :: k -> *) (typ :: k) (scope :: k) (var :: k)
       (bod :: k) (stmt :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, ScopeSym r scope,
 VariableSym r var typ, DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val) =>
Maybe Name -> [Input] -> r scope -> [GenState (MS (r stmt))]
clearTemps Maybe Name
Nothing    [Input]
_  r scope
_   = []
        clearTemps (Just Name
sfx) [Input]
es r scope
scp = (\Input
v -> Name -> Input -> r scope -> GenState (MS (r stmt))
forall {k} (r :: k -> *) (typ :: k) (scope :: k) (var :: k)
       (bod :: k) (stmt :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, ScopeSym r scope,
 VariableSym r var typ, DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val) =>
Name -> Input -> r scope -> GenState (MS (r stmt))
clearTemp Name
sfx Input
v r scope
scp) (Input -> GenState (MS (r stmt)))
-> [Input] -> [GenState (MS (r stmt))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Input]
es
        ---------------
        clearTemp
          ::
            ( TypeSym r typ
            , OOTypeSym r typ
            , ScopeSym r scope
            , VariableSym r var typ
            , DeclStatement r bod stmt var scope val
            , OODeclStatement r stmt var scope val
            )
          => String -> DataItem -> r scope -> GenState (MS (r stmt))
        clearTemp :: forall {k} (r :: k -> *) (typ :: k) (scope :: k) (var :: k)
       (bod :: k) (stmt :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, ScopeSym r scope,
 VariableSym r var typ, DeclStatement r bod stmt var scope val,
 OODeclStatement r stmt var scope val) =>
Name -> Input -> r scope -> GenState (MS (r stmt))
clearTemp Name
sfx Input
v r scope
scp = (\CodeType
t -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef (Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
sfx)
          (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t)) r scope
scp []) (CodeType -> MS (r stmt))
-> StateT DrasilState Identity CodeType
-> StateT DrasilState Identity (MS (r stmt))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v
        ---------------
        appendTemps
          ::
            ( ListStatement r stmt val
            , VariableSym r var typ
            , VariableValue r var val
            , TypeSym r typ
            , OOTypeSym r typ
            )
          => Maybe String -> [DataItem] -> [GenState (MS (r stmt))]
        appendTemps :: forall {k} (r :: k -> *) (stmt :: k) (val :: k) (var :: k)
       (typ :: k).
(ListStatement r stmt val, VariableSym r var typ,
 VariableValue r var val, TypeSym r typ, OOTypeSym r typ) =>
Maybe Name -> [Input] -> [GenState (MS (r stmt))]
appendTemps Maybe Name
Nothing [Input]
_ = []
        appendTemps (Just Name
sfx) [Input]
es = Name -> Input -> GenState (MS (r stmt))
forall {k} (r :: k -> *) (stmt :: k) (val :: k) (var :: k)
       (typ :: k).
(ListStatement r stmt val, VariableSym r var typ,
 VariableValue r var val, TypeSym r typ, OOTypeSym r typ) =>
Name -> Input -> GenState (MS (r stmt))
appendTemp Name
sfx (Input -> GenState (MS (r stmt)))
-> [Input] -> [GenState (MS (r stmt))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Input]
es
        ---------------
        appendTemp
          ::
            ( ListStatement r stmt val
            , VariableSym r var typ
            , VariableValue r var val
            , TypeSym r typ
            , OOTypeSym r typ
            )
          => String -> DataItem -> GenState (MS (r stmt))
        appendTemp :: forall {k} (r :: k -> *) (stmt :: k) (val :: k) (var :: k)
       (typ :: k).
(ListStatement r stmt val, VariableSym r var typ,
 VariableValue r var val, TypeSym r typ, OOTypeSym r typ) =>
Name -> Input -> GenState (MS (r stmt))
appendTemp Name
sfx Input
v = (\CodeType
t -> VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
listAppend
          (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf (VS (r var) -> VS (r val)) -> VS (r var) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t))
          (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf (VS (r var) -> VS (r val)) -> VS (r var) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
sfx) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t))) (CodeType -> MS (r stmt))
-> StateT DrasilState Identity CodeType
-> StateT DrasilState Identity (MS (r stmt))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v

-- | Get entry variables.
getEntryVars
  ::
    ( TypeSym r typ
    , OOTypeSym r typ
    , VariableSym r var typ
    , OOVariableSym r var val typ
    , SelfSym r var
    , VariableElim r var typ
    , VariableValue r var val
    )
  => Maybe String -> LinePattern -> GenState [VS (r var)]
getEntryVars :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Maybe Name -> LinePattern -> GenState [VS (r var)]
getEntryVars Maybe Name
s LinePattern
lp = (Input -> StateT DrasilState Identity (VS (r var)))
-> [Input] -> StateT DrasilState Identity [VS (r var)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((Input -> StateT DrasilState Identity (VS (r var)))
-> (Name -> Input -> StateT DrasilState Identity (VS (r var)))
-> Maybe Name
-> Input
-> StateT DrasilState Identity (VS (r var))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Input -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Input -> GenState (VS (r var))
mkVar (\Name
st Input
v -> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v StateT DrasilState Identity CodeType
-> (CodeType -> StateT DrasilState Identity (VS (r var)))
-> StateT DrasilState Identity (VS (r var))
forall a b.
StateT DrasilState Identity a
-> (a -> StateT DrasilState Identity b)
-> StateT DrasilState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
  (Name -> VS (r typ) -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, OOTypeSym r typ, VariableSym r var typ,
 OOVariableSym r var val typ, SelfSym r var, VariableElim r var typ,
 VariableValue r var val) =>
Name -> VS (r typ) -> GenState (VS (r var))
variable (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
st) (VS (r typ) -> StateT DrasilState Identity (VS (r var)))
-> (CodeType -> VS (r typ))
-> CodeType
-> StateT DrasilState Identity (VS (r var))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ))
-> (CodeType -> VS (r typ)) -> CodeType -> VS (r typ)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO))
    Maybe Name
s) (LinePattern -> [Input]
getPatternInputs LinePattern
lp)

-- Procedural Versions --

-- | If 'UID' for the variable is matched to a concept, call 'conceptToGOOL' to get
-- the GOOL code for the concept, and return.
-- If 'UID' is for a constant and user has chosen 'Inline', convert the constant's
-- defining 'Expr' to a value with 'convExpr'.
-- Otherwise, just a regular variable: construct it by calling the variable, then
-- call 'valueOf' to reference its value.
valueProc
  ::
    ( TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , NativeVector r val typ
    , MathConstant r val
    , VariableSym r var typ
    , VariableValue r var val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , Argument r val
    , List r val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    )
  => UID -> Name -> VS (r typ) -> GenState (VS (r val))
valueProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 NativeVector r val typ, MathConstant r val, VariableSym r var typ,
 VariableValue r var val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 Argument r val, List r val, Reference r val, Set r val,
 TypeElim r typ) =>
UID -> Name -> VS (r typ) -> GenState (VS (r val))
valueProc UID
u Name
s VS (r typ)
t = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let cs = DrasilState
g
      mm = DrasilState
cs DrasilState
-> Getting ConstantMap DrasilState ConstantMap -> ConstantMap
forall s a. s -> Getting a s a -> a
^. Getting ConstantMap DrasilState ConstantMap
forall c. HasCodeSpec c => Lens' c ConstantMap
Lens' DrasilState ConstantMap
constMap
      constDef = do
        cd <- UID -> ConstantMap -> Maybe CodeDefinition
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup UID
u ConstantMap
mm
        maybeInline (g ^. conStruct) cd
      maybeInline ConstantStructure
Inline a
m = a -> Maybe a
forall a. a -> Maybe a
Just a
m
      maybeInline ConstantStructure
_ a
_ = Maybe a
forall a. Maybe a
Nothing
      cm = DrasilState
g DrasilState
-> Getting MatchedConceptMap DrasilState MatchedConceptMap
-> MatchedConceptMap
forall s a. s -> Getting a s a -> a
^. Getting MatchedConceptMap DrasilState MatchedConceptMap
forall a. HasChoices a => Lens' a MatchedConceptMap
Lens' DrasilState MatchedConceptMap
concMatches
      cdCncpt = UID -> MatchedConceptMap -> Maybe CodeConcept
forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup UID
u MatchedConceptMap
cm
  val <- maybe (valueOf <$> variableProc s t)
                (convExprProc . (^. codeExpr)) constDef
  pure $ maybe val conceptToGOOL cdCncpt

-- | If variable is an input, construct it with 'var' and pass to inputVariable.
-- If variable is a constant and 'Var' constant representation is chosen,
-- construct it with 'var' and pass to 'constVariable'.
-- If variable is a constant and 'Const' constant representation is chosen,
-- construct it with 'constant' and pass to 'constVariable'.
-- If variable is neither, just construct it with 'var' and return it.
variableProc
  :: (VariableSym r var typ)
  => Name -> VS (r typ) -> GenState (VS (r var))
variableProc :: forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> GenState (VS (r var))
variableProc Name
s VS (r typ)
t = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let cs = DrasilState
g
      defFunc ConstantRepr
Var = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var
      defFunc ConstantRepr
Const = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
constant -- This might be wrong
  if s `elem` fmap codeName (cs ^. inputs)
    then inputVariableProc (g ^. inStruct) Var (var s t)
    else if s `elem` fmap codeName (cs ^. constDefns)
      then constVariableProc (g ^. conStruct) (g ^. conRepr)
              ((defFunc $ g ^. conRepr) s t)
      else pure $ var s t

-- | If 'Unbundled' inputs, just return variable as-is.
-- If 'Bundled' inputs, throw an error, since procedural renderers
-- don't support 'Bundled' inputs yet.
inputVariableProc
  :: (VariableSym r var typ)
  => Structure -> ConstantRepr -> VS (r var) -> GenState (VS (r var))
inputVariableProc :: forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Structure -> ConstantRepr -> VS (r var) -> GenState (VS (r var))
inputVariableProc Structure
Unbundled ConstantRepr
_ VS (r var)
v = VS (r var) -> StateT DrasilState Identity (VS (r var))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure VS (r var)
v
inputVariableProc Structure
Bundled ConstantRepr
_ VS (r var)
_ = Name -> StateT DrasilState Identity (VS (r var))
forall a. HasCallStack => Name -> a
error Name
"inputVariableProc: Procedural renderers do not support bundled inputs"

-- | If 'Unbundled' constants, just return variable as-is.
-- If 'Bundled' constants, throw an error, since procedural renderers
-- don't support 'Bundled' constants yet.
-- If constants stored 'WithInputs', call 'inputVariable'.
-- If constants are 'Inline'd, the generator should not be attempting to make a
-- variable for one of the constants.
constVariableProc
  :: (VariableSym r var typ)
  => ConstantStructure
  -> ConstantRepr
  -> VS (r var)
  -> GenState (VS (r var))
constVariableProc :: forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
ConstantStructure
-> ConstantRepr -> VS (r var) -> GenState (VS (r var))
constVariableProc (Store Structure
Unbundled) ConstantRepr
_ VS (r var)
v = VS (r var) -> StateT DrasilState Identity (VS (r var))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure VS (r var)
v
constVariableProc (Store Structure
Bundled) ConstantRepr
_ VS (r var)
_ = Name -> StateT DrasilState Identity (VS (r var))
forall a. HasCallStack => Name -> a
error Name
"constVariableProc: Procedural renderers do not support bundled constants"
constVariableProc ConstantStructure
WithInputs ConstantRepr
cr VS (r var)
v = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  inputVariableProc (g ^. inStruct) cr v
constVariableProc ConstantStructure
Inline ConstantRepr
_ VS (r var)
_ = Name -> StateT DrasilState Identity (VS (r var))
forall a. HasCallStack => Name -> a
error (Name -> StateT DrasilState Identity (VS (r var)))
-> Name -> StateT DrasilState Identity (VS (r var))
forall a b. (a -> b) -> a -> b
$ Name
"mkVar called on a constant, but user " Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<>
  Name
"chose to Inline constants. Generator has a bug."

-- | Generates a GOOL Value for a variable represented by a 'CodeVarChunk'.
mkValProc
  ::
    ( NativeVector r val typ
    , TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , MathConstant r val
    , VariableSym r var typ
    , VariableValue r var val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , Argument r val
    , List r val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    )
  => CodeVarChunk -> GenState (VS (r val))
mkValProc :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(NativeVector r val typ, TypeSym r typ, ValueSym r val typ,
 Literal r val typ, MathConstant r val, VariableSym r var typ,
 VariableValue r var val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 Argument r val, List r val, Reference r val, Set r val,
 TypeElim r typ) =>
Input -> GenState (VS (r val))
mkValProc Input
v = do
  t <- Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v
  let toGOOLVal Maybe CodeChunk
Nothing = UID -> Name -> VS (r typ) -> GenState (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 NativeVector r val typ, MathConstant r val, VariableSym r var typ,
 VariableValue r var val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 Argument r val, List r val, Reference r val, Set r val,
 TypeElim r typ) =>
UID -> Name -> VS (r typ) -> GenState (VS (r val))
valueProc (Input
v Input -> Getting UID Input UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID Input UID
forall c. HasUID c => Getter c UID
Getter Input UID
uid) (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
t)
      toGOOLVal (Just CodeChunk
_) = Name -> GenState (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"mkValProc: Procedural renderers do not support objects"
  toGOOLVal (v ^. obv)

-- | Generates a GOOL Variable for a variable represented by a 'CodeVarChunk'.
mkVarProc
  :: (TypeSym r typ, VariableSym r var typ)
  => CodeVarChunk -> GenState (VS (r var))
mkVarProc :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Input -> GenState (VS (r var))
mkVarProc Input
v = do
  t <- Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v
  let toGOOLVar Maybe CodeChunk
Nothing = Name -> VS (r typ) -> GenState (VS (r var))
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> GenState (VS (r var))
variableProc (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
t)
      toGOOLVar (Just CodeChunk
_) = Name -> GenState (VS (r var))
forall a. HasCallStack => Name -> a
error Name
"mkVarProc: Procedural renderers do not support objects"
  toGOOLVar (v ^. obv)

-- | Converts a 'Mod' to GOOL.
genModDefProc
  ::
    ( NativeVector r val typ
    , MathConstant r val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , VariableValue r var val
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , StringStatement r stmt var val
    , FileHandling r stmt var val
    , ReadFile r stmt var val
    , PrintFile r stmt val
    , Argument r val
    , Array r var val
    , List r val
    , Reference r val
    , OO.Set r val
    , ProcProg r prg file mod mthd vis param bod block stmt var scope val binder typ
    , TypeElim r typ
    )
  => Mod -> GenState (FS (r file))
genModDefProc :: forall (r :: * -> *) val typ var binder bod stmt scope prg file mod
       mthd vis param block.
(NativeVector r val typ, MathConstant r val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, VariableValue r var val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 Array r var val, List r val, Reference r val, Set r val,
 ProcProg
   r
   prg
   file
   mod
   mthd
   vis
   param
   bod
   block
   stmt
   var
   scope
   val
   binder
   typ,
 TypeElim r typ) =>
Mod -> GenState (FS (r file))
genModDefProc (Mod Name
n Name
desc [Name]
is [Class]
cs [Func]
fs) = case [Class]
cs of
  [] -> Name
-> Name
-> [Name]
-> [GenState (Maybe (MS (r mthd)))]
-> GenState (FS (r file))
forall (r :: * -> *) prg file mod mthd vis param bod block stmt var
       scope val binder typ.
ProcProg
  r
  prg
  file
  mod
  mthd
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
Name
-> Name
-> [Name]
-> [GenState (Maybe (MS (r mthd)))]
-> GenState (FS (r file))
genModuleWithImportsProc Name
n Name
desc [Name]
is
          ((MS (r mthd) -> Maybe (MS (r mthd)))
-> StateT DrasilState Identity (MS (r mthd))
-> GenState (Maybe (MS (r mthd)))
forall a b.
(a -> b)
-> StateT DrasilState Identity a -> StateT DrasilState Identity b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap MS (r mthd) -> Maybe (MS (r mthd))
forall a. a -> Maybe a
Just (StateT DrasilState Identity (MS (r mthd))
 -> GenState (Maybe (MS (r mthd))))
-> (Func -> StateT DrasilState Identity (MS (r mthd)))
-> Func
-> GenState (Maybe (MS (r mthd)))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> StateT DrasilState Identity (MS (r mthd)))
-> [StateVariable]
-> Func
-> StateT DrasilState Identity (MS (r mthd))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (param :: k)
       (vis :: k) (scope :: k) (mthd :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, NativeVector r val typ, Literal r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val,
 ParameterSym r param var, VisibilitySym r vis, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, MethodSym r mthd vis param bod var typ, Set r val,
 TypeElim r typ, VariableElim r var typ) =>
(Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
genFuncProc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> StateT DrasilState Identity (MS (r mthd))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (vis :: k) (scope :: k) (stmt :: k) (bod :: k)
       (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 VisibilitySym r vis, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicFuncProc [] (Func -> GenState (Maybe (MS (r mthd))))
-> [Func] -> [GenState (Maybe (MS (r mthd)))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Func]
fs)
  [Class]
_  -> Name -> GenState (FS (r file))
forall a. HasCallStack => Name -> a
error Name
"genModDefProc: Procedural renderers do not support classes"

-- | Generates a GOOL Parameter for a parameter represented by a 'ParameterChunk'.
mkParamProc
  :: (TypeSym r typ, VariableSym r var typ, ParameterSym r param var)
  => ParameterChunk -> GenState (MS (r param))
mkParamProc :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (param :: k).
(TypeSym r typ, VariableSym r var typ, ParameterSym r param var) =>
ParameterChunk -> GenState (MS (r param))
mkParamProc ParameterChunk
p = do
  v <- Input -> GenState (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Input -> GenState (VS (r var))
mkVarProc (ParameterChunk -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar ParameterChunk
p)
  pure $ paramFunc (passBy p) v
  where paramFunc :: PassBy -> VS (r var) -> MS (r param)
paramFunc PassBy
Ref = VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
pointerParam
        paramFunc PassBy
Val = VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param

-- | Generates a public function.
publicFuncProc
  ::
    ( TypeSym r typ
    , OO.Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , ParameterSym r param var
    , VisibilitySym r vis
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , BlockSym r block stmt
    , BodySym r bod block
    , MethodSym r mthd vis param bod var typ
    , VariableElim r var typ
    )
  => Label
  -> VS (r typ)
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
publicFuncProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (vis :: k) (scope :: k) (stmt :: k) (bod :: k)
       (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 VisibilitySym r vis, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicFuncProc Name
n VS (r typ)
t Name
desc [ParameterChunk]
ps Maybe Name
r [MS (r block)]
b = do
  (DrasilState -> DrasilState) -> StateT DrasilState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (scope :: k) (stmt :: k) (bod :: k) (block :: k)
       (mthd :: k) (vis :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethodProc (Name
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public VS (r typ)
t) Name
n Name
desc [ParameterChunk]
ps Maybe Name
r [MS (r block)]
b

-- | Generates a private function.
privateFuncProc
  ::
    ( TypeSym r typ
    , OO.Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , ParameterSym r param var
    , VisibilitySym r vis
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , BlockSym r block stmt
    , BodySym r bod block
    , MethodSym r mthd vis param bod var typ
    , VariableElim r var typ
    )
  => Label
  -> VS (r typ)
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
privateFuncProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (vis :: k) (scope :: k) (stmt :: k) (bod :: k)
       (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 VisibilitySym r vis, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
privateFuncProc Name
n VS (r typ)
t Name
desc [ParameterChunk]
ps Maybe Name
r [MS (r block)]
b = do
  (DrasilState -> DrasilState) -> StateT DrasilState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  ([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (scope :: k) (stmt :: k) (bod :: k) (block :: k)
       (mthd :: k) (vis :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethodProc (Name
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private VS (r typ)
t) Name
n Name
desc [ParameterChunk]
ps Maybe Name
r [MS (r block)]
b

-- | Generates a function or method using the passed GOOL constructor. Other
-- parameters are the method's name, description, list of parameters,
-- description of what is returned (if applicable), and body.
genMethodProc
  ::
    ( TypeSym r typ
    , OO.Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , ParameterSym r param var
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , BlockSym r block stmt
    , BodySym r bod block
    , MethodSym r mthd vis param bod var typ
    , VariableElim r var typ
    )
  => ([MS (r param)] -> MS (r bod) -> MS (r mthd))
  -> Label
  -> Description
  -> [ParameterChunk]
  -> Maybe Description
  -> [MS (r block)]
  -> GenState (MS (r mthd))
genMethodProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (scope :: k) (stmt :: k) (bod :: k) (block :: k)
       (mthd :: k) (vis :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
([MS (r param)] -> MS (r bod) -> MS (r mthd))
-> Name
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
genMethodProc [MS (r param)] -> MS (r bod) -> MS (r mthd)
f Name
n Name
desc [ParameterChunk]
p Maybe Name
r [MS (r block)]
b = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  vars <- mapM (mkVarProc . quantvar) p
  ps <- mapM mkParamProc p
  bod <- logBody n vars b
  let fn = [MS (r param)] -> MS (r bod) -> MS (r mthd)
f [MS (r param)]
ps MS (r bod)
bod
  pComms <- mapM renderTermAndUnit p
  pure $ if CommentFunc `elem` (g ^. commented)
    then docFunc desc pComms r fn else fn

-- | Converts a 'Func' (from the Mod AST) to GOOL.
-- The function generator to use is passed as a parameter. Automatically adds
-- variable declaration statements for any undeclared variables. For methods,
-- the list of StateVariables is needed so they can be included in the list of
-- declared variables.
genFuncProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , ValueSym r val typ
    , NativeVector r val typ
    , OO.Literal r val typ
    , MathConstant r val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , VariableSym r var typ
    , VariableValue r var val
    , ParameterSym r param var
    , VisibilitySym r vis
    , ScopeSym r scope
    , MultiStatement r stmt
    , ValueStatement r stmt val
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , StringStatement r stmt var val
    , FileHandling r stmt var val
    , ReadFile r stmt var val
    , PrintFile r stmt val
    , Argument r val
    , Array r var val
    , List r val
    , ListStatement r stmt val
    , Reference r val
    , MethodSym r mthd vis param bod var typ
    , OO.Set r val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => (Name -> VS (r typ) -> Description -> [ParameterChunk] -> Maybe Description -> [MS (r block)] -> GenState (MS (r mthd)))
  -> [StateVariable]
  -> Func
  -> GenState (MS (r mthd))
genFuncProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (param :: k)
       (vis :: k) (scope :: k) (mthd :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, NativeVector r val typ, Literal r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val,
 ParameterSym r param var, VisibilitySym r vis, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, MethodSym r mthd vis param bod var typ, Set r val,
 TypeElim r typ, VariableElim r var typ) =>
(Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
genFuncProc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
f [StateVariable]
svs (FDef (FuncDef Name
n Name
desc [ParameterChunk]
parms Space
o Maybe Name
rd [FuncStmt]
s)) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  stmts <- mapM convStmtProc s
  vars <- mapM mkVarProc (fstdecl (g ^. systemdb) s
    \\ (fmap quantvar parms <> fmap stVar svs))
  t <- spaceCodeType o
  f n (convType t) desc parms rd [block $ (`varDec` local) <$> vars, block stmts]
genFuncProc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
_ [StateVariable]
_ (FDef (CtorDef {})) = Name -> GenState (MS (r mthd))
forall a. HasCallStack => Name -> a
error Name
"genFuncProc: Procedural renderers do not support constructors"
genFuncProc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
_ [StateVariable]
_ (FData (FuncData Name
n Name
desc DataDesc
ddef)) = Name -> Name -> DataDesc -> GenState (MS (r mthd))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (scope :: k)
       (param :: k) (vis :: k) (mthd :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, NativeVector r val typ, Literal r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 ParameterSym r param var, VisibilitySym r vis,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 List r val, ListStatement r stmt val, Reference r val, Set r val,
 MultiStatement r stmt, MethodSym r mthd vis param bod var typ,
 TypeElim r typ, VariableElim r var typ) =>
Name -> Name -> DataDesc -> GenState (MS (r mthd))
genDataFuncProc Name
n Name
desc DataDesc
ddef

-- | Converts a 'Mod'\'s functions to GOOL.
genModFuncsProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , NativeVector r val typ
    , MathConstant r val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , VariableSym r var typ
    , VariableValue r var val
    , ParameterSym r param var
    , VisibilitySym r vis
    , ScopeSym r scope
    , MultiStatement r stmt
    , ValueStatement r stmt val
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , StringStatement r stmt var val
    , FileHandling r stmt var val
    , ReadFile r stmt var val
    , PrintFile r stmt val
    , Argument r val
    , Array r var val
    , List r val
    , ListStatement r stmt val
    , Reference r val
    , MethodSym r mthd vis param bod var typ
    , OO.Set r val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => Mod -> [GenState (MS (r mthd))]
genModFuncsProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (param :: k)
       (vis :: k) (scope :: k) (mthd :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NativeVector r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val,
 ParameterSym r param var, VisibilitySym r vis, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, MethodSym r mthd vis param bod var typ, Set r val,
 TypeElim r typ, VariableElim r var typ) =>
Mod -> [GenState (MS (r mthd))]
genModFuncsProc (Mod Name
_ Name
_ [Name]
_ [Class]
_ [Func]
fs) = (Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (param :: k)
       (vis :: k) (scope :: k) (mthd :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, NativeVector r val typ, Literal r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val,
 ParameterSym r param var, VisibilitySym r vis, ScopeSym r scope,
 MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 Array r var val, List r val, ListStatement r stmt val,
 Reference r val, MethodSym r mthd vis param bod var typ, Set r val,
 TypeElim r typ, VariableElim r var typ) =>
(Name
 -> VS (r typ)
 -> Name
 -> [ParameterChunk]
 -> Maybe Name
 -> [MS (r block)]
 -> GenState (MS (r mthd)))
-> [StateVariable] -> Func -> GenState (MS (r mthd))
genFuncProc Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (param :: k) (vis :: k) (scope :: k) (stmt :: k) (bod :: k)
       (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ParameterSym r param var,
 VisibilitySym r vis, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
Name
-> VS (r typ)
-> Name
-> [ParameterChunk]
-> Maybe Name
-> [MS (r block)]
-> GenState (MS (r mthd))
publicFuncProc [] (Func -> GenState (MS (r mthd)))
-> [Func] -> [GenState (MS (r mthd))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Func]
fs

-- this is really ugly!!
-- | Read from a data description into an 'MS block' of 'MS Statement's.
readDataProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , NativeVector r val typ
    , MathConstant r val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , VariableSym r var typ
    , VariableValue r var val
    , ScopeSym r scope
    , DeclStatement r bod stmt var scope val
    , ControlStatement r bod stmt var val
    , StringStatement r stmt var val
    , FileHandling r stmt var val
    , ReadFile r stmt var val
    , Argument r val
    , List r val
    , ListStatement r stmt val
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    )
  => DataDesc -> GenState [MS (r block)]
readDataProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NativeVector r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val, ScopeSym r scope,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, Argument r val, List r val,
 ListStatement r stmt val, Reference r val, Set r val,
 TypeElim r typ) =>
DataDesc -> GenState [MS (r block)]
readDataProc DataDesc
ddef = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let localScope = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  inD <- mapM (`inData` localScope) ddef
  v_filename <- mkValProc (quantvar inFileName)
  pure [block $
    varDec var_infile localScope :
    (if any (\Data
d -> Data -> Bool
isLine Data
d Bool -> Bool -> Bool
|| Data -> Bool
isLines Data
d) ddef then [varDec var_line localScope,
    listDec 0 var_linetokens localScope] else []) <>
    [listDec 0 var_lines localScope | any isLines ddef] <> (openFileR var_infile
    v_filename : concat inD <> [closeFile v_infile])]
  where inData
          ::
            ( BlockSym r block stmt
            , BodySym r bod block
            , TypeSym r typ
            , OO.Literal r val typ
            , VariableSym r var typ
            , VariableValue r var val
            , ScopeSym r scope
            , NativeVector r val typ
            , List r val
            , ListStatement r stmt val
            , DeclStatement r bod stmt var scope val
            , ControlStatement r bod stmt var val
            , StringStatement r stmt var val
            , ReadFile r stmt var val
            )
          => Data -> r scope -> GenState [MS (r stmt)]
        inData :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 ScopeSym r scope, NativeVector r val typ, List r val,
 ListStatement r stmt val, DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, ReadFile r stmt var val) =>
Data -> r scope -> GenState [MS (r stmt)]
inData (Singleton Input
v) r scope
_ = do
            vv <- Input -> GenState (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Input -> GenState (VS (r var))
mkVarProc Input
v
            pure [getFileInput v_infile vv]
        inData Data
JunkData r scope
_ = [MS (r stmt)] -> StateT DrasilState Identity [MS (r stmt)]
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> MS (r stmt)
discardFileLine VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile]
        inData (Line LinePattern
lp Char
d) r scope
scp = do
          lnI <- Maybe Name
-> LinePattern
-> r scope
-> StateT DrasilState Identity [MS (r stmt)]
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (scope :: k) (stmt :: k) (bod :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val,
 NativeVector r val typ, ScopeSym r scope, ListStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 StringStatement r stmt var val) =>
Maybe Name -> LinePattern -> r scope -> GenState [MS (r stmt)]
lineData Maybe Name
forall a. Maybe a
Nothing LinePattern
lp r scope
scp
          pure $ [getFileInputLine v_infile var_line,
            stringSplit d var_linetokens v_line] <> lnI
        inData (Lines LinePattern
lp Maybe Integer
ls Char
d) r scope
scp = do
          lnV <- Maybe Name
-> LinePattern
-> r scope
-> StateT DrasilState Identity [MS (r stmt)]
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (scope :: k) (stmt :: k) (bod :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val,
 NativeVector r val typ, ScopeSym r scope, ListStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 StringStatement r stmt var val) =>
Maybe Name -> LinePattern -> r scope -> GenState [MS (r stmt)]
lineData (Name -> Maybe Name
forall a. a -> Maybe a
Just Name
"_temp") LinePattern
lp r scope
scp
          let readLines Maybe Integer
Nothing = [VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInputAll VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_lines,
                VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forRange VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_i (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0) (VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_lines) (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1)
                  ([MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements ([MS (r stmt)] -> MS (r bod)) -> [MS (r stmt)] -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ Char -> VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
Char -> VS (r var) -> VS (r val) -> MS (r stmt)
stringSplit Char
d VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_linetokens (
                  VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
listAccess VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_lines VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_i) MS (r stmt) -> [MS (r stmt)] -> [MS (r stmt)]
forall a. a -> [a] -> [a]
: [MS (r stmt)]
lnV)]
              readLines (Just Integer
numLines) = [VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forRange VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_i (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0)
                (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
numLines) (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1)
                ([MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements ([MS (r stmt)] -> MS (r bod)) -> [MS (r stmt)] -> MS (r bod)
forall a b. (a -> b) -> a -> b
$
                  [VS (r val) -> VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInputLine VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_line,
                   Char -> VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
StringStatement r stmt var val =>
Char -> VS (r var) -> VS (r val) -> MS (r stmt)
stringSplit Char
d VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_linetokens VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_line
                  ] [MS (r stmt)] -> [MS (r stmt)] -> [MS (r stmt)]
forall a. Semigroup a => a -> a -> a
<> [MS (r stmt)]
lnV)]
          pure $ readLines ls
        ---------------
        lineData
          ::
            ( TypeSym r typ
            , VariableSym r var typ
            , VariableValue r var val
            , NativeVector r val typ
            , ScopeSym r scope
            , ListStatement r stmt val
            , DeclStatement r bod stmt var scope val
            , StringStatement r stmt var val
            )
          => Maybe String -> LinePattern -> r scope -> GenState [MS (r stmt)]
        lineData :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (scope :: k) (stmt :: k) (bod :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val,
 NativeVector r val typ, ScopeSym r scope, ListStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 StringStatement r stmt var val) =>
Maybe Name -> LinePattern -> r scope -> GenState [MS (r stmt)]
lineData Maybe Name
s p :: LinePattern
p@(Straight [Input]
_) r scope
_ = do
          vs <- Maybe Name -> LinePattern -> GenState [VS (r var)]
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Maybe Name -> LinePattern -> GenState [VS (r var)]
getEntryVarsProc Maybe Name
s LinePattern
p
          pure [stringListVals vs v_linetokens]
        lineData Maybe Name
s p :: LinePattern
p@(Repeat [Input]
ds) r scope
scp = do
          vs <- Maybe Name -> LinePattern -> GenState [VS (r var)]
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Maybe Name -> LinePattern -> GenState [VS (r var)]
getEntryVarsProc Maybe Name
s LinePattern
p
          sequence $ clearTemps s ds scp <> (pure
            (stringListLists vs v_linetokens) : appendTemps s ds)
        ---------------
        clearTemps
          ::
            ( TypeSym r typ
            , VariableSym r var typ
            , ScopeSym r scope
            , DeclStatement r bod stmt var scope val
            )
          => Maybe String -> [DataItem] -> r scope -> [GenState (MS (r stmt))]
        clearTemps :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (scope :: k)
       (bod :: k) (stmt :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, ScopeSym r scope,
 DeclStatement r bod stmt var scope val) =>
Maybe Name -> [Input] -> r scope -> [GenState (MS (r stmt))]
clearTemps Maybe Name
Nothing    [Input]
_  r scope
_   = []
        clearTemps (Just Name
sfx) [Input]
es r scope
scp = (\Input
v -> Name -> Input -> r scope -> GenState (MS (r stmt))
forall {k} (r :: k -> *) (typ :: k) (var :: k) (scope :: k)
       (bod :: k) (stmt :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, ScopeSym r scope,
 DeclStatement r bod stmt var scope val) =>
Name -> Input -> r scope -> GenState (MS (r stmt))
clearTemp Name
sfx Input
v r scope
scp) (Input -> GenState (MS (r stmt)))
-> [Input] -> [GenState (MS (r stmt))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Input]
es
        ---------------
        clearTemp
          ::
            ( TypeSym r typ
            , VariableSym r var typ
            , ScopeSym r scope
            , DeclStatement r bod stmt var scope val
            )
          => String -> DataItem -> r scope -> GenState (MS (r stmt))
        clearTemp :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (scope :: k)
       (bod :: k) (stmt :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, ScopeSym r scope,
 DeclStatement r bod stmt var scope val) =>
Name -> Input -> r scope -> GenState (MS (r stmt))
clearTemp Name
sfx Input
v r scope
scp = (\CodeType
t -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef (Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
sfx)
          (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
t)) r scope
scp []) (CodeType -> MS (r stmt))
-> StateT DrasilState Identity CodeType
-> StateT DrasilState Identity (MS (r stmt))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v
        ---------------
        appendTemps
          ::
            ( TypeSym r typ
            , ListStatement r stmt val
            , VariableSym r var typ
            , VariableValue r var val
            )
          => Maybe String -> [DataItem] -> [GenState (MS (r stmt))]
        appendTemps :: forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (val :: k)
       (var :: k).
(TypeSym r typ, ListStatement r stmt val, VariableSym r var typ,
 VariableValue r var val) =>
Maybe Name -> [Input] -> [GenState (MS (r stmt))]
appendTemps Maybe Name
Nothing [Input]
_ = []
        appendTemps (Just Name
sfx) [Input]
es = Name -> Input -> GenState (MS (r stmt))
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (val :: k)
       (var :: k).
(TypeSym r typ, ListStatement r stmt val, VariableSym r var typ,
 VariableValue r var val) =>
Name -> Input -> GenState (MS (r stmt))
appendTemp Name
sfx (Input -> GenState (MS (r stmt)))
-> [Input] -> [GenState (MS (r stmt))]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Input]
es
        ---------------
        appendTemp
          ::
            ( TypeSym r typ
            , ListStatement r stmt val
            , VariableSym r var typ
            , VariableValue r var val
            )
          => String -> DataItem -> GenState (MS (r stmt))
        appendTemp :: forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (val :: k)
       (var :: k).
(TypeSym r typ, ListStatement r stmt val, VariableSym r var typ,
 VariableValue r var val) =>
Name -> Input -> GenState (MS (r stmt))
appendTemp Name
sfx Input
v = (\CodeType
t -> VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
listAppend
          (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf (VS (r var) -> VS (r val)) -> VS (r var) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
t))
          (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf (VS (r var) -> VS (r val)) -> VS (r var) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
sfx) (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
t))) (CodeType -> MS (r stmt))
-> StateT DrasilState Identity CodeType
-> StateT DrasilState Identity (MS (r stmt))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v

-- | Get entry variables.
getEntryVarsProc
  :: (TypeSym r typ, VariableSym r var typ)
  => Maybe String -> LinePattern -> GenState [VS (r var)]
getEntryVarsProc :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Maybe Name -> LinePattern -> GenState [VS (r var)]
getEntryVarsProc Maybe Name
s LinePattern
lp = (Input -> StateT DrasilState Identity (VS (r var)))
-> [Input] -> StateT DrasilState Identity [VS (r var)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM ((Input -> StateT DrasilState Identity (VS (r var)))
-> (Name -> Input -> StateT DrasilState Identity (VS (r var)))
-> Maybe Name
-> Input
-> StateT DrasilState Identity (VS (r var))
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Input -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Input -> GenState (VS (r var))
mkVarProc (\Name
st Input
v -> Input -> StateT DrasilState Identity CodeType
forall c. HasSpace c => c -> StateT DrasilState Identity CodeType
codeType Input
v StateT DrasilState Identity CodeType
-> (CodeType -> StateT DrasilState Identity (VS (r var)))
-> StateT DrasilState Identity (VS (r var))
forall a b.
StateT DrasilState Identity a
-> (a -> StateT DrasilState Identity b)
-> StateT DrasilState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
  (Name -> VS (r typ) -> StateT DrasilState Identity (VS (r var))
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> GenState (VS (r var))
variableProc (Input -> Name
forall c. CodeIdea c => c -> Name
codeName Input
v Name -> Name -> Name
forall a. Semigroup a => a -> a -> a
<> Name
st) (VS (r typ) -> StateT DrasilState Identity (VS (r var)))
-> (CodeType -> VS (r typ))
-> CodeType
-> StateT DrasilState Identity (VS (r var))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ))
-> (CodeType -> VS (r typ)) -> CodeType -> VS (r typ)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType))
    Maybe Name
s) (LinePattern -> [Input]
getPatternInputs LinePattern
lp)

-- | Converts an 'Expr' to a GOOL Value.
convExprProc
  ::
    ( TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , MathConstant r val
    , VariableSym r var typ
    , VariableValue r var val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , Argument r val
    , NativeVector r val typ
    , Reference r val
    , OO.Set r val
    , List r val
    , TypeElim r typ
    )
  => CodeExpr -> GenState (VS (r val))
convExprProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc (Lit (Dbl Double
d)) = do
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
Real
  let getLiteral CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble Double
d
      getLiteral CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Double -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
d)
      getLiteral CodeType
_ = Name -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Real space matched to invalid CodeType; should be Double or Float"
  pure $ getLiteral sm
convExprProc (Lit (ExactDbl Integer
d)) = CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall a b. (a -> b) -> a -> b
$ Literal -> CodeExpr
Lit (Literal -> CodeExpr) -> (Double -> Literal) -> Double -> CodeExpr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Literal
Dbl (Double -> CodeExpr) -> Double -> CodeExpr
forall a b. (a -> b) -> a -> b
$ Integer -> Double
forall a. Num a => Integer -> a
fromInteger Integer
d
convExprProc (Lit (Int Integer
i))      = VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r val) -> StateT DrasilState Identity (VS (r val)))
-> VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a b. (a -> b) -> a -> b
$ Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
i
convExprProc (Lit (Str Name
s))      = VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r val) -> StateT DrasilState Identity (VS (r val)))
-> VS (r val) -> StateT DrasilState Identity (VS (r val))
forall a b. (a -> b) -> a -> b
$ Name -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Name -> VS (r val)
litString Name
s
convExprProc (Lit (Perc Integer
a Integer
b)) = do
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
Rational
  let getLiteral CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble
      getLiteral CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Float -> VS (r val)) -> (Double -> Float) -> Double -> VS (r val)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> Float
forall a b. (Real a, Fractional b) => a -> b
realToFrac
      getLiteral CodeType
_ = Name -> Double -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Rational space matched to invalid CodeType; should be Double or Float"
  pure $ getLiteral sm (fromIntegral a / (10 ** fromIntegral b))
convExprProc (AssocA AssocArithOper
Add [CodeExpr]
l) = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#+)  ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
convExprProc (AssocA AssocArithOper
Mul [CodeExpr]
l) = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#*)  ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
convExprProc (AssocB AssocBoolOper
And [CodeExpr]
l) = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?&&) ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
convExprProc (AssocB AssocBoolOper
Or [CodeExpr]
l)  = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(?||) ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
convExprProc (AssocC AssocConcatOper
SUnion [CodeExpr]
l)  = (VS (r val) -> VS (r val) -> VS (r val))
-> [VS (r val)] -> VS (r val)
forall a. (a -> a -> a) -> [a] -> a
forall (t :: * -> *) a. Foldable t => (a -> a -> a) -> t a -> a
foldl1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
(#+) ([VS (r val)] -> VS (r val))
-> StateT DrasilState Identity [VS (r val)]
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
convExprProc (C UID
c) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let v = DefinedQuantityDict -> Input
forall c. (Quantity c, MayHaveUnit c, Concept c) => c -> Input
quantvar (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
c)
  mkValProc v
convExprProc (FCall UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns) = UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> StateT DrasilState Identity (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val, List r val,
 NativeVector r val typ, Reference r val, Set r val,
 TypeElim r typ) =>
UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> GenState (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> GenState (VS (r val))
convCallProc UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, Argument r val, TypeElim r typ,
 ValueExpression r var val binder typ) =>
Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
fAppProc Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
Name -> MixedCall r var val typ
libFuncAppMixedArgs
convExprProc (New {}) = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Procedural renderers do not support object creation"
convExprProc (Message {}) = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Procedural renderers do not support methods"
convExprProc (Field UID
_ UID
_) = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Procedural renderers do not support object field access"
convExprProc (UnaryOp UFunc
o CodeExpr
u)    = UFunc -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
(NumericExpression r val, Reference r val) =>
UFunc -> VS (r val) -> VS (r val)
unop UFunc
o (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
u
convExprProc (UnaryOpB UFuncB
o CodeExpr
u)   = UFuncB -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
UFuncB -> VS (r val) -> VS (r val)
unopB UFuncB
o (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
u
convExprProc (UnaryOpVV UFuncVV
NegV CodeExpr
u) = VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecScale (Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble (-Double
1)) (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
u
convExprProc (UnaryOpVN UFuncVN
Dim CodeExpr
u)  = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
u
convExprProc (UnaryOpVN UFuncVN
Norm CodeExpr
u) = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val)
vecMag (VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
u
convExprProc (ArithBinaryOp ArithBinOp
Frac (Lit (Int Integer
a)) (Lit (Int Integer
b))) = do -- hack to deal with integer division
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
Rational
  let getLiteral CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble (Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
a) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble (Integer -> Double
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
b)
      getLiteral CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
a) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat (Integer -> Float
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
b)
      getLiteral CodeType
_ = Name -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Rational space matched to invalid CodeType; should be Double or Float"
  pure $ getLiteral sm
convExprProc (ArithBinaryOp ArithBinOp
o CodeExpr
a CodeExpr
b) = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (ArithBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
ArithBinOp -> VS (r val) -> VS (r val) -> VS (r val)
arithBfunc ArithBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (LABinaryOp LABinOp
o CodeExpr
a CodeExpr
b)    = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (LABinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
LABinOp -> VS (r val) -> VS (r val) -> VS (r val)
laBfunc LABinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (EqBinaryOp EqBinOp
o CodeExpr
a CodeExpr
b)    = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (EqBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
EqBinOp -> VS (r val) -> VS (r val) -> VS (r val)
eqBfunc EqBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (OrdBinaryOp OrdBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (OrdBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
OrdBinOp -> VS (r val) -> VS (r val) -> VS (r val)
ordBfunc OrdBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (VVVBinaryOp VVVBinOp
VAdd CodeExpr
a CodeExpr
b)  = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecAdd (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (VVVBinaryOp VVVBinOp
VSub CodeExpr
a CodeExpr
b) = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (\VS (r val)
x VS (r val)
y -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecAdd VS (r val)
x (VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecScale (Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble (-Double
1)) VS (r val)
y)) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (VVVBinaryOp VVVBinOp
Cross CodeExpr
_ CodeExpr
_) = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Cross product not implemented"
convExprProc (VVNBinaryOp VVNBinOp
Dot CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecDot (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (NVVBinaryOp NVVBinOp
Scale CodeExpr
a CodeExpr
b) = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val) -> VS (r val)
vecScale (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (ESSBinaryOp ESSBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (ESSBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
ESSBinOp -> VS (r val) -> VS (r val) -> VS (r val)
elementSetSetBfunc ESSBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (ESBBinaryOp ESBBinOp
o CodeExpr
a CodeExpr
b)   = (VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 r.
Monad m =>
(a1 -> a2 -> r) -> m a1 -> m a2 -> m r
liftM2 (ESBBinOp -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Set r val =>
ESBBinOp -> VS (r val) -> VS (r val) -> VS (r val)
elementSetBoolBfunc ESBBinOp
o) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
b)
convExprProc (Case Completeness
c [(CodeExpr, CodeExpr)]
l)            = [(CodeExpr, CodeExpr)] -> StateT DrasilState Identity (VS (r val))
doit [(CodeExpr, CodeExpr)]
l -- FIXME this is sub-optimal
  where
    doit :: [(CodeExpr, CodeExpr)] -> StateT DrasilState Identity (VS (r val))
doit [] = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"should never happen" -- TODO: change error message?
    doit [(CodeExpr
e,CodeExpr
_)] = CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e -- should always be the else clause
    doit ((CodeExpr
e,CodeExpr
cond):[(CodeExpr, CodeExpr)]
xs) = (VS (r val) -> VS (r val) -> VS (r val) -> VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
-> StateT DrasilState Identity (VS (r val))
forall (m :: * -> *) a1 a2 a3 r.
Monad m =>
(a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
liftM3 VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
inlineIf (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
cond) (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e)
      (CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc (Completeness -> [(CodeExpr, CodeExpr)] -> CodeExpr
Case Completeness
c [(CodeExpr, CodeExpr)]
xs))
convExprProc (Matrix [[CodeExpr]
l]) = do
  ar <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
                                    -- hd will never fail here
  pure $ litArray (valueType <$> head ar) ar
convExprProc Matrix{} = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Matrix"
convExprProc (S.Set Space
s [CodeExpr]
l) = do
  ar <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
l
  sm <- spaceCodeType s
  pure $ litSet (convType sm) ar
convExprProc (Variable Name
s (S.Set Space
l [CodeExpr]
_)) = do
  sm <- Space -> StateT DrasilState Identity CodeType
spaceCodeType Space
l
  let varSet = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
s (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
setType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
sm)
  pure $ valueOf varSet
convExprProc (Variable Name
_ CodeExpr
_) = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExpr: Variable"
convExprProc Operator{} = Name -> StateT DrasilState Identity (VS (r val))
forall a. HasCallStack => Name -> a
error Name
"convExprProc: Operator"
convExprProc (RealI UID
c RealInterval CodeExpr CodeExpr
ri)  = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  convExprProc $ renderRealInt (lookupC g c) ri

-- | Generates a function call, based on the 'UID' of the chunk representing
-- the function, the list of argument 'Expr's, the list of named argument 'Expr's,
-- the function call generator to use, and the library version of the function
-- call generator (used if the function is in the library export map).
convCallProc
  ::
    ( TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , MathConstant r val
    , VariableSym r var typ
    , VariableValue r var val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , Argument r val
    , List r val
    , NativeVector r val typ
    , Reference r val
    , OO.Set r val
    , TypeElim r typ
    )
  => UID
  -> [CodeExpr]
  -> [(UID, CodeExpr)]
  -> (Name -> Name -> VS (r typ) -> [VS (r val)] -> NamedArgs r var val -> GenState (VS (r val)))
  -> (Name -> Name -> VS (r typ) -> [VS (r val)] -> NamedArgs r var val -> VS (r val))
  -> GenState (VS (r val))
convCallProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val, List r val,
 NativeVector r val typ, Reference r val, Set r val,
 TypeElim r typ) =>
UID
-> [CodeExpr]
-> [(UID, CodeExpr)]
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> GenState (VS (r val)))
-> (Name
    -> Name
    -> VS (r typ)
    -> [VS (r val)]
    -> NamedArgs r var val
    -> VS (r val))
-> GenState (VS (r val))
convCallProc UID
c [CodeExpr]
x [(UID, CodeExpr)]
ns Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
f Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
libf = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let mem = DrasilState -> Map Name Name
eMap DrasilState
g
      lem = DrasilState -> Map Name Name
libEMap DrasilState
g
      funcCd = DefinedQuantityDict -> CodeFuncChunk
forall c.
(Quantity c, MayHaveUnit c, Concept c) =>
c -> CodeFuncChunk
quantfunc (DrasilState -> UID -> DefinedQuantityDict
lookupC DrasilState
g UID
c)
      funcNm = CodeFuncChunk -> Name
forall c. CodeIdea c => c -> Name
codeName CodeFuncChunk
funcCd
  funcTp <- codeType funcCd
  args <- mapM convExprProc x
  nms <- mapM (mkVarProc . quantvar . lookupC g . fst) ns
  nargs <- mapM (convExprProc . snd) ns
  maybe (maybe (error $ "Call to non-existent function " <> funcNm)
      (\Name
m -> VS (r val) -> GenState (VS (r val))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (VS (r val) -> GenState (VS (r val)))
-> VS (r val) -> GenState (VS (r val))
forall a b. (a -> b) -> a -> b
$ Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
libf Name
m Name
funcNm (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
funcTp) [VS (r val)]
args ([VS (r var)] -> [VS (r val)] -> NamedArgs r var val
forall a b. [a] -> [b] -> [(a, b)]
zip [VS (r var)]
nms [VS (r val)]
nargs))
      (Map.lookup funcNm lem))
    (\Name
m -> Name
-> Name
-> VS (r typ)
-> [VS (r val)]
-> NamedArgs r var val
-> GenState (VS (r val))
f Name
m Name
funcNm (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
funcTp) [VS (r val)]
args ([VS (r var)] -> [VS (r val)] -> NamedArgs r var val
forall a b. [a] -> [b] -> [(a, b)]
zip [VS (r var)]
nms [VS (r val)]
nargs))
    (Map.lookup funcNm mem)

-- | Converts a 'FuncStmt' to a GOOL Statement.
convStmtProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , ValueSym r val typ
    , OO.Literal r val typ
    , MathConstant r val
    , ScopeSym r scope
    , VariableSym r var typ
    , VariableValue r var val
    , BooleanExpression r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , Comparison r val
    , Argument r val
    , Array r var val
    , List r val
    , ListStatement r stmt val
    , NativeVector r val typ
    , Reference r val
    , OO.Set r val
    , MultiStatement r stmt
    , ValueStatement r stmt val
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , TypeElim r typ
    , VariableElim r var typ
    )
  => FuncStmt -> GenState (MS (r stmt))
convStmtProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc (FAsg Input
v (Matrix [[CodeExpr]
es])) = do
  els <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
es
  v' <- mkVarProc v
  t <- codeType v
  let listFunc (OO.List CodeType
_) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litList
      listFunc (OO.Array CodeType
_) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litArray
      listFunc CodeType
_ = Name -> VS (r typ) -> [VS (r val)] -> VS (r val)
forall a. HasCallStack => Name -> a
error Name
"Type mismatch between variable and value in assignment FuncStmt"
  pure $ assign v' (listFunc t (innerType $ variableType <$> v')
    els)
convStmtProc (FAsg Input
v CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e
  v' <- mkVarProc v
  pure $ assign v' e'
convStmtProc (FAsgIndex Input
v Integer
i CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e
  v' <- mkVarProc v
  t <- codeType v
  let asgFunc (OO.List CodeType
_) = VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
listSet (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
v') (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
i) VS (r val)
e'
      asgFunc (OO.Array CodeType
_) = VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
assign (VS (r val) -> VS (r val) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k).
Array r var val =>
VS (r val) -> VS (r val) -> VS (r var)
arrayElem (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
v') (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
i)) VS (r val)
e'
      asgFunc CodeType
_ = Name -> MS (r stmt)
forall a. HasCallStack => Name -> a
error Name
"FAsgIndex used with non-indexed value"
  pure $ asgFunc t
convStmtProc (FFor Input
v CodeExpr
start CodeExpr
end CodeExpr
step [FuncStmt]
st) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
st
  vari <- mkVarProc v
  start' <- convExprProc start
  end' <- convExprProc end
  step' <- convExprProc step
  pure $ forRange vari start' end' step' (bodyStatements stmts)
convStmtProc (FForEach Input
v CodeExpr
e [FuncStmt]
st) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
st
  vari <- mkVarProc v
  e' <- convExprProc e
  pure $ forEach vari e' (bodyStatements stmts)
convStmtProc (FWhile CodeExpr
e [FuncStmt]
st) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
st
  e' <- convExprProc e
  pure $ while e' (bodyStatements stmts)
convStmtProc (FCond CodeExpr
e [FuncStmt]
tSt []) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
tSt
  e' <- convExprProc e
  pure $ ifNoElse [(e', bodyStatements stmts)]
convStmtProc (FCond CodeExpr
e [FuncStmt]
tSt [FuncStmt]
eSt) = do
  stmt1 <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
tSt
  stmt2 <- mapM convStmtProc eSt
  e' <- convExprProc e
  pure $ ifCond [(e', bodyStatements stmt1)] (bodyStatements stmt2)
convStmtProc (FRet CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e
  pure $ returnStmt e'
convStmtProc (FThrow Name
s) = MS (r stmt) -> StateT DrasilState Identity (MS (r stmt))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (MS (r stmt) -> StateT DrasilState Identity (MS (r stmt)))
-> MS (r stmt) -> StateT DrasilState Identity (MS (r stmt))
forall a b. (a -> b) -> a -> b
$ Name -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
Name -> MS (r stmt)
throw Name
s
convStmtProc (FTry [FuncStmt]
t [FuncStmt]
c) = do
  stmt1 <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
t
  stmt2 <- mapM convStmtProc c
  pure $ tryCatch (bodyStatements stmt1) (bodyStatements stmt2)
convStmtProc FuncStmt
FContinue = MS (r stmt) -> StateT DrasilState Identity (MS (r stmt))
forall a. a -> StateT DrasilState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
continue
convStmtProc (FDecDef Input
v (Matrix [[]])) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let scp = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  vari <- mkVarProc v
  let convDec (OO.List CodeType
_) = Integer -> VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
Integer -> VS (r var) -> r scope -> MS (r stmt)
listDec Integer
0 VS (r var)
vari
      convDec (OO.Array CodeType
_) = Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
arrayDec Integer
0 VS (r val)
forall a. HasCallStack => a
undefined VS (r var)
vari
      convDec CodeType
_ = VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> MS (r stmt)
varDec VS (r var)
vari
  (`convDec` scp) <$> codeType v
convStmtProc (FDecDef Input
v CodeExpr
e) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let scp = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  v' <- mkVarProc v
  t <- codeType v
  let convDecDef (Matrix [[CodeExpr]
lst]) = do
        let contDecDef :: CodeType -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
contDecDef (OO.List CodeType
_) = VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef
            contDecDef (OO.Array CodeType
_) = VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
arrayDecDef
            contDecDef CodeType
_ = Name -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall a. HasCallStack => Name -> a
error Name
"Type mismatch between variable and value in declare-define FuncStmt"
        e' <- (CodeExpr -> StateT DrasilState Identity (VS (r val)))
-> [CodeExpr] -> StateT DrasilState Identity [VS (r val)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc [CodeExpr]
lst
        pure $ contDecDef t v' scp e'
      convDecDef CodeExpr
_ = do
        e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e
        pure $ varDecDef v' scp e'
  convDecDef e
convStmtProc (FFuncDef CodeFuncChunk
f [ParameterChunk]
ps [FuncStmt]
sts) = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  let scp = ScopeType -> r scope
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeType -> r scope
convScope (ScopeType -> r scope) -> ScopeType -> r scope
forall a b. (a -> b) -> a -> b
$ DrasilState -> ScopeType
currentScope DrasilState
g
  f' <- mkVarProc (quantvar f)
  pms <- mapM (mkVarProc . quantvar) ps
  b <- mapM convStmtProc sts
  pure $ funcDecDef f' scp pms (bodyStatements b)
convStmtProc (FVal CodeExpr
e) = do
  e' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
e
  pure $ valStmt e'
convStmtProc (FMulti [FuncStmt]
ss) = do
  stmts <- (FuncStmt -> StateT DrasilState Identity (MS (r stmt)))
-> [FuncStmt] -> StateT DrasilState Identity [MS (r stmt)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM FuncStmt -> StateT DrasilState Identity (MS (r stmt))
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k) (binder :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, MathConstant r val,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, NumericExpression r val,
 ValueExpression r var val binder typ, Comparison r val,
 Argument r val, Array r var val, List r val,
 ListStatement r stmt val, NativeVector r val typ, Reference r val,
 Set r val, MultiStatement r stmt, ValueStatement r stmt val,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeElim r typ,
 VariableElim r var typ) =>
FuncStmt -> GenState (MS (r stmt))
convStmtProc [FuncStmt]
ss
  pure $ multi stmts
convStmtProc (FAppend CodeExpr
a CodeExpr
b) = do
  a' <- CodeExpr -> StateT DrasilState Identity (VS (r val))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, Literal r val typ,
 MathConstant r val, VariableSym r var typ, VariableValue r var val,
 BooleanExpression r val, Comparison r val, NumericExpression r val,
 ValueExpression r var val binder typ, Argument r val,
 NativeVector r val typ, Reference r val, Set r val, List r val,
 TypeElim r typ) =>
CodeExpr -> GenState (VS (r val))
convExprProc CodeExpr
a
  b' <- convExprProc b
  pure $ listAppend a' b'

-- | Generates a function that reads a file whose format is based on the passed
-- 'DataDesc'.
genDataFuncProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , ValueSym r val typ
    , NativeVector r val typ
    , OO.Literal r val typ
    , MathConstant r val
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , ScopeSym r scope
    , VariableSym r var typ
    , VariableValue r var val
    , ParameterSym r param var
    , VisibilitySym r vis
    , DeclStatement r bod stmt var scope val
    , ControlStatement r bod stmt var val
    , StringStatement r stmt var val
    , FileHandling r stmt var val
    , ReadFile r stmt var val
    , PrintFile r stmt val
    , Argument r val
    , List r val
    , ListStatement r stmt val
    , Reference r val
    , OO.Set r val
    , MultiStatement r stmt
    , MethodSym r mthd vis param bod var typ
    , TypeElim r typ
    , VariableElim r var typ
    )
  => Name -> Description -> DataDesc -> GenState (MS (r mthd))
genDataFuncProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (scope :: k)
       (param :: k) (vis :: k) (mthd :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, NativeVector r val typ, Literal r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 ScopeSym r scope, VariableSym r var typ, VariableValue r var val,
 ParameterSym r param var, VisibilitySym r vis,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, PrintFile r stmt val, Argument r val,
 List r val, ListStatement r stmt val, Reference r val, Set r val,
 MultiStatement r stmt, MethodSym r mthd vis param bod var typ,
 TypeElim r typ, VariableElim r var typ) =>
Name -> Name -> DataDesc -> GenState (MS (r mthd))
genDataFuncProc Name
nameTitle Name
desc DataDesc
ddef = do
  let parms :: [Input]
parms = DataDesc -> [Input]
getInputs DataDesc
ddef
  bod <- DataDesc -> GenState [MS (r block)]
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (binder :: k) (scope :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NativeVector r val typ,
 MathConstant r val, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val, ScopeSym r scope,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val,
 StringStatement r stmt var val, FileHandling r stmt var val,
 ReadFile r stmt var val, Argument r val, List r val,
 ListStatement r stmt val, Reference r val, Set r val,
 TypeElim r typ) =>
DataDesc -> GenState [MS (r block)]
readDataProc DataDesc
ddef
  publicFuncProc nameTitle void desc (pcAuto <$> quantvar inFileName : parms)
    Nothing bod

-- | Generates a public function, defined by its inputs and outputs.
publicInOutFuncProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , OO.Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , VisibilitySym r vis
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , MethodSym r mthd vis param bod var typ
    , VariableElim r var typ
    )
  => Label
  -> Description
  -> [CodeVarChunk]
  -> [CodeVarChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
publicInOutFuncProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (vis :: k) (scope :: k)
       (mthd :: k) (param :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 VisibilitySym r vis, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
publicInOutFuncProc Name
n = ([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (scope :: k) (stmt :: k) (bod :: k) (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 VariableElim r var typ) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
genInOutFuncProc (Name
-> r vis
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name -> r vis -> InOutFunc r mthd bod var
inOutFunc Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public) (Name
-> r vis
-> Name
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name -> r vis -> DocInOutFunc r mthd bod var
docInOutFunc Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public) Name
n

-- | Generates a private function, defined by its inputs and outputs.
privateInOutFuncProc
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , TypeSym r typ
    , OO.Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , VisibilitySym r vis
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , MethodSym r mthd vis param bod var typ
    , VariableElim r var typ
    )
  => Label
  -> Description
  -> [CodeVarChunk]
  -> [CodeVarChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
privateInOutFuncProc :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (typ :: k) (val :: k) (var :: k) (vis :: k) (scope :: k)
       (mthd :: k) (param :: k).
(BlockSym r block stmt, BodySym r bod block, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 VisibilitySym r vis, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 MethodSym r mthd vis param bod var typ, VariableElim r var typ) =>
Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
privateInOutFuncProc Name
n = ([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (scope :: k) (stmt :: k) (bod :: k) (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 VariableElim r var typ) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
genInOutFuncProc (Name
-> r vis
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name -> r vis -> InOutFunc r mthd bod var
inOutFunc Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private) (Name
-> r vis
-> Name
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Name -> r vis -> DocInOutFunc r mthd bod var
docInOutFunc Name
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
private) Name
n

-- | Generates a function or method defined by its inputs and outputs.
-- Parameters are: the GOOL constructor to use, the equivalent GOOL constructor
-- for a documented function/method, the visibility, attachment, name, description,
-- list of inputs, list of outputs, and body.
genInOutFuncProc
  ::
    ( TypeSym r typ
    , OO.Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , FileHandling r stmt var val
    , PrintFile r stmt val
    , BlockSym r block stmt
    , BodySym r bod block
    , VariableElim r var typ
    )
  => ([VS (r var)] -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
  -> (String -> [(String, VS (r var))] -> [(String, VS (r var))] -> [(String, VS (r var))] -> MS (r bod) -> MS (r mthd))
  -> Label
  -> Description
  -> [CodeVarChunk]
  -> [CodeVarChunk]
  -> [MS (r block)]
  -> GenState (MS (r mthd))
genInOutFuncProc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (scope :: k) (stmt :: k) (bod :: k) (block :: k) (mthd :: k).
(TypeSym r typ, Literal r val typ, VariableSym r var typ,
 VariableValue r var val, ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 FileHandling r stmt var val, PrintFile r stmt val,
 BlockSym r block stmt, BodySym r bod block,
 VariableElim r var typ) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> (Name
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> [(Name, VS (r var))]
    -> MS (r bod)
    -> MS (r mthd))
-> Name
-> Name
-> [Input]
-> [Input]
-> [MS (r block)]
-> GenState (MS (r mthd))
genInOutFuncProc [VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f Name
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> [(Name, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
docf Name
n Name
desc [Input]
ins' [Input]
outs' [MS (r block)]
b = do
  g <- StateT DrasilState Identity DrasilState
forall s (m :: * -> *). MonadState s m => m s
get
  modify (\DrasilState
st -> DrasilState
st {currentScope = Local})
  let ins = [Input]
ins' [Input] -> [Input] -> [Input]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Input]
outs'
      outs = [Input]
outs' [Input] -> [Input] -> [Input]
forall a. Eq a => [a] -> [a] -> [a]
\\ [Input]
ins'
      both = [Input]
ins' [Input] -> [Input] -> [Input]
forall a. Eq a => [a] -> [a] -> [a]
`intersect` [Input]
outs'
  inVs <- mapM mkVarProc ins
  outVs <- mapM mkVarProc outs
  bothVs <- mapM mkVarProc both
  bod <- logBody n (bothVs <> inVs) b
  pComms <- mapM renderTermAndUnit ins
  oComms <- mapM renderTermAndUnit outs
  bComms <- mapM renderTermAndUnit both
  pure $ if CommentFunc `elem` g ^. commented
    then docf desc (zip pComms inVs) (zip oComms outVs) (zip
    bComms bothVs) bod else f inVs outVs bothVs bod

-- Used for readData and readDataProc
l_line, l_lines, l_linetokens, l_infile, l_i :: Label
var_line, var_lines, var_linetokens, var_infile, var_i ::
  (TypeSym r typ, VariableSym r var typ) => VS (r var)
v_line, v_lines, v_linetokens, v_infile, v_i ::
  (TypeSym r typ, VariableSym r var typ, VariableValue r var val) => VS (r val)
l_line :: Name
l_line = Name
"line"
var_line :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_line = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
l_line VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string
v_line :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_line = VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_line
l_lines :: Name
l_lines = Name
"lines"
var_lines :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_lines = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
l_lines (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)
v_lines :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_lines = VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_lines
l_linetokens :: Name
l_linetokens = Name
"linetokens"
var_linetokens :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_linetokens = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
l_linetokens (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)
v_linetokens :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_linetokens = VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_linetokens
l_infile :: Name
l_infile = Name
"infile"
var_infile :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_infile = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
l_infile VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile
v_infile :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_infile = VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_infile
l_i :: Name
l_i = Name
"i"
var_i :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_i = Name -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Name -> VS (r typ) -> VS (r var)
var Name
l_i VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
v_i :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
v_i = VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
var_i