{-# LANGUAGE FlexibleContexts #-}

-- | 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, Body, SVariable, Value,
  SValue, MixedCall, bodyStatements, oneLiner,
  TypeSym(infile, outfile, innerType), TypeElim(..), getCodeType, getTypeString,
  VariableElim(variableName, variableType), ValueSym(valueType), Comparison(..),
  (&=), ControlStatement(returnStmt), VisibilitySym(..),
  MethodSym(function), funcApp, listSize)
import qualified Drasil.Shared.InterfaceCommon as IC
import Drasil.GOOL.InterfaceGOOL (File, Module, Class, CSStateVar,
  OOTypeSym(obj), AttachmentSym(..), Initializers, objMethodCallNoParams,
  objMethodCall, OOStatement)
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 smt md svr att, OOStatement r smt)
  => Label -> [MS (r ParamData)] -> Initializers r -> MS (r Body) -> MS (r md)
constructor :: forall (r :: * -> *) vis smt md svr att.
(OORenderSym r vis smt md svr att, OOStatement r smt) =>
String
-> [MS (r ParamData)] -> Initializers r -> MS (r Doc) -> MS (r md)
constructor String
fName [MS (r ParamData)]
ps Initializers r
is MS (r Doc)
b = MS String
getClassName MS String
-> (String -> StateT MethodState Identity (r md))
-> StateT MethodState Identity (r md)
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 att
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r Doc)
-> StateT MethodState Identity (r md)
forall (r :: * -> *) vis md att.
OORenderMethod r vis md att =>
Bool
-> String
-> r vis
-> r att
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r Doc)
-> MS (r md)
intMethod Bool
False String
fName
  r vis
forall (r :: * -> *) vis. VisibilitySym r vis => r vis
public r att
forall (r :: * -> *) att. AttachmentSym r att => r att
instanceLevel (String -> MSMthdType r
forall (r :: * -> *). OOMethodTypeSym r => String -> MSMthdType r
RG.construct String
c) [MS (r ParamData)]
ps ([MS (r Doc)] -> MS (r Doc)
forall (r :: * -> *). RenderBody r => [MS (r Doc)] -> MS (r Doc)
RC.multiBody [Initializers r -> MS (r Doc)
forall (r :: * -> *) smt.
OOStatement r smt =>
Initializers r -> MS (r Doc)
initStmts Initializers r
is, MS (r Doc)
b]))

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

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

doxMod :: (RG.RenderFile r) => String -> String -> String -> [String] ->
  String -> FS (r File) -> FS (r File)
doxMod :: forall (r :: * -> *).
RenderFile r =>
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 :: * -> *).
RenderFile r =>
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
  r TypeData
c <- VS (r TypeData)
c'
  r Variable
v <- SVariable r
v'
  r Variable
vr <- AttachmentTag -> String -> VS (r TypeData) -> Doc -> SVariable r
forall (r :: * -> *).
RenderVariable r =>
AttachmentTag -> String -> VS (r TypeData) -> Doc -> SVariable r
varFromData
    (r Variable -> AttachmentTag
forall (r :: * -> *).
InternalVarElim r =>
r Variable -> AttachmentTag
variableBind r Variable
v) (r TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString r TypeData
c String -> String -> String
`access` r Variable -> String
forall (r :: * -> *). VariableElim r => r Variable -> String
variableName r Variable
v)
    (r TypeData -> VS (r TypeData)
forall a s. a -> State s a
toState (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
v) (Doc -> Doc -> Doc
f (r TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType r TypeData
c) (r Variable -> Doc
forall (r :: * -> *). InternalVarElim r => r Variable -> Doc
RC.variable r Variable
v))
  r Variable -> SVariable r
forall a s. a -> State s a
toState (r Variable -> SVariable r) -> r Variable -> SVariable r
forall a b. (a -> b) -> a -> b
$ r Variable -> r Variable
forall (r :: * -> *). InternalVarElim r => r Variable -> r Variable
classVarAccessCheck r Variable
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, IC.StatementSym r smt)
  => Label -> SValue r -> MS (r smt)
discardFileLine :: forall (r :: * -> *) smt.
(InternalValueExp r, StatementSym r smt) =>
String -> SValue r -> MS (r smt)
discardFileLine String
n SValue r
f = SValue r -> MS (r smt)
forall (r :: * -> *) smt.
StatementSym r smt =>
SValue r -> MS (r smt)
IC.valStmt (SValue r -> MS (r smt)) -> SValue r -> MS (r smt)
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 md, Monad r, RG.StateVarElim r svr, RC.VisibilityElim r vis)
  => (Label -> Doc -> Doc -> Doc -> Doc -> Doc)
  -> Label
  -> r vis
  -> r ParentSpec
  -> [CSStateVar r svr]
  -> [MS (r md)]
  -> [MS (r md)]
  -> CS (r Doc)
intClass :: forall (r :: * -> *) md svr vis.
(MethodElim r md, Monad r, StateVarElim r svr,
 VisibilityElim r vis) =>
(String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> r vis
-> r Doc
-> [CSStateVar r svr]
-> [MS (r md)]
-> [MS (r md)]
-> CS (r Doc)
intClass String -> Doc -> Doc -> Doc -> Doc -> Doc
f String
n r vis
s r Doc
i [CSStateVar r svr]
svrs [MS (r md)]
cstrs [MS (r md)]
mths = do
  (ClassState -> ClassState) -> StateT ClassState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ClassState -> ClassState
setClassName String
n)
  Doc
svs <- ([r svr] -> Doc) -> [CSStateVar r svr] -> State ClassState Doc
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList ([Doc] -> Doc
R.stateVarList ([Doc] -> Doc) -> ([r svr] -> [Doc]) -> [r svr] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r svr -> Doc) -> [r svr] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map r svr -> Doc
forall (r :: * -> *) svr. StateVarElim r svr => r svr -> Doc
RG.stateVar) [CSStateVar r svr]
svrs
  Doc
ms <- ([r md] -> Doc)
-> [State ClassState (r md)] -> State ClassState Doc
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList ([Doc] -> Doc
vibcat ([Doc] -> Doc) -> ([r md] -> [Doc]) -> [r md] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r md -> Doc) -> [r md] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map r md -> Doc
forall (r :: * -> *) md. MethodElim r md => r md -> Doc
RC.method) ((MS (r md) -> State ClassState (r md))
-> [MS (r md)] -> [State ClassState (r md)]
forall a b. (a -> b) -> [a] -> [b]
map (LensLike'
  (Zoomed (StateT MethodState Identity) (r md))
  ClassState
  MethodState
-> MS (r md) -> State ClassState (r md)
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 md))
  ClassState
  MethodState
(MethodState -> Focusing Identity (r md) MethodState)
-> ClassState -> Focusing Identity (r md) ClassState
Lens' ClassState MethodState
lensCStoMS) ([MS (r md)]
cstrs [MS (r md)] -> [MS (r md)] -> [MS (r md)]
forall a. [a] -> [a] -> [a]
++ [MS (r md)]
mths))
  r Doc -> CS (r Doc)
forall a. a -> StateT ClassState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (r Doc -> CS (r Doc)) -> r Doc -> CS (r Doc)
forall a b. (a -> b) -> a -> b
$ (Doc -> Doc) -> r Doc -> r Doc
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (\Doc
p -> String -> Doc -> Doc -> Doc -> Doc -> Doc
f String
n Doc
p (r vis -> Doc
forall (r :: * -> *) vis. VisibilityElim r vis => r vis -> Doc
RC.visibility r vis
s) Doc
svs Doc
ms) r Doc
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 md, RG.RenderMod r)
  => Label -> FS Doc -> FS Doc -> FS Doc -> [MS (r md)] -> [CS (r Class)] -> FS (r Module)
buildModule :: forall (r :: * -> *) md.
(ClassElim r, MethodElim r md, RenderMod r) =>
String
-> FS Doc
-> FS Doc
-> FS Doc
-> [MS (r md)]
-> [CS (r Doc)]
-> FS (r Module)
buildModule String
n FS Doc
imps FS Doc
topDoc FS Doc
bot [MS (r md)]
fs [CS (r Doc)]
cs = String -> FS Doc -> FS (r Module)
forall (r :: * -> *).
RenderMod r =>
String -> FS Doc -> FS (r Module)
RG.modFromData String
n (do
  [r Doc]
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
  [r md]
fns <- (MS (r md) -> StateT FileState Identity (r md))
-> [MS (r md)] -> StateT FileState Identity [r md]
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 MethodState Identity) (r md)) FileState MethodState
-> MS (r md) -> StateT FileState Identity (r md)
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) FileState MethodState
-> StateT MethodState 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 MethodState Identity) (r md)) FileState MethodState
(MethodState -> Focusing Identity (r md) MethodState)
-> FileState -> Focusing Identity (r md) FileState
Lens' FileState MethodState
lensFStoMS) [MS (r md)]
fs
  Doc
is <- FS Doc
imps
  Doc
tp <- FS Doc
topDoc
  Doc
bt <- FS Doc
bot
  Doc -> FS Doc
forall a. a -> StateT FileState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Doc -> FS Doc) -> Doc -> FS Doc
forall a b. (a -> b) -> a -> b
$ Doc -> Doc -> Doc -> Doc
R.module' Doc
is ([Doc] -> Doc
vibcat (Doc
tp Doc -> [Doc] -> [Doc]
forall a. a -> [a] -> [a]
: (r Doc -> Doc) -> [r Doc] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map r Doc -> Doc
forall (r :: * -> *). ClassElim r => r Doc -> Doc
RG.class' [r Doc]
cls))
    ([Doc] -> Doc
vibcat ((r md -> Doc) -> [r md] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map r md -> Doc
forall (r :: * -> *) md. MethodElim r md => r md -> Doc
RC.method [r md]
fns [Doc] -> [Doc] -> [Doc]
forall a. [a] -> [a] -> [a]
++ [Doc
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
  r TypeData
t <- VS (r TypeData)
t'
  CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData (CodeType -> CodeType
Array (r TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType r TypeData
t))
    (r TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString r TypeData
t String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
array) (r TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType r TypeData
t Doc -> Doc -> Doc
<> Doc -> Doc
brackets Doc
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 smt, RC.ValueElim r)
  => SValue r -> SValue r -> MS (r smt)
printSt :: forall (r :: * -> *) smt.
(RenderStatement r smt, ValueElim r) =>
SValue r -> SValue r -> MS (r smt)
printSt SValue r
va' SValue r
vb' = do
  r Value
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'
  r Value
vb <- 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
vb'
  Doc -> MS (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
Doc -> MS (r smt)
mkStmt (r Value -> r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> r Value -> Doc
R.print r Value
va r Value
vb)

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

arrayDecDef
  :: ( IC.DeclStatement r smt
     , RC.RenderStatement r smt
     , RC.StatementElim r smt
     , RC.ValueElim r
     )
  => SVariable r -> r ScopeData -> [SValue r] -> MS (r smt)
arrayDecDef :: forall (r :: * -> *) smt.
(DeclStatement r smt, RenderStatement r smt, StatementElim r smt,
 ValueElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r smt)
arrayDecDef SVariable r
v' r ScopeData
scp [SValue r]
vals' = do
  [r Value]
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'
  r smt
vd <- SVariable r -> r ScopeData -> MS (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> MS (r smt)
IC.varDec SVariable r
v' r ScopeData
scp
  Doc -> MS (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
Doc -> MS (r smt)
mkStmt (r smt -> Doc
forall (r :: * -> *) smt. StatementElim r smt => r smt -> Doc
RC.statement r smt
vd Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+> Doc -> Doc
braces ([r Value] -> Doc
forall (r :: * -> *). ValueElim r => [r Value] -> Doc
valueList [r Value]
vs))

openFileA
  :: (IC.AssignStatement r smt, IC.Literal r)
  => (SValue r -> VS (r TypeData) -> SValue r -> SValue r)
  -> SVariable r
  -> SValue r
  -> MS (r smt)
openFileA :: forall (r :: * -> *) smt.
(AssignStatement r smt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r smt)
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 smt)
forall (r :: * -> *) smt.
AssignStatement r smt =>
SVariable r -> SValue r -> MS (r smt)
&= 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
     , InternalVarElim r
     , RC.RenderStatement r smt
     , UnRepr r TypeData
     , RC.ValueElim r
     , VariableElim r
     )
  => Doc -> Doc -> Doc -> Doc -> SVariable r -> SValue r -> MS (r Body) -> MS (r smt)
forEach :: forall (r :: * -> *) smt.
(BodyElim r, InternalVarElim r, RenderStatement r smt,
 UnRepr r TypeData, ValueElim r, VariableElim r) =>
Doc
-> Doc
-> Doc
-> Doc
-> SVariable r
-> SValue r
-> MS (r Doc)
-> MS (r smt)
forEach Doc
bStart Doc
bEnd Doc
forEachLabel Doc
inLbl SVariable r
e' SValue r
v' MS (r Doc)
b' = do
  r Variable
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'
  r Value
v <- 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
v'
  r Doc
b <- MS (r Doc)
b'
  Doc -> MS (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
Doc -> MS (r smt)
mkStmtNoEnd (Doc -> MS (r smt)) -> Doc -> MS (r smt)
forall a b. (a -> b) -> a -> b
$ [Doc] -> Doc
vcat [
    Doc
forEachLabel Doc -> Doc -> Doc
<+> Doc -> Doc
parens (r TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType (r Variable -> r TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType r Variable
e) Doc -> Doc -> Doc
<+> r Variable -> Doc
forall (r :: * -> *). InternalVarElim r => r Variable -> Doc
RC.variable r Variable
e Doc -> Doc -> Doc
<+>
      Doc
inLbl Doc -> Doc -> Doc
<+> r Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value r Value
v) Doc -> Doc -> Doc
<+> Doc
bStart,
    Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r Doc -> Doc
forall (r :: * -> *). BodyElim r => r Doc -> Doc
RC.body r Doc
b,
    Doc
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 smt md svr att) => MS (r Body) -> MS (r md)
docMain :: forall (r :: * -> *) vis smt md svr att.
OORenderSym r vis smt md svr att =>
MS (r Doc) -> MS (r md)
docMain MS (r Doc)
b = MS (r Doc) -> MS (r md) -> MS (r md)
forall (r :: * -> *) md.
RenderMethod r md =>
MS (r Doc) -> MS (r md) -> MS (r md)
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 Doc) -> MS (r md)
forall (r :: * -> *) vis smt md.
MethodSym r vis smt md =>
MS (r Doc) -> MS (r md)
IC.mainFunction MS (r Doc)
b)

mainFunction
  :: ( AttachmentSym r att
     , OORenderMethod r vis md att
     , IC.ParameterSym r
     , UnRepr r TypeData
     , Monad r
     , VisibilitySym r vis
     )
  => VS (r TypeData) -> Label -> MS (r Body) -> MS (r md)
mainFunction :: forall (r :: * -> *) att vis md.
(AttachmentSym r att, OORenderMethod r vis md att, ParameterSym r,
 UnRepr r TypeData, Monad r, VisibilitySym r vis) =>
VS (r TypeData) -> String -> MS (r Doc) -> MS (r md)
mainFunction VS (r TypeData)
s String
n = Bool
-> String
-> r vis
-> r att
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r Doc)
-> MS (r md)
forall (r :: * -> *) vis md att.
OORenderMethod r vis md att =>
Bool
-> String
-> r vis
-> r att
-> MSMthdType r
-> [MS (r ParamData)]
-> MS (r Doc)
-> MS (r md)
RG.intFunc Bool
True String
n r vis
forall (r :: * -> *) vis. VisibilitySym r vis => r vis
public r att
forall (r :: * -> *) att. AttachmentSym r att => r att
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 smt md svr att, UnRepr r Doc)
  => Label
  -> (String -> r Doc)
  -> [Label]
  -> [MS (r md)]
  -> [CS (r Class)]
  -> FS (r Module)
buildModule' :: forall (r :: * -> *) vis smt md svr att.
(OORenderSym r vis smt md svr att, UnRepr r Doc) =>
String
-> (String -> r Doc)
-> [String]
-> [MS (r md)]
-> [CS (r Doc)]
-> FS (r Module)
buildModule' String
n String -> r Doc
inc [String]
is [MS (r md)]
ms [CS (r Doc)]
cs = String -> FS Doc -> FS (r Module)
forall (r :: * -> *).
RenderMod r =>
String -> FS Doc -> FS (r Module)
RG.modFromData String
n (do
  [r Doc]
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 md)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [MS (r md)]
ms then [CS (r Doc)]
cs else Maybe String
-> [CSStateVar r svr] -> [MS (r md)] -> [MS (r md)] -> CS (r Doc)
forall (r :: * -> *) vis smt md svr att.
ClassSym r vis smt md svr att =>
Maybe String
-> [CSStateVar r svr] -> [MS (r md)] -> [MS (r md)] -> CS (r Doc)
IG.buildClass Maybe String
forall a. Maybe a
Nothing [] [] [MS (r md)]
ms CS (r Doc) -> [CS (r Doc)] -> [CS (r Doc)]
forall a. a -> [a] -> [a]
: [CS (r Doc)]
cs)
  [String]
lis <- FS [String]
getLangImports
  [String]
libis <- FS [String]
getLibImports
  [String]
mis <- FS [String]
getModuleImports
  Doc -> FS Doc
forall a. a -> StateT FileState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (Doc -> FS Doc) -> Doc -> FS Doc
forall a b. (a -> b) -> a -> b
$ [Doc] -> Doc
vibcat [
    [Doc] -> Doc
vcat ((String -> Doc) -> [String] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map (r Doc -> Doc
forall (r :: * -> *). UnRepr r Doc => r Doc -> Doc
RC.import' (r Doc -> Doc) -> (String -> r Doc) -> String -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> r Doc
inc) ([String]
lis [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String] -> [String]
forall a. Ord a => [a] -> [a]
sort ([String]
is [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
libis) [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
mis)),
    [Doc] -> Doc
vibcat ((r Doc -> Doc) -> [r Doc] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map r Doc -> Doc
forall (r :: * -> *). ClassElim r => r Doc -> Doc
RG.class' [r Doc]
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 md)
  => ([SVariable r] -> [SVariable r] -> [SVariable r] -> MS (r Body) -> MS (r md))
  -> String
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> MS (r Body)
  -> MS (r md)
docInOutFunc :: forall (r :: * -> *) md.
RenderMethod r md =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r md))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r Doc)
-> MS (r md)
docInOutFunc [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r md)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)
o] [] MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
forall (r :: * -> *) md.
RenderMethod r md =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
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 Doc) -> MS (r md)
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 Doc)
b)
docInOutFunc [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r md)
f String
desc [(String, SVariable r)]
is [] [(String, SVariable r)
both] MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
forall (r :: * -> *) md.
RenderMethod r md =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
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 Doc) -> MS (r md)
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 Doc)
b)
docInOutFunc [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r md)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)]
os [(String, SVariable r)]
bs MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
forall (r :: * -> *) md.
RenderMethod r md =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
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 Doc) -> MS (r md)
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 Doc)
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 smt, IC.Literal r, VariableElim r)
  => SVariable r -> r ScopeData -> [SValue r] -> MS (r smt)
listDecDef :: forall (r :: * -> *) smt.
(DeclStatement r smt, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r smt)
listDecDef SVariable r
v r ScopeData
scp [SValue r]
vals = do
  r Variable
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 :: SValue r
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
  SVariable r -> r ScopeData -> SValue r -> MS (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> SValue r -> MS (r smt)
IC.varDecDef (r Variable -> SVariable r
forall a. a -> StateT ValueState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return r Variable
vr) r ScopeData
scp SValue r
lst

setDecDef
  :: (IC.DeclStatement r smt, IC.Literal r, VariableElim r)
  => SVariable r -> r ScopeData -> [SValue r] -> MS (r smt)
setDecDef :: forall (r :: * -> *) smt.
(DeclStatement r smt, Literal r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r smt)
setDecDef SVariable r
v r ScopeData
scp [SValue r]
vals = do
  r Variable
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 :: SValue r
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
  SVariable r -> r ScopeData -> SValue r -> MS (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> SValue r -> MS (r smt)
IC.varDecDef (r Variable -> SVariable r
forall a. a -> StateT ValueState Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return r Variable
vr) r ScopeData
scp SValue r
st

setDec
  :: (IC.DeclStatement r smt, RC.RenderStatement r smt, RC.StatementElim r smt)
  => (r Value -> Doc) -> SValue r -> SVariable r -> r ScopeData -> MS (r smt)
setDec :: forall (r :: * -> *) smt.
(DeclStatement r smt, RenderStatement r smt,
 StatementElim r smt) =>
(r Value -> Doc)
-> SValue r -> SVariable r -> r ScopeData -> MS (r smt)
setDec r Value -> Doc
f SValue r
vl SVariable r
v r ScopeData
scp = do
  r Value
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
  r smt
vd <- SVariable r -> r ScopeData -> MS (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> MS (r smt)
IC.varDec SVariable r
v r ScopeData
scp
  Doc -> MS (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
Doc -> MS (r smt)
mkStmt (r smt -> Doc
forall (r :: * -> *) smt. StatementElim r smt => r smt -> Doc
RC.statement r smt
vd Doc -> Doc -> Doc
<> r Value -> Doc
f r Value
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 smt md svr att, Monad r)
  => r vis -> r att -> SVariable r -> SValue r -> CS (r Doc)
stateVarDef :: forall (r :: * -> *) vis smt md svr att.
(OORenderSym r vis smt md svr att, Monad r) =>
r vis -> r att -> SVariable r -> SValue r -> CS (r Doc)
stateVarDef r vis
s r att
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 smt -> r Doc)
-> State MethodState (r smt) -> 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 smt -> Doc) -> r smt -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc -> Doc -> Doc
R.stateVar
  (r vis -> Doc
forall (r :: * -> *) vis. VisibilityElim r vis => r vis -> Doc
RC.visibility  r vis
s) (r att -> Doc
forall (r :: * -> *) att. PermElim r att => r att -> Doc
RG.perm r att
p) (Doc -> Doc) -> (r smt -> Doc) -> r smt -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r smt -> Doc
forall (r :: * -> *) smt. StatementElim r smt => r smt -> Doc
RC.statement)
  (State MethodState (r smt) -> State MethodState (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
MS (r smt) -> MS (r smt)
RC.stmt (State MethodState (r smt) -> State MethodState (r smt))
-> State MethodState (r smt) -> State MethodState (r smt)
forall a b. (a -> b) -> a -> b
$ SVariable r -> r ScopeData -> SValue r -> State MethodState (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> SValue r -> MS (r smt)
IC.varDecDef SVariable r
vr r ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
IC.local SValue r
vl)

constVar :: (CommonRenderSym r vis smt md, Monad r) => Doc -> r vis ->
  SVariable r -> SValue r -> CS (r Doc)
constVar :: forall (r :: * -> *) vis smt md.
(CommonRenderSym r vis smt md, 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 smt -> r Doc)
-> State MethodState (r smt) -> 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 smt -> Doc) -> r smt -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc -> Doc -> Doc
R.stateVar
  (r vis -> Doc
forall (r :: * -> *) vis. VisibilityElim r vis => r vis -> Doc
RC.visibility r vis
s) Doc
p (Doc -> Doc) -> (r smt -> Doc) -> r smt -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r smt -> Doc
forall (r :: * -> *) smt. StatementElim r smt => r smt -> Doc
RC.statement) (State MethodState (r smt) -> State MethodState (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
MS (r smt) -> MS (r smt)
RC.stmt (State MethodState (r smt) -> State MethodState (r smt))
-> State MethodState (r smt) -> State MethodState (r smt)
forall a b. (a -> b) -> a -> b
$ SVariable r -> r ScopeData -> SValue r -> State MethodState (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> SValue r -> MS (r smt)
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 md svr, VisibilitySym r vis)
  =>  Label -> Maybe Label -> [CSStateVar r svr] -> [MS (r md)] -> [MS (r md)] -> CS (r Class)
extraClass :: forall (r :: * -> *) vis md svr.
(RenderClass r vis md svr, VisibilitySym r vis) =>
String
-> Maybe String
-> [CSStateVar r svr]
-> [MS (r md)]
-> [MS (r md)]
-> CS (r Doc)
extraClass String
n = String
-> r vis
-> r Doc
-> [CSStateVar r svr]
-> [MS (r md)]
-> [MS (r md)]
-> CS (r Doc)
forall (r :: * -> *) vis md svr.
RenderClass r vis md svr =>
String
-> r vis
-> r Doc
-> [CSStateVar r svr]
-> [MS (r md)]
-> [MS (r md)]
-> CS (r Doc)
RG.intClass String
n r vis
forall (r :: * -> *) vis. VisibilitySym r vis => r vis
public (r Doc
 -> [CSStateVar r svr] -> [MS (r md)] -> [MS (r md)] -> CS (r Doc))
-> (Maybe String -> r Doc)
-> Maybe String
-> [CSStateVar r svr]
-> [MS (r md)]
-> [MS (r md)]
-> CS (r Doc)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe String -> r Doc
forall (r :: * -> *) vis md svr.
RenderClass r vis md svr =>
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 smt)
  => (SValue r -> VS (r TypeData) -> SValue r)
  -> SVariable r
  -> SValue r
  -> MS (r smt)
openFileR :: forall (r :: * -> *) smt.
AssignStatement r smt =>
(SValue r -> VS (r TypeData) -> SValue r)
-> SVariable r -> SValue r -> MS (r smt)
openFileR SValue r -> VS (r TypeData) -> SValue r
f SVariable r
vr SValue r
vl = SVariable r
vr SVariable r -> SValue r -> MS (r smt)
forall (r :: * -> *) smt.
AssignStatement r smt =>
SVariable r -> SValue r -> MS (r smt)
&= 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 smt, IC.Literal r)
  => (SValue r -> VS (r TypeData) -> SValue r -> SValue r)
  -> SVariable r
  -> SValue r
  -> MS (r smt)
openFileW :: forall (r :: * -> *) smt.
(AssignStatement r smt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r smt)
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 smt)
forall (r :: * -> *) smt.
AssignStatement r smt =>
SVariable r -> SValue r -> MS (r smt)
&= 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 smt md svr att)
  => r vis -> r att -> SVariable r -> CS (r Doc)
stateVar :: forall (r :: * -> *) vis smt md svr att.
(Monad r, OORenderSym r vis smt md svr att) =>
r vis -> r att -> SVariable r -> CS (r Doc)
stateVar r vis
s r att
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 smt -> r Doc)
-> State MethodState (r smt) -> 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 smt -> Doc) -> r smt -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc -> Doc -> Doc
R.stateVar
  (r vis -> Doc
forall (r :: * -> *) vis. VisibilityElim r vis => r vis -> Doc
RC.visibility r vis
s) (r att -> Doc
forall (r :: * -> *) att. PermElim r att => r att -> Doc
RG.perm r att
p) (Doc -> Doc) -> (r smt -> Doc) -> r smt -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r smt -> Doc
forall (r :: * -> *) smt. StatementElim r smt => r smt -> Doc
RC.statement) (State MethodState (r smt) -> State MethodState (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
MS (r smt) -> MS (r smt)
RC.stmt (State MethodState (r smt) -> State MethodState (r smt))
-> State MethodState (r smt) -> State MethodState (r smt)
forall a b. (a -> b) -> a -> b
$ SVariable r -> r ScopeData -> State MethodState (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> MS (r smt)
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 smt
     , InternalVarElim r
     , RC.RenderValue r
     , RC.RenderVariable r
     , RC.ValueElim r
     )
  => (Doc -> Doc) -> [SVariable r] -> [SValue r] -> MS (r smt)
multiAssign :: forall (r :: * -> *) smt.
(AssignStatement r smt, InternalVarElim r, RenderValue r,
 RenderVariable r, ValueElim r) =>
(Doc -> Doc) -> [SVariable r] -> [SValue r] -> MS (r smt)
multiAssign Doc -> Doc
_ [] [SValue r]
_ = String -> MS (r smt)
forall a. HasCallStack => String -> a
error String
"Attempt to write assign statement for no variables."
multiAssign Doc -> Doc
_ [SVariable r]
_ [] = String -> MS (r smt)
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 smt)
forall a. HasCallStack => String -> a
error (String -> MS (r smt)) -> String -> MS (r smt)
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
  [r Variable]
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
  [r Value]
vls <- (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
  let wrapIfMult :: [a] -> Doc -> Doc
      wrapIfMult :: forall a. [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
  String -> VS (r TypeData) -> Doc -> SVariable r
forall (r :: * -> *).
RenderVariable r =>
String -> VS (r TypeData) -> Doc -> SVariable r
mkStateVar String
"" VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
IC.void ([r Variable] -> Doc -> Doc
forall a. [a] -> Doc -> Doc
wrapIfMult [r Variable]
vrs ([r Variable] -> Doc
forall (r :: * -> *). InternalVarElim r => [r Variable] -> Doc
variableList [r Variable]
vrs)) SVariable r -> SValue r -> MS (r smt)
forall (r :: * -> *) smt.
AssignStatement r smt =>
SVariable r -> SValue r -> MS (r smt)
&=
    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.void ([r Value] -> Doc -> Doc
forall a. [a] -> Doc -> Doc
wrapIfMult [r Value]
vls ([r Value] -> Doc
forall (r :: * -> *). ValueElim r => [r Value] -> Doc
valueList [r Value]
vls))

multiReturn
  :: (IC.ControlStatement r smt, RC.RenderValue r, RC.ValueElim r)
  => (Doc -> Doc) -> [SValue r] -> MS (r smt)
multiReturn :: forall (r :: * -> *) smt.
(ControlStatement r smt, RenderValue r, ValueElim r) =>
(Doc -> Doc) -> [SValue r] -> MS (r smt)
multiReturn Doc -> Doc
_ [] = String -> MS (r smt)
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 smt)
forall (r :: * -> *) smt.
ControlStatement r smt =>
SValue r -> MS (r smt)
returnStmt SValue r
v
multiReturn Doc -> Doc
f [SValue r]
vs = do
  [r Value]
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
  SValue r -> MS (r smt)
forall (r :: * -> *) smt.
ControlStatement r smt =>
SValue r -> MS (r smt)
returnStmt (SValue r -> MS (r smt)) -> SValue r -> MS (r smt)
forall a b. (a -> b) -> a -> b
$ 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.void (Doc -> SValue r) -> Doc -> SValue r
forall a b. (a -> b) -> a -> b
$ 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]
vs'

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

funcDecDef
  :: (OORenderSym r vis smt md svr att)
  => SVariable r -> r ScopeData -> [SVariable r] -> MS (r Body) -> MS (r smt)
funcDecDef :: forall (r :: * -> *) vis smt md svr att.
OORenderSym r vis smt md svr att =>
SVariable r
-> r ScopeData -> [SVariable r] -> MS (r Doc) -> MS (r smt)
funcDecDef SVariable r
v r ScopeData
scp [SVariable r]
ps MS (r Doc)
b = do
  r Variable
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
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MethodState -> MethodState) -> StateT MethodState Identity ())
-> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ String -> MethodState -> MethodState
useVarName (String -> MethodState -> MethodState)
-> String -> MethodState -> MethodState
forall a b. (a -> b) -> a -> b
$ r Variable -> String
forall (r :: * -> *). VariableElim r => r Variable -> String
variableName r Variable
vr
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MethodState -> MethodState) -> StateT MethodState Identity ())
-> (MethodState -> MethodState) -> StateT MethodState Identity ()
forall a b. (a -> b) -> a -> b
$ String -> ScopeData -> MethodState -> MethodState
setVarScope (r Variable -> String
forall (r :: * -> *). VariableElim r => r Variable -> String
variableName r Variable
vr) (r ScopeData -> ScopeData
forall (r :: * -> *). ScopeElim r => r ScopeData -> ScopeData
scopeData r ScopeData
scp)
  MethodState
s <- StateT MethodState Identity MethodState
forall s (m :: * -> *). MonadState s m => m s
get
  r md
f <- String
-> r vis
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r Doc)
-> MS (r md)
forall (r :: * -> *) vis smt md.
MethodSym r vis smt md =>
String
-> r vis
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r Doc)
-> MS (r md)
function (r Variable -> String
forall (r :: * -> *). VariableElim r => r Variable -> String
variableName r Variable
vr) r vis
forall (r :: * -> *) vis. VisibilitySym r vis => r vis
private (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)
    ((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]
ps) MS (r Doc)
b
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (ASetter MethodState MethodState [String] [String]
-> [String] -> MethodState -> MethodState
forall s t a b. ASetter s t a b -> b -> s -> t
L.set ASetter MethodState MethodState [String] [String]
Lens' MethodState [String]
currParameters (MethodState
s MethodState -> Getting [String] MethodState [String] -> [String]
forall s a. s -> Getting a s a -> a
^. Getting [String] MethodState [String]
Lens' MethodState [String]
currParameters))
  Doc -> MS (r smt)
forall (r :: * -> *) smt.
RenderStatement r smt =>
Doc -> MS (r smt)
mkStmtNoEnd (Doc -> MS (r smt)) -> Doc -> MS (r smt)
forall a b. (a -> b) -> a -> b
$ r md -> Doc
forall (r :: * -> *) md. MethodElim r md => r md -> Doc
RC.method r md
f

inOutCall
  :: (RC.InternalAssignStmt r smt, IC.StatementSym r smt, IC.VariableValue r)
  => (Label -> VS (r TypeData) -> [SValue r] -> SValue r)
  -> Label
  -> [SValue r]
  -> [SVariable r]
  -> [SVariable r]
  -> MS (r smt)
inOutCall :: forall (r :: * -> *) smt.
(InternalAssignStmt r smt, StatementSym r smt, VariableValue r) =>
(String -> VS (r TypeData) -> [SValue r] -> SValue r)
-> String
-> [SValue r]
-> [SVariable r]
-> [SVariable r]
-> MS (r smt)
inOutCall String -> VS (r TypeData) -> [SValue r] -> SValue r
f String
n [SValue r]
ins [] [] = SValue r -> MS (r smt)
forall (r :: * -> *) smt.
StatementSym r smt =>
SValue r -> MS (r smt)
IC.valStmt (SValue r -> MS (r smt)) -> SValue r -> MS (r smt)
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 smt)
forall (r :: * -> *) smt.
InternalAssignStmt r smt =>
[SVariable r] -> [SValue r] -> MS (r smt)
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, RC.RenderMethod r md) => MS (r Body) -> MS (r md)
mainBody :: forall (r :: * -> *) md.
(BodyElim r, RenderMethod r md) =>
MS (r Doc) -> MS (r md)
mainBody MS (r Doc)
b = do
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
setCurrMain
  r Doc
bod <- MS (r Doc)
b
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (Doc -> MethodState -> MethodState
setMainDoc (Doc -> MethodState -> MethodState)
-> Doc -> MethodState -> MethodState
forall a b. (a -> b) -> a -> b
$ r Doc -> Doc
forall (r :: * -> *). BodyElim r => r Doc -> Doc
RC.body r Doc
bod)
  VisibilityTag -> Doc -> MS (r md)
forall (r :: * -> *) md.
RenderMethod r md =>
VisibilityTag -> Doc -> MS (r md)
mthdFromData VisibilityTag
Pub Doc
empty

inOutFunc
  :: ( RC.InternalControlStmt r smt
     , IC.SharedStatement r smt
     , RenderBody r
     , RenderType r
     , VariableElim r
     )
  => (VS (r TypeData) -> [MS (r ParamData)] -> MS (r Body) -> MS (r md))
  -> [SVariable r]
  -> [SVariable r]
  -> [SVariable r]
  -> MS (r Body)
  -> MS (r md)
inOutFunc :: forall (r :: * -> *) smt md.
(InternalControlStmt r smt, SharedStatement r smt, RenderBody r,
 RenderType r, VariableElim r) =>
(VS (r TypeData) -> [MS (r ParamData)] -> MS (r Doc) -> MS (r md))
-> [SVariable r]
-> [SVariable r]
-> [SVariable r]
-> MS (r Doc)
-> MS (r md)
inOutFunc VS (r TypeData) -> [MS (r ParamData)] -> MS (r Doc) -> MS (r md)
f [SVariable r]
ins [] [] MS (r Doc)
b = VS (r TypeData) -> [MS (r ParamData)] -> MS (r Doc) -> MS (r md)
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 Doc)
b
inOutFunc VS (r TypeData) -> [MS (r ParamData)] -> MS (r Doc) -> MS (r md)
f [SVariable r]
ins [SVariable r]
outs [SVariable r]
both MS (r Doc)
b = VS (r TypeData) -> [MS (r ParamData)] -> MS (r Doc) -> MS (r md)
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 Doc)] -> MS (r Doc)
forall (r :: * -> *). RenderBody r => [MS (r Doc)] -> MS (r Doc)
multiBody [[MS (r smt)] -> MS (r Doc)
forall (r :: * -> *) smt.
BodySym r smt =>
[MS (r smt)] -> MS (r Doc)
bodyStatements ([MS (r smt)] -> MS (r Doc)) -> [MS (r smt)] -> MS (r Doc)
forall a b. (a -> b) -> a -> b
$ (SVariable r -> MS (r smt)) -> [SVariable r] -> [MS (r smt)]
forall a b. (a -> b) -> [a] -> [b]
map (SVariable r -> r ScopeData -> MS (r smt)
forall (r :: * -> *) smt.
DeclStatement r smt =>
SVariable r -> r ScopeData -> MS (r smt)
`IC.varDec` r ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
IC.local) [SVariable r]
outs, MS (r Doc)
b,
    MS (r smt) -> MS (r Doc)
forall (r :: * -> *) smt. BodySym r smt => MS (r smt) -> MS (r Doc)
oneLiner (MS (r smt) -> MS (r Doc)) -> MS (r smt) -> MS (r Doc)
forall a b. (a -> b) -> a -> b
$ [SValue r] -> MS (r smt)
forall (r :: * -> *) smt.
InternalControlStmt r smt =>
[SValue r] -> MS (r smt)
RC.multiReturn ([SValue r] -> MS (r smt)) -> [SValue r] -> MS (r smt)
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 md)
  => FuncDocRenderer
  -> ([SVariable r] -> [SVariable r] -> [SVariable r] -> MS (r Body) -> MS (r md))
  -> String
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> [(String, SVariable r)]
  -> MS (r Body) -> MS (r md)
docInOutFunc' :: forall (r :: * -> *) md.
RenderMethod r md =>
FuncDocRenderer
-> ([SVariable r]
    -> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r md))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r Doc)
-> MS (r md)
docInOutFunc' FuncDocRenderer
dfr [SVariable r]
-> [SVariable r] -> [SVariable r] -> MS (r Doc) -> MS (r md)
f String
desc [(String, SVariable r)]
is [(String, SVariable r)]
os [(String, SVariable r)]
bs MS (r Doc)
b = FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
forall (r :: * -> *) md.
RenderMethod r md =>
FuncDocRenderer
-> String -> [String] -> [String] -> MS (r md) -> MS (r md)
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 Doc) -> MS (r md)
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 Doc)
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.SharedStatement r smt) => Integer -> SValue r
argExists :: forall (r :: * -> *) smt.
SharedStatement r smt =>
Integer -> SValue r
argExists Integer
i = SValue r -> SValue r
forall (r :: * -> *) smt. List r smt => 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 smt
     , IC.IndexTranslator r
     , RC.RenderVariable r
     , RC.ValueElim r
     )
  => SValue r -> SValue r -> SValue r -> MS (r smt)
listSet :: forall (r :: * -> *) smt.
(AssignStatement r smt, IndexTranslator r, RenderVariable r,
 ValueElim r) =>
SValue r -> SValue r -> SValue r -> MS (r smt)
listSet SValue r
list SValue r
idx SValue r
val = do
  r Value
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
  r Value
idx' <- 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 -> SValue r
forall (r :: * -> *). IndexTranslator r => SValue r -> SValue r
IC.intToIndex SValue r
idx)
  let listAccessVar :: SVariable r
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
  SVariable r
listAccessVar SVariable r -> SValue r -> MS (r smt)
forall (r :: * -> *) smt.
AssignStatement r smt =>
SVariable r -> SValue r -> MS (r smt)
&= SValue r
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