{-# LANGUAGE TypeFamilies #-}
-- | The logic to render Julia code is contained in this module
module Drasil.GProc.LanguageRenderer.JuliaRenderer (
  -- * Julia Code Configuration -- defines syntax of all Julia code
  JuliaCode(..), jlName, jlVersion
) where

import Drasil.FileHandling.Legacy (indent)

import Drasil.Shared.CodeType (CodeType(..))
import Drasil.Shared.InterfaceCommon (UnRepr(..), Label, Body, Value, Variable,
  Block, BodySym(..), BlockSym(..), TypeSym(..), TypeElim(..), getTypeString,
  VariableSym(..), VariableElim(..), ValueSym(..), Argument(..), Literal(..),
  MathConstant(..), VariableValue(..), CommandLineArgs(..),
  NumericExpression(..), BooleanExpression(..), Comparison(..),
  ValueExpression(..), funcApp, extFuncApp, libFuncApp, IndexTranslator(..),
  Reference(..), Array(..), List(..), ListStatement(..), Set(..),
  NativeVector(..), InternalList(..), EmptyStatement(..), MultiStatement(..),
  ValueStatement(..), AssignStatement(..), DeclStatement(..), PrintConsole(..),
  ReadConsole(..), FileHandling(..), PrintFile(..), ReadFile(..),
  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
  ControlStatement(..), VisibilitySym(..), ScopeSym(..), ParameterSym(..),
  BinderSym(..), BinderElim(..), MethodSym(..), (&=), switchAsIf, convScope)
import Drasil.GProc.InterfaceProc (ProcProg, ProgramSym(..), FileSym(..),
  ModuleSym(..))

import Drasil.Shared.RendererClassesCommon (CommonRenderSym, ImportSym(..),
  RenderBody(..), BodyElim, RenderBlock(..), BlockElim, RenderType(..),
  UnaryOpSym(..), BinaryOpSym(..), OpElim(uOpPrec, bOpPrec), RenderVariable(..),
  InternalVarElim(variableBind), RenderValue(..), ValueElim(..),
  InternalListFunc(..), RenderFunction(..), FunctionElim(functionType),
  InternalAssignStmt(..), InternalIOStmt(..), InternalControlStmt(..),
  RenderStatement(..), StatementElim(statementTerm), RenderVisibility(..),
  VisibilityElim, MethodTypeSym(..), RenderParam(..),
  ParamElim(parameterName, parameterType), RenderMethod(..), MethodElim,
  BlockCommentSym(..), BlockCommentElim, ScopeElim(..), InternalBinderElim(..))
import qualified Drasil.Shared.RendererClassesCommon as RC (import', body, block,
  uOp, bOp, variable, value, function, statement, visibility, parameter, method,
  blockComment')
import Drasil.GProc.RendererClassesProc (ProcRenderSym, RenderFile(..),
  RenderMod(..), ModuleElim, ProcRenderMethod(..))
import qualified Drasil.GProc.RendererClassesProc as RC (module')
import Drasil.Shared.LanguageRenderer (printLabel, listSep, listSep',
  parameterList, forLabel, inLabel, tryLabel, catchLabel,
  valueList, binderList)
import qualified Drasil.Shared.LanguageRenderer as R (sqrt, abs, log10, log,
  exp, sin, cos, tan, asin, acos, atan, floor, ceil, multiStmt, body,
  addComments, blockCmt, docCmt, commentedMod, commentedItem, break, continue,
  constDec', assign, subAssign, addAssign)
import Drasil.Shared.LanguageRenderer.Constructors (mkVal, mkStateVal, VSOp,
  unOpPrec, powerPrec, unExpr, unExpr', binExpr, multPrec, typeUnExpr,
  typeBinExpr, mkStmtNoEnd, typeFromData)
import Drasil.Shared.LanguageRenderer.LanguagePolymorphic (OptionalSpace(..))
import qualified Drasil.Shared.LanguageRenderer.LanguagePolymorphic as G (
  block, multiBlock, litChar, litDouble, litInt, litString, valueOf, negateOp,
  equalOp, notEqualOp, greaterOp, greaterEqualOp, lessOp, lessEqualOp, plusOp,
  minusOp, multOp, divideOp, moduloOp, call, funcAppMixedArgs, lambda,
  listAccess, tryCatch, csc, multiBody, sec, cot, stmt, loopStmt, emptyStmt,
  print, comment, valStmt, returnStmt, param, docFunc, throw, arg, argsList,
  ifCond, smartAdd, local, var, smartSub)
import Drasil.GProc.Renderers (renderType)

import qualified Drasil.Shared.LanguageRenderer.Common as CS

import qualified Drasil.Shared.LanguageRenderer.CommonPseudoOO as CP (listDec,
  listDecDef, listSet, notNull, functionDoc, intToIndex', indexToInt', inOutFunc,
  docInOutFunc', forLoopError, openFileR', openFileW', openFileA', multiReturn,
  multiAssign, inOutCall, mainBody, argExists, litSet)

import qualified Drasil.Shared.LanguageRenderer.CLike as C (litTrue, litFalse,
  notOp, andOp, orOp, inlineIf, while)

import qualified Drasil.GProc.LanguageRenderer.AbstractProc as A (fileDoc,
  fileFromData, buildModule, docMod, modFromData, listAppend, listAdd,
  innerType, arrayElem, funcDecDef, function)
import qualified Drasil.Shared.LanguageRenderer.Macros as M (increment1,
  decrement1, ifExists, stringListVals, stringListLists, arrayDecAsList)
import Drasil.Shared.AST (Terminator(..), FileType(..), fileD, FuncData(..),
  ModData(..), md, updateMod, MethodData(..), mthd, OpData(..), ParamData(..),
  ProgData(..), TypeData(..), ValData(..), vd, VarData(..), vard, progD, fd, pd,
  updateMthd, ScopeTag(..), ScopeData(..), sd, BinderD(..), bindFormD, FileData,
  Statement)
import Drasil.Shared.Helpers (vibcat, toCode, toState, onCodeValue, onStateValue,
  on2CodeValues, on2StateValues, onCodeList, onStateList, emptyIfEmpty)
import Drasil.Shared.State (FS, MS, VS, lensGStoFS, revFiles, setFileType,
  lensMStoVS, getModuleImports, addModuleImportVS, getLangImports, getLibImports,
  addLibImportVS, useVarName, getMainDoc, genVarNameIf, setVarScope, getVarScope)

import Prelude hiding (break,print,sin,cos,tan,floor,(<>))
import qualified Prelude as P ((<>))
import Data.Maybe (fromMaybe, isNothing)
import Data.Functor ((<&>))
import Control.Lens.Zoom (zoom)
import Control.Monad.State (modify)
import Data.List (intercalate, sort)
import Text.PrettyPrint.HughesPJ (Doc, text, (<>), (<+>), empty, brackets, vcat,
  quotes, doubleQuotes, parens, equals, colon)
import qualified Text.PrettyPrint.HughesPJ as D (float)

jlExt :: String
jlExt :: Label
jlExt = Label
"jl"

newtype JuliaCode a = JLC {forall a. JuliaCode a -> a
unJLC :: a} deriving (forall a b. (a -> b) -> JuliaCode a -> JuliaCode b)
-> (forall a b. a -> JuliaCode b -> JuliaCode a)
-> Functor JuliaCode
forall a b. a -> JuliaCode b -> JuliaCode a
forall a b. (a -> b) -> JuliaCode a -> JuliaCode b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> JuliaCode a -> JuliaCode b
fmap :: forall a b. (a -> b) -> JuliaCode a -> JuliaCode b
$c<$ :: forall a b. a -> JuliaCode b -> JuliaCode a
<$ :: forall a b. a -> JuliaCode b -> JuliaCode a
Functor

instance Applicative JuliaCode where
  pure :: forall a. a -> JuliaCode a
pure = a -> JuliaCode a
forall a. a -> JuliaCode a
JLC
  (JLC a -> b
f) <*> :: forall a b. JuliaCode (a -> b) -> JuliaCode a -> JuliaCode b
<*> (JLC a
x) = b -> JuliaCode b
forall a. a -> JuliaCode a
JLC (a -> b
f a
x)

instance Monad JuliaCode where
  JLC a
x >>= :: forall a b. JuliaCode a -> (a -> JuliaCode b) -> JuliaCode b
>>= a -> JuliaCode b
f = a -> JuliaCode b
f a
x

instance ProcProg JuliaCode ProgData FileData ModData MethodData Doc ParamData Body Block Statement Variable ScopeData Value BinderD TypeData

instance ProgramSym JuliaCode ProgData FileData where
  prog :: Label
-> Label
-> [FS (JuliaCode FileData)]
-> GSProgram JuliaCode ProgData
prog Label
n Label
st [FS (JuliaCode FileData)]
files = do
    fs <- (FS (JuliaCode FileData)
 -> StateT GOOLState Identity (JuliaCode FileData))
-> [FS (JuliaCode FileData)]
-> StateT GOOLState Identity [JuliaCode FileData]
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 (LensLike'
  (Zoomed (StateT FileState Identity) (JuliaCode FileData))
  GOOLState
  FileState
-> FS (JuliaCode FileData)
-> StateT GOOLState Identity (JuliaCode FileData)
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) GOOLState FileState
-> StateT FileState Identity c -> StateT GOOLState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT FileState Identity) (JuliaCode FileData))
  GOOLState
  FileState
(FileState -> Focusing Identity (JuliaCode FileData) FileState)
-> GOOLState -> Focusing Identity (JuliaCode FileData) GOOLState
Lens' GOOLState FileState
lensGStoFS) [FS (JuliaCode FileData)]
files
    modify revFiles
    pure $ onCodeList (progD n st) fs

instance CommonRenderSym JuliaCode MethodData Doc ParamData Body Block Statement Variable ScopeData Value BinderD TypeData
instance ProcRenderSym JuliaCode FileData ModData MethodData Doc ParamData Body Block Statement Variable ScopeData Value BinderD TypeData

instance UnRepr JuliaCode inner where
  unRepr :: JuliaCode inner -> inner
unRepr = JuliaCode inner -> inner
forall a. JuliaCode a -> a
unJLC

instance FileSym JuliaCode FileData ModData where
  fileDoc :: FS (JuliaCode ModData) -> FS (JuliaCode FileData)
fileDoc FS (JuliaCode ModData)
m = do
    (FileState -> FileState) -> StateT FileState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (FileType -> FileState -> FileState
setFileType FileType
Combined)
    Label -> FS (JuliaCode ModData) -> FS (JuliaCode FileData)
forall (r :: * -> *) file mod.
RenderFile r file mod =>
Label -> FS (r mod) -> FS (r file)
A.fileDoc Label
jlExt FS (JuliaCode ModData)
m
  docMod :: Label
-> Label
-> [Label]
-> Label
-> FS (JuliaCode FileData)
-> FS (JuliaCode FileData)
docMod = Label
-> Label
-> Label
-> [Label]
-> Label
-> FS (JuliaCode FileData)
-> FS (JuliaCode FileData)
forall (r :: * -> *) file mod.
(BlockCommentSym r, RenderFile r file mod) =>
Label
-> Label -> Label -> [Label] -> Label -> FS (r file) -> FS (r file)
A.docMod Label
jlExt

instance RenderFile JuliaCode FileData ModData where
  top :: JuliaCode ModData -> JuliaCode Doc
top JuliaCode ModData
_ = Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty
  bottom :: JuliaCode Doc
bottom = Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty

  commentedMod :: FS (JuliaCode FileData)
-> FS (JuliaCode Doc) -> FS (JuliaCode FileData)
commentedMod = (JuliaCode FileData -> JuliaCode Doc -> JuliaCode FileData)
-> FS (JuliaCode FileData)
-> FS (JuliaCode Doc)
-> FS (JuliaCode FileData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((FileData -> Doc -> FileData)
-> JuliaCode FileData -> JuliaCode Doc -> JuliaCode FileData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues FileData -> Doc -> FileData
R.commentedMod)

  fileFromData :: Label -> FS (JuliaCode ModData) -> FS (JuliaCode FileData)
fileFromData = (Label -> JuliaCode ModData -> JuliaCode FileData)
-> Label -> FS (JuliaCode ModData) -> FS (JuliaCode FileData)
forall {k} (r :: k -> *) (mod :: k) (file :: k).
ModuleElim r mod =>
(Label -> r mod -> r file) -> Label -> FS (r mod) -> FS (r file)
A.fileFromData ((ModData -> FileData) -> JuliaCode ModData -> JuliaCode FileData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((ModData -> FileData) -> JuliaCode ModData -> JuliaCode FileData)
-> (Label -> ModData -> FileData)
-> Label
-> JuliaCode ModData
-> JuliaCode FileData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Label -> ModData -> FileData
fileD)

instance ImportSym JuliaCode where
  langImport :: Label -> JuliaCode Doc
langImport Label
n = let modName :: Doc
modName = Label -> Doc
text Label
n
    in Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JuliaCode Doc) -> Doc -> JuliaCode Doc
forall a b. (a -> b) -> a -> b
$ Doc
importLabel Doc -> Doc -> Doc
<+> Doc
modName
  modImport :: Label -> JuliaCode Doc
modImport Label
n = let modName :: Doc
modName = Label -> Doc
text Label
n
                    fileName :: Doc
fileName = Label -> Doc
text (Label -> Doc) -> Label -> Doc
forall a b. (a -> b) -> a -> b
$ Label
n Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> (Char
'.' Char -> Label -> Label
forall a. a -> [a] -> [a]
: Label
jlExt)
    in Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JuliaCode Doc) -> Doc -> JuliaCode Doc
forall a b. (a -> b) -> a -> b
$ [Doc] -> Doc
vcat [Doc
includeLabel Doc -> Doc -> Doc
<> Doc -> Doc
parens (Doc -> Doc
doubleQuotes Doc
fileName),
                      Doc
importLabel Doc -> Doc -> Doc
<+> Label -> Doc
text Label
"." Doc -> Doc -> Doc
<> Doc
modName]

instance BodySym JuliaCode Body Block where
  body :: [MS (JuliaCode Doc)] -> MS (JuliaCode Doc)
body = ([JuliaCode Doc] -> JuliaCode Doc)
-> [MS (JuliaCode Doc)] -> MS (JuliaCode Doc)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (([Doc] -> Doc) -> [JuliaCode Doc] -> JuliaCode Doc
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList [Doc] -> Doc
R.body)

  addComments :: Label -> MS (JuliaCode Doc) -> MS (JuliaCode Doc)
addComments Label
s = (JuliaCode Doc -> JuliaCode Doc)
-> MS (JuliaCode Doc) -> MS (JuliaCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Doc -> Doc) -> JuliaCode Doc -> JuliaCode Doc
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (Label -> Doc -> Doc -> Doc
R.addComments Label
s Doc
jlCmtStart))

instance RenderBody JuliaCode Body where
  multiBody :: [MS (JuliaCode Doc)] -> MS (JuliaCode Doc)
multiBody = [MS (JuliaCode Doc)] -> MS (JuliaCode Doc)
forall (r :: * -> *) bod.
(BodyElim r bod, Monad r) =>
[MS (r bod)] -> MS (r Doc)
G.multiBody

instance BodyElim JuliaCode Body where
  body :: JuliaCode Doc -> Doc
body = JuliaCode Doc -> Doc
forall a. JuliaCode a -> a
unJLC

instance BlockSym JuliaCode Block Statement where
  block :: [MS (JuliaCode Statement)] -> MS (JuliaCode Doc)
block = [MS (JuliaCode Statement)] -> MS (JuliaCode Doc)
forall (r :: * -> *) stmt.
(Monad r, RenderStatement r stmt, StatementElim r stmt) =>
[MS (r stmt)] -> MS (r Doc)
G.block

instance RenderBlock JuliaCode Block where
  multiBlock :: [MS (JuliaCode Doc)] -> MS (JuliaCode Doc)
multiBlock = [MS (JuliaCode Doc)] -> MS (JuliaCode Doc)
forall (r :: * -> *) block.
(BlockElim r block, Monad r) =>
[MS (r block)] -> MS (r Doc)
G.multiBlock

instance BlockElim JuliaCode Block where
  block :: JuliaCode Doc -> Doc
block = JuliaCode Doc -> Doc
forall a. JuliaCode a -> a
unJLC

instance TypeSym JuliaCode TypeData where
  bool :: VS (JuliaCode TypeData)
bool = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CS.bool
  int :: VS (JuliaCode TypeData)
int = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlIntType
  float :: VS (JuliaCode TypeData)
float = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlFloatType
  double :: VS (JuliaCode TypeData)
double = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlDoubleType
  char :: VS (JuliaCode TypeData)
char = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlCharType
  string :: VS (JuliaCode TypeData)
string = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlStringType
  infile :: VS (JuliaCode TypeData)
infile = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlInfileType
  outfile :: VS (JuliaCode TypeData)
outfile = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlOutfileType
  referenceType :: VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
referenceType = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall a. a -> a
id -- Ignore reference types in "high-level" langauges for now; later on think about using boxed/unboxed types
  listType :: VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
listType = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
jlListType
  setType :: VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
setType = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
jlSetType
  arrayType :: VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
arrayType = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType -- Treat arrays and lists the same, as in Python
  innerType :: VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
innerType = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, TypeElim r typ) =>
VS (r typ) -> VS (r typ)
A.innerType
  funcType :: [VS (JuliaCode TypeData)]
-> VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
funcType = [VS (JuliaCode TypeData)]
-> VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r TypeData) =>
[VS (r TypeData)] -> VS (r TypeData) -> VS (r TypeData)
CS.funcType
  void :: VS (JuliaCode TypeData)
void = VS (JuliaCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
jlVoidType

instance TypeElim JuliaCode TypeData where
  getCodeType :: JuliaCode TypeData -> CodeType
getCodeType = TypeData -> CodeType
cType (TypeData -> CodeType)
-> (JuliaCode TypeData -> TypeData)
-> JuliaCode TypeData
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode TypeData -> TypeData
forall a. JuliaCode a -> a
unJLC

instance RenderType JuliaCode TypeData where
  multiType :: [VS (JuliaCode TypeData)] -> VS (JuliaCode TypeData)
multiType [VS (JuliaCode TypeData)]
ts = do
    typs <- [VS (JuliaCode TypeData)]
-> StateT ValueState Identity [JuliaCode TypeData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [VS (JuliaCode TypeData)]
ts
    let mt = [Label] -> Label
jlTuple ([Label] -> Label) -> [Label] -> Label
forall a b. (a -> b) -> a -> b
$ JuliaCode TypeData -> Label
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Label
getTypeString (JuliaCode TypeData -> Label) -> [JuliaCode TypeData] -> [Label]
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> [JuliaCode TypeData]
typs
    typeFromData Void mt (text mt)

instance UnaryOpSym JuliaCode where
  notOp :: VSUnOp JuliaCode
notOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
C.notOp
  negateOp :: VSUnOp JuliaCode
negateOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.negateOp
  sqrtOp :: VSUnOp JuliaCode
sqrtOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.sqrt
  absOp :: VSUnOp JuliaCode
absOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.abs
  logOp :: VSUnOp JuliaCode
logOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.log10
  lnOp :: VSUnOp JuliaCode
lnOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.log
  expOp :: VSUnOp JuliaCode
expOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.exp
  sinOp :: VSUnOp JuliaCode
sinOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.sin
  cosOp :: VSUnOp JuliaCode
cosOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.cos
  tanOp :: VSUnOp JuliaCode
tanOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.tan
  asinOp :: VSUnOp JuliaCode
asinOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.asin
  acosOp :: VSUnOp JuliaCode
acosOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.acos
  atanOp :: VSUnOp JuliaCode
atanOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.atan
  floorOp :: VSUnOp JuliaCode
floorOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.floor
  ceilOp :: VSUnOp JuliaCode
ceilOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath Label
R.ceil

instance BinaryOpSym JuliaCode where
  equalOp :: VSUnOp JuliaCode
equalOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.equalOp
  notEqualOp :: VSUnOp JuliaCode
notEqualOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.notEqualOp
  greaterOp :: VSUnOp JuliaCode
greaterOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.greaterOp
  greaterEqualOp :: VSUnOp JuliaCode
greaterEqualOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.greaterEqualOp
  lessOp :: VSUnOp JuliaCode
lessOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.lessOp
  lessEqualOp :: VSUnOp JuliaCode
lessEqualOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.lessEqualOp
  plusOp :: VSUnOp JuliaCode
plusOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.plusOp
  minusOp :: VSUnOp JuliaCode
minusOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.minusOp
  multOp :: VSUnOp JuliaCode
multOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.multOp
  divideOp :: VSUnOp JuliaCode
divideOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.divideOp
  powerOp :: VSUnOp JuliaCode
powerOp = Label -> VSUnOp JuliaCode
forall (r :: * -> *). Monad r => Label -> VSOp r
powerPrec Label
jlPower
  moduloOp :: VSUnOp JuliaCode
moduloOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
G.moduloOp
  andOp :: VSUnOp JuliaCode
andOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
C.andOp
  orOp :: VSUnOp JuliaCode
orOp = VSUnOp JuliaCode
forall (r :: * -> *). Monad r => VSOp r
C.orOp

instance OpElim JuliaCode where
  uOp :: JuliaCode OpData -> Doc
uOp = OpData -> Doc
opDoc (OpData -> Doc)
-> (JuliaCode OpData -> OpData) -> JuliaCode OpData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode OpData -> OpData
forall a. JuliaCode a -> a
unJLC
  bOp :: JuliaCode OpData -> Doc
bOp = OpData -> Doc
opDoc (OpData -> Doc)
-> (JuliaCode OpData -> OpData) -> JuliaCode OpData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode OpData -> OpData
forall a. JuliaCode a -> a
unJLC
  uOpPrec :: JuliaCode OpData -> Int
uOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (JuliaCode OpData -> OpData) -> JuliaCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode OpData -> OpData
forall a. JuliaCode a -> a
unJLC
  bOpPrec :: JuliaCode OpData -> Int
bOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (JuliaCode OpData -> OpData) -> JuliaCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode OpData -> OpData
forall a. JuliaCode a -> a
unJLC

instance ScopeSym JuliaCode ScopeData where
  global :: JuliaCode ScopeData
global = ScopeData -> JuliaCode ScopeData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (ScopeData -> JuliaCode ScopeData)
-> ScopeData -> JuliaCode ScopeData
forall a b. (a -> b) -> a -> b
$ ScopeTag -> ScopeData
sd ScopeTag
Global
  mainFn :: JuliaCode ScopeData
mainFn = JuliaCode ScopeData
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
global
  local :: JuliaCode ScopeData
local = JuliaCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
G.local

instance ScopeElim JuliaCode ScopeData where
  scopeData :: JuliaCode ScopeData -> ScopeData
scopeData = JuliaCode ScopeData -> ScopeData
forall a. JuliaCode a -> a
unJLC

instance VariableSym JuliaCode Variable TypeData where
  var :: Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
var = Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
Label -> VS (r typ) -> VS (r var)
G.var
  constant :: Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
constant = Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
var
  extVar :: Label
-> Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
extVar Label
l Label
n VS (JuliaCode TypeData)
t = (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (Label -> ValueState -> ValueState
addModuleImportVS Label
l) StateT ValueState Identity ()
-> VS (JuliaCode Variable) -> VS (JuliaCode Variable)
forall a b.
StateT ValueState Identity a
-> StateT ValueState Identity b -> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Label
-> Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
Label -> Label -> VS (r typ) -> VS (r var)
CS.extVar Label
l Label
n VS (JuliaCode TypeData)
t

instance VariableElim JuliaCode Variable TypeData where
  variableName :: JuliaCode Variable -> Label
variableName = Variable -> Label
varName (Variable -> Label)
-> (JuliaCode Variable -> Variable) -> JuliaCode Variable -> Label
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Variable -> Variable
forall a. JuliaCode a -> a
unJLC
  variableType :: JuliaCode Variable -> JuliaCode TypeData
variableType = (Variable -> TypeData) -> JuliaCode Variable -> JuliaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Variable -> TypeData
varType

instance InternalVarElim JuliaCode Variable where
  variableBind :: JuliaCode Variable -> AttachmentTag
variableBind = Variable -> AttachmentTag
varBind (Variable -> AttachmentTag)
-> (JuliaCode Variable -> Variable)
-> JuliaCode Variable
-> AttachmentTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Variable -> Variable
forall a. JuliaCode a -> a
unJLC
  variable :: JuliaCode Variable -> Doc
variable = Variable -> Doc
varDoc (Variable -> Doc)
-> (JuliaCode Variable -> Variable) -> JuliaCode Variable -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Variable -> Variable
forall a. JuliaCode a -> a
unJLC

instance RenderVariable JuliaCode Variable TypeData where
  varFromData :: AttachmentTag
-> Label
-> VS (JuliaCode TypeData)
-> Doc
-> VS (JuliaCode Variable)
varFromData AttachmentTag
b Label
n VS (JuliaCode TypeData)
t' Doc
d = do
    t <- VS (JuliaCode TypeData)
t'
    toState $ on2CodeValues (vard b n) t (toCode d)

instance ValueSym JuliaCode Value TypeData where
  valueType :: JuliaCode Value -> JuliaCode TypeData
valueType JuliaCode Value
v = Value -> TypeData
valType (Value -> TypeData) -> JuliaCode Value -> JuliaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> JuliaCode Value
v

instance Argument JuliaCode Value where
  pointerArg :: VS (JuliaCode Value) -> VS (JuliaCode Value)
pointerArg = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall a. a -> a
id

instance Literal JuliaCode Value TypeData where
  litTrue :: VS (JuliaCode Value)
litTrue = VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
C.litTrue
  litFalse :: VS (JuliaCode Value)
litFalse = VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
C.litFalse
  litChar :: Char -> VS (JuliaCode Value)
litChar = (Doc -> Doc) -> Char -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
(Doc -> Doc) -> Char -> VS (r val)
G.litChar Doc -> Doc
quotes
  litDouble :: Double -> VS (JuliaCode Value)
litDouble = Double -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Double -> VS (r val)
G.litDouble
  litFloat :: Float -> VS (JuliaCode Value)
litFloat = Float -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Float -> VS (r val)
jlLitFloat
  litInt :: Integer -> VS (JuliaCode Value)
litInt = Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
G.litInt
  litString :: Label -> VS (JuliaCode Value)
litString = Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Label -> VS (r val)
G.litString
  litArray :: VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
litArray = VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litList
  litList :: VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
litList = VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
jlLitList
  litSet :: VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
litSet = (Doc -> Doc)
-> (Doc -> Doc)
-> VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)]
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
(Doc -> Doc)
-> (Doc -> Doc) -> VS (r typ) -> [VS (r val)] -> VS (r val)
CP.litSet (Label -> Doc
text Label
"Set" Doc -> Doc -> Doc
<>) (Doc -> Doc
parens (Doc -> Doc) -> (Doc -> Doc) -> Doc -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc
brackets)

instance MathConstant JuliaCode Value where
  pi :: VS (JuliaCode Value)
  pi :: VS (JuliaCode Value)
pi = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double Doc
jlPi

instance VariableValue JuliaCode Variable Value where
  valueOf :: VS (JuliaCode Variable) -> VS (JuliaCode Value)
valueOf = VS (JuliaCode Variable) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 VariableElim r var typ) =>
VS (r var) -> VS (r val)
G.valueOf

instance CommandLineArgs JuliaCode Value where
  arg :: Integer -> VS (JuliaCode Value)
arg Integer
n = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
G.arg (Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt (Integer -> VS (JuliaCode Value))
-> Integer -> VS (JuliaCode Value)
forall a b. (a -> b) -> a -> b
$ Integer
nInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1) VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
argsList
  argsList :: VS (JuliaCode Value)
argsList = Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Label -> VS (r val)
G.argsList Label
jlArgs
  argExists :: Integer -> VS (JuliaCode Value)
argExists = Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(Literal r val typ, CommandLineArgs r val, Comparison r val,
 List r val) =>
Integer -> VS (r val)
CP.argExists

instance NumericExpression JuliaCode Value where
  #~ :: VS (JuliaCode Value) -> VS (JuliaCode Value)
(#~) = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr' VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
negateOp
  #/^ :: VS (JuliaCode Value) -> VS (JuliaCode Value)
(#/^) = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sqrtOp
  #| :: VS (JuliaCode Value) -> VS (JuliaCode Value)
(#|) = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
absOp
  #+ :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(#+) = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp
  #- :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(#-) = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
minusOp
  #* :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(#*) = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp
  #/ :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(#/) VS (JuliaCode Value)
v1' VS (JuliaCode Value)
v2' = do -- Julia has integer division via `÷` or `div()`
    v1 <- VS (JuliaCode Value)
v1'
    v2 <- v2'
    let jlDivision CodeType
Integer CodeType
Integer = VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr (Label -> VSBinOp r
forall (r :: * -> *). Monad r => Label -> VSOp r
multPrec Label
jlIntDiv)
        jlDivision CodeType
_ CodeType
_ = VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSBinOp r
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
divideOp
    jlDivision (getCodeType $ valueType v1) (getCodeType $ valueType v2)
        (pure v1) (pure v2)
  #% :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(#%) = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
moduloOp
  #^ :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(#^) = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp

  log :: VS (JuliaCode Value) -> VS (JuliaCode Value)
log = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
logOp
  ln :: VS (JuliaCode Value) -> VS (JuliaCode Value)
ln = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
lnOp
  exp :: VS (JuliaCode Value) -> VS (JuliaCode Value)
exp = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
expOp
  sin :: VS (JuliaCode Value) -> VS (JuliaCode Value)
sin = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sinOp
  cos :: VS (JuliaCode Value) -> VS (JuliaCode Value)
cos = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
cosOp
  tan :: VS (JuliaCode Value) -> VS (JuliaCode Value)
tan = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
tanOp
  csc :: VS (JuliaCode Value) -> VS (JuliaCode Value)
csc = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
G.csc
  sec :: VS (JuliaCode Value) -> VS (JuliaCode Value)
sec = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
G.sec
  cot :: VS (JuliaCode Value) -> VS (JuliaCode Value)
cot = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
G.cot
  arcsin :: VS (JuliaCode Value) -> VS (JuliaCode Value)
arcsin = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
asinOp
  arccos :: VS (JuliaCode Value) -> VS (JuliaCode Value)
arccos = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
acosOp
  arctan :: VS (JuliaCode Value) -> VS (JuliaCode Value)
arctan = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
atanOp
  floor :: VS (JuliaCode Value) -> VS (JuliaCode Value)
floor = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
floorOp
  ceil :: VS (JuliaCode Value) -> VS (JuliaCode Value)
ceil = VSUnOp JuliaCode -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
ceilOp

instance BooleanExpression JuliaCode Value where
  ?! :: VS (JuliaCode Value) -> VS (JuliaCode Value)
(?!) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSUnOp r -> VS (r typ) -> VS (r val) -> VS (r val)
typeUnExpr VSUnOp JuliaCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
notOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?&& :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?&&) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
andOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?|| :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?||) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
orOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool

instance Comparison JuliaCode Value where
  ?< :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?<) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?<= :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?<=) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessEqualOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?> :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?>) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?>= :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?>=) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterEqualOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?== :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?==) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
equalOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?!= :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
(?!=) = VSUnOp JuliaCode
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
notEqualOp VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool

instance ValueExpression JuliaCode Variable Value BinderD TypeData where
  inlineIf :: VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
inlineIf = VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
C.inlineIf

  funcAppMixedArgs :: MixedCall JuliaCode Variable Value TypeData
funcAppMixedArgs = MixedCall JuliaCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
MixedCall r var val typ
G.funcAppMixedArgs
  extFuncAppMixedArgs :: Label -> MixedCall JuliaCode Variable Value TypeData
extFuncAppMixedArgs Label
l Label
n VS (JuliaCode TypeData)
t [VS (JuliaCode Value)]
ps NamedArgs JuliaCode Variable Value
ns = do
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (Label -> ValueState -> ValueState
addModuleImportVS Label
l)
    Label -> MixedCall JuliaCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
Label -> MixedCall r var val typ
CS.extFuncAppMixedArgs Label
l Label
n VS (JuliaCode TypeData)
t [VS (JuliaCode Value)]
ps NamedArgs JuliaCode Variable Value
ns
  libFuncAppMixedArgs :: Label -> MixedCall JuliaCode Variable Value TypeData
libFuncAppMixedArgs Label
l Label
n VS (JuliaCode TypeData)
t [VS (JuliaCode Value)]
ps NamedArgs JuliaCode Variable Value
ns = do
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (Label -> ValueState -> ValueState
addLibImportVS Label
l)
    Label -> MixedCall JuliaCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
Label -> MixedCall r var val typ
CS.extFuncAppMixedArgs Label
l Label
n VS (JuliaCode TypeData)
t [VS (JuliaCode Value)]
ps NamedArgs JuliaCode Variable Value
ns

  lambda :: [VS (JuliaCode BinderD)]
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
lambda = ([JuliaCode BinderD] -> JuliaCode Value -> Doc)
-> [VS (JuliaCode BinderD)]
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (binder :: k) (typ :: k) (var :: k)
       (val :: k).
(BinderElim r binder typ, RenderValue r var val typ, TypeSym r typ,
 ValueSym r val typ) =>
([r binder] -> r val -> Doc)
-> [VS (r binder)] -> VS (r val) -> VS (r val)
G.lambda [JuliaCode BinderD] -> JuliaCode Value -> Doc
forall {k} (r :: k -> *) (binder :: k) (val :: k).
(InternalBinderElim r binder, ValueElim r val) =>
[r binder] -> r val -> Doc
jlLambda

  notNull :: VS (JuliaCode Value) -> VS (JuliaCode Value)
notNull = Label -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k).
(ValueSym r val typ, Comparison r val, VariableSym r var typ,
 VariableValue r var val) =>
Label -> VS (r val) -> VS (r val)
CP.notNull Label
jlNull

instance RenderValue JuliaCode Variable Value TypeData where
  inputFunc :: VS (JuliaCode Value)
inputFunc = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string (Doc
jlReadLine Doc -> Doc -> Doc
<> Doc -> Doc
parens Doc
empty)
  printFunc :: VS (JuliaCode Value)
printFunc = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Doc
jlPrintFunc
  printLnFunc :: VS (JuliaCode Value)
printLnFunc = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Doc
jlPrintLnFunc
  printFileFunc :: VS (JuliaCode Value) -> VS (JuliaCode Value)
printFileFunc VS (JuliaCode Value)
_ = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Doc
empty
  printFileLnFunc :: VS (JuliaCode Value) -> VS (JuliaCode Value)
printFileLnFunc VS (JuliaCode Value)
_ = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Doc
empty

  cast :: VS (JuliaCode TypeData)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
cast = VS (JuliaCode TypeData)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
jlCast

  call :: Maybe Label
-> Maybe Doc -> MixedCall JuliaCode Variable Value TypeData
call = Doc
-> Maybe Label
-> Maybe Doc
-> MixedCall JuliaCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 ValueElim r val) =>
Doc -> Maybe Label -> Maybe Doc -> MixedCall r var val typ
G.call Doc
jlNamedArgSep

  valFromData :: Maybe Int
-> Maybe Integer
-> VS (JuliaCode TypeData)
-> Doc
-> VS (JuliaCode Value)
valFromData Maybe Int
p Maybe Integer
i VS (JuliaCode TypeData)
t' Doc
d = do
    t <- VS (JuliaCode TypeData)
t'
    toState $ on2CodeValues (vd p i) t (toCode d)

instance ValueElim JuliaCode Value where
  valuePrec :: JuliaCode Value -> Maybe Int
valuePrec = Value -> Maybe Int
valPrec (Value -> Maybe Int)
-> (JuliaCode Value -> Value) -> JuliaCode Value -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Value -> Value
forall a. JuliaCode a -> a
unJLC
  valueInt :: JuliaCode Value -> Maybe Integer
valueInt = Value -> Maybe Integer
valInt (Value -> Maybe Integer)
-> (JuliaCode Value -> Value) -> JuliaCode Value -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Value -> Value
forall a. JuliaCode a -> a
unJLC
  value :: JuliaCode Value -> Doc
value = Value -> Doc
val (Value -> Doc)
-> (JuliaCode Value -> Value) -> JuliaCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Value -> Value
forall a. JuliaCode a -> a
unJLC

instance IndexTranslator JuliaCode Value where
  intToIndex :: VS (JuliaCode Value) -> VS (JuliaCode Value)
intToIndex = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, Literal r val typ, NumericExpression r val,
 RenderValue r var val typ, ValueElim r val) =>
VS (r val) -> VS (r val)
CP.intToIndex'
  indexToInt :: VS (JuliaCode Value) -> VS (JuliaCode Value)
indexToInt = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, Literal r val typ, NumericExpression r val,
 RenderValue r var val typ, ValueElim r val) =>
VS (r val) -> VS (r val)
CP.indexToInt'

instance Reference JuliaCode Value where
  makeRef :: VS (JuliaCode Value) -> VS (JuliaCode Value)
makeRef = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall a. a -> a
id
  maybeDeref :: VS (JuliaCode Value) -> VS (JuliaCode Value)
maybeDeref = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall a. a -> a
id

instance Array JuliaCode Variable Value where
  arrayElem :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Variable)
arrayElem = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Variable)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 RenderVariable r var typ, TypeElim r typ, ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r var)
A.arrayElem
  arrayLength :: VS (JuliaCode Value) -> VS (JuliaCode Value)
arrayLength = VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize
  arrayCopy :: VS (JuliaCode Value) -> VS (JuliaCode Value)
arrayCopy VS (JuliaCode Value)
arr = let
    arrTp :: VS (JuliaCode TypeData)
arrTp = (JuliaCode Value -> JuliaCode TypeData)
-> VS (JuliaCode Value) -> VS (JuliaCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue JuliaCode Value -> JuliaCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType VS (JuliaCode Value)
arr
    in PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
"copy" VS (JuliaCode TypeData)
arrTp [VS (JuliaCode Value)
arr]

instance List JuliaCode Value where
  listSize :: VS (JuliaCode Value) -> VS (JuliaCode Value)
listSize = Label -> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, ValueExpression r var val binder typ) =>
Label -> VS (r val) -> VS (r val)
CS.listSize Label
jlListSize
  listAccess :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
listAccess = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) typ val var.
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 InternalListFunc r val typ, FunctionElim r typ,
 RenderFunction r typ, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
G.listAccess
  indexOf :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
indexOf = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, IndexTranslator r val,
 ValueExpression r var val binder typ, BinderSym r binder typ,
 VariableSym r var typ, VariableValue r var val,
 Comparison r val) =>
VS (r val) -> VS (r val) -> VS (r val)
jlIndexOf

instance ListStatement JuliaCode Statement Value where
  listAdd :: VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
listAdd = Label
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (stmt :: k)
       (var :: k) (binder :: k).
(TypeSym r typ, IndexTranslator r val, ValueStatement r stmt val,
 ValueExpression r var val binder typ) =>
Label -> VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
A.listAdd Label
jlListAdd
  listAppend :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
listAppend = Label
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (val :: k)
       (var :: k) (binder :: k).
(TypeSym r typ, ValueStatement r stmt val,
 ValueExpression r var val binder typ) =>
Label -> VS (r val) -> VS (r val) -> MS (r stmt)
A.listAppend Label
jlListAppend
  listSet :: VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
listSet = VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, ValueSym r val typ,
 IndexTranslator r val, RenderVariable r var typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
CP.listSet

instance Set JuliaCode Value where
  contains :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
contains VS (JuliaCode Value)
s VS (JuliaCode Value)
e = PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
"in" VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool [VS (JuliaCode Value)
e, VS (JuliaCode Value)
s]
  setAdd :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
setAdd VS (JuliaCode Value)
s VS (JuliaCode Value)
e = PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
"push!" VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void [VS (JuliaCode Value)
s, VS (JuliaCode Value)
e]
  setRemove :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
setRemove VS (JuliaCode Value)
s VS (JuliaCode Value)
e = PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
"delete!" VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void [VS (JuliaCode Value)
s, VS (JuliaCode Value)
e]
  setUnion :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
setUnion VS (JuliaCode Value)
a VS (JuliaCode Value)
b = PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
"union!" VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void [VS (JuliaCode Value)
a, VS (JuliaCode Value)
b]

instance NativeVector JuliaCode Value TypeData where
  vecType :: VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
vecType = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType
  litVec :: VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
litVec = VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litList
  vecScale :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
vecScale = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp
  vecAdd :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
vecAdd   = VSUnOp JuliaCode
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp JuliaCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp
  vecIndex :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
vecIndex = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall (r :: * -> *) typ val var.
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 InternalListFunc r val typ, FunctionElim r typ,
 RenderFunction r typ, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
G.listAccess
  vecDot :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
vecDot VS (JuliaCode Value)
a VS (JuliaCode Value)
b = Label -> PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
Label -> PosCall r val typ
libFuncApp Label
"LinearAlgebra" Label
"dot" VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double [VS (JuliaCode Value)
a, VS (JuliaCode Value)
b]
  vecMag :: VS (JuliaCode Value) -> VS (JuliaCode Value)
vecMag VS (JuliaCode Value)
a   = Label -> PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
Label -> PosCall r val typ
libFuncApp Label
"LinearAlgebra" Label
"norm" VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double [VS (JuliaCode Value)
a]
  vecUnit :: VS (JuliaCode Value) -> VS (JuliaCode Value)
vecUnit VS (JuliaCode Value)
a  = VS (JuliaCode Value)
a VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
NativeVector r val typ =>
VS (r val) -> VS (r val)
vecMag VS (JuliaCode Value)
a

instance InternalList JuliaCode Block Variable Value where
  listSlice' :: Maybe (VS (JuliaCode Value))
-> Maybe (VS (JuliaCode Value))
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
listSlice' Maybe (VS (JuliaCode Value))
b Maybe (VS (JuliaCode Value))
e Maybe (VS (JuliaCode Value))
s VS (JuliaCode Variable)
vn VS (JuliaCode Value)
vo = VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> Maybe (VS (JuliaCode Value))
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
jlListSlice VS (JuliaCode Variable)
vn VS (JuliaCode Value)
vo Maybe (VS (JuliaCode Value))
b Maybe (VS (JuliaCode Value))
e (VS (JuliaCode Value)
-> Maybe (VS (JuliaCode Value)) -> VS (JuliaCode Value)
forall a. a -> Maybe a -> a
fromMaybe (Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1) Maybe (VS (JuliaCode Value))
s)

instance InternalListFunc JuliaCode Value TypeData where
  listAccessFunc :: VS (JuliaCode TypeData)
-> VS (JuliaCode Value) -> VS (JuliaCode FuncData)
listAccessFunc = VS (JuliaCode TypeData)
-> VS (JuliaCode Value) -> VS (JuliaCode FuncData)
forall (r :: * -> *) typ val.
(RenderFunction r typ, TypeElim r typ, ValueElim r val,
 ValueSym r val typ) =>
VS (r typ) -> VS (r val) -> VS (r FuncData)
CS.listAccessFunc

instance BinderSym JuliaCode BinderD TypeData where
  binder :: Label -> VS (JuliaCode TypeData) -> VS (JuliaCode BinderD)
binder Label
nm VS (JuliaCode TypeData)
tp = (TypeData -> BinderD) -> JuliaCode TypeData -> JuliaCode BinderD
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (Label -> TypeData -> BinderD
bindFormD Label
nm) (JuliaCode TypeData -> JuliaCode BinderD)
-> VS (JuliaCode TypeData) -> VS (JuliaCode BinderD)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> VS (JuliaCode TypeData)
tp

instance BinderElim JuliaCode BinderD TypeData where
  binderName :: JuliaCode BinderD -> Label
binderName = BinderD -> Label
bindName (BinderD -> Label)
-> (JuliaCode BinderD -> BinderD) -> JuliaCode BinderD -> Label
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode BinderD -> BinderD
forall a. JuliaCode a -> a
unJLC
  binderType :: JuliaCode BinderD -> JuliaCode TypeData
binderType = (BinderD -> TypeData) -> JuliaCode BinderD -> JuliaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue BinderD -> TypeData
bindType

instance InternalBinderElim JuliaCode BinderD where
  binderElim :: JuliaCode BinderD -> Doc
binderElim = Label -> Doc
text (Label -> Doc)
-> (JuliaCode BinderD -> Label) -> JuliaCode BinderD -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinderD -> Label
bindName (BinderD -> Label)
-> (JuliaCode BinderD -> BinderD) -> JuliaCode BinderD -> Label
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode BinderD -> BinderD
forall a. JuliaCode a -> a
unJLC

instance RenderFunction JuliaCode TypeData where
  funcFromData :: Doc -> VS (JuliaCode TypeData) -> VS (JuliaCode FuncData)
funcFromData Doc
d = (JuliaCode TypeData -> JuliaCode FuncData)
-> VS (JuliaCode TypeData) -> VS (JuliaCode FuncData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((JuliaCode TypeData -> JuliaCode FuncData)
 -> VS (JuliaCode TypeData) -> VS (JuliaCode FuncData))
-> (JuliaCode TypeData -> JuliaCode FuncData)
-> VS (JuliaCode TypeData)
-> VS (JuliaCode FuncData)
forall a b. (a -> b) -> a -> b
$ (TypeData -> FuncData) -> JuliaCode TypeData -> JuliaCode FuncData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (TypeData -> Doc -> FuncData
`fd` Doc
d)

instance FunctionElim JuliaCode TypeData where
  functionType :: JuliaCode FuncData -> JuliaCode TypeData
functionType = (FuncData -> TypeData) -> JuliaCode FuncData -> JuliaCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue FuncData -> TypeData
fType
  function :: JuliaCode FuncData -> Doc
function = FuncData -> Doc
funcDoc (FuncData -> Doc)
-> (JuliaCode FuncData -> FuncData) -> JuliaCode FuncData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode FuncData -> FuncData
forall a. JuliaCode a -> a
unJLC

instance InternalAssignStmt JuliaCode Statement Variable Value where
  multiAssign :: [VS (JuliaCode Variable)]
-> [VS (JuliaCode Value)] -> MS (JuliaCode Statement)
multiAssign = (Doc -> Doc)
-> [VS (JuliaCode Variable)]
-> [VS (JuliaCode Value)]
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, AssignStatement r stmt var val,
 InternalVarElim r var, RenderValue r var val typ,
 RenderVariable r var typ, ValueElim r val) =>
(Doc -> Doc) -> [VS (r var)] -> [VS (r val)] -> MS (r stmt)
CP.multiAssign Doc -> Doc
forall a. a -> a
id

instance InternalIOStmt JuliaCode Statement Value where
  printSt :: Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
printSt = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
jlPrint

instance InternalControlStmt JuliaCode Statement Value where
  multiReturn :: [VS (JuliaCode Value)] -> MS (JuliaCode Statement)
multiReturn = (Doc -> Doc) -> [VS (JuliaCode Value)] -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (typ :: k) (bod :: k) (stmt :: k)
       (var :: k) (val :: k).
(TypeSym r typ, ControlStatement r bod stmt var val,
 RenderValue r var val typ, ValueElim r val) =>
(Doc -> Doc) -> [VS (r val)] -> MS (r stmt)
CP.multiReturn Doc -> Doc
forall a. a -> a
id

instance RenderStatement JuliaCode Statement where
  stmt :: MS (JuliaCode Statement) -> MS (JuliaCode Statement)
stmt = MS (JuliaCode Statement) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
G.stmt
  loopStmt :: MS (JuliaCode Statement) -> MS (JuliaCode Statement)
loopStmt = MS (JuliaCode Statement) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
G.loopStmt
  stmtFromData :: Doc -> Terminator -> MS (JuliaCode Statement)
stmtFromData Doc
d Terminator
t = JuliaCode Statement -> MS (JuliaCode Statement)
forall a s. a -> State s a
toState (JuliaCode Statement -> MS (JuliaCode Statement))
-> JuliaCode Statement -> MS (JuliaCode Statement)
forall a b. (a -> b) -> a -> b
$ Statement -> JuliaCode Statement
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc
d, Terminator
t)

instance StatementElim JuliaCode Statement where
  statement :: JuliaCode Statement -> Doc
statement = Statement -> Doc
forall a b. (a, b) -> a
fst (Statement -> Doc)
-> (JuliaCode Statement -> Statement) -> JuliaCode Statement -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Statement -> Statement
forall a. JuliaCode a -> a
unJLC
  statementTerm :: JuliaCode Statement -> Terminator
statementTerm = Statement -> Terminator
forall a b. (a, b) -> b
snd (Statement -> Terminator)
-> (JuliaCode Statement -> Statement)
-> JuliaCode Statement
-> Terminator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Statement -> Statement
forall a. JuliaCode a -> a
unJLC

instance EmptyStatement JuliaCode Statement where
  emptyStmt :: MS (JuliaCode Statement)
emptyStmt = MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt)
G.emptyStmt

instance MultiStatement JuliaCode Statement where
  multi :: [MS (JuliaCode Statement)] -> MS (JuliaCode Statement)
multi = ([JuliaCode Statement] -> JuliaCode Statement)
-> [MS (JuliaCode Statement)] -> MS (JuliaCode Statement)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (([Statement] -> Statement)
-> [JuliaCode Statement] -> JuliaCode Statement
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList [Statement] -> Statement
R.multiStmt)

instance ValueStatement JuliaCode Statement Value where
  valStmt :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
valStmt = Terminator -> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r val) -> MS (r stmt)
G.valStmt Terminator
Empty

instance AssignStatement JuliaCode Statement Variable Value where
  assign :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
assign = VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
jlAssign
  &-= :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
(&-=) = VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
jlSubAssign
  &+= :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
(&+=) = VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
jlIncrement
  &++ :: VS (JuliaCode Variable) -> MS (JuliaCode Statement)
(&++) = VS (JuliaCode Variable) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, Literal r val typ) =>
VS (r var) -> MS (r stmt)
M.increment1
  &-- :: VS (JuliaCode Variable) -> MS (JuliaCode Statement)
(&--) = VS (JuliaCode Variable) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, Literal r val typ) =>
VS (r var) -> MS (r stmt)
M.decrement1

instance DeclStatement JuliaCode Body Statement Variable ScopeData Value where
  varDec :: VS (JuliaCode Variable)
-> JuliaCode ScopeData -> MS (JuliaCode Statement)
varDec VS (JuliaCode Variable)
v JuliaCode ScopeData
scp = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> Maybe (VS (JuliaCode Value))
-> MS (JuliaCode Statement)
forall (r :: * -> *) stmt var val typ.
(EmptyStatement r stmt, AssignStatement r stmt var val,
 ScopeElim r ScopeData, VariableElim r var typ) =>
VS (r var) -> r ScopeData -> Maybe (VS (r val)) -> MS (r stmt)
CS.varDecDef VS (JuliaCode Variable)
v JuliaCode ScopeData
scp Maybe (VS (JuliaCode Value))
forall a. Maybe a
Nothing
  varDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
varDecDef VS (JuliaCode Variable)
v JuliaCode ScopeData
scp VS (JuliaCode Value)
e = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> Maybe (VS (JuliaCode Value))
-> MS (JuliaCode Statement)
forall (r :: * -> *) stmt var val typ.
(EmptyStatement r stmt, AssignStatement r stmt var val,
 ScopeElim r ScopeData, VariableElim r var typ) =>
VS (r var) -> r ScopeData -> Maybe (VS (r val)) -> MS (r stmt)
CS.varDecDef VS (JuliaCode Variable)
v JuliaCode ScopeData
scp (VS (JuliaCode Value) -> Maybe (VS (JuliaCode Value))
forall a. a -> Maybe a
Just VS (JuliaCode Value)
e)
  setDec :: VS (JuliaCode Variable)
-> JuliaCode ScopeData -> MS (JuliaCode Statement)
setDec = VS (JuliaCode Variable)
-> JuliaCode ScopeData -> MS (JuliaCode Statement)
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
  setDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
setDecDef = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
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)
varDecDef
  listDec :: Integer
-> VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> MS (JuliaCode Statement)
listDec Integer
_ = VS (JuliaCode Variable)
-> JuliaCode ScopeData -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val, TypeSym r typ,
 Literal r val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> MS (r stmt)
CP.listDec
  listDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> [VS (JuliaCode Value)]
-> MS (JuliaCode Statement)
listDecDef = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> [VS (JuliaCode Value)]
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val, TypeSym r typ,
 Literal r val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
CP.listDecDef
  arrayDec :: Integer
-> VS (JuliaCode Value)
-> VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> MS (JuliaCode Statement)
arrayDec = Integer
-> VS (JuliaCode Value)
-> VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (scope :: k) (val :: k) (typ :: k).
(BodySym r bod block, BlockSym r block stmt, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 ListStatement r stmt val, VariableElim r var typ) =>
Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
M.arrayDecAsList
  arrayDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> [VS (JuliaCode Value)]
-> MS (JuliaCode Statement)
arrayDecDef = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> [VS (JuliaCode Value)]
-> MS (JuliaCode Statement)
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
  constDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
constDecDef = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
jlConstDecDef
  funcDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> [VS (JuliaCode Variable)]
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
funcDecDef = VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> [VS (JuliaCode Variable)]
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall (r :: * -> *) file mod mthd vis param bod block stmt var val
       binder typ.
ProcRenderSym
  r
  file
  mod
  mthd
  vis
  param
  bod
  block
  stmt
  var
  ScopeData
  val
  binder
  typ =>
VS (r var)
-> r ScopeData -> [VS (r var)] -> MS (r bod) -> MS (r stmt)
A.funcDecDef

instance PrintConsole JuliaCode Statement Value where
  print :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
print      = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
False Maybe (VS (JuliaCode Value))
forall a. Maybe a
Nothing VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc
  printLn :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
printLn    = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
True  Maybe (VS (JuliaCode Value))
forall a. Maybe a
Nothing VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc
  printStr :: Label -> MS (JuliaCode Statement)
printStr   = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
False Maybe (VS (JuliaCode Value))
forall a. Maybe a
Nothing VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc   (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> (Label -> VS (JuliaCode Value))
-> Label
-> MS (JuliaCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Label -> VS (r val)
litString
  printStrLn :: Label -> MS (JuliaCode Statement)
printStrLn = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
True  Maybe (VS (JuliaCode Value))
forall a. Maybe a
Nothing VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> (Label -> VS (JuliaCode Value))
-> Label
-> MS (JuliaCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Label -> VS (r val)
litString

instance ReadConsole JuliaCode Statement Variable where
  getInput :: VS (JuliaCode Variable) -> MS (JuliaCode Statement)
getInput = VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
jlInput VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
inputFunc
  discardInput :: MS (JuliaCode Statement)
discardInput = VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
inputFunc

instance FileHandling JuliaCode Statement Variable Value where
  openFileR :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
openFileR VS (JuliaCode Variable)
f VS (JuliaCode Value)
n = VS (JuliaCode Variable)
f VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, Literal r val typ,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
CP.openFileR' VS (JuliaCode Value)
n
  openFileW :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
openFileW VS (JuliaCode Variable)
f VS (JuliaCode Value)
n = VS (JuliaCode Variable)
f VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, Literal r val typ,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
CP.openFileW' VS (JuliaCode Value)
n
  openFileA :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
openFileA VS (JuliaCode Variable)
f VS (JuliaCode Value)
n = VS (JuliaCode Variable)
f VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, Literal r val typ,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
CP.openFileA' VS (JuliaCode Value)
n
  closeFile :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
closeFile VS (JuliaCode Value)
f = VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall a b. (a -> b) -> a -> b
$ PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
jlCloseFunc VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void [VS (JuliaCode Value)
f]

instance PrintFile JuliaCode Statement Value where
  printFile :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
printFile VS (JuliaCode Value)
f      = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
False (VS (JuliaCode Value) -> Maybe (VS (JuliaCode Value))
forall a. a -> Maybe a
Just VS (JuliaCode Value)
f) VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc
  printFileLn :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
printFileLn VS (JuliaCode Value)
f    = Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
True (VS (JuliaCode Value) -> Maybe (VS (JuliaCode Value))
forall a. a -> Maybe a
Just VS (JuliaCode Value)
f) VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc
  printFileStr :: VS (JuliaCode Value) -> Label -> MS (JuliaCode Statement)
printFileStr VS (JuliaCode Value)
f   = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
printFile   VS (JuliaCode Value)
f (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> (Label -> VS (JuliaCode Value))
-> Label
-> MS (JuliaCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Label -> VS (r val)
litString
  printFileStrLn :: VS (JuliaCode Value) -> Label -> MS (JuliaCode Statement)
printFileStrLn VS (JuliaCode Value)
f = VS (JuliaCode Value)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
printFileLn VS (JuliaCode Value)
f (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> (Label -> VS (JuliaCode Value))
-> Label
-> MS (JuliaCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Label -> VS (r val)
litString

instance ReadFile JuliaCode Statement Variable Value where
  getFileInput :: VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
getFileInput VS (JuliaCode Value)
f = VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
jlInput (VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
readLine VS (JuliaCode Value)
f)
  discardFileInput :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
discardFileInput VS (JuliaCode Value)
f = VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
readLine VS (JuliaCode Value)
f)
  getFileInputLine :: VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
getFileInputLine = VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInput
  discardFileLine :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
discardFileLine = VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> MS (r stmt)
discardFileInput
  getFileInputAll :: VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
getFileInputAll VS (JuliaCode Value)
f VS (JuliaCode Variable)
v = VS (JuliaCode Variable)
v VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
readLines VS (JuliaCode Value)
f

instance StringStatement JuliaCode Statement Variable Value where
  stringSplit :: Char
-> VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
stringSplit Char
d VS (JuliaCode Variable)
vnew VS (JuliaCode Value)
s = VS (JuliaCode Variable)
vnew VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
jlSplit (VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string) [VS (JuliaCode Value)
s, Label -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Label -> VS (r val)
litString [Char
d]]
  stringListVals :: [VS (JuliaCode Variable)]
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
stringListVals = [VS (JuliaCode Variable)]
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(MultiStatement r stmt, AssignStatement r stmt var val, List r val,
 ValueSym r val typ, Literal r val typ, RenderValue r var val typ,
 TypeElim r typ, VariableElim r var typ) =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
M.stringListVals
  stringListLists :: [VS (JuliaCode Variable)]
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
stringListLists = [VS (JuliaCode Variable)]
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (val :: k) (typ :: k).
(BodySym r bod block, BlockSym r block stmt,
 ControlStatement r bod stmt var val, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 VariableSym r var typ, VariableValue r var val, List r val,
 ListStatement r stmt val, TypeElim r typ, VariableElim r var typ,
 RenderValue r var val typ) =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
M.stringListLists

instance FuncAppStatement JuliaCode Statement Variable Value where
  inOutCall :: InOutCall JuliaCode Statement Variable Value
inOutCall = PosCall JuliaCode Value TypeData
-> InOutCall JuliaCode Statement Variable Value
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, InternalAssignStmt r stmt var val,
 ValueStatement r stmt val, VariableValue r var val) =>
(Label -> VS (r typ) -> [VS (r val)] -> VS (r val))
-> Label
-> [VS (r val)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r stmt)
CP.inOutCall PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp
  extInOutCall :: Label -> InOutCall JuliaCode Statement Variable Value
extInOutCall Label
m = PosCall JuliaCode Value TypeData
-> InOutCall JuliaCode Statement Variable Value
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, InternalAssignStmt r stmt var val,
 ValueStatement r stmt val, VariableValue r var val) =>
(Label -> VS (r typ) -> [VS (r val)] -> VS (r val))
-> Label
-> [VS (r val)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r stmt)
CP.inOutCall (Label -> PosCall JuliaCode Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
Label -> PosCall r val typ
extFuncApp Label
m)

instance CommentStatement JuliaCode Statement where
  comment :: Label -> MS (JuliaCode Statement)
comment = Doc -> Label -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> Label -> MS (r stmt)
G.comment Doc
jlCmtStart

instance ControlStatement JuliaCode Body Statement Variable Value where
  break :: MS (JuliaCode Statement)
break = Doc -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd Doc
R.break
  continue :: MS (JuliaCode Statement)
continue = Doc -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd Doc
R.continue
  returnStmt :: VS (JuliaCode Value) -> MS (JuliaCode Statement)
returnStmt = Terminator -> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r val) -> MS (r stmt)
G.returnStmt Terminator
Empty
  throw :: Label -> MS (JuliaCode Statement)
throw = (JuliaCode Value -> Doc)
-> Terminator -> Label -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (stmt :: k).
(Literal r val typ, RenderStatement r stmt) =>
(r val -> Doc) -> Terminator -> Label -> MS (r stmt)
G.throw JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
jlThrow Terminator
Empty
  ifCond :: [(VS (JuliaCode Value), MS (JuliaCode Doc))]
-> MS (JuliaCode Doc) -> MS (JuliaCode Statement)
ifCond = (Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(VS (JuliaCode Value), MS (JuliaCode Doc))]
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(VS (r val), MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
G.ifCond Doc -> Doc
forall a. a -> a
id Doc
empty OptionalSpace
jlSpace Doc
elseIfLabel Doc
empty Doc
jlEnd
  switch :: VS (JuliaCode Value)
-> [(VS (JuliaCode Value), MS (JuliaCode Doc))]
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
switch = VS (JuliaCode Value)
-> [(VS (JuliaCode Value), MS (JuliaCode Doc))]
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
(ControlStatement r bod stmt var val, Comparison r val) =>
VS (r val)
-> [(VS (r val), MS (r bod))] -> MS (r bod) -> MS (r stmt)
switchAsIf
  ifExists :: VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
ifExists = VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k) (binder :: k) (typ :: k).
(ControlStatement r bod stmt var val,
 ValueExpression r var val binder typ) =>
VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
M.ifExists
  for :: MS (JuliaCode Statement)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
for MS (JuliaCode Statement)
_ VS (JuliaCode Value)
_ MS (JuliaCode Statement)
_ MS (JuliaCode Doc)
_ = Label -> MS (JuliaCode Statement)
forall a. HasCallStack => Label -> a
error (Label -> MS (JuliaCode Statement))
-> Label -> MS (JuliaCode Statement)
forall a b. (a -> b) -> a -> b
$ Label -> Label
CP.forLoopError Label
jlName
  forRange :: VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forRange VS (JuliaCode Variable)
i VS (JuliaCode Value)
initv VS (JuliaCode Value)
finalv VS (JuliaCode Value)
stepv = VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt)
forEach VS (JuliaCode Variable)
i (VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
jlRange VS (JuliaCode Value)
initv VS (JuliaCode Value)
finalv VS (JuliaCode Value)
stepv)
  forEach :: VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forEach = (JuliaCode Variable -> JuliaCode Value -> JuliaCode Doc -> Doc)
-> VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall (r :: * -> *) stmt var val.
RenderStatement r stmt =>
(r var -> r val -> r Doc -> Doc)
-> VS (r var) -> VS (r val) -> MS (r Doc) -> MS (r stmt)
CS.forEach' JuliaCode Variable -> JuliaCode Value -> JuliaCode Doc -> Doc
forall {k} (r :: k -> *) (bod :: k) (var :: k) (val :: k).
(BodyElim r bod, InternalVarElim r var, ValueElim r val) =>
r var -> r val -> r bod -> Doc
jlForEach
  while :: VS (JuliaCode Value)
-> MS (JuliaCode Doc) -> MS (JuliaCode Statement)
while = (Doc -> Doc)
-> Doc
-> Doc
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Doc -> Doc)
-> Doc -> Doc -> VS (r val) -> MS (r bod) -> MS (r stmt)
C.while Doc -> Doc
forall a. a -> a
id Doc
empty Doc
jlEnd
  tryCatch :: MS (JuliaCode Doc)
-> MS (JuliaCode Doc) -> MS (JuliaCode Statement)
tryCatch = (JuliaCode Doc -> JuliaCode Doc -> Doc)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Doc)
-> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (bod :: k).
RenderStatement r stmt =>
(r bod -> r bod -> Doc) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
G.tryCatch JuliaCode Doc -> JuliaCode Doc -> Doc
forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> r bod -> Doc
jlTryCatch
  assert :: VS (JuliaCode Value)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
assert VS (JuliaCode Value)
condition VS (JuliaCode Value)
errorMessage = do
    cond <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Value))
  MethodState
  ValueState
-> VS (JuliaCode Value)
-> StateT MethodState Identity (JuliaCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Value) ValueState)
-> MethodState -> Focusing Identity (JuliaCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Value)
condition
    errMsg <- zoom lensMStoVS errorMessage
    mkStmtNoEnd (jlAssert cond errMsg)

instance VisibilitySym JuliaCode Doc where

  private :: JuliaCode Doc
private = Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty -- Julia doesn't have private/public members
  public :: JuliaCode Doc
public = Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty

instance RenderVisibility JuliaCode Doc where
  visibilityFromData :: VisibilityTag -> Doc -> JuliaCode Doc
visibilityFromData VisibilityTag
_ = Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode

instance VisibilityElim JuliaCode Doc where
  visibility :: JuliaCode Doc -> Doc
visibility = JuliaCode Doc -> Doc
forall a. JuliaCode a -> a
unJLC

instance MethodTypeSym JuliaCode TypeData where
  mType :: VS (JuliaCode TypeData) -> MS (JuliaCode TypeData)
mType = LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode TypeData))
  MethodState
  ValueState
-> VS (JuliaCode TypeData) -> MS (JuliaCode TypeData)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode TypeData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode TypeData) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode TypeData) MethodState
Lens' MethodState ValueState
lensMStoVS

instance ParameterSym JuliaCode ParamData Variable where
  param :: VS (JuliaCode Variable) -> MS (JuliaCode ParamData)
param = (JuliaCode Variable -> Doc)
-> VS (JuliaCode Variable) -> MS (JuliaCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k) (typ :: k).
(RenderParam r param var, VariableElim r var typ) =>
(r var -> Doc) -> VS (r var) -> MS (r param)
G.param JuliaCode Variable -> Doc
jlParam
  pointerParam :: VS (JuliaCode Variable) -> MS (JuliaCode ParamData)
pointerParam = VS (JuliaCode Variable) -> MS (JuliaCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param

instance RenderParam JuliaCode ParamData Variable where
  paramFromData :: VS (JuliaCode Variable) -> Doc -> MS (JuliaCode ParamData)
paramFromData VS (JuliaCode Variable)
v' Doc
d = do
    v <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
-> VS (JuliaCode Variable)
-> StateT MethodState Identity (JuliaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Variable) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Variable)
v'
    toState $ on2CodeValues pd v (toCode d)

instance ParamElim JuliaCode ParamData TypeData where
  parameterName :: JuliaCode ParamData -> Label
parameterName = JuliaCode Variable -> Label
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> Label
variableName (JuliaCode Variable -> Label)
-> (JuliaCode ParamData -> JuliaCode Variable)
-> JuliaCode ParamData
-> Label
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> Variable)
-> JuliaCode ParamData -> JuliaCode Variable
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> Variable
paramVar
  parameterType :: JuliaCode ParamData -> JuliaCode TypeData
parameterType = JuliaCode Variable -> JuliaCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType (JuliaCode Variable -> JuliaCode TypeData)
-> (JuliaCode ParamData -> JuliaCode Variable)
-> JuliaCode ParamData
-> JuliaCode TypeData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> Variable)
-> JuliaCode ParamData -> JuliaCode Variable
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> Variable
paramVar
  parameter :: JuliaCode ParamData -> Doc
parameter = ParamData -> Doc
paramDoc (ParamData -> Doc)
-> (JuliaCode ParamData -> ParamData) -> JuliaCode ParamData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode ParamData -> ParamData
forall a. JuliaCode a -> a
unJLC

instance MethodSym JuliaCode MethodData Doc ParamData Body Variable TypeData where
  docMain :: MS (JuliaCode Doc) -> MS (JuliaCode MethodData)
docMain = MS (JuliaCode Doc) -> MS (JuliaCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
MS (r bod) -> MS (r mthd)
mainFunction
  function :: Label
-> JuliaCode Doc
-> VS (JuliaCode TypeData)
-> [MS (JuliaCode ParamData)]
-> MS (JuliaCode Doc)
-> MS (JuliaCode MethodData)
function = Label
-> JuliaCode Doc
-> VS (JuliaCode TypeData)
-> [MS (JuliaCode ParamData)]
-> MS (JuliaCode Doc)
-> MS (JuliaCode MethodData)
forall {k} (r :: k -> *) (typ :: k) (mthd :: k) (vis :: k)
       (param :: k) (bod :: k).
(MethodTypeSym r typ, ProcRenderMethod r mthd vis param bod typ) =>
Label
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
A.function
  mainFunction :: MS (JuliaCode Doc) -> MS (JuliaCode MethodData)
mainFunction = MS (JuliaCode Doc) -> MS (JuliaCode MethodData)
forall (r :: * -> *) bod mthd.
(BodyElim r bod, RenderMethod r mthd) =>
MS (r bod) -> MS (r mthd)
CP.mainBody
  docFunc :: Label
-> [Label]
-> Maybe Label
-> MS (JuliaCode MethodData)
-> MS (JuliaCode MethodData)
docFunc = FuncDocRenderer
-> Label
-> [Label]
-> Maybe Label
-> MS (JuliaCode MethodData)
-> MS (JuliaCode MethodData)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> Label -> [Label] -> Maybe Label -> MS (r mthd) -> MS (r mthd)
G.docFunc FuncDocRenderer
CP.functionDoc

  inOutFunc :: Label
-> JuliaCode Doc -> InOutFunc JuliaCode MethodData Doc Variable
inOutFunc Label
n JuliaCode Doc
s = (VS (JuliaCode TypeData)
 -> [MS (JuliaCode ParamData)]
 -> MS (JuliaCode Doc)
 -> MS (JuliaCode MethodData))
-> InOutFunc JuliaCode MethodData Doc Variable
forall {k} (r :: k -> *) (var :: k) (val :: k) (param :: k)
       (typ :: k) (scope :: k) (bod :: k) (stmt :: k) (block :: k)
       (mthd :: k).
(VariableValue r var val, ParameterSym r param var, TypeSym r typ,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 BlockSym r block stmt, BodySym r bod block, VariableElim r var typ,
 RenderBody r bod, RenderType r typ,
 InternalControlStmt r stmt val) =>
(VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd))
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
CP.inOutFunc (Label
-> JuliaCode Doc
-> VS (JuliaCode TypeData)
-> [MS (JuliaCode ParamData)]
-> MS (JuliaCode Doc)
-> MS (JuliaCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Label
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function Label
n JuliaCode Doc
s)
  docInOutFunc :: Label
-> JuliaCode Doc -> DocInOutFunc JuliaCode MethodData Doc Variable
docInOutFunc Label
n JuliaCode Doc
s = FuncDocRenderer
-> InOutFunc JuliaCode MethodData Doc Variable
-> DocInOutFunc JuliaCode MethodData Doc Variable
forall (r :: * -> *) mthd var bod.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> ([VS (r var)]
    -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> Label
-> [(Label, VS (r var))]
-> [(Label, VS (r var))]
-> [(Label, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc' FuncDocRenderer
CP.functionDoc (Label
-> JuliaCode Doc -> InOutFunc JuliaCode MethodData Doc Variable
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
Label -> r vis -> InOutFunc r mthd bod var
inOutFunc Label
n JuliaCode Doc
s)

instance RenderMethod JuliaCode MethodData where
  commentedFunc :: MS (JuliaCode Doc)
-> MS (JuliaCode MethodData) -> MS (JuliaCode MethodData)
commentedFunc MS (JuliaCode Doc)
cmt MS (JuliaCode MethodData)
m = (JuliaCode MethodData
 -> JuliaCode (Doc -> Doc) -> JuliaCode MethodData)
-> MS (JuliaCode MethodData)
-> State MethodState (JuliaCode (Doc -> Doc))
-> MS (JuliaCode MethodData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((MethodData -> (Doc -> Doc) -> MethodData)
-> JuliaCode MethodData
-> JuliaCode (Doc -> Doc)
-> JuliaCode MethodData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues MethodData -> (Doc -> Doc) -> MethodData
updateMthd) MS (JuliaCode MethodData)
m
    ((JuliaCode Doc -> JuliaCode (Doc -> Doc))
-> MS (JuliaCode Doc) -> State MethodState (JuliaCode (Doc -> Doc))
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Doc -> Doc -> Doc) -> JuliaCode Doc -> JuliaCode (Doc -> Doc)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Doc -> Doc -> Doc
R.commentedItem) MS (JuliaCode Doc)
cmt)
  mthdFromData :: VisibilityTag -> Doc -> MS (JuliaCode MethodData)
mthdFromData VisibilityTag
_ Doc
d = JuliaCode MethodData -> MS (JuliaCode MethodData)
forall a s. a -> State s a
toState (JuliaCode MethodData -> MS (JuliaCode MethodData))
-> JuliaCode MethodData -> MS (JuliaCode MethodData)
forall a b. (a -> b) -> a -> b
$ MethodData -> JuliaCode MethodData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (MethodData -> JuliaCode MethodData)
-> MethodData -> JuliaCode MethodData
forall a b. (a -> b) -> a -> b
$ Label -> Doc -> MethodData
mthd Label
"" Doc
d

instance ProcRenderMethod JuliaCode MethodData Doc ParamData Body TypeData where
  intFunc :: Bool
-> Label
-> JuliaCode Doc
-> MS (JuliaCode TypeData)
-> [MS (JuliaCode ParamData)]
-> MS (JuliaCode Doc)
-> MS (JuliaCode MethodData)
intFunc Bool
_ Label
n JuliaCode Doc
_ MS (JuliaCode TypeData)
_ [MS (JuliaCode ParamData)]
ps MS (JuliaCode Doc)
b = do
    pms <- [MS (JuliaCode ParamData)]
-> StateT MethodState Identity [JuliaCode ParamData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [MS (JuliaCode ParamData)]
ps
    toCode . mthd n . jlIntFunc n pms <$> b

instance MethodElim JuliaCode MethodData where
  method :: JuliaCode MethodData -> Doc
method = MethodData -> Doc
mthdDoc (MethodData -> Doc)
-> (JuliaCode MethodData -> MethodData)
-> JuliaCode MethodData
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode MethodData -> MethodData
forall a. JuliaCode a -> a
unJLC

instance ModuleSym JuliaCode ModData MethodData where
  buildModule :: Label
-> [Label] -> [MS (JuliaCode MethodData)] -> FS (JuliaCode ModData)
buildModule Label
n [Label]
is [MS (JuliaCode MethodData)]
fs = Label
-> [Label] -> [MS (JuliaCode MethodData)] -> FS (JuliaCode ModData)
jlModContents Label
n [Label]
is [MS (JuliaCode MethodData)]
fs FS (JuliaCode ModData)
-> (JuliaCode ModData -> JuliaCode ModData)
-> FS (JuliaCode ModData)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&>
    (Doc -> Doc) -> JuliaCode ModData -> JuliaCode ModData
forall {k} (r :: k -> *) (mod :: k).
RenderMod r mod =>
(Doc -> Doc) -> r mod -> r mod
updateModuleDoc (\Doc
m -> Doc -> Doc -> Doc
emptyIfEmpty Doc
m ([Doc] -> Doc
vibcat [Label -> Doc
jlModStart Label
n, Doc
m, Doc
jlEnd]))

instance RenderMod JuliaCode ModData where
  modFromData :: Label -> FS Doc -> FS (JuliaCode ModData)
modFromData Label
n = Label
-> (Doc -> JuliaCode ModData) -> FS Doc -> FS (JuliaCode ModData)
forall {k} (r :: k -> *) (mod :: k).
Label -> (Doc -> r mod) -> FS Doc -> FS (r mod)
A.modFromData Label
n (ModData -> JuliaCode ModData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (ModData -> JuliaCode ModData)
-> (Doc -> ModData) -> Doc -> JuliaCode ModData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Label -> Doc -> ModData
md Label
n)
  updateModuleDoc :: (Doc -> Doc) -> JuliaCode ModData -> JuliaCode ModData
updateModuleDoc Doc -> Doc
f = (ModData -> ModData) -> JuliaCode ModData -> JuliaCode ModData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Doc -> Doc) -> ModData -> ModData
updateMod Doc -> Doc
f)

instance ModuleElim JuliaCode ModData where
  module' :: JuliaCode ModData -> Doc
module' = ModData -> Doc
modDoc (ModData -> Doc)
-> (JuliaCode ModData -> ModData) -> JuliaCode ModData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode ModData -> ModData
forall a. JuliaCode a -> a
unJLC

instance BlockCommentSym JuliaCode where
  blockComment :: [Label] -> JuliaCode Doc
blockComment [Label]
lns = Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JuliaCode Doc) -> Doc -> JuliaCode Doc
forall a b. (a -> b) -> a -> b
$ [Label] -> Doc -> Doc -> Doc
R.blockCmt [Label]
lns Doc
jlBlockCmtStart Doc
jlBlockCmtEnd
  docComment :: forall a. State a [Label] -> State a (JuliaCode Doc)
docComment = ([Label] -> JuliaCode Doc)
-> State a [Label] -> State a (JuliaCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\[Label]
lns -> Doc -> JuliaCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> JuliaCode Doc) -> Doc -> JuliaCode Doc
forall a b. (a -> b) -> a -> b
$ [Label] -> Doc -> Doc -> Doc
R.docCmt [Label]
lns Doc
jlDocCmtStart
    Doc
jlDocCmtEnd)

instance BlockCommentElim JuliaCode where
  blockComment' :: JuliaCode Doc -> Doc
blockComment' = JuliaCode Doc -> Doc
forall a. JuliaCode a -> a
unJLC

-- convenience
jlName, jlVersion :: String
jlName :: Label
jlName = Label
"Julia"
jlVersion :: Label
jlVersion = Label
"1.10.3"

-- Concrete versions of each Julia datatype
jlIntConc, jlFloatConc, jlDoubleConc, jlCharConc, jlStringConc, jlListConc,
  jlSetConc, jlFile, jlVoid :: String
jlIntConc :: Label
jlIntConc = Label
"Int64"
jlFloatConc :: Label
jlFloatConc = Label
"Float32"
jlDoubleConc :: Label
jlDoubleConc = Label
"Float64"
jlCharConc :: Label
jlCharConc = Label
"Char"
jlStringConc :: Label
jlStringConc = Label
"String"
jlListConc :: Label
jlListConc = Label
"Array"
jlSetConc :: Label
jlSetConc = Label
"Set"
jlFile :: Label
jlFile = Label
"IOStream"
jlVoid :: Label
jlVoid = Label
"Nothing"

-- The only consistent way of creating floats is by casting
jlLitFloat :: (RenderValue r var val typ, TypeSym r typ) => Float -> VS (r val)
jlLitFloat :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Float -> VS (r val)
jlLitFloat Float
f = VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float (Label -> Doc
text Label
jlFloatConc Doc -> Doc -> Doc
<> Doc -> Doc
parens (Float -> Doc
D.float Float
f))

jlLitList
  :: VS (JuliaCode TypeData) -> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
jlLitList :: VS (JuliaCode TypeData)
-> [VS (JuliaCode Value)] -> VS (JuliaCode Value)
jlLitList VS (JuliaCode TypeData)
t' [VS (JuliaCode Value)]
es = do
  t <- VS (JuliaCode TypeData)
t'
  let lt' = VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (JuliaCode TypeData)
t'
  elems <- sequence es
  let typeDec = if [VS (JuliaCode Value)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [VS (JuliaCode Value)]
es then JuliaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType JuliaCode TypeData
t else Doc
empty
  mkStateVal lt' (typeDec <> brackets (valueList elems))

jlCast :: VS (JuliaCode TypeData) -> VS (JuliaCode Value) -> VS (JuliaCode Value)
jlCast :: VS (JuliaCode TypeData)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
jlCast VS (JuliaCode TypeData)
t' VS (JuliaCode Value)
v' = do
  t <- VS (JuliaCode TypeData)
t'
  v <- v'
  let vTp = JuliaCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (JuliaCode TypeData -> CodeType) -> JuliaCode TypeData -> CodeType
forall a b. (a -> b) -> a -> b
$ JuliaCode Value -> JuliaCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType JuliaCode Value
v
      tTp = JuliaCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType JuliaCode TypeData
t
      vDoc = JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
v
      tDoc = JuliaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType JuliaCode TypeData
t
      jlCast' :: CodeType -> CodeType -> Doc -> Doc -> Doc
      -- Converting string to char
      jlCast' CodeType
String CodeType
Char Doc
vDoc' Doc
_ = Label -> Doc
text Label
"only" Doc -> Doc -> Doc
<> Doc -> Doc
parens Doc
vDoc'
      -- Converting string to something else
      jlCast' CodeType
String CodeType
_    Doc
vDoc' Doc
tDoc' = Label -> Doc
text Label
"parse" Doc -> Doc -> Doc
<> Doc -> Doc
parens (Doc
tDoc' Doc -> Doc -> Doc
<> Doc
listSep' Doc -> Doc -> Doc
<+> Doc
vDoc')
      -- Converting non-string to char
      jlCast' CodeType
_      CodeType
Char Doc
vDoc' Doc
_ = Label -> Doc
text Label
"only" Doc -> Doc -> Doc
<> Doc -> Doc
parens (Label -> Doc
text Label
"string" Doc -> Doc -> Doc
<> Doc -> Doc
parens Doc
vDoc')
      -- Converting something to string
      jlCast' CodeType
_      CodeType
String Doc
vDoc' Doc
_ = Label -> Doc
text Label
"string" Doc -> Doc -> Doc
<> Doc -> Doc
parens Doc
vDoc'
      -- Converting non-string to non-string
      jlCast' CodeType
_      CodeType
_    Doc
vDoc' Doc
tDoc' = Doc
tDoc' Doc -> Doc -> Doc
<> Doc -> Doc
parens Doc
vDoc'
  mkVal t (jlCast' vTp tTp vDoc tDoc)

jlAssign
  :: VS (JuliaCode Variable)
  -> VS (JuliaCode Value)
  -> MS (JuliaCode Statement)
jlAssign :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
jlAssign VS (JuliaCode Variable)
vr' VS (JuliaCode Value)
v' = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
-> VS (JuliaCode Variable)
-> StateT MethodState Identity (JuliaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Variable) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Variable)
vr'
  v <- zoom lensMStoVS v'
  scpData <- getVarScope (variableName vr) -- Need to do global declarations
  mkStmtNoEnd $ jlGlobalDec scpData <+> R.assign vr v

jlSubAssign
  :: VS (JuliaCode Variable)
  -> VS (JuliaCode Value)
  -> MS (JuliaCode Statement)
jlSubAssign :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
jlSubAssign VS (JuliaCode Variable)
vr' VS (JuliaCode Value)
v' = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
-> VS (JuliaCode Variable)
-> StateT MethodState Identity (JuliaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Variable) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Variable)
vr'
  v <- zoom lensMStoVS v'
  scpData <- getVarScope (variableName vr) -- Need to do global declarations
  mkStmtNoEnd $ jlGlobalDec scpData <+> R.subAssign vr v

jlIncrement
  :: VS (JuliaCode Variable)
  -> VS (JuliaCode Value)
  -> MS (JuliaCode Statement)
jlIncrement :: VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
jlIncrement VS (JuliaCode Variable)
vr' VS (JuliaCode Value)
v'= do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
-> VS (JuliaCode Variable)
-> StateT MethodState Identity (JuliaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Variable) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Variable)
vr'
  v <- zoom lensMStoVS v'
  scpData <- getVarScope (variableName vr) -- Need to do global declarations
  mkStmtNoEnd $ jlGlobalDec scpData <+> R.addAssign vr v

jlGlobalDec :: ScopeData -> Doc
jlGlobalDec :: ScopeData -> Doc
jlGlobalDec ScopeData
scp = if ScopeData -> ScopeTag
scopeTag ScopeData
scp ScopeTag -> ScopeTag -> Bool
forall a. Eq a => a -> a -> Bool
== ScopeTag
Global then Doc
jlGlobal else Doc
empty

jlGlobal :: Doc
jlGlobal :: Doc
jlGlobal = Label -> Doc
text Label
"global"

jlConstDecDef
  :: VS (JuliaCode Variable)
  -> JuliaCode ScopeData
  -> VS (JuliaCode Value)
  -> MS (JuliaCode Statement)
jlConstDecDef :: VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
jlConstDecDef VS (JuliaCode Variable)
v' JuliaCode ScopeData
scp VS (JuliaCode Value)
def' = do
  let scpData :: ScopeData
scpData = JuliaCode ScopeData -> ScopeData
forall (r :: * -> *) scope. ScopeElim r scope => r scope -> scope
scopeData JuliaCode ScopeData
scp
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
-> VS (JuliaCode Variable)
-> StateT MethodState Identity (JuliaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Variable) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Variable)
v'
  def <- zoom lensMStoVS def'
  modify $ useVarName $ variableName v
  modify $ setVarScope (variableName v) scpData
  let decDoc = if ScopeData -> ScopeTag
scopeTag ScopeData
scpData ScopeTag -> ScopeTag -> Bool
forall a. Eq a => a -> a -> Bool
== ScopeTag
Global then Doc
R.constDec' else Doc
empty
  mkStmtNoEnd $ decDoc <+> RC.variable v <+> equals <+> RC.value def

-- List API
jlListSize, jlListAdd, jlListAppend, jlListAbsdex :: Label
jlListSize :: Label
jlListSize   = Label
"length"
jlListAdd :: Label
jlListAdd    = Label
"insert!"
jlListAppend :: Label
jlListAppend = Label
"append!"
jlListAbsdex :: Label
jlListAbsdex = Label
"findfirst"

jlIndexOf
  ::
    ( ValueSym r val typ
    , IndexTranslator r val
    , ValueExpression r var val binder typ
    , BinderSym r binder typ
    , VariableSym r var typ
    , VariableValue r var val
    , Comparison r val
    )
  => VS (r val)
  -> VS (r val)
  -> VS (r val)
jlIndexOf :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k)
       (binder :: k).
(ValueSym r val typ, IndexTranslator r val,
 ValueExpression r var val binder typ, BinderSym r binder typ,
 VariableSym r var typ, VariableValue r var val,
 Comparison r val) =>
VS (r val) -> VS (r val) -> VS (r val)
jlIndexOf VS (r val)
l VS (r val)
v = do
  v' <- VS (r val)
v
  let t = r typ -> StateT ValueState Identity (r typ)
forall (r :: * -> *) a. Monad r => a -> r a
toCode (r typ -> StateT ValueState Identity (r typ))
-> r typ -> StateT ValueState Identity (r typ)
forall a b. (a -> b) -> a -> b
$ r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType r val
v'
  indexToInt $ funcApp
    jlListAbsdex t [lambda [binder "x" t] (valueOf (var "x" t) ?== v), l]

-- List slicing in Julia.  See HelloWorld.jl to see the full suite of
-- possible outputs of this function.
jlListSlice
  :: VS (JuliaCode Variable)
  -> VS (JuliaCode Value)
  -> Maybe (VS (JuliaCode Value))
  -> Maybe (VS (JuliaCode Value))
  -> VS (JuliaCode Value)
  -> MS (JuliaCode Block)
jlListSlice :: VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> Maybe (VS (JuliaCode Value))
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> MS (JuliaCode Doc)
jlListSlice VS (JuliaCode Variable)
vn VS (JuliaCode Value)
vo Maybe (VS (JuliaCode Value))
beg Maybe (VS (JuliaCode Value))
end VS (JuliaCode Value)
step = do

  vnew <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
-> VS (JuliaCode Variable)
-> StateT MethodState Identity (JuliaCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Variable) ValueState)
-> MethodState
-> Focusing Identity (JuliaCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Variable)
vn
  scpData <- getVarScope $ variableName vnew
  let scp = ScopeData -> JuliaCode ScopeData
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeData -> r scope
convScope ScopeData
scpData

  stepV <- zoom lensMStoVS step

  let mbStepV = JuliaCode Value -> Maybe Integer
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Maybe Integer
valueInt JuliaCode Value
stepV
  bName <- genVarNameIf (isNothing beg && isNothing mbStepV) "begIdx"
  eName <- genVarNameIf (isNothing mbStepV) "endIdx"

  let begVar = Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
var Label
bName VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
      endVar = Label -> VS (JuliaCode TypeData) -> VS (JuliaCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
var Label
eName VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int

      (setBeg, begVal) = case (beg, mbStepV) of
        -- If we have a value for beg, just use it
        (Just VS (JuliaCode Value)
b, Maybe Integer
_)        -> (MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt, VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
IndexTranslator r val =>
VS (r val) -> VS (r val)
intToIndex VS (JuliaCode Value)
b)
        -- If we don't have a value for `beg` but we do for `step`, use `begin` or `end`
        (Maybe (VS (JuliaCode Value))
Nothing, Just Integer
s)  -> (MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt,
          if Integer
s Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0 then VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int Doc
jlBegin else VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int Doc
jlEnd)
        -- Otherwise, generate an if-statement to calculate `beg` at runtime
        (Maybe (VS (JuliaCode Value))
Nothing, Maybe Integer
Nothing) -> (VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
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)
varDecDef VS (JuliaCode Variable)
begVar JuliaCode ScopeData
scp (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall a b. (a -> b) -> a -> b
$
          VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
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 (VS (JuliaCode Value)
step VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0) (Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1) (VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (JuliaCode Value)
vo),
          VS (JuliaCode Variable) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (JuliaCode Variable)
begVar)

      -- Similar to `begVal`, but if we're given a value, we have to either
      -- do nothing or add 2 based on the sign of `step`, because `end` needs
      -- to be inclusive
      (setEnd, endVal) = case (end, mbStepV) of
        (Just VS (JuliaCode Value)
e, Just Integer
s)  -> (MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt,
          if Integer
s Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0 then VS (JuliaCode Value)
e else VS (JuliaCode Value)
e VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, NumericExpression r val, RenderValue r var val typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
`G.smartAdd` Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
2)
        (Just VS (JuliaCode Value)
e, Maybe Integer
Nothing) -> (VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
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)
varDecDef VS (JuliaCode Variable)
endVar JuliaCode ScopeData
scp (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall a b. (a -> b) -> a -> b
$
          VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
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 (VS (JuliaCode Value)
step VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0) VS (JuliaCode Value)
e (VS (JuliaCode Value)
e VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, NumericExpression r val, RenderValue r var val typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
`G.smartAdd` Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
2),
          VS (JuliaCode Variable) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (JuliaCode Variable)
endVar)
        (Maybe (VS (JuliaCode Value))
Nothing, Just Integer
s) -> (MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt,
          if Integer
s Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0 then VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int Doc
jlEnd else VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int Doc
jlBegin)
        (Maybe (VS (JuliaCode Value))
Nothing, Maybe Integer
Nothing) -> (VS (JuliaCode Variable)
-> JuliaCode ScopeData
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
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)
varDecDef VS (JuliaCode Variable)
endVar JuliaCode ScopeData
scp (VS (JuliaCode Value) -> MS (JuliaCode Statement))
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall a b. (a -> b) -> a -> b
$
          VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
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 (VS (JuliaCode Value)
step VS (JuliaCode Value)
-> VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0) (VS (JuliaCode Value) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (JuliaCode Value)
vo) (Integer -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1), VS (JuliaCode Variable) -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (JuliaCode Variable)
endVar)

      setToSlice = VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> Maybe Integer
-> MS (JuliaCode Statement)
jlListSlice' VS (JuliaCode Variable)
vn VS (JuliaCode Value)
vo VS (JuliaCode Value)
begVal VS (JuliaCode Value)
endVal VS (JuliaCode Value)
step Maybe Integer
mbStepV

  block [
      setBeg,
      setEnd,
      setToSlice
    ]

jlListSlice'
  :: VS (JuliaCode Variable)
  -> VS (JuliaCode Value)
  -> VS (JuliaCode Value)
  -> VS (JuliaCode Value)
  -> VS (JuliaCode Value)
  -> Maybe Integer
  -> MS (JuliaCode Statement)
jlListSlice' :: VS (JuliaCode Variable)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> Maybe Integer
-> MS (JuliaCode Statement)
jlListSlice' VS (JuliaCode Variable)
vn VS (JuliaCode Value)
vo VS (JuliaCode Value)
beg VS (JuliaCode Value)
end VS (JuliaCode Value)
step Maybe Integer
mStep = do
  vold  <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Value))
  MethodState
  ValueState
-> VS (JuliaCode Value)
-> StateT MethodState Identity (JuliaCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Value) ValueState)
-> MethodState -> Focusing Identity (JuliaCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS VS (JuliaCode Value)
vo
  beg'  <- zoom lensMStoVS beg
  end'  <- zoom lensMStoVS end
  step' <- zoom lensMStoVS step
  let stepDoc = case Maybe Integer
mStep of
        (Just Integer
1) -> Doc
empty
        Maybe Integer
_        -> Doc
colon Doc -> Doc -> Doc
<> JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
step'
      theSlice = VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void (JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
vold Doc -> Doc -> Doc
<> Doc -> Doc
brackets (JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
beg' Doc -> Doc -> Doc
<> Doc
stepDoc Doc -> Doc -> Doc
<> Doc
colon Doc -> Doc -> Doc
<> JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
end'))
  vn &= theSlice

-- Other functionality
jlRange
  :: VS (JuliaCode Value)
  -> VS (JuliaCode Value)
  -> VS (JuliaCode Value)
  -> VS (JuliaCode Value)
jlRange :: VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
jlRange VS (JuliaCode Value)
initv VS (JuliaCode Value)
finalv VS (JuliaCode Value)
stepv = do
  t <- VS (JuliaCode TypeData) -> VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
  iv <- initv
  sv <- stepv
  fv <- finalv `G.smartSub` litInt 1
  mkVal t (RC.value iv <> colon <> RC.value sv <> colon <> RC.value fv)

jlSplit :: String
jlSplit :: Label
jlSplit = Label
"split"

jlPrintFunc, jlPrintLnFunc :: Doc
jlPrintFunc :: Doc
jlPrintFunc = Label -> Doc
text Label
printLabel
jlPrintLnFunc :: Doc
jlPrintLnFunc = Label -> Doc
text Label
"println"

jlParseFunc :: Label
jlParseFunc :: Label
jlParseFunc = Label
"parse"

jlType, arrow, jlNamedArgSep :: Doc
jlType :: Doc
jlType = Doc
colon Doc -> Doc -> Doc
<> Doc
colon
arrow :: Doc
arrow = Label -> Doc
text Label
"->"
jlNamedArgSep :: Doc
jlNamedArgSep = Doc
equals

jlTuple :: [String] -> String
jlTuple :: [Label] -> Label
jlTuple [Label]
ts = Label
"Tuple{" Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> Label -> [Label] -> Label
forall a. [a] -> [[a]] -> [a]
intercalate Label
listSep [Label]
ts Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> Label
"}"

-- Operators
jlUnaryMath :: (Monad r) => String -> VSOp r
jlUnaryMath :: forall (r :: * -> *). Monad r => Label -> VSOp r
jlUnaryMath = Label -> VSOp r
forall (r :: * -> *). Monad r => Label -> VSOp r
unOpPrec

jlPower, jlIntDiv :: String
jlPower :: Label
jlPower = Label
"^"
jlIntDiv :: Label
jlIntDiv = Label
"÷"

-- Constants
jlPi :: Doc
jlPi :: Doc
jlPi = Label -> Doc
text Label
"pi"

-- Comments
jlCmtStart, jlBlockCmtStart, jlBlockCmtEnd, jlDocCmtStart, jlDocCmtEnd :: Doc
jlCmtStart :: Doc
jlCmtStart      = Label -> Doc
text Label
"#"
jlBlockCmtStart :: Doc
jlBlockCmtStart = Label -> Doc
text Label
"#="
jlBlockCmtEnd :: Doc
jlBlockCmtEnd   = Label -> Doc
text Label
"=#"
jlDocCmtStart :: Doc
jlDocCmtStart   = Label -> Doc
text Label
"\"\"\""
jlDocCmtEnd :: Doc
jlDocCmtEnd     = Label -> Doc
text Label
"\"\"\""

-- Control structures

jlSpace :: OptionalSpace
jlSpace :: OptionalSpace
jlSpace = OSpace {oSpace :: Doc
oSpace = Doc
empty}

-- | Creates a for-each loop in Julia
jlForEach
  :: (BodyElim r bod, InternalVarElim r var, ValueElim r val)
  => r var -> r val -> r bod -> Doc
jlForEach :: forall {k} (r :: k -> *) (bod :: k) (var :: k) (val :: k).
(BodyElim r bod, InternalVarElim r var, ValueElim r val) =>
r var -> r val -> r bod -> Doc
jlForEach r var
i r val
lstVar r bod
b = [Doc] -> Doc
vcat [
  Doc
forLabel Doc -> Doc -> Doc
<+> r var -> Doc
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> Doc
RC.variable r var
i Doc -> Doc -> Doc
<+> Doc
inLabel Doc -> Doc -> Doc
<+> r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
lstVar,
  Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
b,
  Doc
jlEnd]

-- | Creates the contents of a module in Julia
jlModContents
  :: Label -> [Label] -> [MS (JuliaCode MethodData)] -> FS (JuliaCode ModData)
jlModContents :: Label
-> [Label] -> [MS (JuliaCode MethodData)] -> FS (JuliaCode ModData)
jlModContents Label
n [Label]
is = Label
-> FS Doc
-> FS Doc
-> [MS (JuliaCode MethodData)]
-> FS (JuliaCode ModData)
forall {k} (r :: k -> *) (mthd :: k) (mod :: k).
(MethodElim r mthd, RenderMod r mod) =>
Label -> FS Doc -> FS Doc -> [MS (r mthd)] -> FS (r mod)
A.buildModule Label
n (do
  lis <- FS [Label]
getLangImports
  libis <- getLibImports
  mis <- getModuleImports
  pure $ vibcat [
    vcat (RC.import' . li <$> lis),
    vcat (RC.import' . li <$> sort (is P.<> libis)),
    vcat (RC.import' . mi <$> mis)])
  (do getMainDoc)
  where mi, li :: Label -> JuliaCode Doc
        mi :: Label -> JuliaCode Doc
mi = Label -> JuliaCode Doc
forall (r :: * -> *). ImportSym r => Label -> r Doc
modImport
        li :: Label -> JuliaCode Doc
li = Label -> JuliaCode Doc
forall (r :: * -> *). ImportSym r => Label -> r Doc
langImport

-- Functions
-- | Creates a function.  n is function name, pms is list of parameters, and
--   bod is body.
jlIntFunc
  :: (BodyElim r bod, ParamElim r param typ)
  => Label -> [r param] -> r bod -> Doc
jlIntFunc :: forall {k} (r :: k -> *) (bod :: k) (param :: k) (typ :: k).
(BodyElim r bod, ParamElim r param typ) =>
Label -> [r param] -> r bod -> Doc
jlIntFunc Label
n [r param]
pms r bod
bod = do
  [Doc] -> Doc
vcat [Doc
jlFunc Doc -> Doc -> Doc
<+> Label -> Doc
text Label
n Doc -> Doc -> Doc
<> Doc -> Doc
parens ([r param] -> Doc
forall {k} (r :: k -> *) (param :: k) (typ :: k).
ParamElim r param typ =>
[r param] -> Doc
parameterList [r param]
pms),
        Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
bod,
        Doc
jlEnd]

jlLambda
  :: (InternalBinderElim r binder, ValueElim r val)
  => [r binder] -> r val -> Doc
jlLambda :: forall {k} (r :: k -> *) (binder :: k) (val :: k).
(InternalBinderElim r binder, ValueElim r val) =>
[r binder] -> r val -> Doc
jlLambda [r binder]
ps r val
ex = [r binder] -> Doc
forall {k} (r :: k -> *) (binder :: k).
InternalBinderElim r binder =>
[r binder] -> Doc
binderList [r binder]
ps Doc -> Doc -> Doc
<+> Doc
arrow Doc -> Doc -> Doc
<+> r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
ex

-- Exceptions
jlThrow :: (ValueElim r val) => r val -> Doc
jlThrow :: forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
jlThrow r val
errMsg = Doc
jlThrowLabel Doc -> Doc -> Doc
<> Doc -> Doc
parens (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
errMsg)

jlTryCatch :: (BodyElim r bod) => r bod -> r bod -> Doc
jlTryCatch :: forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> r bod -> Doc
jlTryCatch r bod
tryB r bod
catchB = [Doc] -> Doc
vcat [
  Doc
tryLabel,
  Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
tryB,
  Doc
catchLabel Doc -> Doc -> Doc
<+> Doc
jlException,
  Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
catchB,
  Doc
jlEnd]

jlException :: Doc
jlException :: Doc
jlException = Label -> Doc
text Label
"ErrorException"

includeLabel, importLabel :: Doc
includeLabel :: Doc
includeLabel = Label -> Doc
text Label
"include"
importLabel :: Doc
importLabel = Label -> Doc
text Label
"import"

-- Assertions
jlAssert :: (ValueElim r val) => r val -> r val -> Doc
jlAssert :: forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> r val -> Doc
jlAssert r val
condition r val
errorMessage = [Doc] -> Doc
vcat [
  Label -> Doc
text Label
"@assert" Doc -> Doc -> Doc
<+> r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
condition Doc -> Doc -> Doc
<+> r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
errorMessage
  ]

jlMod, elseIfLabel, jlFunc, jlBegin, jlEnd, jlThrowLabel :: Doc
jlMod :: Doc
jlMod        = Label -> Doc
text Label
"module"
elseIfLabel :: Doc
elseIfLabel  = Label -> Doc
text Label
"elseif"
jlFunc :: Doc
jlFunc       = Label -> Doc
text Label
"function"
jlBegin :: Doc
jlBegin      = Label -> Doc
text Label
"begin"
jlEnd :: Doc
jlEnd        = Label -> Doc
text Label
"end"
jlThrowLabel :: Doc
jlThrowLabel = Label -> Doc
text Label
"error" -- TODO: this hints at an underdeveloped exception system

jlParam :: JuliaCode Variable -> Doc
jlParam :: JuliaCode Variable -> Doc
jlParam JuliaCode Variable
v = JuliaCode Variable -> Doc
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> Doc
RC.variable JuliaCode Variable
v Doc -> Doc -> Doc
<> Doc
jlType Doc -> Doc -> Doc
<> JuliaCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType (JuliaCode Variable -> JuliaCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType JuliaCode Variable
v)

-- Type names specific to Julia (there's a lot of them)
jlIntType :: (Monad r) => VS (r TypeData)
jlIntType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlIntType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
Integer Label
jlIntConc (Label -> Doc
text Label
jlIntConc)

jlFloatType :: (Monad r) => VS (r TypeData)
jlFloatType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlFloatType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
Float Label
jlFloatConc (Label -> Doc
text Label
jlFloatConc)

jlDoubleType :: (Monad r) => VS (r TypeData)
jlDoubleType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlDoubleType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
Double Label
jlDoubleConc (Label -> Doc
text Label
jlDoubleConc)

jlCharType :: (Monad r) => VS (r TypeData)
jlCharType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlCharType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
Char Label
jlCharConc (Label -> Doc
text Label
jlCharConc)

jlStringType :: (Monad r) => VS (r TypeData)
jlStringType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlStringType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
String Label
jlStringConc (Label -> Doc
text Label
jlStringConc)

jlInfileType :: (Monad r) => VS (r TypeData)
jlInfileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlInfileType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
InFile Label
jlFile (Label -> Doc
text Label
jlFile)

jlOutfileType :: (Monad r) => VS (r TypeData)
jlOutfileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlOutfileType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
OutFile Label
jlFile (Label -> Doc
text Label
jlFile)

jlListType :: (Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
  VS (r TypeData) -> VS (r TypeData)
jlListType :: forall (r :: * -> *).
(Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
jlListType VS (r TypeData)
t' = do
  t <- VS (r TypeData)
t'
  let typeName = Label
jlListConc Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> Label
"{" Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> r TypeData -> Label
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Label
getTypeString r TypeData
t Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> Label
"}"
  typeFromData (List $ getCodeType t) typeName (text typeName)

jlSetType
  :: (Monad r, TypeElim r TypeData, UnRepr r TypeData)
  => VS (r TypeData) -> VS (r TypeData)
jlSetType :: forall (r :: * -> *).
(Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
jlSetType VS (r TypeData)
t' = do
  t <- VS (r TypeData)
t'
  let typeName = Label
jlSetConc Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> Label
"{" Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> r TypeData -> Label
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Label
getTypeString r TypeData
t Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
P.<> Label
"}"
  typeFromData (Set $ getCodeType t) typeName (text typeName)

jlVoidType :: (Monad r) => VS (r TypeData)
jlVoidType :: forall (r :: * -> *). Monad r => VS (r TypeData)
jlVoidType = CodeType -> Label -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> Label -> Doc -> VS (r TypeData)
typeFromData CodeType
Void Label
jlVoid (Label -> Doc
text Label
jlVoid)

jlNull :: Label
jlNull :: Label
jlNull = Label
"nothing"

-- Modules
-- | Creates the text for the start of a module.
--   n is the name of the module.
jlModStart :: Label -> Doc
jlModStart :: Label -> Doc
jlModStart Label
n = Doc
jlMod Doc -> Doc -> Doc
<+> Label -> Doc
text Label
n

-- IO
jlPrint
  :: Bool
  -> Maybe (VS (JuliaCode Value))
  -> VS (JuliaCode Value)
  -> VS (JuliaCode Value)
  -> MS (JuliaCode Statement)
-- Printing to console
jlPrint :: Bool
-> Maybe (VS (JuliaCode Value))
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
-> MS (JuliaCode Statement)
jlPrint Bool
_ Maybe (VS (JuliaCode Value))
f' VS (JuliaCode Value)
p' VS (JuliaCode Value)
v' = do
  f <- LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Value))
  MethodState
  ValueState
-> VS (JuliaCode Value)
-> StateT MethodState Identity (JuliaCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (JuliaCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (JuliaCode Value) ValueState)
-> MethodState -> Focusing Identity (JuliaCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS (VS (JuliaCode Value)
 -> StateT MethodState Identity (JuliaCode Value))
-> VS (JuliaCode Value)
-> StateT MethodState Identity (JuliaCode Value)
forall a b. (a -> b) -> a -> b
$ VS (JuliaCode Value)
-> Maybe (VS (JuliaCode Value)) -> VS (JuliaCode Value)
forall a. a -> Maybe a -> a
fromMaybe (VS (JuliaCode TypeData) -> Doc -> VS (JuliaCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Doc
empty) Maybe (VS (JuliaCode Value))
f' -- The file to print to
  prf <- zoom lensMStoVS p' -- The print function to use
  v <- zoom lensMStoVS v' -- The value to print
  let fl = Doc -> Doc -> Doc
emptyIfEmpty (JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
f) (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ JuliaCode Value -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value JuliaCode Value
f Doc -> Doc -> Doc
<> Doc
listSep'
  mkStmtNoEnd $ RC.value prf <> parens (fl <> RC.value v)

-- jlPrint can handle lists, so don't use G.print for lists
jlOut
  ::
    ( BodySym r bod block
    , BlockSym r block stmt
    , TypeSym r typ
    , ValueSym r val typ
    , Literal r val typ
    , NumericExpression r val
    , Comparison r val
    , ScopeSym r scope
    , VariableSym r var typ
    , VariableValue r var val
    , List r val
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , PrintConsole r stmt val
    , PrintFile r stmt val
    , TypeElim r typ
    , InternalIOStmt r stmt val
    )
  => Bool -> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut :: forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (typ :: k) (val :: k) (scope :: k) (var :: k).
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 Comparison r val, ScopeSym r scope, VariableSym r var typ,
 VariableValue r var val, List r val, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
jlOut Bool
newLn Maybe (VS (r val))
f VS (r val)
printFn VS (r val)
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> VS (r val) -> StateT MethodState Identity (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r val)
v StateT MethodState Identity (r val)
-> (r val -> StateT MethodState Identity (r stmt))
-> StateT MethodState Identity (r stmt)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> StateT MethodState Identity (r stmt)
jlOut' (CodeType -> StateT MethodState Identity (r stmt))
-> (r val -> CodeType)
-> r val
-> StateT MethodState Identity (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r typ -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (r typ -> CodeType) -> (r val -> r typ) -> r val -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType
  where jlOut' :: CodeType -> StateT MethodState Identity (r stmt)
jlOut' (List CodeType
_) = Bool
-> Maybe (VS (r val))
-> VS (r val)
-> VS (r val)
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
InternalIOStmt r stmt val =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
printSt Bool
newLn Maybe (VS (r val))
f VS (r val)
printFn VS (r val)
v
        jlOut' CodeType
_ = Bool
-> Maybe (VS (r val))
-> VS (r val)
-> VS (r val)
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (scope :: k) (var :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 PrintConsole r stmt val, PrintFile r stmt val, ScopeSym r scope,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, ValueSym r val typ,
 Literal r val typ, NumericExpression r val, Comparison r val,
 VariableSym r var typ, VariableValue r var val, List r val,
 TypeSym r typ, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
G.print Bool
newLn Maybe (VS (r val))
f VS (r val)
printFn VS (r val)
v

jlInput
  :: VS (JuliaCode Value)
  -> VS (JuliaCode Variable)
  -> MS (JuliaCode Statement)
jlInput :: VS (JuliaCode Value)
-> VS (JuliaCode Variable) -> MS (JuliaCode Statement)
jlInput VS (JuliaCode Value)
inSrc VS (JuliaCode Variable)
v = VS (JuliaCode Variable)
v VS (JuliaCode Variable)
-> VS (JuliaCode Value) -> MS (JuliaCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= (VS (JuliaCode Variable)
v VS (JuliaCode Variable)
-> (JuliaCode Variable -> VS (JuliaCode Value))
-> VS (JuliaCode Value)
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> VS (JuliaCode Value)
jlInput' (CodeType -> VS (JuliaCode Value))
-> (JuliaCode Variable -> CodeType)
-> JuliaCode Variable
-> VS (JuliaCode Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (JuliaCode TypeData -> CodeType)
-> (JuliaCode Variable -> JuliaCode TypeData)
-> JuliaCode Variable
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. JuliaCode Variable -> JuliaCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType)
  where jlInput' :: CodeType -> VS (JuliaCode Value)
jlInput' CodeType
Integer = Label
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse Label
jlIntConc VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int VS (JuliaCode Value)
inSrc
        jlInput' CodeType
Float = Label
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse Label
jlFloatConc VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float VS (JuliaCode Value)
inSrc
        jlInput' CodeType
Double = Label
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse Label
jlDoubleConc VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double VS (JuliaCode Value)
inSrc
        jlInput' CodeType
Boolean = Label
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse Label
CS.boolRender VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool VS (JuliaCode Value)
inSrc
        jlInput' CodeType
String = VS (JuliaCode Value)
inSrc
        jlInput' CodeType
Char = Label
-> VS (JuliaCode TypeData)
-> VS (JuliaCode Value)
-> VS (JuliaCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse Label
jlCharConc VS (JuliaCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
char VS (JuliaCode Value)
inSrc
        jlInput' CodeType
_ = Label -> VS (JuliaCode Value)
forall a. HasCallStack => Label -> a
error Label
"Attempt to read a value of unreadable type"

readLine, readLines
  :: (TypeSym r typ, ValueExpression r var val binder typ)
  => VS (r val) -> VS (r val)
readLine :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
readLine VS (r val)
f = PosCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
jlReadLineFunc VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string [VS (r val)
f]
readLines :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
readLines VS (r val)
f = PosCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
jlReadLinesFunc (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) [VS (r val)
f]

jlReadLine :: Doc
jlReadLine :: Doc
jlReadLine = Label -> Doc
text Label
jlReadLineFunc

jlReadLineFunc, jlReadLinesFunc, jlCloseFunc :: Label
jlReadLineFunc :: Label
jlReadLineFunc = Label
"readline"
jlReadLinesFunc :: Label
jlReadLinesFunc = Label
"readlines"
jlCloseFunc :: Label
jlCloseFunc = Label
"close"

jlArgs :: Label
jlArgs :: Label
jlArgs = Label
"ARGS"

jlParse
  ::
    ( TypeSym r typ
    , RenderValue r var val typ
    , ValueExpression r var val binder typ
    )
  => Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
Label -> VS (r typ) -> VS (r val) -> VS (r val)
jlParse Label
tl VS (r typ)
tp VS (r val)
v = let
  typeLabel :: VS (r val)
typeLabel = VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void (Label -> Doc
text Label
tl)
  in PosCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp Label
jlParseFunc VS (r typ)
tp [VS (r val)
typeLabel, VS (r val)
v]