-- | Implementations defined here are valid in some, but not all, language renderers
module Drasil.Shared.LanguageRenderer.CommonPseudoOO (
  int, constructor, doxFunc, doxClass, doxMod, modDoc', functionDoc, extVar,
  classVarAccess, indexOf, contains, containsInt, discardFileLine, intClass,
  funcType, buildModule, arrayType, pi, printSt, arrayDec, arrayDecDef,
  openFileA, forEach, docMain, mainFunction, buildModule', call', listSizeFunc,
  listAccessFunc', string, docInOutFunc, bindingError, extFuncAppMixedArgs,
  notNull, listDecDef, destructorError, stateVarDef, constVar, litArray, litSet,
  litSetFunc, extraClass, listAccessFunc, doubleRender, double, openFileR,
  openFileW, stateVar, self, multiAssign, multiReturn, listDec, funcDecDef,
  inOutCall, forLoopError, mainBody, inOutFunc, docInOutFunc', bool, floatRender,
  float, stringRender', string', inherit, implements, listSize, listSet,
  setDecDef, setDec, intToIndex, indexToInt, intToIndex', indexToInt', varDecDef,
  openFileR', openFileW', openFileA', argExists, global, setMethodCall
) where

import Utils.Drasil (stringList)
import Drasil.FileHandling.Legacy (indent)

import Drasil.Shared.CodeType (CodeType(..))

import Drasil.Shared.InterfaceCommon (UnRepr(..), varDecDef, bool,
  extFuncAppMixedArgs,funcType, extVar, Label, Library, MixedCall,
  bodyStatements, oneLiner, TypeSym(infile, outfile, innerType), TypeElim(..),
  getCodeType, getTypeString, VariableElim(variableName, variableType),
  ValueSym(valueType), Comparison(..), (&=), ValueStatement(valStmt),
  ControlStatement(returnStmt), VisibilitySym(..), MethodSym(function),
  funcApp, listSize, BlockSym)
import qualified Drasil.Shared.InterfaceCommon as IC
import Drasil.GOOL.InterfaceGOOL (CSStateVar, OOTypeSym(obj), AttachmentSym(..),
  Initializers, objMethodCallNoParams, objMethodCall)
import qualified Drasil.GOOL.InterfaceGOOL as IG
import Drasil.Shared.RendererClassesCommon (CommonRenderSym, RenderBody(..),
  RenderType(..), RenderVariable(varFromData), InternalVarElim(variableBind),
  MethodTypeSym(mType), RenderMethod(commentedFunc, mthdFromData),
  BlockCommentSym(..), ScopeElim(scopeData))
import qualified Drasil.Shared.RendererClassesCommon as RC
import Drasil.Shared.Helpers (vibcat, toCode, toState, onCodeValue, onStateValue,
  onStateList)
import Drasil.GOOL.RendererClassesOO (OORenderSym, OORenderMethod(intMethod),
  ParentSpec)
import qualified Drasil.GOOL.RendererClassesOO as RG
import Drasil.Shared.LanguageRenderer (listAccessFunc, array', new', args, array,
  listSep, access, mathFunc, ModuleDocRenderer, FuncDocRenderer, functionDox,
  classDox, moduleDox, variableList, valueList, intValue)
import Drasil.GOOL.Renderers (renderType)
import qualified Drasil.Shared.LanguageRenderer as R
import Drasil.Shared.LanguageRenderer.Constructors (mkStmt, mkStmtNoEnd,
  mkStateVal, mkStateVar, typeFromData, mkVar)
import Drasil.Shared.LanguageRenderer.LanguagePolymorphic (
  classVarAccessCheck, call, initStmts, docFunc, docFuncRepr, docClass,
  docMod, smartAdd, smartSub)
import Drasil.Shared.AST (VisibilityTag(..), ScopeTag(Global), ScopeData, sd,
  TypeData, FuncData)
import Drasil.Shared.State (MS, VS, FS, CS, lensFStoCS, lensFStoMS, lensCStoMS,
  lensMStoVS, lensVStoMS, currParameters, getClassName, getLangImports,
  getLibImports, getModuleImports, setClassName, setCurrMain, setMainDoc,
  useVarName, setVarScope)

import Prelude hiding (print,pi,(<>))
import qualified Prelude as P ((<>))
import Data.List (sort, intercalate)
import Control.Monad.State (get, modify)
import Control.Lens ((^.))
import qualified Control.Lens as L
import Control.Lens.Zoom (zoom)
import Text.PrettyPrint.HughesPJ (Doc, text, empty, render, (<>), (<+>), parens,
  brackets, braces, colon, vcat, equals)

-- Python, Java, C#, C++, and Swift --
-- | Convert an integer to an index in a 0-indexed language
--   Since GOOL is 0-indexed, no adjustments need be made
intToIndex :: VS (r val) -> VS (r val)
intToIndex :: forall {k} (r :: k -> *) (val :: k). VS (r val) -> VS (r val)
intToIndex = VS (r val) -> VS (r val)
forall a. a -> a
id

-- | Convert an index to an integer in a 0-indexed language
--   Since GOOL is 0-indexed, no adjustments need be made
indexToInt :: VS (r val) -> VS (r val)
indexToInt :: forall {k} (r :: k -> *) (val :: k). VS (r val) -> VS (r val)
indexToInt = VS (r val) -> VS (r val)
forall a. a -> a
id

-- Global for langauges that don't use declarations for them
global :: (Monad r) => r ScopeData
global :: forall (r :: * -> *). Monad r => r ScopeData
global = ScopeData -> r ScopeData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (ScopeData -> r ScopeData) -> ScopeData -> r ScopeData
forall a b. (a -> b) -> a -> b
$ ScopeTag -> ScopeData
sd ScopeTag
Global

-- Python, Java, C#, and C++ --

intRender :: String
intRender :: String
intRender = String
"int"

int :: (Monad r) => VS (r TypeData)
int :: forall (r :: * -> *). Monad r => VS (r TypeData)
int = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
Integer String
intRender (String -> Doc
text String
intRender)

constructor
  :: (OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => Label
  -> [MS (r param)]
  -> Initializers r var val
  -> MS (r bod)
  -> MS (r mthd)
constructor :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
String
-> [MS (r param)]
-> Initializers r var val
-> MS (r bod)
-> MS (r mthd)
constructor String
fName [MS (r param)]
ps Initializers r var val
is MS (r bod)
b = MS String
getClassName MS String
-> (String -> StateT MethodState Identity (r mthd))
-> StateT MethodState Identity (r mthd)
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
>>= (\String
c -> Bool
-> String
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> StateT MethodState Identity (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (typ :: k).
OORenderMethod r mthd attch vis param bod typ =>
Bool
-> String
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
intMethod Bool
False String
fName
  r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel (String -> MS (r typ)
forall {k} (r :: k -> *) (typ :: k).
OOMethodTypeSym r typ =>
String -> MS (r typ)
RG.construct String
c) [MS (r param)]
ps ([MS (r bod)] -> MS (r bod)
forall {k} (r :: k -> *) (bod :: k).
RenderBody r bod =>
[MS (r bod)] -> MS (r bod)
RC.multiBody [Initializers r var val -> MS (r bod)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k)
       (stmt :: k) (block :: k) (bod :: k).
(OOVariableSym r var val typ, VariableValue r var val,
 SelfSym r var, AssignStatement r stmt var val,
 BlockSym r block stmt, BodySym r bod block) =>
Initializers r var val -> MS (r bod)
initStmts Initializers r var val
is, MS (r bod)
b]))

doxFunc
  :: (BlockCommentSym r, RenderMethod r mthd)
  => String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
doxFunc :: forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
doxFunc = FuncDocRenderer
-> String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
docFunc FuncDocRenderer
functionDox

doxClass
  :: (BlockCommentSym r, RG.RenderClass r cls stvr mthd vis)
  => String -> CS (r cls) -> CS (r cls)
doxClass :: forall (r :: * -> *) cls stvr mthd vis.
(BlockCommentSym r, RenderClass r cls stvr mthd vis) =>
String -> CS (r cls) -> CS (r cls)
doxClass = ClassDocRenderer -> String -> CS (r cls) -> CS (r cls)
forall (r :: * -> *) cls stvr mthd vis.
(BlockCommentSym r, RenderClass r cls stvr mthd vis) =>
ClassDocRenderer -> String -> CS (r cls) -> CS (r cls)
docClass ClassDocRenderer
classDox

doxMod
  :: (BlockCommentSym r, RG.RenderFile r file mod)
  => String
  -> String
  -> String
  -> [String]
  -> String
  -> FS (r file)
  -> FS (r file)
doxMod :: forall (r :: * -> *) file mod.
(BlockCommentSym r, RenderFile r file mod) =>
String
-> String
-> String
-> [String]
-> String
-> FS (r file)
-> FS (r file)
doxMod = ModuleDocRenderer
-> String
-> String
-> String
-> [String]
-> String
-> FS (r file)
-> FS (r file)
forall (r :: * -> *) file mod.
(BlockCommentSym r, RenderFile r file mod) =>
ModuleDocRenderer
-> String
-> String
-> String
-> [String]
-> String
-> FS (r file)
-> FS (r file)
docMod ModuleDocRenderer
moduleDox

-- Python, Java, and C# --

classVarAccess
  ::
    ( InternalVarElim r var
    , RenderVariable r var TypeData
    , UnRepr r TypeData
    , VariableElim r var TypeData
    )
  => (Doc -> Doc -> Doc) -> VS (r TypeData) -> VS (r var) -> VS (r var)
classVarAccess :: forall (r :: * -> *) var.
(InternalVarElim r var, RenderVariable r var TypeData,
 UnRepr r TypeData, VariableElim r var TypeData) =>
(Doc -> Doc -> Doc) -> VS (r TypeData) -> VS (r var) -> VS (r var)
classVarAccess Doc -> Doc -> Doc
f VS (r TypeData)
c' VS (r var)
v'= do
  c <- VS (r TypeData)
c'
  v <- v'
  vr <- varFromData
    (variableBind v) (getTypeString c `access` variableName v)
    (toState $ variableType v) (f (renderType c) (RC.variable v))
  toState $ classVarAccessCheck vr

indexOf
  :: (TypeSym r typ, IC.IndexTranslator r val, IG.OOFunctionSym r val typ)
  => Label -> VS (r val) -> VS (r val) -> VS (r val)
indexOf :: forall (r :: * -> *) typ val.
(TypeSym r typ, IndexTranslator r val, OOFunctionSym r val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
indexOf String
f VS (r val)
l VS (r val)
v = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
IndexTranslator r val =>
VS (r val) -> VS (r val)
IC.indexToInt (VS (r val) -> VS (r val)) -> VS (r val) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ VS (r val) -> VS (r FuncData) -> VS (r val)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
IG.objAccess VS (r val)
l (String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func String
f VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int [VS (r val)
v])

contains
  :: (TypeSym r typ, IG.OOFunctionSym r val typ)
  => Label -> VS (r val) -> VS (r val) -> VS (r val)
contains :: forall (r :: * -> *) typ val.
(TypeSym r typ, OOFunctionSym r val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
contains String
f VS (r val)
s VS (r val)
v = VS (r val) -> VS (r FuncData) -> VS (r val)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
IG.objAccess VS (r val)
s (String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func String
f VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.bool [VS (r val)
v])

containsInt
  :: (TypeSym r typ, Comparison r val, IG.OOFunctionSym r val typ)
  => Label -> Label -> VS (r val) -> VS (r val) -> VS (r val)
containsInt :: forall (r :: * -> *) typ val.
(TypeSym r typ, Comparison r val, OOFunctionSym r val typ) =>
String -> String -> VS (r val) -> VS (r val) -> VS (r val)
containsInt String
f String
fn VS (r val)
s VS (r val)
v = String -> VS (r val) -> VS (r val) -> VS (r val)
forall (r :: * -> *) typ val.
(TypeSym r typ, OOFunctionSym r val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
contains String
f VS (r val)
s VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?!= VS (r val) -> VS (r FuncData) -> VS (r val)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
IG.objAccess VS (r val)
s (String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func String
fn VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.bool [])

discardFileLine
  ::
    ( TypeSym r typ
    , IG.InternalValueExp r var val typ
    , ValueStatement r stmt val
    )
  => Label -> VS (r val) -> MS (r stmt)
discardFileLine :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (stmt :: k).
(TypeSym r typ, InternalValueExp r var val typ,
 ValueStatement r stmt val) =>
String -> VS (r val) -> MS (r stmt)
discardFileLine String
n VS (r val)
f = VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (r val) -> MS (r stmt)) -> VS (r val) -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r typ) -> VS (r val) -> String -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> VS (r val)
objMethodCallNoParams VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.string VS (r val)
f String
n

-- | An internal function for creating a class.
--   Parameters: render function, class name, scope, parent, class variables,
--               constructor(s), methods
intClass
  :: (RC.MethodElim r mthd, Monad r, RG.StateVarElim r stvr, RC.VisibilityElim r vis)
  => (Label -> Doc -> Doc -> Doc -> Doc -> Doc)
  -> Label
  -> r vis
  -> r ParentSpec
  -> [CSStateVar r stvr]
  -> [MS (r mthd)]
  -> [MS (r mthd)]
  -> CS (r Doc)
intClass :: forall (r :: * -> *) mthd stvr vis.
(MethodElim r mthd, Monad r, StateVarElim r stvr,
 VisibilityElim r vis) =>
(String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
intClass String -> Doc -> Doc -> Doc -> Doc -> Doc
f String
n r vis
s r Doc
i [CSStateVar r stvr]
svrs [StateT MethodState Identity (r mthd)]
cstrs [StateT MethodState Identity (r mthd)]
mths = do
  (ClassState -> ClassState) -> StateT ClassState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ClassState -> ClassState
setClassName String
n)
  svs <- ([r stvr] -> Doc) -> [CSStateVar r stvr] -> State ClassState Doc
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList ([Doc] -> Doc
R.stateVarList ([Doc] -> Doc) -> ([r stvr] -> [Doc]) -> [r stvr] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r stvr -> Doc) -> [r stvr] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap r stvr -> Doc
forall {k} (r :: k -> *) (stvr :: k).
StateVarElim r stvr =>
r stvr -> Doc
RG.stateVar) [CSStateVar r stvr]
svrs
  ms <- onStateList (vibcat . fmap RC.method) (zoom lensCStoMS <$> (cstrs P.<> mths))
  pure $ onCodeValue (\Doc
p -> String -> Doc -> Doc -> Doc -> Doc -> Doc
f String
n Doc
p (r vis -> Doc
forall {k} (r :: k -> *) (vis :: k).
VisibilityElim r vis =>
r vis -> Doc
RC.visibility r vis
s) Doc
svs Doc
ms) i

-- Python and C++ --

-- Parameters: Module name, Doc for imports, Doc to put at top of module (but
-- after imports), Doc to put at bottom of module, methods, classes
-- Renamed top to topDoc to fix shadowing error with RendererClassesOO top
buildModule
  :: (RG.ClassElim r cls, RC.MethodElim r mthd, RG.RenderMod r mod)
  => Label
  -> FS Doc
  -> FS Doc
  -> FS Doc
  -> [MS (r mthd)]
  -> [CS (r cls)]
  -> FS (r mod)
buildModule :: forall {k} (r :: k -> *) (cls :: k) (mthd :: k) (mod :: k).
(ClassElim r cls, MethodElim r mthd, RenderMod r mod) =>
String
-> FS Doc
-> FS Doc
-> FS Doc
-> [MS (r mthd)]
-> [CS (r cls)]
-> FS (r mod)
buildModule String
n FS Doc
imps FS Doc
topDoc FS Doc
bot [MS (r mthd)]
fs [CS (r cls)]
cs = String -> FS Doc -> FS (r mod)
forall {k} (r :: k -> *) (mod :: k).
RenderMod r mod =>
String -> FS Doc -> FS (r mod)
RG.modFromData String
n (do
  cls <- (CS (r cls) -> StateT FileState Identity (r cls))
-> [CS (r cls)] -> StateT FileState Identity [r cls]
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 ClassState Identity) (r cls)) FileState ClassState
-> CS (r cls) -> StateT FileState Identity (r cls)
forall c.
LensLike'
  (Zoomed (StateT ClassState Identity) c) FileState ClassState
-> StateT ClassState Identity c -> StateT FileState 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 ClassState Identity) (r cls)) FileState ClassState
(ClassState -> Focusing Identity (r cls) ClassState)
-> FileState -> Focusing Identity (r cls) FileState
Lens' FileState ClassState
lensFStoCS) [CS (r cls)]
cs
  fns <- mapM (zoom lensFStoMS) fs
  is <- imps
  tp <- topDoc
  bt <- bot
  pure $ R.module' is (vibcat (tp : fmap RG.class' cls))
    (vibcat (fmap RC.method fns P.<> [bt])))

-- Java and C# --

arrayType
  :: (TypeElim r TypeData, Monad r, UnRepr r TypeData)
  => VS (r TypeData) -> VS (r TypeData)
arrayType :: forall (r :: * -> *).
(TypeElim r TypeData, Monad r, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
arrayType VS (r TypeData)
t' = do
  t <- VS (r TypeData)
t'
  typeFromData (Array (getCodeType t))
    (getTypeString t P.<> array) (renderType t <> brackets empty)

pi :: (RC.RenderValue r var val typ, TypeSym r typ) => VS (r val)
pi :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
pi = 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)
IC.double (String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String -> String
mathFunc String
"PI")

printSt
  :: (RC.RenderStatement r stmt, RC.ValueElim r val)
  => VS (r val) -> VS (r val) -> MS (r stmt)
printSt :: forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
VS (r val) -> VS (r val) -> MS (r stmt)
printSt VS (r val)
va' VS (r val)
vb' = do
  va <- 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)
va'
  vb <- zoom lensMStoVS vb'
  mkStmt (R.print va vb)

arrayDec
  :: ( TypeSym r TypeData
     , ScopeElim r ScopeData
     , UnRepr r TypeData
     , InternalVarElim r var
     , RC.RenderStatement r stmt
     , RC.ValueElim r val
     , VariableElim r var TypeData
     )
  => VS (r val) -> VS (r var) -> r ScopeData -> MS (r stmt)
arrayDec :: forall (r :: * -> *) var stmt val.
(TypeSym r TypeData, ScopeElim r ScopeData, UnRepr r TypeData,
 InternalVarElim r var, RenderStatement r stmt, ValueElim r val,
 VariableElim r var TypeData) =>
VS (r val) -> VS (r var) -> r ScopeData -> MS (r stmt)
arrayDec VS (r val)
n VS (r var)
vr r ScopeData
scp = do
  sz <- 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)
n
  v <- zoom lensMStoVS vr
  modify $ useVarName $ variableName v
  modify $ setVarScope (variableName v) (scopeData scp)
  let tp = r var -> r TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
v
  innerTp <- zoom lensMStoVS $ innerType $ pure tp
  mkStmt $ renderType tp <+> RC.variable v <+> equals <+> new' <+>
    renderType innerTp <> brackets (RC.value sz)

arrayDecDef
  :: ( IC.DeclStatement r bod stmt var scope val
     , RC.RenderStatement r stmt
     , RC.StatementElim r stmt
     , RC.ValueElim r val
     )
  => VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
arrayDecDef :: forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r val) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
arrayDecDef VS (r var)
v' r scope
scp [VS (r val)]
vals' = do
  vs <- (VS (r val) -> StateT MethodState Identity (r val))
-> [VS (r val)] -> StateT MethodState Identity [r val]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (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)]
vals'
  vd <- IC.varDec v' scp
  mkStmt (RC.statement vd <+> equals <+> braces (valueList vs))

openFileA
  ::
    ( IC.AssignStatement r stmt var val
    , TypeSym r typ
    , IC.Literal r val typ
    )
  => (VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
  -> VS (r var)
  -> VS (r val)
  -> MS (r stmt)
openFileA :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, TypeSym r typ,
 Literal r val typ) =>
(VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
openFileA VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
f VS (r var)
vr VS (r val)
vl = VS (r var)
vr VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
f VS (r val)
vl VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
outfile VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
IC.litTrue

forEach
  ::
    ( RC.BodyElim r bod
    , InternalVarElim r var
    , RC.RenderStatement r stmt
    , UnRepr r TypeData
    , RC.ValueElim r val
    , VariableElim r var TypeData
    )
  => Doc
  -> Doc
  -> Doc
  -> Doc
  -> VS (r var)
  -> VS (r val)
  -> MS (r bod)
  -> MS (r stmt)
forEach :: forall (r :: * -> *) bod var stmt val.
(BodyElim r bod, InternalVarElim r var, RenderStatement r stmt,
 UnRepr r TypeData, ValueElim r val, VariableElim r var TypeData) =>
Doc
-> Doc
-> Doc
-> Doc
-> VS (r var)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forEach Doc
bStart Doc
bEnd Doc
forEachLabel Doc
inLbl VS (r var)
e' VS (r val)
v' MS (r bod)
b' = do
  e <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
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 var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
e'
  v <- zoom lensMStoVS v'
  b <- b'
  mkStmtNoEnd $ vcat [
    forEachLabel <+> parens (renderType (variableType e) <+> RC.variable e <+>
      inLbl <+> RC.value v) <+> bStart,
    indent $ RC.body b,
    bEnd]

mainDesc, argsDesc :: String
mainDesc :: String
mainDesc = String
"Controls the flow of the program"
argsDesc :: String
argsDesc = String
"List of command-line arguments"

docMain
  :: (OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => MS (r bod) -> MS (r mthd)
docMain :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
MS (r bod) -> MS (r mthd)
docMain MS (r bod)
b = MS (r Doc) -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
MS (r Doc) -> MS (r mthd) -> MS (r mthd)
commentedFunc (State MethodState [String] -> MS (r Doc)
forall a. State a [String] -> State a (r Doc)
forall (r :: * -> *) a.
BlockCommentSym r =>
State a [String] -> State a (r Doc)
docComment (State MethodState [String] -> MS (r Doc))
-> State MethodState [String] -> MS (r Doc)
forall a b. (a -> b) -> a -> b
$ [String] -> State MethodState [String]
forall a s. a -> State s a
toState ([String] -> State MethodState [String])
-> [String] -> State MethodState [String]
forall a b. (a -> b) -> a -> b
$ FuncDocRenderer
functionDox
  String
mainDesc [(String
args, String
argsDesc)] []) (MS (r bod) -> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
MS (r bod) -> MS (r mthd)
IC.mainFunction MS (r bod)
b)

mainFunction
  :: ( AttachmentSym r attch
     , TypeSym r TypeData
     , IC.VariableSym r var TypeData
     , MethodTypeSym r TypeData
     , OORenderMethod r mthd attch vis param bod TypeData
     , IC.ParameterSym r param var
     , UnRepr r TypeData
     , Monad r
     , VisibilitySym r vis
     )
  => VS (r TypeData) -> Label -> MS (r bod) -> MS (r mthd)
mainFunction :: forall (r :: * -> *) attch var mthd vis param bod.
(AttachmentSym r attch, TypeSym r TypeData,
 VariableSym r var TypeData, MethodTypeSym r TypeData,
 OORenderMethod r mthd attch vis param bod TypeData,
 ParameterSym r param var, UnRepr r TypeData, Monad r,
 VisibilitySym r vis) =>
VS (r TypeData) -> String -> MS (r bod) -> MS (r mthd)
mainFunction VS (r TypeData)
s String
n = Bool
-> String
-> r vis
-> r attch
-> MS (r TypeData)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (typ :: k).
OORenderMethod r mthd attch vis param bod typ =>
Bool
-> String
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
RG.intFunc Bool
True String
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel (VS (r TypeData) -> MS (r TypeData)
forall {k} (r :: k -> *) (typ :: k).
MethodTypeSym r typ =>
VS (r typ) -> MS (r typ)
mType VS (r TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.void)
  [VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
IC.param (String -> VS (r TypeData) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
IC.var String
args (VS (r TypeData)
s VS (r TypeData)
-> (r TypeData -> VS (r TypeData)) -> VS (r TypeData)
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
>>= (\r TypeData
argT -> CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData (CodeType -> CodeType
List CodeType
String)
  (Doc -> String
render (r TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType r TypeData
argT) String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
array) (r TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType r TypeData
argT Doc -> Doc -> Doc
<> Doc
array'))))]

-- | Used by the language renderers to build the module.
--   n is the module name
--   inc is the include
--   is is the import statements
--   ms is the class methods
--   cs is the classes
buildModule'
  ::
    ( OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ
    , UnRepr r Doc
    )
  => Label
  -> (String -> r Doc)
  -> [Label]
  -> [MS (r mthd)]
  -> [CS (r cls)]
  -> FS (r mod)
buildModule' :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
(OORenderSym
   r
   file
   mod
   cls
   stvr
   mthd
   attch
   vis
   param
   bod
   block
   stmt
   var
   scope
   val
   binder
   typ,
 UnRepr r Doc) =>
String
-> (String -> r Doc)
-> [String]
-> [MS (r mthd)]
-> [CS (r cls)]
-> FS (r mod)
buildModule' String
n String -> r Doc
inc [String]
is [MS (r mthd)]
ms [CS (r cls)]
cs = String -> FS Doc -> FS (r mod)
forall {k} (r :: k -> *) (mod :: k).
RenderMod r mod =>
String -> FS Doc -> FS (r mod)
RG.modFromData String
n (do
  cls <- (CS (r cls) -> StateT FileState Identity (r cls))
-> [CS (r cls)] -> StateT FileState Identity [r cls]
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 ClassState Identity) (r cls)) FileState ClassState
-> CS (r cls) -> StateT FileState Identity (r cls)
forall c.
LensLike'
  (Zoomed (StateT ClassState Identity) c) FileState ClassState
-> StateT ClassState Identity c -> StateT FileState 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 ClassState Identity) (r cls)) FileState ClassState
(ClassState -> Focusing Identity (r cls) ClassState)
-> FileState -> Focusing Identity (r cls) FileState
Lens' FileState ClassState
lensFStoCS)
          (if [MS (r mthd)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [MS (r mthd)]
ms then [CS (r cls)]
cs else Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall {k} (r :: k -> *) (cls :: k) (stvr :: k) (mthd :: k).
ClassSym r cls stvr mthd =>
Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
IG.buildClass Maybe String
forall a. Maybe a
Nothing [] [] [MS (r mthd)]
ms CS (r cls) -> [CS (r cls)] -> [CS (r cls)]
forall a. a -> [a] -> [a]
: [CS (r cls)]
cs)
  lis <- getLangImports
  libis <- getLibImports
  mis <- getModuleImports
  pure $ vibcat [
    vcat (RC.import' . inc <$> (lis P.<> sort (is P.<> libis) P.<> mis)),
    vibcat (RG.class' <$> cls)])

-- Java and C++ --

-- | First parameter is language name, rest similar to call from RendererClassesCommon
call'
  :: (InternalVarElim r var, RC.RenderValue r var val typ, RC.ValueElim r val)
  => String -> Maybe Library -> Maybe Doc -> MixedCall r var val typ
call' :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 ValueElim r val) =>
String -> Maybe String -> Maybe Doc -> MixedCall r var val typ
call' String
l Maybe String
_ Maybe Doc
_ String
_ VS (r typ)
_ [VS (r val)]
_ ((VS (r var), VS (r val))
_:[(VS (r var), VS (r val))]
_) = String -> VS (r val)
forall a. HasCallStack => String -> a
error (String -> VS (r val)) -> String -> VS (r val)
forall a b. (a -> b) -> a -> b
$ String -> String
namedArgError String
l
call' String
_ Maybe String
l Maybe Doc
o String
n VS (r typ)
t [VS (r val)]
ps [(VS (r var), VS (r val))]
ns = Doc -> Maybe String -> Maybe Doc -> MixedCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 ValueElim r val) =>
Doc -> Maybe String -> Maybe Doc -> MixedCall r var val typ
call Doc
empty Maybe String
l Maybe Doc
o String
n VS (r typ)
t [VS (r val)]
ps [(VS (r var), VS (r val))]
ns

namedArgError :: String -> String
namedArgError :: String -> String
namedArgError String
l = String
"Named arguments not supported in " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
l

listSizeFunc :: (TypeSym r typ, IG.OOFunctionSym r val typ) => VS (r FuncData)
listSizeFunc :: forall (r :: * -> *) typ val.
(TypeSym r typ, OOFunctionSym r val typ) =>
VS (r FuncData)
listSizeFunc = String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func String
"size" VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int []

listAccessFunc'
  :: (ValueSym r val typ, IG.OOFunctionSym r val typ, TypeElim r typ)
  => Label -> VS (r typ) -> VS (r val) -> VS (r FuncData)
listAccessFunc' :: forall (r :: * -> *) val typ.
(ValueSym r val typ, OOFunctionSym r val typ, TypeElim r typ) =>
String -> VS (r typ) -> VS (r val) -> VS (r FuncData)
listAccessFunc' String
f VS (r typ)
t VS (r val)
i = String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func String
f VS (r typ)
t [VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (typ :: k) (val :: k).
(TypeElim r typ, ValueSym r val typ) =>
VS (r val) -> VS (r val)
intValue VS (r val)
i]

-- C# and C++ --

stringRender :: String
stringRender :: String
stringRender = String
"string"

string :: (Monad r) => VS (r TypeData)
string :: forall (r :: * -> *). Monad r => VS (r TypeData)
string = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
String String
stringRender (String -> Doc
text String
stringRender)

docInOutFunc
  :: (BlockCommentSym r, RenderMethod r mthd)
  => ([VS (r var)] -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
  -> String
  -> [(String, VS (r var))]
  -> [(String, VS (r var))]
  -> [(String, VS (r var))]
  -> MS (r bod)
  -> MS (r mthd)
docInOutFunc :: forall (r :: * -> *) mthd var bod.
(BlockCommentSym r, RenderMethod r mthd) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
docInOutFunc [VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, VS (r var))]
is [(String, VS (r var))
o] [] MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc ((String, VS (r var)) -> String
forall a b. (a, b) -> a
fst ((String, VS (r var)) -> String)
-> [(String, VS (r var))] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
is)
  [(String, VS (r var)) -> String
forall a b. (a, b) -> a
fst (String, VS (r var))
o] ([VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
is) [(String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd (String, VS (r var))
o] [] MS (r bod)
b)
docInOutFunc [VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, VS (r var))]
is [] [(String, VS (r var))
both] MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc ((String, VS (r var)) -> String
forall a b. (a, b) -> a
fst ((String, VS (r var)) -> String)
-> [(String, VS (r var))] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
  (String, VS (r var))
both (String, VS (r var))
-> [(String, VS (r var))] -> [(String, VS (r var))]
forall a. a -> [a] -> [a]
: [(String, VS (r var))]
is) [(String, VS (r var)) -> String
forall a b. (a, b) -> a
fst (String, VS (r var))
both] ([VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
is) [] [(String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd (String, VS (r var))
both] MS (r bod)
b)
docInOutFunc [VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, VS (r var))]
is [(String, VS (r var))]
os [(String, VS (r var))]
bs MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc ((String, VS (r var)) -> String
forall a b. (a, b) -> a
fst ((String, VS (r var)) -> String)
-> [(String, VS (r var))] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
bs [(String, VS (r var))]
-> [(String, VS (r var))] -> [(String, VS (r var))]
forall a. Semigroup a => a -> a -> a
P.<>
  [(String, VS (r var))]
is [(String, VS (r var))]
-> [(String, VS (r var))] -> [(String, VS (r var))]
forall a. Semigroup a => a -> a -> a
P.<> [(String, VS (r var))]
os) [] ([VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
is) ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
os) ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
bs) MS (r bod)
b)

-- Python, Java, C#, and Swift --

bindingError :: String -> String
bindingError :: String -> String
bindingError String
l = String
"AttachmentTag unimplemented in " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
l

notNull
  ::
    ( ValueSym r val typ
    , Comparison r val
    , IC.VariableSym r var typ
    , IC.VariableValue r var val
    )
  => String -> VS (r val) -> VS (r val)
notNull :: 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) =>
String -> VS (r val) -> VS (r val)
notNull String
nil VS (r val)
v = VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?!= VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf (String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
IC.var String
nil (VS (r typ) -> VS (r var)) -> VS (r typ) -> VS (r var)
forall a b. (a -> b) -> a -> b
$ (r val -> r typ) -> VS (r val) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType VS (r val)
v)

listDecDef
  ::
    ( IC.DeclStatement r bod stmt var scope val
    , TypeSym r typ
    , IC.Literal r val typ
    , VariableElim r var typ
    )
  => VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef :: 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)
listDecDef VS (r var)
v r scope
scp [VS (r val)]
vals = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
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 var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
v
  let lst = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
IC.litList (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r typ -> VS (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
vr) [VS (r val)]
vals
  IC.varDecDef (pure vr) scp lst

setDecDef
  ::
    ( IC.DeclStatement r bod stmt var scope val
    , TypeSym r typ
    , IC.Literal r val typ
    , VariableElim r var typ
    )
  => VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
setDecDef :: 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)
setDecDef VS (r var)
v r scope
scp [VS (r val)]
vals = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
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 var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
v
  let st = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
IC.litSet (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r typ -> VS (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
vr) [VS (r val)]
vals
  IC.varDecDef (pure vr) scp st

setDec
  ::
    ( IC.DeclStatement r bod stmt var scope val
    , RC.RenderStatement r stmt
    , RC.StatementElim r stmt
    )
  => (r val -> Doc)
  -> VS (r val)
  -> VS (r var)
  -> r scope
  -> MS (r stmt)
setDec :: forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt) =>
(r val -> Doc)
-> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
setDec r val -> Doc
f VS (r val)
vl VS (r var)
v r scope
scp = do
  sz <- 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)
vl
  vd <- IC.varDec v scp
  mkStmt (RC.statement vd <> f sz)

setMethodCall
  :: (TypeSym r typ, ValueSym r val typ, IG.InternalValueExp r var val typ)
  => Label -> VS (r val) ->  VS (r val) -> VS (r val)
setMethodCall :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
setMethodCall String
n VS (r val)
a VS (r val)
b = VS (r typ) -> VS (r val) -> String -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> [VS (r val)] -> VS (r val)
objMethodCall (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ (r val -> r typ) -> VS (r val) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType VS (r val)
a) VS (r val)
a String
n [VS (r val)
b]

destructorError :: String -> String
destructorError :: String -> String
destructorError String
l = String
"Destructors not allowed in " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
l

stateVarDef
  ::
    ( OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ
    , Monad r
    )
  => r vis -> r attch -> VS (r var) -> VS (r val) -> CS (r Doc)
stateVarDef :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
(OORenderSym
   r
   file
   mod
   cls
   stvr
   mthd
   attch
   vis
   param
   bod
   block
   stmt
   var
   scope
   val
   binder
   typ,
 Monad r) =>
r vis -> r attch -> VS (r var) -> VS (r val) -> CS (r Doc)
stateVarDef r vis
s r attch
p VS (r var)
vr VS (r val)
vl = LensLike'
  (Zoomed (StateT MethodState Identity) (r Doc))
  ClassState
  MethodState
-> StateT MethodState Identity (r Doc)
-> StateT ClassState Identity (r Doc)
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) ClassState MethodState
-> StateT MethodState Identity c -> StateT ClassState 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 MethodState Identity) (r Doc))
  ClassState
  MethodState
(MethodState -> Focusing Identity (r Doc) MethodState)
-> ClassState -> Focusing Identity (r Doc) ClassState
Lens' ClassState MethodState
lensCStoMS (StateT MethodState Identity (r Doc)
 -> StateT ClassState Identity (r Doc))
-> StateT MethodState Identity (r Doc)
-> StateT ClassState Identity (r Doc)
forall a b. (a -> b) -> a -> b
$ (r stmt -> r Doc)
-> State MethodState (r stmt)
-> StateT MethodState Identity (r Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> (r stmt -> Doc) -> r stmt -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc -> Doc -> Doc
R.stateVar
  (r vis -> Doc
forall {k} (r :: k -> *) (vis :: k).
VisibilityElim r vis =>
r vis -> Doc
RC.visibility  r vis
s) (r attch -> Doc
forall {k} (r :: k -> *) (attch :: k).
PermElim r attch =>
r attch -> Doc
RG.perm r attch
p) (Doc -> Doc) -> (r stmt -> Doc) -> r stmt -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r stmt -> Doc
forall {k} (r :: k -> *) (stmt :: k).
StatementElim r stmt =>
r stmt -> Doc
RC.statement)
  (State MethodState (r stmt) -> State MethodState (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
RC.stmt (State MethodState (r stmt) -> State MethodState (r stmt))
-> State MethodState (r stmt) -> State MethodState (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> r scope -> VS (r val) -> State MethodState (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
IC.varDecDef VS (r var)
vr r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
IC.local VS (r val)
vl)

constVar
  ::
    ( CommonRenderSym r mthd vis param bod block stmt var scope val binder typ
    , Monad r
    )
  => Doc -> r vis -> VS (r var) -> VS (r val) -> CS (r Doc)
constVar :: forall (r :: * -> *) mthd vis param bod block stmt var scope val
       binder typ.
(CommonRenderSym
   r mthd vis param bod block stmt var scope val binder typ,
 Monad r) =>
Doc -> r vis -> VS (r var) -> VS (r val) -> CS (r Doc)
constVar Doc
p r vis
s VS (r var)
vr VS (r val)
vl = LensLike'
  (Zoomed (StateT MethodState Identity) (r Doc))
  ClassState
  MethodState
-> StateT MethodState Identity (r Doc)
-> StateT ClassState Identity (r Doc)
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) ClassState MethodState
-> StateT MethodState Identity c -> StateT ClassState 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 MethodState Identity) (r Doc))
  ClassState
  MethodState
(MethodState -> Focusing Identity (r Doc) MethodState)
-> ClassState -> Focusing Identity (r Doc) ClassState
Lens' ClassState MethodState
lensCStoMS (StateT MethodState Identity (r Doc)
 -> StateT ClassState Identity (r Doc))
-> StateT MethodState Identity (r Doc)
-> StateT ClassState Identity (r Doc)
forall a b. (a -> b) -> a -> b
$ (r stmt -> r Doc)
-> State MethodState (r stmt)
-> StateT MethodState Identity (r Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> (r stmt -> Doc) -> r stmt -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc -> Doc -> Doc
R.stateVar
  (r vis -> Doc
forall {k} (r :: k -> *) (vis :: k).
VisibilityElim r vis =>
r vis -> Doc
RC.visibility r vis
s) Doc
p (Doc -> Doc) -> (r stmt -> Doc) -> r stmt -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r stmt -> Doc
forall {k} (r :: k -> *) (stmt :: k).
StatementElim r stmt =>
r stmt -> Doc
RC.statement) (State MethodState (r stmt) -> State MethodState (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
RC.stmt (State MethodState (r stmt) -> State MethodState (r stmt))
-> State MethodState (r stmt) -> State MethodState (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> r scope -> VS (r val) -> State MethodState (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
IC.constDecDef VS (r var)
vr r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
IC.local VS (r val)
vl)

-- Python, Java, C++, and Swift --

litArray
  :: (RC.RenderValue r var val typ, IC.TypeSym r typ, RC.ValueElim r val)
  => (Doc -> Doc) -> VS (r typ) -> [VS (r val)] -> VS (r val)
litArray :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
(Doc -> Doc) -> VS (r typ) -> [VS (r val)] -> VS (r val)
litArray Doc -> Doc
f VS (r typ)
t [VS (r val)]
es = [VS (r val)] -> StateT ValueState Identity [r val]
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 (r val)]
es StateT ValueState Identity [r val]
-> ([r val] -> VS (r val)) -> VS (r val)
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
>>= (\[r val]
elems -> 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) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
IC.arrayType VS (r typ)
t)
  (Doc -> Doc
f (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ [r val] -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
[r val] -> Doc
valueList [r val]
elems))

litSet
  :: (RC.RenderValue r var val typ, IC.TypeSym r typ, RC.ValueElim r val)
  => (Doc -> Doc) -> (Doc -> Doc) -> VS (r typ) -> [VS (r val)] -> VS (r val)
litSet :: 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)
litSet Doc -> Doc
f1 Doc -> Doc
f2 VS (r typ)
t [VS (r val)]
es = [VS (r val)] -> StateT ValueState Identity [r val]
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 (r val)]
es StateT ValueState Identity [r val]
-> ([r val] -> VS (r val)) -> VS (r val)
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
>>= (\[r val]
elems -> 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) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
IC.arrayType VS (r typ)
t)
  (Doc -> Doc
f1 (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ Doc -> Doc
f2 (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ [r val] -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
[r val] -> Doc
valueList [r val]
elems))

litSetFunc
  :: (RC.RenderValue r var val typ, IC.TypeSym r typ, RC.ValueElim r val)
  => String -> VS (r typ) -> [VS (r val)] -> VS (r val)
litSetFunc :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
String -> VS (r typ) -> [VS (r val)] -> VS (r val)
litSetFunc String
s VS (r typ)
t [VS (r val)]
es = [VS (r val)] -> StateT ValueState Identity [r val]
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 (r val)]
es StateT ValueState Identity [r val]
-> ([r val] -> VS (r val)) -> VS (r val)
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
>>= (\[r val]
elems -> 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) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
IC.arrayType VS (r typ)
t)
  (String -> Doc
text String
s Doc -> Doc -> Doc
<> Doc -> Doc
parens ([r val] -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
[r val] -> Doc
valueList [r val]
elems)))

-- Python, C#, C++, and Swift--

extraClass
  :: (RG.RenderClass r cls stvr mthd vis, VisibilitySym r vis)
  =>  Label
  -> Maybe Label
  -> [CSStateVar r stvr]
  -> [MS (r mthd)]
  -> [MS (r mthd)]
  -> CS (r cls)
extraClass :: forall (r :: * -> *) cls stvr mthd vis.
(RenderClass r cls stvr mthd vis, VisibilitySym r vis) =>
String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
extraClass String
n = String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall (r :: * -> *) cls stvr mthd vis.
RenderClass r cls stvr mthd vis =>
String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
RG.intClass String
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public (r Doc
 -> [CSStateVar r stvr]
 -> [MS (r mthd)]
 -> [MS (r mthd)]
 -> CS (r cls))
-> (Maybe String -> r Doc)
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String -> r Doc
forall (r :: * -> *) cls stvr mthd vis.
RenderClass r cls stvr mthd vis =>
Maybe String -> r Doc
RG.inherit

-- Java, C#, and Swift --

doubleRender :: String
doubleRender :: String
doubleRender = String
"Double"

double :: (Monad r) => VS (r TypeData)
double :: forall (r :: * -> *). Monad r => VS (r TypeData)
double = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
Double String
doubleRender (String -> Doc
text String
doubleRender)

openFileR
  :: (TypeSym r typ, IC.AssignStatement r stmt var val)
  => (VS (r val) -> VS (r typ) -> VS (r val))
  -> VS (r var)
  -> VS (r val)
  -> MS (r stmt)
openFileR :: forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, AssignStatement r stmt var val) =>
(VS (r val) -> VS (r typ) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
openFileR VS (r val) -> VS (r typ) -> VS (r val)
f VS (r var)
vr VS (r val)
vl = VS (r var)
vr VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (r val) -> VS (r typ) -> VS (r val)
f VS (r val)
vl VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile

openFileW
  :: (IC.AssignStatement r stmt var val, TypeSym r typ, IC.Literal r val typ)
  => (VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
  -> VS (r var)
  -> VS (r val)
  -> MS (r stmt)
openFileW :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, TypeSym r typ,
 Literal r val typ) =>
(VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
openFileW VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
f VS (r var)
vr VS (r val)
vl = VS (r var)
vr VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
f VS (r val)
vl VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
outfile VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
IC.litFalse

stateVar
  ::
    ( Monad r
    , OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ
    )
  => r vis -> r attch -> VS (r var) -> CS (r Doc)
stateVar :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
(Monad r,
 OORenderSym
   r
   file
   mod
   cls
   stvr
   mthd
   attch
   vis
   param
   bod
   block
   stmt
   var
   scope
   val
   binder
   typ) =>
r vis -> r attch -> VS (r var) -> CS (r Doc)
stateVar r vis
s r attch
p VS (r var)
v = LensLike'
  (Zoomed (StateT MethodState Identity) (r Doc))
  ClassState
  MethodState
-> StateT MethodState Identity (r Doc)
-> StateT ClassState Identity (r Doc)
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) ClassState MethodState
-> StateT MethodState Identity c -> StateT ClassState 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 MethodState Identity) (r Doc))
  ClassState
  MethodState
(MethodState -> Focusing Identity (r Doc) MethodState)
-> ClassState -> Focusing Identity (r Doc) ClassState
Lens' ClassState MethodState
lensCStoMS (StateT MethodState Identity (r Doc)
 -> StateT ClassState Identity (r Doc))
-> StateT MethodState Identity (r Doc)
-> StateT ClassState Identity (r Doc)
forall a b. (a -> b) -> a -> b
$ (r stmt -> r Doc)
-> State MethodState (r stmt)
-> StateT MethodState Identity (r Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> (r stmt -> Doc) -> r stmt -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc -> Doc -> Doc
R.stateVar
  (r vis -> Doc
forall {k} (r :: k -> *) (vis :: k).
VisibilityElim r vis =>
r vis -> Doc
RC.visibility r vis
s) (r attch -> Doc
forall {k} (r :: k -> *) (attch :: k).
PermElim r attch =>
r attch -> Doc
RG.perm r attch
p) (Doc -> Doc) -> (r stmt -> Doc) -> r stmt -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r stmt -> Doc
forall {k} (r :: k -> *) (stmt :: k).
StatementElim r stmt =>
r stmt -> Doc
RC.statement) (State MethodState (r stmt) -> State MethodState (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
RC.stmt (State MethodState (r stmt) -> State MethodState (r stmt))
-> State MethodState (r stmt) -> State MethodState (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> r scope -> State MethodState (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> MS (r stmt)
IC.varDec VS (r var)
v r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
IC.local)

-- Python and Swift --

self :: (OOTypeSym r typ, RenderVariable r var typ) => VS (r var)
self :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(OOTypeSym r typ, RenderVariable r var typ) =>
VS (r var)
self = LensLike'
  (Zoomed (StateT MethodState Identity) String)
  ValueState
  MethodState
-> MS String -> StateT ValueState Identity String
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) ValueState MethodState
-> StateT MethodState Identity c -> StateT ValueState 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 MethodState Identity) String)
  ValueState
  MethodState
(MethodState -> Focusing Identity String MethodState)
-> ValueState -> Focusing Identity String ValueState
Lens' ValueState MethodState
lensVStoMS MS String
getClassName StateT ValueState Identity String
-> (String -> StateT ValueState Identity (r var))
-> StateT ValueState Identity (r var)
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
>>= (\String
l -> String -> VS (r typ) -> Doc -> StateT ValueState Identity (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
String -> VS (r typ) -> Doc -> VS (r var)
mkStateVar String
R.self (String -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
l)
  Doc
R.self')

multiAssign
  :: ( TypeSym r typ
     , IC.AssignStatement r stmt var val
     , InternalVarElim r var
     , RC.RenderValue r var val typ
     , RC.RenderVariable r var typ
     , RC.ValueElim r val
     )
  => (Doc -> Doc) -> [VS (r var)] -> [VS (r val)] -> MS (r stmt)
multiAssign :: 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)
multiAssign Doc -> Doc
_ [] [VS (r val)]
_ = String -> MS (r stmt)
forall a. HasCallStack => String -> a
error String
"Attempt to write assign statement for no variables."
multiAssign Doc -> Doc
_ [VS (r var)]
_ [] = String -> MS (r stmt)
forall a. HasCallStack => String -> a
error String
"Attempt to write assign statement with no values."
multiAssign Doc -> Doc
f [VS (r var)]
vars [VS (r val)]
vals = if [VS (r val)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [VS (r val)]
vals Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
1 Bool -> Bool -> Bool
&& [VS (r var)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [VS (r var)]
vars Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= [VS (r val)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [VS (r val)]
vals
  then String -> MS (r stmt)
forall a. HasCallStack => String -> a
error (String -> MS (r stmt)) -> String -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ String
"Attempted multiple assign statement with different number " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<>
    String
"of variables than values"
  else do
  vrs <- (VS (r var) -> StateT MethodState Identity (r var))
-> [VS (r var)] -> StateT MethodState Identity [r var]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
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 var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS) [VS (r var)]
vars
  vls <- mapM (zoom lensMStoVS) vals
  let wrapIfMult :: [a] -> Doc -> Doc
      wrapIfMult [a]
l = if [a] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [a]
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
1 then Doc -> Doc
f else Doc -> Doc
forall a. a -> a
id
  mkStateVar "" IC.void (wrapIfMult vrs (variableList vrs)) &=
    mkStateVal IC.void (wrapIfMult vls (valueList vls))

multiReturn
  ::
    ( TypeSym r typ
    , IC.ControlStatement r bod stmt var val
    , RC.RenderValue r var val typ
    , RC.ValueElim r val
    )
  => (Doc -> Doc) -> [VS (r val)] -> MS (r stmt)
multiReturn :: 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)
multiReturn Doc -> Doc
_ [] = String -> MS (r stmt)
forall a. HasCallStack => String -> a
error String
"Attempt to write return statement with no values."
multiReturn Doc -> Doc
_ [VS (r val)
v] = VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r stmt)
returnStmt VS (r val)
v
multiReturn Doc -> Doc
f [VS (r val)]
vs = do
  vs' <- (VS (r val) -> StateT MethodState Identity (r val))
-> [VS (r val)] -> StateT MethodState Identity [r val]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (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)]
vs
  returnStmt $ mkStateVal IC.void $ f $ valueList vs'

listDec
  ::
    ( IC.DeclStatement r bod stmt var scope val
    , TypeSym r typ
    , IC.Literal r val typ
    , VariableElim r var typ
    )
  => VS (r var) -> r scope -> MS (r stmt)
listDec :: 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)
listDec VS (r var)
v r scope
scp = VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (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)
listDecDef VS (r var)
v r scope
scp []

funcDecDef
  :: (OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var ScopeData val binder typ)
  => VS (r var)
  -> r ScopeData
  -> [VS (r var)]
  -> MS (r bod)
  -> MS (r stmt)
funcDecDef :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  ScopeData
  val
  binder
  typ =>
VS (r var)
-> r ScopeData -> [VS (r var)] -> MS (r bod) -> MS (r stmt)
funcDecDef VS (r var)
v r ScopeData
scp [VS (r var)]
ps MS (r bod)
b = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
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 var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
v
  modify $ useVarName $ variableName vr
  modify $ setVarScope (variableName vr) (scopeData scp)
  s <- get
  f <- function (variableName vr) private (pure $ variableType vr)
    (IC.param <$> ps) b
  modify (L.set currParameters (s ^. currParameters))
  mkStmtNoEnd $ RC.method f

inOutCall
  ::
    ( TypeSym r typ
    , RC.InternalAssignStmt r stmt var val
    , ValueStatement r stmt val
    , IC.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)
inOutCall :: 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) =>
(String -> VS (r typ) -> [VS (r val)] -> VS (r val))
-> String
-> [VS (r val)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r stmt)
inOutCall String -> VS (r typ) -> [VS (r val)] -> VS (r val)
f String
n [VS (r val)]
ins [] [] = VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
IC.valStmt (VS (r val) -> MS (r stmt)) -> VS (r val) -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ String -> VS (r typ) -> [VS (r val)] -> VS (r val)
f String
n VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.void [VS (r val)]
ins
inOutCall String -> VS (r typ) -> [VS (r val)] -> VS (r val)
f String
n [VS (r val)]
ins [VS (r var)]
outs [VS (r var)]
both = [VS (r var)] -> [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
InternalAssignStmt r stmt var val =>
[VS (r var)] -> [VS (r val)] -> MS (r stmt)
RC.multiAssign [VS (r var)]
rets [String -> VS (r typ) -> [VS (r val)] -> VS (r val)
f String
n VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.void ((VS (r var) -> VS (r val)) -> [VS (r var)] -> [VS (r val)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf
  [VS (r var)]
both [VS (r val)] -> [VS (r val)] -> [VS (r val)]
forall a. Semigroup a => a -> a -> a
P.<> [VS (r val)]
ins)]
  where rets :: [VS (r var)]
rets = [VS (r var)]
both [VS (r var)] -> [VS (r var)] -> [VS (r var)]
forall a. Semigroup a => a -> a -> a
P.<> [VS (r var)]
outs

forLoopError :: String -> String
forLoopError :: String -> String
forLoopError String
l = String
"Classic for loops not available in " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
l String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
", use " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<>
  String
"forRange, forEach, or while instead"

mainBody
  :: (RC.BodyElim r bod, RC.RenderMethod r mthd) => MS (r bod) -> MS (r mthd)
mainBody :: forall (r :: * -> *) bod mthd.
(BodyElim r bod, RenderMethod r mthd) =>
MS (r bod) -> MS (r mthd)
mainBody MS (r bod)
b = do
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
setCurrMain
  bod <- MS (r bod)
b
  modify (setMainDoc $ RC.body bod)
  mthdFromData Pub empty

inOutFunc
  ::
    ( IC.VariableValue r var val
    , IC.ParameterSym r param var
    , TypeSym r typ
    , IC.ScopeSym r scope
    , IC.DeclStatement r bod stmt var scope val
    , BlockSym r block stmt
    , IC.BodySym r bod block
    , VariableElim r var typ
    , RenderBody r bod
    , RenderType r typ
    , RC.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)
inOutFunc :: 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)
inOutFunc VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd)
f [VS (r var)]
ins [] [] MS (r bod)
b = VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd)
f VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.void (VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
IC.param (VS (r var) -> MS (r param)) -> [VS (r var)] -> [MS (r param)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VS (r var)]
ins) MS (r bod)
b
inOutFunc VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd)
f [VS (r var)]
ins [VS (r var)]
outs [VS (r var)]
both MS (r bod)
b = VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd)
f
  ([VS (r typ)] -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
RenderType r typ =>
[VS (r typ)] -> VS (r typ)
multiType ([VS (r typ)] -> VS (r typ)) -> [VS (r typ)] -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ (r var -> r typ) -> VS (r var) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType (VS (r var) -> VS (r typ)) -> [VS (r var)] -> [VS (r typ)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VS (r var)]
rets)
  ((VS (r var) -> MS (r param)) -> [VS (r var)] -> [MS (r param)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
IC.pointerParam [VS (r var)]
both [MS (r param)] -> [MS (r param)] -> [MS (r param)]
forall a. Semigroup a => a -> a -> a
P.<> (VS (r var) -> MS (r param)) -> [VS (r var)] -> [MS (r param)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
IC.param [VS (r var)]
ins)
  ([MS (r bod)] -> MS (r bod)
forall {k} (r :: k -> *) (bod :: k).
RenderBody r bod =>
[MS (r bod)] -> MS (r bod)
multiBody [[MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements ([MS (r stmt)] -> MS (r bod)) -> [MS (r stmt)] -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ (VS (r var) -> r scope -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> MS (r stmt)
`IC.varDec` r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
IC.local) (VS (r var) -> MS (r stmt)) -> [VS (r var)] -> [MS (r stmt)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VS (r var)]
outs, MS (r bod)
b,
    MS (r stmt) -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (r stmt) -> MS (r bod)) -> MS (r stmt) -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ [VS (r val)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
InternalControlStmt r stmt val =>
[VS (r val)] -> MS (r stmt)
RC.multiReturn ([VS (r val)] -> MS (r stmt)) -> [VS (r val)] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf (VS (r var) -> VS (r val)) -> [VS (r var)] -> [VS (r val)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VS (r var)]
rets])
  where rets :: [VS (r var)]
rets = [VS (r var)]
both [VS (r var)] -> [VS (r var)] -> [VS (r var)]
forall a. Semigroup a => a -> a -> a
P.<> [VS (r var)]
outs

docInOutFunc'
  :: (BlockCommentSym r, RenderMethod r mthd)
  => FuncDocRenderer
  -> ([VS (r var)] -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
  -> String
  -> [(String, VS (r var))]
  -> [(String, VS (r var))]
  -> [(String, VS (r var))]
  -> MS (r bod) -> MS (r mthd)
docInOutFunc' :: 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))
-> String
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
docInOutFunc' FuncDocRenderer
dfr [VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, VS (r var))]
is [(String, VS (r var))]
os [(String, VS (r var))]
bs MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
dfr String
desc ((String, VS (r var)) -> String
forall a b. (a, b) -> a
fst ((String, VS (r var)) -> String)
-> [(String, VS (r var))] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
bs [(String, VS (r var))]
-> [(String, VS (r var))] -> [(String, VS (r var))]
forall a. Semigroup a => a -> a -> a
P.<> [(String, VS (r var))]
is)
  ((String, VS (r var)) -> String
forall a b. (a, b) -> a
fst ((String, VS (r var)) -> String)
-> [(String, VS (r var))] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
bs [(String, VS (r var))]
-> [(String, VS (r var))] -> [(String, VS (r var))]
forall a. Semigroup a => a -> a -> a
P.<> [(String, VS (r var))]
os) ([VS (r var)]
-> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd)
f ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
is) ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
os) ((String, VS (r var)) -> VS (r var)
forall a b. (a, b) -> b
snd ((String, VS (r var)) -> VS (r var))
-> [(String, VS (r var))] -> [VS (r var)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(String, VS (r var))]
bs) MS (r bod)
b)

-- Java and Swift --

floatRender :: String
floatRender :: String
floatRender = String
"Float"

float :: (Monad r) => VS (r TypeData)
float :: forall (r :: * -> *). Monad r => VS (r TypeData)
float = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
Float String
floatRender (String -> Doc
text String
floatRender)

stringRender' :: String
stringRender' :: String
stringRender' = String
"String"

string' :: (Monad r) => VS (r TypeData)
string' :: forall (r :: * -> *). Monad r => VS (r TypeData)
string' = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
String String
stringRender' (String -> Doc
text String
stringRender')

-- C# and Swift --

inherit :: (Monad r) => Maybe Label -> r ParentSpec
inherit :: forall (r :: * -> *). Monad r => Maybe String -> r Doc
inherit Maybe String
n = Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> Doc -> r Doc
forall a b. (a -> b) -> a -> b
$ Doc -> (String -> Doc) -> Maybe String -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Doc
empty ((Doc
colon Doc -> Doc -> Doc
<+>) (Doc -> Doc) -> (String -> Doc) -> String -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
text) Maybe String
n

implements :: (Monad r) => [Label] -> r ParentSpec
implements :: forall (r :: * -> *). Monad r => [String] -> r Doc
implements [String]
is = Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> Doc -> r Doc
forall a b. (a -> b) -> a -> b
$ Doc
colon Doc -> Doc -> Doc
<+> String -> Doc
text (String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
listSep [String]
is)

-- | Generates Markdown/DocC style module doc comment.  Useful for Swift, which follows
-- DocC, Julia, which uses Markdown, and any other language that doesn't have
-- Support for a document generator.
modDoc' :: ModuleDocRenderer
modDoc' :: ModuleDocRenderer
modDoc' String
desc String
watermark [String]
as String
date String
m = String
m String -> [String] -> [String]
forall a. a -> [a] -> [a]
: [String
desc | Bool -> Bool
not (String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
desc)] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
P.<>
      [String -> String -> String
docField String
authorDoc ([String] -> String
stringList [String]
as) | Bool -> Bool
not ([String] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [String]
as)] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
P.<>
      [String -> String -> String
docField String
dateDoc String
date | Bool -> Bool
not (String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
date)] [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
P.<>
      [String -> String -> String
docField String
noteDoc String
watermark]

-- | Creates an arbitrary Markdown/DocC style field for documentation.
-- Takes two strings, one for the field type ('ty'), and another
-- for the field documentation ('info')
docField :: String -> String -> String
docField :: String -> String -> String
docField String
ty String
info = String
docCommandInit String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
ty String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
docCommandSep String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
info

-- | Generates Markdown/DocC style function doc comment.
functionDoc :: FuncDocRenderer
functionDoc :: FuncDocRenderer
functionDoc String
desc [(String, String)]
params [String]
returns = [String
desc | Bool -> Bool
not (String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
desc)]
  [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
P.<> ((String, String) -> String) -> [(String, String)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(String
v, String
vDesc) -> String
docCommandInit String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
paramDoc String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
" " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<>
    String
v String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
docCommandSep String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
vDesc) [(String, String)]
params
  [String] -> [String] -> [String]
forall a. Semigroup a => a -> a -> a
P.<> (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((String
docCommandInit String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
returnDoc String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
docCommandSep) String -> String -> String
forall a. [a] -> [a] -> [a]
++) [String]
returns

docCommandInit, docCommandSep, authorDoc, dateDoc,
  noteDoc, paramDoc, returnDoc :: String
docCommandInit :: String
docCommandInit = String
"- "
docCommandSep :: String
docCommandSep = String
": "
authorDoc :: String
authorDoc = String
"Authors"
dateDoc :: String
dateDoc = String
"Date"
noteDoc :: String
noteDoc = String
"Note"
paramDoc :: String
paramDoc = String
"Parameter"
returnDoc :: String
returnDoc = String
"Returns"

-- | For declaring and optionally defining a variable in a language where
--   declaring a variable before defining it is not required.
--   v is the variable to declare, and e is Nothing if we are not defining it,
--   and (Just d) if d is the value we are defining it as.

fileOpen, fileR, fileW, fileA :: Label
fileOpen :: String
fileOpen = String
"open"
fileR :: String
fileR = String
"r"
fileW :: String
fileW = String
"w"
fileA :: String
fileA = String
"a"

openFileR', openFileW', openFileA'
  ::
    ( TypeSym r typ
    , IC.Literal r val typ
    , IC.ValueExpression r var val binder typ
    )
  => VS (r val) -> VS (r val)
openFileR' :: 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)
openFileR' VS (r val)
n = 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 String
fileOpen VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile [VS (r val)
n, String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
IC.litString String
fileR]
openFileW' :: 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)
openFileW' VS (r val)
n = 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 String
fileOpen VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile [VS (r val)
n, String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
IC.litString String
fileW]
openFileA' :: 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)
openFileA' VS (r val)
n = 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 String
fileOpen VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile [VS (r val)
n, String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
IC.litString String
fileA]

argExists
  ::
    ( IC.Literal r val typ
    , IC.CommandLineArgs r val
    , Comparison r val
    , IC.List r val
    )
  => Integer -> VS (r val)
argExists :: 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)
argExists Integer
i = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (r val)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
IC.argsList VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt (Integer -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Integer -> Integer) -> Integer -> Integer
forall a b. (a -> b) -> a -> b
$ Integer
iInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)

-- Python, C#, Swift, and Julia

listSet
  :: ( IC.AssignStatement r stmt var val
     , ValueSym r val typ
     , IC.IndexTranslator r val
     , RC.RenderVariable r var typ
     , RC.ValueElim r val
     )
  => VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
listSet :: 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)
listSet VS (r val)
list VS (r val)
idx VS (r val)
val = do
  list' <- 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)
list
  idx' <- zoom lensMStoVS (IC.intToIndex idx)
  let listAccessVar = String -> r typ -> Doc -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
String -> r typ -> Doc -> VS (r var)
mkVar (Doc -> String
render (Doc -> String) -> Doc -> String
forall a b. (a -> b) -> a -> b
$ r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
list') (r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType r val
list')
                        (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
list' Doc -> Doc -> Doc
<> Doc -> Doc
brackets (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
idx')) -- hack
  listAccessVar &= val

-- Julia and MATLAB --

-- | Convert an integer to an index in a 1-indexed language
--   Since GOOL is 0-indexed, we need to add 1
intToIndex'
  ::
    ( TypeSym r typ
    , IC.Literal r val typ
    , IC.NumericExpression r val
    , RC.RenderValue r var val typ
    , RC.ValueElim r val
    )
  => VS (r val) -> VS (r val)
intToIndex' :: 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)
intToIndex' VS (r val)
v = VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
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)
`smartAdd` Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1

-- | Convert an index to an integer in a 1-indexed language
--   Since GOOL is 0-indexed, we need to subtract 1
indexToInt'
  ::
    ( TypeSym r typ
    , IC.Literal r val typ
    , IC.NumericExpression r val
    , RC.RenderValue r var val typ
    , RC.ValueElim r val
    )
  => VS (r val) -> VS (r val)
indexToInt' :: 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)
indexToInt' VS (r val)
v = VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
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)
`smartSub` Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1