-- | 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, SVariable, Value, SValue,
  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 (Class, 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, ParamData, 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 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 :: SValue r -> SValue r
intToIndex :: forall (r :: * -> *). SValue r -> SValue r
intToIndex = SValue r -> SValue r
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 :: SValue r -> SValue r
indexToInt :: forall (r :: * -> *). SValue r -> SValue r
indexToInt = SValue r -> SValue r
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 vis stmt mthd stvr attch file mod bod block)
  => Label -> [MS (r ParamData)] -> Initializers r -> MS (r bod) -> MS (r mthd)
constructor :: forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
String
-> [MS (r ParamData)]
-> Initializers r
-> MS (r bod)
-> MS (r mthd)
constructor String
fName [MS (r ParamData)]
ps Initializers r
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
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r bod)
-> StateT MethodState Identity (r mthd)
forall (r :: * -> *) vis mthd attch bod.
OORenderMethod r vis mthd attch bod =>
Bool
-> String
-> r vis
-> r attch
-> MSMthdType r
-> [MS (r ParamData)]
-> 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 -> MSMthdType r
forall (r :: * -> *). OOMethodTypeSym r => String -> MSMthdType r
RG.construct String
c) [MS (r ParamData)]
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 -> MS (r bod)
forall (r :: * -> *) stmt block bod.
(VariableValue r, SelfSym r, AssignStatement r stmt,
 BlockSym r block stmt, BodySym r bod block) =>
Initializers r -> MS (r bod)
initStmts Initializers r
is, MS (r bod)
b]))

doxFunc :: (RenderMethod r mthd) => String -> [String] -> Maybe String ->
  MS (r mthd) -> MS (r mthd)
doxFunc :: forall (r :: * -> *) mthd.
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.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
docFunc FuncDocRenderer
functionDox

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

doxMod
  :: (RG.RenderFile r file mod)
  => String
  -> String
  -> String
  -> [String]
  -> String
  -> FS (r file)
  -> FS (r file)
doxMod :: forall (r :: * -> *) file mod.
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.
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, RenderVariable r, UnRepr r TypeData, VariableElim r)
  => (Doc -> Doc -> Doc) -> VS (r TypeData) -> SVariable r -> SVariable r
classVarAccess :: forall (r :: * -> *).
(InternalVarElim r, RenderVariable r, UnRepr r TypeData,
 VariableElim r) =>
(Doc -> Doc -> Doc)
-> VS (r TypeData) -> SVariable r -> SVariable r
classVarAccess Doc -> Doc -> Doc
f VS (r TypeData)
c' SVariable r
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
  :: (IC.IndexTranslator r, IG.OOFunctionSym r)
  => Label -> SValue r -> SValue r -> SValue r
indexOf :: forall (r :: * -> *).
(IndexTranslator r, OOFunctionSym r) =>
String -> SValue r -> SValue r -> SValue r
indexOf String
f SValue r
l SValue r
v = SValue r -> SValue r
forall (r :: * -> *). IndexTranslator r => SValue r -> SValue r
IC.indexToInt (SValue r -> SValue r) -> SValue r -> SValue r
forall a b. (a -> b) -> a -> b
$ SValue r -> VS (r FuncData) -> SValue r
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
IG.objAccess SValue r
l (String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
IG.func String
f VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.int [SValue r
v])

contains :: (IG.OOFunctionSym r) => Label -> SValue r -> SValue r -> SValue r
contains :: forall (r :: * -> *).
OOFunctionSym r =>
String -> SValue r -> SValue r -> SValue r
contains String
f SValue r
s SValue r
v = SValue r -> VS (r FuncData) -> SValue r
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
IG.objAccess SValue r
s (String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
IG.func String
f VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.bool [SValue r
v])

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

discardFileLine
  :: (IG.InternalValueExp r, ValueStatement r stmt)
  => Label -> SValue r -> MS (r stmt)
discardFileLine :: forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> MS (r stmt)
discardFileLine String
n SValue r
f = SValue r -> MS (r stmt)
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt (SValue r -> MS (r stmt)) -> SValue r -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r TypeData) -> SValue r -> String -> SValue r
forall (r :: * -> *).
InternalValueExp r =>
VS (r TypeData) -> SValue r -> String -> SValue r
objMethodCallNoParams VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.string SValue r
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 [MS (r mthd)]
cstrs [MS (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]
map r stvr -> Doc
forall {k} (r :: k -> *) (stvr :: k).
StateVarElim r stvr =>
r stvr -> Doc
RG.stateVar) [CSStateVar r stvr]
svrs
  ms <- onStateList (vibcat . map RC.method) (map (zoom lensCStoMS) (cstrs ++ mths))
  return $ 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, RC.MethodElim r mthd, RG.RenderMod r mod)
  => Label
  -> FS Doc
  -> FS Doc
  -> FS Doc
  -> [MS (r mthd)]
  -> [CS (r Class)]
  -> FS (r mod)
buildModule :: forall (r :: * -> *) mthd mod.
(ClassElim r, MethodElim r mthd, RenderMod r mod) =>
String
-> FS Doc
-> FS Doc
-> FS Doc
-> [MS (r mthd)]
-> [CS (r Doc)]
-> FS (r mod)
buildModule String
n FS Doc
imps FS Doc
topDoc FS Doc
bot [MS (r mthd)]
fs [CS (r Doc)]
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 Doc) -> StateT FileState Identity (r Doc))
-> [CS (r Doc)] -> StateT FileState Identity [r Doc]
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 Doc)) FileState ClassState
-> CS (r Doc) -> StateT FileState Identity (r Doc)
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 Doc)) FileState ClassState
(ClassState -> Focusing Identity (r Doc) ClassState)
-> FileState -> Focusing Identity (r Doc) FileState
Lens' FileState ClassState
lensFStoCS) [CS (r Doc)]
cs
  fns <- mapM (zoom lensFStoMS) fs
  is <- imps
  tp <- topDoc
  bt <- bot
  return $ R.module' is (vibcat (tp : map RG.class' cls))
    (vibcat (map RC.method fns ++ [bt])))

-- Java and C# --

arrayType :: (TypeElim r, Monad r, UnRepr r TypeData) =>
  VS (r TypeData) -> VS (r TypeData)
arrayType :: forall (r :: * -> *).
(TypeElim r, 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 ++ array) (renderType t <> brackets empty)

pi :: (RC.RenderValue r, TypeSym r) => SValue r
pi :: forall (r :: * -> *). (RenderValue r, TypeSym r) => SValue r
pi = VS (r TypeData) -> Doc -> SValue r
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
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)
  => SValue r -> SValue r -> MS (r stmt)
printSt :: forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
SValue r -> SValue r -> MS (r stmt)
printSt SValue r
va' SValue r
vb' = do
  va <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
va'
  vb <- zoom lensMStoVS vb'
  mkStmt (R.print va vb)

arrayDec
  :: ( ScopeElim r
     , UnRepr r TypeData
     , InternalVarElim r
     , RC.RenderStatement r stmt
     , RC.ValueElim r
     , VariableElim r
     )
  => SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
arrayDec :: forall (r :: * -> *) stmt.
(ScopeElim r, UnRepr r TypeData, InternalVarElim r,
 RenderStatement r stmt, ValueElim r, VariableElim r) =>
SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
arrayDec SValue r
n SVariable r
vr r ScopeData
scp = do
  sz <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
n
  v <- zoom lensMStoVS vr
  modify $ useVarName $ variableName v
  modify $ setVarScope (variableName v) (scopeData scp)
  let tp = r Variable -> r TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType r Variable
v
  innerTp <- zoom lensMStoVS $ innerType $ return tp
  mkStmt $ renderType tp <+> RC.variable v <+> equals <+> new' <+>
    renderType innerTp <> brackets (RC.value sz)

arrayDecDef
  :: ( IC.DeclStatement r stmt bod
     , RC.RenderStatement r stmt
     , RC.StatementElim r stmt
     , RC.ValueElim r
     )
  => SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
arrayDecDef :: forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
arrayDecDef SVariable r
v' r ScopeData
scp [SValue r]
vals' = do
  vs <- (SValue r -> StateT MethodState Identity (r Value))
-> [SValue r] -> StateT MethodState Identity [r Value]
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 Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS) [SValue r]
vals'
  vd <- IC.varDec v' scp
  mkStmt (RC.statement vd <+> equals <+> braces (valueList vs))

openFileA
  :: (IC.AssignStatement r stmt, IC.Literal r)
  => (SValue r -> VS (r TypeData) -> SValue r -> SValue r)
  -> SVariable r
  -> SValue r
  -> MS (r stmt)
openFileA :: forall (r :: * -> *) stmt.
(AssignStatement r stmt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
openFileA SValue r -> VS (r TypeData) -> SValue r -> SValue r
f SVariable r
vr SValue r
vl = SVariable r
vr SVariable r -> SValue r -> MS (r stmt)
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SValue r -> VS (r TypeData) -> SValue r -> SValue r
f SValue r
vl VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
outfile SValue r
forall (r :: * -> *). Literal r => SValue r
IC.litTrue

forEach
  :: ( RC.BodyElim r bod
     , InternalVarElim r
     , RC.RenderStatement r stmt
     , UnRepr r TypeData
     , RC.ValueElim r
     , VariableElim r
     )
  => Doc -> Doc -> Doc -> Doc -> SVariable r -> SValue r -> MS (r bod) -> MS (r stmt)
forEach :: forall (r :: * -> *) bod stmt.
(BodyElim r bod, InternalVarElim r, RenderStatement r stmt,
 UnRepr r TypeData, ValueElim r, VariableElim r) =>
Doc
-> Doc
-> Doc
-> Doc
-> SVariable r
-> SValue r
-> MS (r bod)
-> MS (r stmt)
forEach Doc
bStart Doc
bEnd Doc
forEachLabel Doc
inLbl SVariable r
e' SValue r
v' MS (r bod)
b' = do
  e <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Variable) ValueState)
-> MethodState -> Focusing Identity (r Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable r
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 vis stmt mthd stvr attch file mod bod block)
  => MS (r bod) -> MS (r mthd)
docMain :: forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
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 (r :: * -> *) vis mthd bod.
MethodSym r vis mthd bod =>
MS (r bod) -> MS (r mthd)
IC.mainFunction MS (r bod)
b)

mainFunction
  :: ( AttachmentSym r attch
     , OORenderMethod r vis mthd attch bod
     , IC.ParameterSym r
     , UnRepr r TypeData
     , Monad r
     , VisibilitySym r vis
     )
  => VS (r TypeData) -> Label -> MS (r bod) -> MS (r mthd)
mainFunction :: forall (r :: * -> *) attch vis mthd bod.
(AttachmentSym r attch, OORenderMethod r vis mthd attch bod,
 ParameterSym r, 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
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
forall (r :: * -> *) vis mthd attch bod.
OORenderMethod r vis mthd attch bod =>
Bool
-> String
-> r vis
-> r attch
-> MSMthdType r
-> [MS (r ParamData)]
-> 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) -> MSMthdType r
forall (r :: * -> *).
MethodTypeSym r =>
VS (r TypeData) -> MSMthdType r
mType VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.void)
  [SVariable r -> MS (r ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
IC.param (String -> VS (r TypeData) -> SVariable r
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
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. [a] -> [a] -> [a]
++ 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 vis stmt mthd stvr attch file mod bod block, UnRepr r Doc)
  => Label
  -> (String -> r Doc)
  -> [Label]
  -> [MS (r mthd)]
  -> [CS (r Class)]
  -> FS (r mod)
buildModule' :: forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(OORenderSym r vis stmt mthd stvr attch file mod bod block,
 UnRepr r Doc) =>
String
-> (String -> r Doc)
-> [String]
-> [MS (r mthd)]
-> [CS (r Doc)]
-> FS (r mod)
buildModule' String
n String -> r Doc
inc [String]
is [MS (r mthd)]
ms [CS (r Doc)]
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 Doc) -> StateT FileState Identity (r Doc))
-> [CS (r Doc)] -> StateT FileState Identity [r Doc]
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 Doc)) FileState ClassState
-> CS (r Doc) -> StateT FileState Identity (r Doc)
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 Doc)) FileState ClassState
(ClassState -> Focusing Identity (r Doc) ClassState)
-> FileState -> Focusing Identity (r Doc) 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 Doc)]
cs else Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
forall (r :: * -> *) vis mthd stvr attch.
ClassSym r vis mthd stvr attch =>
Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
IG.buildClass Maybe String
forall a. Maybe a
Nothing [] [] [MS (r mthd)]
ms CS (r Doc) -> [CS (r Doc)] -> [CS (r Doc)]
forall a. a -> [a] -> [a]
: [CS (r Doc)]
cs)
  lis <- getLangImports
  libis <- getLibImports
  mis <- getModuleImports
  return $ vibcat [
    vcat (map (RC.import' . inc) (lis ++ sort (is ++ libis) ++ mis)),
    vibcat (map RG.class' cls)])

-- Java and C++ --

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

namedArgError :: String -> String
namedArgError :: String -> String
namedArgError String
l = String
"Named arguments not supported in " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
l

listSizeFunc :: (IG.OOFunctionSym r) => VS (r FuncData)
listSizeFunc :: forall (r :: * -> *). OOFunctionSym r => VS (r FuncData)
listSizeFunc = String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
IG.func String
"size" VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.int []

listAccessFunc'
  :: (IG.OOFunctionSym r, TypeElim r)
  => Label -> VS (r TypeData) -> SValue r -> VS (r FuncData)
listAccessFunc' :: forall (r :: * -> *).
(OOFunctionSym r, TypeElim r) =>
String -> VS (r TypeData) -> SValue r -> VS (r FuncData)
listAccessFunc' String
f VS (r TypeData)
t SValue r
i = String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
forall (r :: * -> *).
OOFunctionSym r =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
IG.func String
f VS (r TypeData)
t [SValue r -> SValue r
forall (r :: * -> *).
(TypeElim r, ValueSym r) =>
SValue r -> SValue r
intValue SValue r
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
  :: (RenderMethod r mthd)
  => ([SVariable r] -> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd))
  -> String
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> MS (r bod)
  -> MS (r mthd)
docInOutFunc :: forall (r :: * -> *) mthd bod.
RenderMethod r mthd =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r bod)
-> MS (r mthd)
docInOutFunc [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)
o] [] MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst [(String, SVariable r)]
is)
  [(String, SVariable r) -> String
forall a b. (a, b) -> a
fst (String, SVariable r)
o] ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) [(String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd (String, SVariable r)
o] [] MS (r bod)
b)
docInOutFunc [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [] [(String, SVariable r)
both] MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst ([(String, SVariable r)] -> [String])
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> a -> b
$
  (String, SVariable r)
both (String, SVariable r)
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. a -> [a] -> [a]
: [(String, SVariable r)]
is) [(String, SVariable r) -> String
forall a b. (a, b) -> a
fst (String, SVariable r)
both] ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) [] [(String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd (String, SVariable r)
both] MS (r bod)
b)
docInOutFunc [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)]
os [(String, SVariable r)]
bs MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
functionDox String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst ([(String, SVariable r)] -> [String])
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> a -> b
$ [(String, SVariable r)]
bs [(String, SVariable r)]
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. [a] -> [a] -> [a]
++
  [(String, SVariable r)]
is [(String, SVariable r)]
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. [a] -> [a] -> [a]
++ [(String, SVariable r)]
os) [] ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
os) (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
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. [a] -> [a] -> [a]
++ String
l

notNull :: (Comparison r, IC.VariableValue r) => String -> SValue r -> SValue r
notNull :: forall (r :: * -> *).
(Comparison r, VariableValue r) =>
String -> SValue r -> SValue r
notNull String
nil SValue r
v = SValue r
v SValue r -> SValue r -> SValue r
forall (r :: * -> *).
Comparison r =>
SValue r -> SValue r -> SValue r
?!= SVariable r -> SValue r
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
IC.valueOf (String -> VS (r TypeData) -> SVariable r
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
IC.var String
nil (VS (r TypeData) -> SVariable r) -> VS (r TypeData) -> SVariable r
forall a b. (a -> b) -> a -> b
$ (r Value -> r TypeData) -> SValue r -> VS (r TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r Value -> r TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType SValue r
v)

listDecDef
  :: (IC.DeclStatement r stmt bod, IC.Literal r, VariableElim r)
  => SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
listDecDef :: forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
listDecDef SVariable r
v r ScopeData
scp [SValue r]
vals = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Variable) ValueState)
-> MethodState -> Focusing Identity (r Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable r
v
  let lst = VS (r TypeData) -> [SValue r] -> SValue r
forall (r :: * -> *).
Literal r =>
VS (r TypeData) -> [SValue r] -> SValue r
IC.litList (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
innerType (VS (r TypeData) -> VS (r TypeData))
-> VS (r TypeData) -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ r TypeData -> VS (r TypeData)
forall a. a -> StateT ValueState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (r TypeData -> VS (r TypeData)) -> r TypeData -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ r Variable -> r TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType r Variable
vr) [SValue r]
vals
  IC.varDecDef (return vr) scp lst

setDecDef
  :: (IC.DeclStatement r stmt bod, IC.Literal r, VariableElim r)
  => SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
setDecDef :: forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
setDecDef SVariable r
v r ScopeData
scp [SValue r]
vals = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Variable) ValueState)
-> MethodState -> Focusing Identity (r Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable r
v
  let st = VS (r TypeData) -> [SValue r] -> SValue r
forall (r :: * -> *).
Literal r =>
VS (r TypeData) -> [SValue r] -> SValue r
IC.litSet (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
innerType (VS (r TypeData) -> VS (r TypeData))
-> VS (r TypeData) -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ r TypeData -> VS (r TypeData)
forall a. a -> StateT ValueState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (r TypeData -> VS (r TypeData)) -> r TypeData -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ r Variable -> r TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType r Variable
vr) [SValue r]
vals
  IC.varDecDef (return vr) scp st

setDec
  :: (IC.DeclStatement r stmt bod, RC.RenderStatement r stmt, RC.StatementElim r stmt)
  => (r Value -> Doc) -> SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
setDec :: forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, RenderStatement r stmt,
 StatementElim r stmt) =>
(r Value -> Doc)
-> SValue r -> SVariable r -> r ScopeData -> MS (r stmt)
setDec r Value -> Doc
f SValue r
vl SVariable r
v r ScopeData
scp = do
  sz <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
vl
  vd <- IC.varDec v scp
  mkStmt (RC.statement vd <> f sz)

setMethodCall
  :: (IG.InternalValueExp r) => Label -> SValue r ->  SValue r -> SValue r
setMethodCall :: forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
setMethodCall String
n SValue r
a SValue r
b = VS (r TypeData) -> SValue r -> String -> [SValue r] -> SValue r
forall (r :: * -> *).
InternalValueExp r =>
VS (r TypeData) -> SValue r -> String -> [SValue r] -> SValue r
objMethodCall (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
innerType (VS (r TypeData) -> VS (r TypeData))
-> VS (r TypeData) -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ (r Value -> r TypeData) -> SValue r -> VS (r TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r Value -> r TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType SValue r
a) SValue r
a String
n [SValue r
b]

destructorError :: String -> String
destructorError :: String -> String
destructorError String
l = String
"Destructors not allowed in " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
l

stateVarDef
  :: (OORenderSym r vis stmt mthd stvr attch file mod bod block, Monad r)
  => r vis -> r attch -> SVariable r -> SValue r -> CS (r Doc)
stateVarDef :: forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(OORenderSym r vis stmt mthd stvr attch file mod bod block,
 Monad r) =>
r vis -> r attch -> SVariable r -> SValue r -> CS (r Doc)
stateVarDef r vis
s r attch
p SVariable r
vr SValue r
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
$ SVariable r
-> r ScopeData -> SValue r -> State MethodState (r stmt)
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
IC.varDecDef SVariable r
vr r ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
IC.local SValue r
vl)

constVar :: (CommonRenderSym r vis stmt mthd bod block, Monad r) => Doc -> r vis ->
  SVariable r -> SValue r -> CS (r Doc)
constVar :: forall (r :: * -> *) vis stmt mthd bod block.
(CommonRenderSym r vis stmt mthd bod block, Monad r) =>
Doc -> r vis -> SVariable r -> SValue r -> CS (r Doc)
constVar Doc
p r vis
s SVariable r
vr SValue r
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
$ SVariable r
-> r ScopeData -> SValue r -> State MethodState (r stmt)
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
IC.constDecDef SVariable r
vr r ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
IC.local SValue r
vl)

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

litArray
  :: (RC.RenderValue r, IC.TypeSym r, RC.ValueElim r)
  => (Doc -> Doc) -> VS (r TypeData) -> [SValue r] -> SValue r
litArray :: forall (r :: * -> *).
(RenderValue r, TypeSym r, ValueElim r) =>
(Doc -> Doc) -> VS (r TypeData) -> [SValue r] -> SValue r
litArray Doc -> Doc
f VS (r TypeData)
t [SValue r]
es = [SValue r] -> StateT ValueState Identity [r Value]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SValue r]
es StateT ValueState Identity [r Value]
-> ([r Value] -> SValue r) -> SValue r
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 Value]
elems -> VS (r TypeData) -> Doc -> SValue r
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
IC.arrayType VS (r TypeData)
t)
  (Doc -> Doc
f (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ [r Value] -> Doc
forall (r :: * -> *). ValueElim r => [r Value] -> Doc
valueList [r Value]
elems))

litSet
  :: (RC.RenderValue r, IC.TypeSym r, RC.ValueElim r)
  => (Doc -> Doc) -> (Doc -> Doc) -> VS (r TypeData) -> [SValue r] -> SValue r
litSet :: forall (r :: * -> *).
(RenderValue r, TypeSym r, ValueElim r) =>
(Doc -> Doc)
-> (Doc -> Doc) -> VS (r TypeData) -> [SValue r] -> SValue r
litSet Doc -> Doc
f1 Doc -> Doc
f2 VS (r TypeData)
t [SValue r]
es = [SValue r] -> StateT ValueState Identity [r Value]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SValue r]
es StateT ValueState Identity [r Value]
-> ([r Value] -> SValue r) -> SValue r
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 Value]
elems -> VS (r TypeData) -> Doc -> SValue r
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
IC.arrayType VS (r TypeData)
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 Value] -> Doc
forall (r :: * -> *). ValueElim r => [r Value] -> Doc
valueList [r Value]
elems))

litSetFunc
  :: (RC.RenderValue r, IC.TypeSym r, RC.ValueElim r)
  => String -> VS (r TypeData) -> [SValue r] -> SValue r
litSetFunc :: forall (r :: * -> *).
(RenderValue r, TypeSym r, ValueElim r) =>
String -> VS (r TypeData) -> [SValue r] -> SValue r
litSetFunc String
s VS (r TypeData)
t [SValue r]
es = [SValue r] -> StateT ValueState Identity [r Value]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [SValue r]
es StateT ValueState Identity [r Value]
-> ([r Value] -> SValue r) -> SValue r
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 Value]
elems -> VS (r TypeData) -> Doc -> SValue r
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal (VS (r TypeData) -> VS (r TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
IC.arrayType VS (r TypeData)
t)
  (String -> Doc
text String
s Doc -> Doc -> Doc
<> Doc -> Doc
parens ([r Value] -> Doc
forall (r :: * -> *). ValueElim r => [r Value] -> Doc
valueList [r Value]
elems)))

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

extraClass
  :: (RG.RenderClass r vis mthd stvr, VisibilitySym r vis)
  =>  Label -> Maybe Label -> [CSStateVar r stvr] -> [MS (r mthd)] -> [MS (r mthd)] -> CS (r Class)
extraClass :: forall (r :: * -> *) vis mthd stvr.
(RenderClass r vis mthd stvr, VisibilitySym r vis) =>
String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
extraClass String
n = String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
forall (r :: * -> *) vis mthd stvr.
RenderClass r vis mthd stvr =>
String
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
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 Doc))
-> (Maybe String -> r Doc)
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Doc)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String -> r Doc
forall (r :: * -> *) vis mthd stvr.
RenderClass r vis mthd stvr =>
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
  :: (IC.AssignStatement r stmt)
  => (SValue r -> VS (r TypeData) -> SValue r)
  -> SVariable r
  -> SValue r
  -> MS (r stmt)
openFileR :: forall (r :: * -> *) stmt.
AssignStatement r stmt =>
(SValue r -> VS (r TypeData) -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
openFileR SValue r -> VS (r TypeData) -> SValue r
f SVariable r
vr SValue r
vl = SVariable r
vr SVariable r -> SValue r -> MS (r stmt)
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SValue r -> VS (r TypeData) -> SValue r
f SValue r
vl VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
infile

openFileW
  :: (IC.AssignStatement r stmt, IC.Literal r)
  => (SValue r -> VS (r TypeData) -> SValue r -> SValue r)
  -> SVariable r
  -> SValue r
  -> MS (r stmt)
openFileW :: forall (r :: * -> *) stmt.
(AssignStatement r stmt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
openFileW SValue r -> VS (r TypeData) -> SValue r -> SValue r
f SVariable r
vr SValue r
vl = SVariable r
vr SVariable r -> SValue r -> MS (r stmt)
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= SValue r -> VS (r TypeData) -> SValue r -> SValue r
f SValue r
vl VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
outfile SValue r
forall (r :: * -> *). Literal r => SValue r
IC.litFalse

stateVar
  :: (Monad r, OORenderSym r vis stmt mthd stvr attch file mod bod block)
  => r vis -> r attch -> SVariable r -> CS (r Doc)
stateVar :: forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(Monad r,
 OORenderSym r vis stmt mthd stvr attch file mod bod block) =>
r vis -> r attch -> SVariable r -> CS (r Doc)
stateVar r vis
s r attch
p SVariable r
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
$ SVariable r -> r ScopeData -> State MethodState (r stmt)
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> MS (r stmt)
IC.varDec SVariable r
v r ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
IC.local)

-- Python and Swift --

self :: (OOTypeSym r, RenderVariable r) => SVariable r
self :: forall (r :: * -> *).
(OOTypeSym r, RenderVariable r) =>
SVariable r
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 Variable))
-> StateT ValueState Identity (r Variable)
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 TypeData)
-> Doc
-> StateT ValueState Identity (r Variable)
forall (r :: * -> *).
RenderVariable r =>
String -> VS (r TypeData) -> Doc -> SVariable r
mkStateVar String
R.self (String -> VS (r TypeData)
forall (r :: * -> *). OOTypeSym r => String -> VS (r TypeData)
obj String
l)
  Doc
R.self')

multiAssign
  :: ( IC.AssignStatement r stmt
     , InternalVarElim r
     , RC.RenderValue r
     , RC.RenderVariable r
     , RC.ValueElim r
     )
  => (Doc -> Doc) -> [SVariable r] -> [SValue r] -> MS (r stmt)
multiAssign :: forall (r :: * -> *) stmt.
(AssignStatement r stmt, InternalVarElim r, RenderValue r,
 RenderVariable r, ValueElim r) =>
(Doc -> Doc) -> [SVariable r] -> [SValue r] -> MS (r stmt)
multiAssign Doc -> Doc
_ [] [SValue r]
_ = String -> MS (r stmt)
forall a. HasCallStack => String -> a
error String
"Attempt to write assign statement for no variables."
multiAssign Doc -> Doc
_ [SVariable r]
_ [] = String -> MS (r stmt)
forall a. HasCallStack => String -> a
error String
"Attempt to write assign statement with no values."
multiAssign Doc -> Doc
f [SVariable r]
vars [SValue r]
vals = if [SValue r] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SValue r]
vals Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
1 Bool -> Bool -> Bool
&& [SVariable r] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SVariable r]
vars Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= [SValue r] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [SValue r]
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. [a] -> [a] -> [a]
++
    String
"of variables than values"
  else do
  vrs <- (SVariable r -> StateT MethodState Identity (r Variable))
-> [SVariable r] -> StateT MethodState Identity [r Variable]
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 Variable))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Variable) ValueState)
-> MethodState -> Focusing Identity (r Variable) MethodState
Lens' MethodState ValueState
lensMStoVS) [SVariable r]
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
  :: (IC.ControlStatement r stmt bod, RC.RenderValue r, RC.ValueElim r)
  => (Doc -> Doc) -> [SValue r] -> MS (r stmt)
multiReturn :: forall (r :: * -> *) stmt bod.
(ControlStatement r stmt bod, RenderValue r, ValueElim r) =>
(Doc -> Doc) -> [SValue r] -> 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
_ [SValue r
v] = SValue r -> MS (r stmt)
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt SValue r
v
multiReturn Doc -> Doc
f [SValue r]
vs = do
  vs' <- (SValue r -> StateT MethodState Identity (r Value))
-> [SValue r] -> StateT MethodState Identity [r Value]
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 Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS) [SValue r]
vs
  returnStmt $ mkStateVal IC.void $ f $ valueList vs'

listDec
  :: (IC.DeclStatement r stmt bod, IC.Literal r, VariableElim r)
  => SVariable r -> r ScopeData -> MS (r stmt)
listDec :: forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> MS (r stmt)
listDec SVariable r
v r ScopeData
scp = SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
listDecDef SVariable r
v r ScopeData
scp []

funcDecDef
  :: (OORenderSym r vis stmt mthd stvr attch file mod bod block)
  => SVariable r -> r ScopeData -> [SVariable r] -> MS (r bod) -> MS (r stmt)
funcDecDef :: forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
SVariable r
-> r ScopeData -> [SVariable r] -> MS (r bod) -> MS (r stmt)
funcDecDef SVariable r
v r ScopeData
scp [SVariable r]
ps MS (r bod)
b = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Variable) ValueState)
-> MethodState -> Focusing Identity (r Variable) MethodState
Lens' MethodState ValueState
lensMStoVS SVariable r
v
  modify $ useVarName $ variableName vr
  modify $ setVarScope (variableName vr) (scopeData scp)
  s <- get
  f <- function (variableName vr) private (return $ variableType vr)
    (map IC.param ps) b
  modify (L.set currParameters (s ^. currParameters))
  mkStmtNoEnd $ RC.method f

inOutCall
  :: (RC.InternalAssignStmt r stmt, ValueStatement r stmt, IC.VariableValue r)
  => (Label -> VS (r TypeData) -> [SValue r] -> SValue r)
  -> Label
  -> [SValue r]
  -> [SVariable r]
  -> [SVariable r]
  -> MS (r stmt)
inOutCall :: forall (r :: * -> *) stmt.
(InternalAssignStmt r stmt, ValueStatement r stmt,
 VariableValue r) =>
(String -> VS (r TypeData) -> [SValue r] -> SValue r)
-> String
-> [SValue r]
-> [SVariable r]
-> [SVariable r]
-> MS (r stmt)
inOutCall String -> VS (r TypeData) -> [SValue r] -> SValue r
f String
n [SValue r]
ins [] [] = SValue r -> MS (r stmt)
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
IC.valStmt (SValue r -> MS (r stmt)) -> SValue r -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ String -> VS (r TypeData) -> [SValue r] -> SValue r
f String
n VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.void [SValue r]
ins
inOutCall String -> VS (r TypeData) -> [SValue r] -> SValue r
f String
n [SValue r]
ins [SVariable r]
outs [SVariable r]
both = [SVariable r] -> [SValue r] -> MS (r stmt)
forall (r :: * -> *) stmt.
InternalAssignStmt r stmt =>
[SVariable r] -> [SValue r] -> MS (r stmt)
RC.multiAssign [SVariable r]
rets [String -> VS (r TypeData) -> [SValue r] -> SValue r
f String
n VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.void ((SVariable r -> SValue r) -> [SVariable r] -> [SValue r]
forall a b. (a -> b) -> [a] -> [b]
map SVariable r -> SValue r
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
IC.valueOf
  [SVariable r]
both [SValue r] -> [SValue r] -> [SValue r]
forall a. [a] -> [a] -> [a]
++ [SValue r]
ins)]
  where rets :: [SVariable r]
rets = [SVariable r]
both [SVariable r] -> [SVariable r] -> [SVariable r]
forall a. [a] -> [a] -> [a]
++ [SVariable r]
outs

forLoopError :: String -> String
forLoopError :: String -> String
forLoopError String
l = String
"Classic for loops not available in " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
l String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
", use " String -> String -> String
forall a. [a] -> [a] -> [a]
++
  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
     , IC.ParameterSym r
     , IC.DeclStatement r stmt bod
     , BlockSym r block stmt
     , IC.BodySym r bod block
     , VariableElim r
     , RenderBody r bod
     , RenderType r
     , RC.InternalControlStmt r stmt
     )
  => (VS (r TypeData) -> [MS (r ParamData)] -> MS (r bod) -> MS (r mthd))
  -> [SVariable r]
  -> [SVariable r]
  -> [SVariable r]
  -> MS (r bod)
  -> MS (r mthd)
inOutFunc :: forall (r :: * -> *) stmt bod block mthd.
(VariableValue r, ParameterSym r, DeclStatement r stmt bod,
 BlockSym r block stmt, BodySym r bod block, VariableElim r,
 RenderBody r bod, RenderType r, InternalControlStmt r stmt) =>
(VS (r TypeData)
 -> [MS (r ParamData)] -> MS (r bod) -> MS (r mthd))
-> [SVariable r]
-> [SVariable r]
-> [SVariable r]
-> MS (r bod)
-> MS (r mthd)
inOutFunc VS (r TypeData) -> [MS (r ParamData)] -> MS (r bod) -> MS (r mthd)
f [SVariable r]
ins [] [] MS (r bod)
b = VS (r TypeData) -> [MS (r ParamData)] -> MS (r bod) -> MS (r mthd)
f VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.void ((SVariable r -> MS (r ParamData))
-> [SVariable r] -> [MS (r ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable r -> MS (r ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
IC.param [SVariable r]
ins) MS (r bod)
b
inOutFunc VS (r TypeData) -> [MS (r ParamData)] -> MS (r bod) -> MS (r mthd)
f [SVariable r]
ins [SVariable r]
outs [SVariable r]
both MS (r bod)
b = VS (r TypeData) -> [MS (r ParamData)] -> MS (r bod) -> MS (r mthd)
f
  ([VS (r TypeData)] -> VS (r TypeData)
forall (r :: * -> *).
RenderType r =>
[VS (r TypeData)] -> VS (r TypeData)
multiType ([VS (r TypeData)] -> VS (r TypeData))
-> [VS (r TypeData)] -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ (SVariable r -> VS (r TypeData))
-> [SVariable r] -> [VS (r TypeData)]
forall a b. (a -> b) -> [a] -> [b]
map ((r Variable -> r TypeData) -> SVariable r -> VS (r TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r Variable -> r TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType) [SVariable r]
rets)
  ((SVariable r -> MS (r ParamData))
-> [SVariable r] -> [MS (r ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable r -> MS (r ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
IC.pointerParam [SVariable r]
both [MS (r ParamData)] -> [MS (r ParamData)] -> [MS (r ParamData)]
forall a. [a] -> [a] -> [a]
++ (SVariable r -> MS (r ParamData))
-> [SVariable r] -> [MS (r ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable r -> MS (r ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
IC.param [SVariable r]
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
$ (SVariable r -> MS (r stmt)) -> [SVariable r] -> [MS (r stmt)]
forall a b. (a -> b) -> [a] -> [b]
map (SVariable r -> r ScopeData -> MS (r stmt)
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> MS (r stmt)
`IC.varDec` r ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
IC.local) [SVariable r]
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
$ [SValue r] -> MS (r stmt)
forall (r :: * -> *) stmt.
InternalControlStmt r stmt =>
[SValue r] -> MS (r stmt)
RC.multiReturn ([SValue r] -> MS (r stmt)) -> [SValue r] -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ (SVariable r -> SValue r) -> [SVariable r] -> [SValue r]
forall a b. (a -> b) -> [a] -> [b]
map SVariable r -> SValue r
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
IC.valueOf [SVariable r]
rets])
  where rets :: [SVariable r]
rets = [SVariable r]
both [SVariable r] -> [SVariable r] -> [SVariable r]
forall a. [a] -> [a] -> [a]
++ [SVariable r]
outs

docInOutFunc'
  :: (RenderMethod r mthd)
  => FuncDocRenderer
  -> ([SVariable r] -> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd))
  -> String
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> MS (r bod) -> MS (r mthd)
docInOutFunc' :: forall (r :: * -> *) mthd bod.
RenderMethod r mthd =>
FuncDocRenderer
-> ([SVariable r]
    -> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r bod)
-> MS (r mthd)
docInOutFunc' FuncDocRenderer
dfr [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)]
os [(String, SVariable r)]
bs MS (r bod)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r mthd) -> MS (r mthd)
docFuncRepr FuncDocRenderer
dfr String
desc (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst ([(String, SVariable r)] -> [String])
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> a -> b
$ [(String, SVariable r)]
bs [(String, SVariable r)]
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. [a] -> [a] -> [a]
++ [(String, SVariable r)]
is)
  (((String, SVariable r) -> String)
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> String
forall a b. (a, b) -> a
fst ([(String, SVariable r)] -> [String])
-> [(String, SVariable r)] -> [String]
forall a b. (a -> b) -> a -> b
$ [(String, SVariable r)]
bs [(String, SVariable r)]
-> [(String, SVariable r)] -> [(String, SVariable r)]
forall a. [a] -> [a] -> [a]
++ [(String, SVariable r)]
os) ([SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd)
f (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
is) (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
os) (((String, SVariable r) -> SVariable r)
-> [(String, SVariable r)] -> [SVariable r]
forall a b. (a -> b) -> [a] -> [b]
map (String, SVariable r) -> SVariable r
forall a b. (a, b) -> b
snd [(String, SVariable r)]
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. [a] -> [a] -> [a]
++
      [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. [a] -> [a] -> [a]
++
      [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. [a] -> [a] -> [a]
++
      [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. [a] -> [a] -> [a]
++ String
ty String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
docCommandSep String -> String -> String
forall a. [a] -> [a] -> [a]
++ 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. [a] -> [a] -> [a]
++ ((String, String) -> String) -> [(String, String)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map (\(String
v, String
vDesc) -> String
docCommandInit String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
paramDoc String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" " String -> String -> String
forall a. [a] -> [a] -> [a]
++
    String
v String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
docCommandSep String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
vDesc) [(String, String)]
params
  [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ((String
docCommandInit String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
returnDoc String -> String -> String
forall a. [a] -> [a] -> [a]
++ 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'
  :: (IC.Literal r, IC.ValueExpression r) => SValue r -> SValue r
openFileR' :: forall (r :: * -> *).
(Literal r, ValueExpression r) =>
SValue r -> SValue r
openFileR' SValue r
n = PosCall r
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
fileOpen VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
infile [SValue r
n, String -> SValue r
forall (r :: * -> *). Literal r => String -> SValue r
IC.litString String
fileR]
openFileW' :: forall (r :: * -> *).
(Literal r, ValueExpression r) =>
SValue r -> SValue r
openFileW' SValue r
n = PosCall r
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
fileOpen VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
infile [SValue r
n, String -> SValue r
forall (r :: * -> *). Literal r => String -> SValue r
IC.litString String
fileW]
openFileA' :: forall (r :: * -> *).
(Literal r, ValueExpression r) =>
SValue r -> SValue r
openFileA' SValue r
n = PosCall r
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp String
fileOpen VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
infile [SValue r
n, String -> SValue r
forall (r :: * -> *). Literal r => String -> SValue r
IC.litString String
fileA]

argExists
  :: (IC.Literal r, IC.CommandLineArgs r, Comparison r, IC.List r)
  => Integer -> SValue r
argExists :: forall (r :: * -> *).
(Literal r, CommandLineArgs r, Comparison r, List r) =>
Integer -> SValue r
argExists Integer
i = SValue r -> SValue r
forall (r :: * -> *). List r => SValue r -> SValue r
listSize SValue r
forall (r :: * -> *). CommandLineArgs r => SValue r
IC.argsList SValue r -> SValue r -> SValue r
forall (r :: * -> *).
Comparison r =>
SValue r -> SValue r -> SValue r
?> Integer -> SValue r
forall (r :: * -> *). Literal r => Integer -> SValue r
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
     , IC.IndexTranslator r
     , RC.RenderVariable r
     , RC.ValueElim r
     )
  => SValue r -> SValue r -> SValue r -> MS (r stmt)
listSet :: forall (r :: * -> *) stmt.
(AssignStatement r stmt, IndexTranslator r, RenderVariable r,
 ValueElim r) =>
SValue r -> SValue r -> SValue r -> MS (r stmt)
listSet SValue r
list SValue r
idx SValue r
val = do
  list' <- LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
list
  idx' <- zoom lensMStoVS (IC.intToIndex idx)
  let listAccessVar = String -> r TypeData -> Doc -> SVariable r
forall (r :: * -> *).
RenderVariable r =>
String -> r TypeData -> Doc -> SVariable r
mkVar (Doc -> String
render (Doc -> String) -> Doc -> String
forall a b. (a -> b) -> a -> b
$ r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
list') (r Value -> r TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType r Value
list')
                        (r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
list' Doc -> Doc -> Doc
<> Doc -> Doc
brackets (r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
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'
  :: (IC.Literal r, IC.NumericExpression r, RC.RenderValue r, RC.ValueElim r)
  => SValue r -> SValue r
intToIndex' :: forall (r :: * -> *).
(Literal r, NumericExpression r, RenderValue r, ValueElim r) =>
SValue r -> SValue r
intToIndex' SValue r
v = SValue r
v SValue r -> SValue r -> SValue r
forall (r :: * -> *).
(Literal r, NumericExpression r, RenderValue r, ValueElim r) =>
SValue r -> SValue r -> SValue r
`smartAdd` Integer -> SValue r
forall (r :: * -> *). Literal r => Integer -> SValue r
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'
  :: (IC.Literal r, IC.NumericExpression r, RC.RenderValue r, RC.ValueElim r)
  => SValue r -> SValue r
indexToInt' :: forall (r :: * -> *).
(Literal r, NumericExpression r, RenderValue r, ValueElim r) =>
SValue r -> SValue r
indexToInt' SValue r
v = SValue r
v SValue r -> SValue r -> SValue r
forall (r :: * -> *).
(Literal r, NumericExpression r, RenderValue r, ValueElim r) =>
SValue r -> SValue r -> SValue r
`smartSub` Integer -> SValue r
forall (r :: * -> *). Literal r => Integer -> SValue r
IC.litInt Integer
1