{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
-- | Implementations defined here are valid for any language renderer.
module Drasil.Shared.LanguageRenderer.LanguagePolymorphic (fileFromData,
  multiBody, block, multiBlock, obj, negateOp, csc, sec, cot, equalOp,
  notEqualOp, greaterOp, greaterEqualOp, lessOp, lessEqualOp, plusOp, minusOp,
  multOp, divideOp, moduloOp, var, classVar, instanceVarAccess,
  classVarAccessCheck, arrayElem, local, litChar, litDouble, litInt, litString,
  valueOf, arg, argsList, call, funcAppMixedArgs, newObjMixedArgs, lambda,
  objAccess, objMethodCall, func, get, set, listAccess, getFunc, setFunc, stmt,
  loopStmt, emptyStmt, assign, subAssign, objDecNew, print, closeFile,
  returnStmt, valStmt, comment, throw, ifCond, tryCatch, construct, param,
  method, getMethod, setMethod, initStmts, function, docFuncRepr, docFunc,
  buildClass, implementingClass, docClass, commentedClass, modFromData, fileDoc,
  docMod, OptionalSpace(..), defaultOptSpace, smartAdd, smartSub
) where

import Drasil.FileHandling.Legacy (indent)

import Drasil.Shared.CodeType (CodeType(..), ClassName)
import Drasil.Shared.InterfaceCommon (UnRepr(..), Label, Library, NamedArgs,
  MixedCall, MixedCtorCall, bodyStatements, oneLiner, VisibilitySym(..),
  VariableElim(variableName, variableType), ValueSym(valueType),
  NumericExpression((#+), (#-), (#/), sin, cos, tan), Comparison(..), funcApp,
  MultiStatement(multi), AssignStatement((&++)), (&=), TypeElim(..),
  PrintConsole(printStr, printStrLn),
  PrintFile(printFile, printFileStr, printFileStrLn), ifNoElse, convType,
  BinderElim(..), getCodeType, getTypeString, ValueExpression, VariableValue,
  BlockSym, BodySym)
import qualified Drasil.Shared.InterfaceCommon as IC
import Drasil.GOOL.InterfaceGOOL (Initializers, CSStateVar, newObj,
  objMethodCallNoParams, ($.), AttachmentSym(..), SelfSym, OOVariableSym)
import qualified Drasil.GOOL.InterfaceGOOL as IG
import Drasil.Shared.RendererClassesCommon (InternalVarElim(variableBind),
  RenderValue(valFromData), RenderFunction(funcFromData),
  FunctionElim(functionType), RenderStatement(stmtFromData),
  StatementElim(statementTerm), MethodTypeSym(mType), RenderParam(paramFromData),
  RenderMethod(commentedFunc), BlockCommentSym(..), ValueElim (value),
  RenderVariable)
import qualified Drasil.Shared.RendererClassesCommon as RC
import Drasil.GOOL.RendererClassesOO (OORenderSym, RenderFile(commentedMod),
  OORenderMethod(intMethod), RenderClass(inherit, implements),
  RenderMod(updateModuleDoc))
import qualified Drasil.GOOL.RendererClassesOO as RO
import Drasil.Shared.AST (AttachmentTag(..), Terminator(..), isSource,
  ScopeTag(Local), ScopeData, sd, TypeData(..), FuncData)
import Drasil.Shared.Helpers (doubleQuotedText, vibcat, emptyIfEmpty, toCode,
  toState, onStateValue, on2StateValues, onStateList, getNestDegree,
  on2StateWrapped)
import Drasil.Shared.LanguageRenderer (dot, ifLabel, elseLabel, access, addExt,
  FuncDocRenderer, ClassDocRenderer, ModuleDocRenderer, getterName, setterName,
  valueList, namedArgList)
import qualified Drasil.Shared.LanguageRenderer as R
import Drasil.Shared.LanguageRenderer.Constructors (mkStmtNoEnd, mkStateVal,
  mkVal, mkStateVar, mkVar, mkClassVar, VSOp, unOpPrec, compEqualPrec, compPrec,
  addPrec, multPrec, typeFromData)
import Drasil.Shared.State (VS, FS, CS, MS, lensFStoGS, lensMStoVS, lensCStoFS,
  currMain, currFileType, addFile, setMainMod, setModuleName, getModuleName,
  addParameter, getParameters, useVarName)

import Prelude hiding (print,sin,cos,tan,(<>))
import qualified Prelude as P ((<>))
import Data.Foldable (fold)
import Data.Maybe (maybeToList)
import Control.Monad.State (modify)
import Control.Lens ((^.), over)
import Control.Lens.Zoom (zoom)
import Text.PrettyPrint.HughesPJ (Doc, text, empty, render, (<>), (<+>), ($+$),
  parens, brackets, integer, vcat, comma, isEmpty, space)
import qualified Text.PrettyPrint.HughesPJ as D

-- Bodies --

multiBody :: (RC.BodyElim r bod, Monad r) => [MS (r bod)] -> MS (r Doc)
multiBody :: forall (r :: * -> *) bod.
(BodyElim r bod, Monad r) =>
[MS (r bod)] -> MS (r Doc)
multiBody [MS (r bod)]
bs = ([Doc] -> r Doc)
-> [State MethodState Doc] -> State MethodState (r Doc)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> ([Doc] -> Doc) -> [Doc] -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc] -> Doc
vibcat) ([State MethodState Doc] -> State MethodState (r Doc))
-> [State MethodState Doc] -> State MethodState (r Doc)
forall a b. (a -> b) -> a -> b
$ (r bod -> Doc) -> MS (r bod) -> State MethodState Doc
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body (MS (r bod) -> State MethodState Doc)
-> [MS (r bod)] -> [State MethodState Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [MS (r bod)]
bs

-- Blocks --

block
  :: (Monad r, RenderStatement r stmt, StatementElim r stmt)
  => [MS (r stmt)] -> MS (r Doc)
block :: forall (r :: * -> *) stmt.
(Monad r, RenderStatement r stmt, StatementElim r stmt) =>
[MS (r stmt)] -> MS (r Doc)
block [MS (r stmt)]
sts = ([r stmt] -> r Doc) -> [MS (r stmt)] -> State MethodState (r Doc)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> ([r stmt] -> Doc) -> [r stmt] -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc] -> Doc
R.block ([Doc] -> Doc) -> ([r stmt] -> [Doc]) -> [r stmt] -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (r stmt -> Doc) -> [r stmt] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap r stmt -> Doc
forall {k} (r :: k -> *) (stmt :: k).
StatementElim r stmt =>
r stmt -> Doc
RC.statement) (MS (r stmt) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
RC.stmt (MS (r stmt) -> MS (r stmt)) -> [MS (r stmt)] -> [MS (r stmt)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [MS (r stmt)]
sts)

multiBlock :: (RC.BlockElim r block, Monad r) => [MS (r block)] -> MS (r Doc)
multiBlock :: forall (r :: * -> *) block.
(BlockElim r block, Monad r) =>
[MS (r block)] -> MS (r Doc)
multiBlock [MS (r block)]
bs = ([Doc] -> r Doc)
-> [State MethodState Doc] -> State MethodState (r Doc)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (Doc -> r Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> r Doc) -> ([Doc] -> Doc) -> [Doc] -> r Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc] -> Doc
vibcat) ([State MethodState Doc] -> State MethodState (r Doc))
-> [State MethodState Doc] -> State MethodState (r Doc)
forall a b. (a -> b) -> a -> b
$ (r block -> Doc) -> MS (r block) -> State MethodState Doc
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r block -> Doc
forall {k} (r :: k -> *) (block :: k).
BlockElim r block =>
r block -> Doc
RC.block (MS (r block) -> State MethodState Doc)
-> [MS (r block)] -> [State MethodState Doc]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [MS (r block)]
bs

-- Types --

obj :: (Monad r) => ClassName -> VS (r TypeData)
obj :: forall (r :: * -> *). Monad r => ClassName -> VS (r TypeData)
obj ClassName
n = CodeType -> ClassName -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> ClassName -> Doc -> VS (r TypeData)
typeFromData (ClassName -> CodeType
Object ClassName
n) ClassName
n (ClassName -> Doc
text ClassName
n)

-- Unary Operators --

negateOp :: (Monad r) => VSOp r
negateOp :: forall (r :: * -> *). Monad r => VSOp r
negateOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
unOpPrec ClassName
"-"

csc
  ::
    ( ValueSym r val typ
    , IC.Literal r val typ
    , IC.NumericExpression r val
    , TypeElim r typ
    )
  => VS (r val) -> VS (r val)
csc :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
csc VS (r val)
v = VS (r typ) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(Literal r val typ, TypeElim r typ) =>
VS (r typ) -> VS (r val)
valOfOne (r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType (r val -> r typ) -> VS (r val) -> VS (r typ)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VS (r val)
v) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
sin VS (r val)
v

sec
  ::
    ( ValueSym r val typ
    , IC.Literal r val typ
    , IC.NumericExpression r val
    , TypeElim r typ
    )
  => VS (r val) -> VS (r val)
sec :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
sec VS (r val)
v = VS (r typ) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(Literal r val typ, TypeElim r typ) =>
VS (r typ) -> VS (r val)
valOfOne (r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType (r val -> r typ) -> VS (r val) -> VS (r typ)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VS (r val)
v) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
cos VS (r val)
v

cot
  ::
    ( ValueSym r val typ
    , IC.Literal r val typ
    , IC.NumericExpression r val
    , TypeElim r typ
    )
  => VS (r val) -> VS (r val)
cot :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
cot VS (r val)
v = VS (r typ) -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(Literal r val typ, TypeElim r typ) =>
VS (r typ) -> VS (r val)
valOfOne (r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType (r val -> r typ) -> VS (r val) -> VS (r typ)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> VS (r val)
v) VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#/ VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val)
tan VS (r val)
v

valOfOne :: (IC.Literal r val typ, TypeElim r typ) => VS (r typ) -> VS (r val)
valOfOne :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
(Literal r val typ, TypeElim r typ) =>
VS (r typ) -> VS (r val)
valOfOne VS (r typ)
t = VS (r typ)
t VS (r typ)
-> (r typ -> StateT ValueState Identity (r val))
-> StateT ValueState Identity (r val)
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (CodeType -> StateT ValueState Identity (r val)
forall {k} {r :: k -> *} {val :: k} {typ :: k}.
Literal r val typ =>
CodeType -> VS (r val)
getVal (CodeType -> StateT ValueState Identity (r val))
-> (r typ -> CodeType)
-> r typ
-> StateT ValueState Identity (r val)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r typ -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType)
  where getVal :: CodeType -> VS (r val)
getVal CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
IC.litFloat Float
1.0
        getVal CodeType
_ = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
IC.litDouble Double
1.0

-- Binary Operators --

smartAdd
  ::
    ( IC.TypeSym r typ
    , NumericExpression r val
    , RenderValue r var val typ
    , ValueElim r val
    )
  => VS (r val) -> VS (r val) -> VS (r val)
smartAdd :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, NumericExpression r val, RenderValue r var val typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
smartAdd VS (r val)
v1 VS (r val)
v2 = do
  v1' <- VS (r val)
v1
  v2' <- v2
  case (RC.valueInt v1', RC.valueInt v2') of
    (Just Integer
i1, Just Integer
i2) -> Integer -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
litInt (Integer
i1 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Integer
i2)
    (Maybe Integer
_, Just Integer
i2) | Integer
i2 Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
< Integer
0 -> VS (r val)
v1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#- Integer -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
litInt (Integer -> Integer
forall a. Num a => a -> a
negate Integer
i2)
    (Maybe Integer, Maybe Integer)
_                  -> VS (r val)
v1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#+ VS (r val)
v2

smartSub
  ::
    ( IC.TypeSym r typ
    , IC.NumericExpression r val
    , RenderValue r var val typ
    , ValueElim r val
    )
  => VS (r val) -> VS (r val) -> VS (r val)
smartSub :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, NumericExpression r val, RenderValue r var val typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
smartSub VS (r val)
v1 VS (r val)
v2 = do
  v1' <- VS (r val)
v1
  v2' <- v2
  case (RC.valueInt v1', RC.valueInt v2') of
    (Just Integer
i1, Just Integer
i2) -> Integer -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
litInt (Integer
i1 Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
- Integer
i2)
    (Maybe Integer, Maybe Integer)
_                  -> VS (r val)
v1 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#- VS (r val)
v2

equalOp :: (Monad r) => VSOp r
equalOp :: forall (r :: * -> *). Monad r => VSOp r
equalOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
compEqualPrec ClassName
"=="

notEqualOp :: (Monad r) => VSOp r
notEqualOp :: forall (r :: * -> *). Monad r => VSOp r
notEqualOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
compEqualPrec ClassName
"!="

greaterOp :: (Monad r) => VSOp r
greaterOp :: forall (r :: * -> *). Monad r => VSOp r
greaterOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
compPrec ClassName
">"

greaterEqualOp :: (Monad r) => VSOp r
greaterEqualOp :: forall (r :: * -> *). Monad r => VSOp r
greaterEqualOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
compPrec ClassName
">="

lessOp :: (Monad r) => VSOp r
lessOp :: forall (r :: * -> *). Monad r => VSOp r
lessOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
compPrec ClassName
"<"

lessEqualOp :: (Monad r) => VSOp r
lessEqualOp :: forall (r :: * -> *). Monad r => VSOp r
lessEqualOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
compPrec ClassName
"<="

plusOp :: (Monad r) => VSOp r
plusOp :: forall (r :: * -> *). Monad r => VSOp r
plusOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
addPrec ClassName
"+"

minusOp :: (Monad r) => VSOp r
minusOp :: forall (r :: * -> *). Monad r => VSOp r
minusOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
addPrec ClassName
"-"

multOp :: (Monad r) => VSOp r
multOp :: forall (r :: * -> *). Monad r => VSOp r
multOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
multPrec ClassName
"*"

divideOp :: (Monad r) => VSOp r
divideOp :: forall (r :: * -> *). Monad r => VSOp r
divideOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
multPrec ClassName
"/"

moduloOp :: (Monad r) => VSOp r
moduloOp :: forall (r :: * -> *). Monad r => VSOp r
moduloOp = ClassName -> VSOp r
forall (r :: * -> *). Monad r => ClassName -> VSOp r
multPrec ClassName
"%"

-- Variables --

var :: (RenderVariable r var typ) => Label -> VS (r typ) -> VS (r var)
var :: forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
ClassName -> VS (r typ) -> VS (r var)
var ClassName
n VS (r typ)
t = ClassName -> VS (r typ) -> Doc -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
ClassName -> VS (r typ) -> Doc -> VS (r var)
mkStateVar ClassName
n VS (r typ)
t (ClassName -> Doc
R.var ClassName
n)

classVar :: (RenderVariable r var typ) => Label -> VS (r typ) -> VS (r var)
classVar :: forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
ClassName -> VS (r typ) -> VS (r var)
classVar ClassName
n VS (r typ)
t = ClassName -> VS (r typ) -> Doc -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
ClassName -> VS (r typ) -> Doc -> VS (r var)
mkClassVar ClassName
n VS (r typ)
t (ClassName -> Doc
R.var ClassName
n)

-- | To be used in classVarAccess implementations. Throws an error if the variable is
-- not class-level since classVarAccess is for accessing class-level variables from a class
classVarAccessCheck :: (InternalVarElim r var) => r var -> r var
classVarAccessCheck :: forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> r var
classVarAccessCheck r var
v = AttachmentTag -> r var
classVarCS (r var -> AttachmentTag
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> AttachmentTag
variableBind r var
v)
  where classVarCS :: AttachmentTag -> r var
classVarCS AttachmentTag
InstanceLevel = ClassName -> r var
forall a. HasCallStack => ClassName -> a
error
          ClassName
"classVarAccess can only be used to access class-level variables"
        classVarCS AttachmentTag
ClassLevel = r var
v

instanceVarAccess
  ::
    ( InternalVarElim r var
    , RenderVariable r var typ
    , ValueElim r val
    , VariableElim r var typ
    )
  => VS (r val) -> VS (r var) -> VS (r var)
instanceVarAccess :: forall {k} (r :: k -> *) (var :: k) (typ :: k) (val :: k).
(InternalVarElim r var, RenderVariable r var typ, ValueElim r val,
 VariableElim r var typ) =>
VS (r val) -> VS (r var) -> VS (r var)
instanceVarAccess VS (r val)
o' VS (r var)
v' = do
  o <- VS (r val)
o'
  v <- v'
  let instanceVarAccess' AttachmentTag
ClassLevel = ClassName -> VS (r var)
forall a. HasCallStack => ClassName -> a
error
        ClassName
"Cannot access class-level variables through an object, use classVarAccess instead"
      instanceVarAccess' AttachmentTag
InstanceLevel = ClassName -> r typ -> Doc -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
ClassName -> r typ -> Doc -> VS (r var)
mkVar (Doc -> ClassName
render (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
value r val
o) ClassName -> ClassName -> ClassName
`access` r var -> ClassName
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> ClassName
variableName r var
v)
        (r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
v) (Doc -> Doc -> Doc
R.instanceVarAccess (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
o) (r var -> Doc
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> Doc
RC.variable r var
v))
  instanceVarAccess' (variableBind v)

arrayElem
  ::
    ( IC.TypeSym r typ
    , ValueSym r val typ
    , IC.IndexTranslator r val
    , RenderVariable r var typ
    , ValueElim r val
    )
  => VS (r val) -> VS (r val) -> VS (r var)
arrayElem :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 RenderVariable r var typ, ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r var)
arrayElem VS (r val)
arr' VS (r val)
i' = do
  i <- VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
IndexTranslator r val =>
VS (r val) -> VS (r val)
IC.intToIndex VS (r val)
i'
  arr <- arr'
  let vName = Doc -> ClassName
render (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
arr) ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> ClassName
"[" ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> Doc -> ClassName
render (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
i) ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> ClassName
"]"
      vType = VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
IC.innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r typ -> VS (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType r val
arr
      vRender = r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
arr Doc -> Doc -> Doc
<> Doc -> Doc
brackets (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
i)
  mkStateVar vName vType vRender

-- Scope --
local :: (Monad r) => r ScopeData
local :: forall (r :: * -> *). Monad r => r ScopeData
local = 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
Local

-- Values --

litChar
  :: (RenderValue r var val typ, IC.TypeSym r typ)
  => (Doc -> Doc) -> Char -> VS (r val)
litChar :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
(Doc -> Doc) -> Char -> VS (r val)
litChar Doc -> Doc
f Char
c = VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.char (Doc -> Doc
f (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ if Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\n' then ClassName -> Doc
text ClassName
"\\n" else Char -> Doc
D.char Char
c)

litDouble
  :: (RenderValue r var val typ, IC.TypeSym r typ)
  => Double -> VS (r val)
litDouble :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Double -> VS (r val)
litDouble Double
d = VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.double (Double -> Doc
D.double Double
d)

litInt :: (RenderValue r var val typ, IC.TypeSym r typ) => Integer -> VS (r val)
litInt :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
litInt Integer
i = Maybe Int -> Maybe Integer -> VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
Maybe Int -> Maybe Integer -> VS (r typ) -> Doc -> VS (r val)
valFromData Maybe Int
forall a. Maybe a
Nothing (Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
i) VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int (Integer -> Doc
integer Integer
i)

litString
  :: (RenderValue r var val typ, IC.TypeSym r typ)
  => String -> VS (r val)
litString :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
ClassName -> VS (r val)
litString ClassName
s = VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.string (ClassName -> Doc
doubleQuotedText ClassName
s)

valueOf
  :: (InternalVarElim r var, RenderValue r var val typ, VariableElim r var typ)
  => VS (r var) -> VS (r val)
valueOf :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 VariableElim r var typ) =>
VS (r var) -> VS (r val)
valueOf VS (r var)
v' = do
  v <- VS (r var)
v'
  mkVal (variableType v) (RC.variable v)

arg
  :: (RenderValue r var val typ, IC.TypeSym r typ, ValueElim r val)
  => VS (r val) -> VS (r val) -> VS (r val)
arg :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
arg VS (r val)
n' VS (r val)
args' = do
  n <- VS (r val)
n'
  args <- args'
  s <- IC.string
  mkVal s (R.arg n args)

argsList :: (RenderValue r var val typ, IC.TypeSym r typ) => String -> VS (r val)
argsList :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
ClassName -> VS (r val)
argsList ClassName
l = VS (r typ) -> Doc -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Doc -> VS (r val)
mkStateVal (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
IC.arrayType VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.string) (ClassName -> Doc
text ClassName
l)

-- | First parameter is separator between name and value for named arguments,
-- rest similar to call from RendererClasses
call
  :: (InternalVarElim r var, RenderValue r var val typ, ValueElim r val)
  => Doc -> Maybe Library -> Maybe Doc -> MixedCall r var val typ
call :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 ValueElim r val) =>
Doc -> Maybe ClassName -> Maybe Doc -> MixedCall r var val typ
call Doc
sep Maybe ClassName
lib Maybe Doc
o ClassName
n VS (r typ)
t [VS (r val)]
pas NamedArgs r var val
nas = do
  pargs <- [VS (r val)] -> StateT ValueState Identity [r val]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [VS (r val)]
pas
  nms <- mapM fst nas
  nargs <- mapM snd nas
  let libDoc = Doc -> (ClassName -> Doc) -> Maybe ClassName -> Doc
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (ClassName -> Doc
text ClassName
n) (ClassName -> Doc
text (ClassName -> Doc) -> (ClassName -> ClassName) -> ClassName -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClassName -> ClassName -> ClassName
`access` ClassName
n)) Maybe ClassName
lib
      obDoc = Maybe Doc -> Doc
forall m. Monoid m => Maybe m -> m
forall (t :: * -> *) m. (Foldable t, Monoid m) => t m -> m
fold Maybe Doc
o
  mkStateVal t $ obDoc <> libDoc <> parens (valueList pargs <>
    (if null pas || null nas then empty else comma) <+> namedArgList sep
    (zip nms nargs))

funcAppMixedArgs :: (RenderValue r var val typ) => MixedCall r var val typ
funcAppMixedArgs :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
MixedCall r var val typ
funcAppMixedArgs = Maybe ClassName -> Maybe Doc -> MixedCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
Maybe ClassName -> Maybe Doc -> MixedCall r var val typ
RC.call Maybe ClassName
forall a. Maybe a
Nothing Maybe Doc
forall a. Maybe a
Nothing

newObjMixedArgs
  :: (RenderValue r var val TypeData, UnRepr r TypeData)
  => String -> MixedCtorCall r var val TypeData
newObjMixedArgs :: forall (r :: * -> *) var val.
(RenderValue r var val TypeData, UnRepr r TypeData) =>
ClassName -> MixedCtorCall r var val TypeData
newObjMixedArgs ClassName
s VS (r TypeData)
tp [VS (r val)]
vs NamedArgs r var val
ns = do
  t <- VS (r TypeData)
tp
  RC.call Nothing Nothing (s P.<> getTypeString t) (pure t) vs ns

lambda
  ::
    ( BinderElim r binder typ
    , RenderValue r var val typ
    , IC.TypeSym r typ
    , ValueSym r val typ
    )
  => ([r binder] -> r val -> Doc)
  -> [VS (r binder)]
  -> VS (r val)
  -> VS (r val)
lambda :: forall {k} (r :: k -> *) (binder :: k) (typ :: k) (var :: k)
       (val :: k).
(BinderElim r binder typ, RenderValue r var val typ, TypeSym r typ,
 ValueSym r val typ) =>
([r binder] -> r val -> Doc)
-> [VS (r binder)] -> VS (r val) -> VS (r val)
lambda [r binder] -> r val -> Doc
f [VS (r binder)]
ps' VS (r val)
ex' = do
  ps <- [VS (r binder)] -> StateT ValueState Identity [r binder]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [VS (r binder)]
ps'
  ex <- ex'
  let ft = [VS (r typ)] -> VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
[VS (r typ)] -> VS (r typ) -> VS (r typ)
IC.funcType (r typ -> VS (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> VS (r typ))
-> (r binder -> r typ) -> r binder -> VS (r typ)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r binder -> r typ
forall {k} (r :: k -> *) (binder :: k) (typ :: k).
BinderElim r binder typ =>
r binder -> r typ
binderType (r binder -> VS (r typ)) -> [r binder] -> [VS (r typ)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [r binder]
ps) (r typ -> VS (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType r val
ex)
  valFromData (Just 0) Nothing ft (f ps ex)

objAccess
  :: (FunctionElim r typ, RenderValue r var val typ, ValueElim r val)
  => VS (r val) -> VS (r FuncData) -> VS (r val)
objAccess :: forall (r :: * -> *) typ var val.
(FunctionElim r typ, RenderValue r var val typ, ValueElim r val) =>
VS (r val) -> VS (r FuncData) -> VS (r val)
objAccess = (r val -> r FuncData -> StateT ValueState Identity (r val))
-> StateT ValueState Identity (r val)
-> StateT ValueState Identity (r FuncData)
-> StateT ValueState Identity (r val)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\r val
v r FuncData
f-> r typ -> Doc -> StateT ValueState Identity (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
r typ -> Doc -> VS (r val)
mkVal (r FuncData -> r typ
forall (r :: * -> *) typ. FunctionElim r typ => r FuncData -> r typ
functionType r FuncData
f)
  (Doc -> Doc -> Doc
R.objAccess (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
v) (r FuncData -> Doc
forall (r :: * -> *) typ. FunctionElim r typ => r FuncData -> Doc
RC.function r FuncData
f)))

objMethodCall
  :: (RenderValue r var val typ, ValueElim r val)
  => Label
  -> VS (r typ)
  -> VS (r val)
  -> [VS (r val)]
  -> NamedArgs r var val
  -> VS (r val)
objMethodCall :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val) =>
ClassName
-> VS (r typ)
-> VS (r val)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
objMethodCall ClassName
f VS (r typ)
t VS (r val)
ob [VS (r val)]
vs NamedArgs r var val
ns = VS (r val)
ob VS (r val) -> (r val -> VS (r val)) -> VS (r val)
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\r val
o -> Maybe ClassName -> Maybe Doc -> MixedCall r var val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
Maybe ClassName -> Maybe Doc -> MixedCall r var val typ
RC.call Maybe ClassName
forall a. Maybe a
Nothing
  (Doc -> Maybe Doc
forall a. a -> Maybe a
Just (Doc -> Maybe Doc) -> Doc -> Maybe Doc
forall a b. (a -> b) -> a -> b
$ r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
o Doc -> Doc -> Doc
<> Doc
dot) ClassName
f VS (r typ)
t [VS (r val)]
vs NamedArgs r var val
ns)

-- Functions --

func
  ::
    ( RenderFunction r typ
    , ValueElim r val
    , ValueExpression r var val binder typ
    )
  => Label -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
func :: forall (r :: * -> *) typ val var binder.
(RenderFunction r typ, ValueElim r val,
 ValueExpression r var val binder typ) =>
ClassName -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
func ClassName
l VS (r typ)
t [VS (r val)]
vs = PosCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp ClassName
l VS (r typ)
t [VS (r val)]
vs VS (r val)
-> (r val -> StateT ValueState Identity (r FuncData))
-> StateT ValueState Identity (r FuncData)
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
>>= ((Doc -> VS (r typ) -> StateT ValueState Identity (r FuncData)
forall (r :: * -> *) typ.
RenderFunction r typ =>
Doc -> VS (r typ) -> VS (r FuncData)
`funcFromData` VS (r typ)
t) (Doc -> StateT ValueState Identity (r FuncData))
-> (r val -> Doc)
-> r val
-> StateT ValueState Identity (r FuncData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> Doc
R.func (Doc -> Doc) -> (r val -> Doc) -> r val -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value)

get
  :: (RO.InternalGetSet r var val typ, IG.OOFunctionSym r val typ)
  => VS (r val) -> VS (r var) -> VS (r val)
get :: forall (r :: * -> *) var val typ.
(InternalGetSet r var val typ, OOFunctionSym r val typ) =>
VS (r val) -> VS (r var) -> VS (r val)
get VS (r val)
v VS (r var)
vToGet = VS (r val)
v VS (r val) -> VS (r FuncData) -> VS (r val)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. VS (r var) -> VS (r FuncData)
forall (r :: * -> *) var val typ.
InternalGetSet r var val typ =>
VS (r var) -> VS (r FuncData)
RO.getFunc VS (r var)
vToGet

set
  ::
    ( ValueSym r val typ
    , RO.InternalGetSet r var val typ
    , IG.OOFunctionSym r val typ
    )
  => VS (r val) -> VS (r var) -> VS (r val) -> VS (r val)
set :: forall (r :: * -> *) val typ var.
(ValueSym r val typ, InternalGetSet r var val typ,
 OOFunctionSym r val typ) =>
VS (r val) -> VS (r var) -> VS (r val) -> VS (r val)
set VS (r val)
v VS (r var)
vToSet VS (r val)
toVal = VS (r val)
v VS (r val) -> VS (r FuncData) -> VS (r val)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. VS (r typ) -> VS (r var) -> VS (r val) -> VS (r FuncData)
forall (r :: * -> *) var val typ.
InternalGetSet r var val typ =>
VS (r typ) -> VS (r var) -> VS (r val) -> VS (r FuncData)
RO.setFunc ((r val -> r typ) -> VS (r val) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType VS (r val)
v) VS (r var)
vToSet VS (r val)
toVal

-- TODO [Brandon Bosman, 06/10/2026]: Figure out what to do with this
listAccess
  :: ( IC.TypeSym r typ
     , ValueSym r val typ
     , IC.IndexTranslator r val
     , RC.InternalListFunc r val typ
     , FunctionElim r typ
     , RenderFunction r typ
     , RenderValue r var val typ
     , TypeElim r typ
     , ValueElim r val
     )
  => VS (r val) -> VS (r val) -> VS (r val)
listAccess :: forall (r :: * -> *) typ val var.
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 InternalListFunc r val typ, FunctionElim r typ,
 RenderFunction r typ, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
listAccess VS (r val)
v VS (r val)
i = do
  v' <- VS (r val)
v
  let i' = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
IndexTranslator r val =>
VS (r val) -> VS (r val)
IC.intToIndex VS (r val)
i
      t  = VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
IC.innerType (VS (r typ) -> VS (r typ)) -> VS (r typ) -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r typ -> VS (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType r val
v'
      checkType (List CodeType
_) = VS (r typ) -> VS (r val) -> VS (r FuncData)
forall (r :: * -> *) val typ.
InternalListFunc r val typ =>
VS (r typ) -> VS (r val) -> VS (r FuncData)
RC.listAccessFunc VS (r typ)
t VS (r val)
i'
      checkType (Set CodeType
_) = VS (r typ) -> VS (r val) -> VS (r FuncData)
forall (r :: * -> *) val typ.
InternalListFunc r val typ =>
VS (r typ) -> VS (r val) -> VS (r FuncData)
RC.listAccessFunc VS (r typ)
t VS (r val)
i'
      checkType (Array CodeType
_) = VS (r val)
i' VS (r val) -> (r val -> VS (r FuncData)) -> VS (r FuncData)
forall a b.
StateT ValueState Identity a
-> (a -> StateT ValueState Identity b)
-> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>=
                              (\r val
ix -> Doc -> VS (r typ) -> VS (r FuncData)
forall (r :: * -> *) typ.
RenderFunction r typ =>
Doc -> VS (r typ) -> VS (r FuncData)
funcFromData (Doc -> Doc
brackets (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
ix)) VS (r typ)
t)
      checkType CodeType
_ = ClassName -> VS (r FuncData)
forall a. HasCallStack => ClassName -> a
error ClassName
"listAccess called on non-list-type value"
  f <- checkType (getCodeType (valueType v'))
  mkVal (RC.functionType f) (RC.value v' <> RC.function f)

getFunc
  :: (IG.OOFunctionSym r val typ, VariableElim r var typ)
  => VS (r var) -> VS (r FuncData)
getFunc :: forall (r :: * -> *) val typ var.
(OOFunctionSym r val typ, VariableElim r var typ) =>
VS (r var) -> VS (r FuncData)
getFunc VS (r var)
v = VS (r var)
v VS (r var)
-> (r var -> StateT ValueState Identity (r FuncData))
-> StateT ValueState Identity (r FuncData)
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 var
vr -> ClassName
-> VS (r typ)
-> [VS (r val)]
-> StateT ValueState Identity (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
ClassName -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func (ClassName -> ClassName
getterName (ClassName -> ClassName) -> ClassName -> ClassName
forall a b. (a -> b) -> a -> b
$ r var -> ClassName
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> ClassName
variableName r var
vr)
  (r typ -> VS (r typ)
forall a s. a -> State s a
toState (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
vr) [])

setFunc
  :: (IG.OOFunctionSym r val typ, VariableElim r var typ)
  => VS (r typ) -> VS (r var) -> VS (r val) -> VS (r FuncData)
setFunc :: forall (r :: * -> *) val typ var.
(OOFunctionSym r val typ, VariableElim r var typ) =>
VS (r typ) -> VS (r var) -> VS (r val) -> VS (r FuncData)
setFunc VS (r typ)
t VS (r var)
v VS (r val)
toVal = VS (r var)
v VS (r var)
-> (r var -> StateT ValueState Identity (r FuncData))
-> StateT ValueState Identity (r FuncData)
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 var
vr -> ClassName
-> VS (r typ)
-> [VS (r val)]
-> StateT ValueState Identity (r FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
ClassName -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
IG.func (ClassName -> ClassName
setterName (ClassName -> ClassName) -> ClassName -> ClassName
forall a b. (a -> b) -> a -> b
$ r var -> ClassName
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> ClassName
variableName r var
vr) VS (r typ)
t
  [VS (r val)
toVal])

-- Statements --

stmt
  :: (RenderStatement r stmt, StatementElim r stmt)
  => MS (r stmt) -> MS (r stmt)
stmt :: forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
stmt MS (r stmt)
s' = do
  s <- MS (r stmt)
s'
  mkStmtNoEnd (RC.statement s <> R.getTerm (statementTerm s))

loopStmt
  :: (RenderStatement r stmt, StatementElim r stmt)
  => MS (r stmt) -> MS (r stmt)
loopStmt :: forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
loopStmt = MS (r stmt) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
RC.stmt (MS (r stmt) -> MS (r stmt))
-> (MS (r stmt) -> MS (r stmt)) -> MS (r stmt) -> MS (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. MS (r stmt) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
setEmpty

emptyStmt :: (RenderStatement r stmt) => MS (r stmt)
emptyStmt :: forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt)
emptyStmt = Doc -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd Doc
empty

assign
  :: (InternalVarElim r var, RenderStatement r stmt, ValueElim r val)
  => Terminator -> VS (r var) -> VS (r val) -> MS (r stmt)
assign :: forall {k} (r :: k -> *) (var :: k) (stmt :: k) (val :: k).
(InternalVarElim r var, RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> VS (r val) -> MS (r stmt)
assign Terminator
t VS (r var)
vr' VS (r val)
v' = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
vr'
  v <- zoom lensMStoVS v'
  stmtFromData (R.assign vr v) t

subAssign
  :: (InternalVarElim r var, RenderStatement r stmt, ValueElim r val)
  => Terminator -> VS (r var) -> VS (r val) -> MS (r stmt)
subAssign :: forall {k} (r :: k -> *) (var :: k) (stmt :: k) (val :: k).
(InternalVarElim r var, RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> VS (r val) -> MS (r stmt)
subAssign Terminator
t VS (r var)
vr' VS (r val)
v' = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
vr'
  v <- zoom lensMStoVS v'
  stmtFromData (R.subAssign vr v) t

objDecNew
  ::
    ( IC.DeclStatement r bod stmt var scope val
    , IG.OOValueExpression r var val typ
    , VariableElim r var typ
    )
  => VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
objDecNew :: forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val,
 OOValueExpression r var val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
objDecNew VS (r var)
v r scope
scp [VS (r val)]
vs = VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
IC.varDecDef VS (r var)
v r scope
scp (PosCtorCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
PosCtorCall r val typ
newObj ((r var -> r typ) -> VS (r var) -> State ValueState (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (r var)
v) [VS (r val)]
vs)

printList
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , MultiStatement r stmt
    , IC.ScopeSym r scope
    , IC.DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , IC.ControlStatement r bod stmt var val
    , IC.TypeSym r typ
    , IC.Literal r val typ
    , NumericExpression r val
    , Comparison r val
    , IC.VariableSym r var typ
    , IC.VariableValue r var val
    , IC.List r val
    )
  => Integer
  -> VS (r val)
  -> (VS (r val) -> MS (r stmt))
  -> (String -> MS (r stmt))
  -> (String -> MS (r stmt))
  -> MS (r stmt)
printList :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (scope :: k) (var :: k) (val :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeSym r typ,
 Literal r val typ, NumericExpression r val, Comparison r val,
 VariableSym r var typ, VariableValue r var val, List r val) =>
Integer
-> VS (r val)
-> (VS (r val) -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> MS (r stmt)
printList Integer
n VS (r val)
v VS (r val) -> MS (r stmt)
prFn ClassName -> MS (r stmt)
prStrFn ClassName -> MS (r stmt)
prLnFn = [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi [ClassName -> MS (r stmt)
prStrFn ClassName
"[",
  MS (r stmt)
-> VS (r val) -> MS (r stmt) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
-> VS (r val) -> MS (r stmt) -> MS (r bod) -> MS (r stmt)
IC.for (VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
IC.varDecDef VS (r var)
i r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
IC.local (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
0))
    (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf VS (r var)
i VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?< (VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
IC.listSize VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#- Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1)) (VS (r var)
i VS (r var) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> MS (r stmt)
&++)
    ([MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements [VS (r val) -> MS (r stmt)
prFn (VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
IC.listAccess VS (r val)
v (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf VS (r var)
i)), ClassName -> MS (r stmt)
prStrFn ClassName
", "]),
  [(VS (r val), MS (r bod))] -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (val :: k).
(BodySym r bod block, ControlStatement r bod stmt var val) =>
[(VS (r val), MS (r bod))] -> MS (r stmt)
ifNoElse [(VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
IC.listSize VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
0, MS (r stmt) -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (r stmt) -> MS (r bod)) -> MS (r stmt) -> MS (r bod)
forall a b. (a -> b) -> a -> b
$
    VS (r val) -> MS (r stmt)
prFn (VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
IC.listAccess VS (r val)
v (VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
IC.listSize VS (r val)
v VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
NumericExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
#- Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1)))],
  ClassName -> MS (r stmt)
prLnFn ClassName
"]"]
  where l_i :: ClassName
l_i = ClassName
"list_i" ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> Integer -> ClassName
forall a. Show a => a -> ClassName
show Integer
n
        i :: VS (r var)
i = ClassName -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
ClassName -> VS (r typ) -> VS (r var)
IC.var ClassName
l_i VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int

printSet
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , MultiStatement r stmt
    , IC.ControlStatement r bod stmt var val
    , IC.VariableSym r var typ
    , IC.VariableValue r var val
    )
  => Integer
  -> VS (r val)
  -> (VS (r val) -> MS (r stmt))
  -> (String -> MS (r stmt))
  -> (String -> MS (r stmt))
  -> VS (r typ)
  -> MS (r stmt)
printSet :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (var :: k) (val :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 ControlStatement r bod stmt var val, VariableSym r var typ,
 VariableValue r var val) =>
Integer
-> VS (r val)
-> (VS (r val) -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> VS (r typ)
-> MS (r stmt)
printSet Integer
n VS (r val)
v VS (r val) -> MS (r stmt)
prFn ClassName -> MS (r stmt)
prStrFn ClassName -> MS (r stmt)
prLnFn VS (r typ)
s = [MS (r stmt)] -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi [ClassName -> MS (r stmt)
prStrFn ClassName
"{ ",
  VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt)
IC.forEach VS (r var)
i VS (r val)
v
    ([MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements [VS (r val) -> MS (r stmt)
prFn (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf VS (r var)
i),ClassName -> MS (r stmt)
prStrFn ClassName
" "]),
  ClassName -> MS (r stmt)
prLnFn ClassName
"}"]
  where set_i :: ClassName
set_i = ClassName
"set_i" ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> Integer -> ClassName
forall a. Show a => a -> ClassName
show Integer
n
        i :: VS (r var)
i = ClassName -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
ClassName -> VS (r typ) -> VS (r var)
IC.var ClassName
set_i VS (r typ)
s

printObj :: ClassName -> (String -> MS (r stmt)) -> MS (r stmt)
printObj :: forall {k} (r :: k -> *) (stmt :: k).
ClassName -> (ClassName -> MS (r stmt)) -> MS (r stmt)
printObj ClassName
n ClassName -> MS (r stmt)
prLnFn = ClassName -> MS (r stmt)
prLnFn (ClassName -> MS (r stmt)) -> ClassName -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ ClassName
"Instance of " ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> ClassName
n ClassName -> ClassName -> ClassName
forall a. Semigroup a => a -> a -> a
P.<> ClassName
" object"

print
  ::
    ( BlockSym r block stmt
    , BodySym r bod block
    , MultiStatement r stmt
    , PrintConsole r stmt val
    , PrintFile r stmt val
    , IC.ScopeSym r scope
    , IC.DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , IC.ControlStatement r bod stmt var val
    , ValueSym r val typ
    , IC.Literal r val typ
    , NumericExpression r val
    , Comparison r val
    , IC.VariableSym r var typ
    , IC.VariableValue r var val
    , IC.List r val
    , IC.TypeSym r typ
    , TypeElim r typ
    , RC.InternalIOStmt r stmt val
    )
  => Bool -> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
print :: forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (scope :: k) (var :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 PrintConsole r stmt val, PrintFile r stmt val, ScopeSym r scope,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, ValueSym r val typ,
 Literal r val typ, NumericExpression r val, Comparison r val,
 VariableSym r var typ, VariableValue r var val, List r val,
 TypeSym r typ, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
print Bool
newLn Maybe (VS (r val))
f VS (r val)
printFn VS (r val)
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> VS (r val) -> StateT MethodState Identity (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r val)
v StateT MethodState Identity (r val)
-> (r val -> StateT MethodState Identity (r stmt))
-> StateT MethodState Identity (r stmt)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> StateT MethodState Identity (r stmt)
print' (CodeType -> StateT MethodState Identity (r stmt))
-> (r val -> CodeType)
-> r val
-> StateT MethodState Identity (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r typ -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (r typ -> CodeType) -> (r val -> r typ) -> r val -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType
  where print' :: CodeType -> StateT MethodState Identity (r stmt)
print' (List CodeType
t) = Integer
-> VS (r val)
-> (VS (r val) -> StateT MethodState Identity (r stmt))
-> (ClassName -> StateT MethodState Identity (r stmt))
-> (ClassName -> StateT MethodState Identity (r stmt))
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (scope :: k) (var :: k) (val :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeSym r typ,
 Literal r val typ, NumericExpression r val, Comparison r val,
 VariableSym r var typ, VariableValue r var val, List r val) =>
Integer
-> VS (r val)
-> (VS (r val) -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> MS (r stmt)
printList (Integer -> CodeType -> Integer
getNestDegree Integer
1 CodeType
t) VS (r val)
v VS (r val) -> StateT MethodState Identity (r stmt)
prFn ClassName -> StateT MethodState Identity (r stmt)
prStrFn ClassName -> StateT MethodState Identity (r stmt)
prLnFn
        print' (Object ClassName
n) = ClassName
-> (ClassName -> StateT MethodState Identity (r stmt))
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
ClassName -> (ClassName -> MS (r stmt)) -> MS (r stmt)
printObj ClassName
n ClassName -> StateT MethodState Identity (r stmt)
prLnFn
        print' (Set CodeType
t) = Integer
-> VS (r val)
-> (VS (r val) -> StateT MethodState Identity (r stmt))
-> (ClassName -> StateT MethodState Identity (r stmt))
-> (ClassName -> StateT MethodState Identity (r stmt))
-> VS (r typ)
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (var :: k) (val :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 ControlStatement r bod stmt var val, VariableSym r var typ,
 VariableValue r var val) =>
Integer
-> VS (r val)
-> (VS (r val) -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> (ClassName -> MS (r stmt))
-> VS (r typ)
-> MS (r stmt)
printSet (Integer -> CodeType -> Integer
getNestDegree Integer
1 CodeType
t) VS (r val)
v VS (r val) -> StateT MethodState Identity (r stmt)
prFn ClassName -> StateT MethodState Identity (r stmt)
prStrFn ClassName -> StateT MethodState Identity (r stmt)
prLnFn (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
CodeType -> VS (r typ)
convType CodeType
t)
        print' CodeType
_ = Bool
-> Maybe (VS (r val))
-> VS (r val)
-> VS (r val)
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
InternalIOStmt r stmt val =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
RC.printSt Bool
newLn Maybe (VS (r val))
f VS (r val)
printFn VS (r val)
v
        prFn :: VS (r val) -> StateT MethodState Identity (r stmt)
prFn = (VS (r val) -> StateT MethodState Identity (r stmt))
-> (VS (r val)
    -> VS (r val) -> StateT MethodState Identity (r stmt))
-> Maybe (VS (r val))
-> VS (r val)
-> StateT MethodState Identity (r stmt)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe VS (r val) -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
VS (r val) -> MS (r stmt)
IC.print VS (r val) -> VS (r val) -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
printFile Maybe (VS (r val))
f
        prStrFn :: ClassName -> StateT MethodState Identity (r stmt)
prStrFn = (ClassName -> StateT MethodState Identity (r stmt))
-> (VS (r val)
    -> ClassName -> StateT MethodState Identity (r stmt))
-> Maybe (VS (r val))
-> ClassName
-> StateT MethodState Identity (r stmt)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ClassName -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
ClassName -> MS (r stmt)
printStr VS (r val) -> ClassName -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> ClassName -> MS (r stmt)
printFileStr Maybe (VS (r val))
f
        prLnFn :: ClassName -> StateT MethodState Identity (r stmt)
prLnFn = if Bool
newLn then (ClassName -> StateT MethodState Identity (r stmt))
-> (VS (r val)
    -> ClassName -> StateT MethodState Identity (r stmt))
-> Maybe (VS (r val))
-> ClassName
-> StateT MethodState Identity (r stmt)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ClassName -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
ClassName -> MS (r stmt)
printStrLn VS (r val) -> ClassName -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> ClassName -> MS (r stmt)
printFileStrLn Maybe (VS (r val))
f else (ClassName -> StateT MethodState Identity (r stmt))
-> (VS (r val)
    -> ClassName -> StateT MethodState Identity (r stmt))
-> Maybe (VS (r val))
-> ClassName
-> StateT MethodState Identity (r stmt)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
          ClassName -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
ClassName -> MS (r stmt)
printStr VS (r val) -> ClassName -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintFile r stmt val =>
VS (r val) -> ClassName -> MS (r stmt)
printFileStr Maybe (VS (r val))
f

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

returnStmt
  :: (RenderStatement r stmt, ValueElim r val)
  => Terminator -> VS (r val) -> MS (r stmt)
returnStmt :: forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r val) -> MS (r stmt)
returnStmt Terminator
t VS (r val)
v' = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> VS (r val) -> StateT MethodState Identity (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r val)
v'
  stmtFromData (R.return' [v]) t

valStmt
  :: (RenderStatement r stmt, ValueElim r val)
  => Terminator -> VS (r val) -> MS (r stmt)
valStmt :: forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r val) -> MS (r stmt)
valStmt Terminator
t VS (r val)
v' = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> VS (r val) -> StateT MethodState Identity (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r val)
v'
  stmtFromData (RC.value v) t

comment :: (RenderStatement r stmt) => Doc -> Label -> MS (r stmt)
comment :: forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> ClassName -> MS (r stmt)
comment Doc
cs ClassName
c = Doc -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd (ClassName -> Doc -> Doc
R.comment ClassName
c Doc
cs)

throw
  :: (IC.Literal r val typ, RenderStatement r stmt)
  => (r val -> Doc) -> Terminator -> Label -> MS (r stmt)
throw :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (stmt :: k).
(Literal r val typ, RenderStatement r stmt) =>
(r val -> Doc) -> Terminator -> ClassName -> MS (r stmt)
throw r val -> Doc
f Terminator
t ClassName
l = do
  msg <- LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> StateT ValueState Identity (r val)
-> StateT MethodState Identity (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS (ClassName -> StateT ValueState Identity (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
ClassName -> VS (r val)
IC.litString ClassName
l)
  stmtFromData (f msg) t

newtype OptionalSpace = OSpace {OptionalSpace -> Doc
oSpace :: Doc}

defaultOptSpace :: OptionalSpace
defaultOptSpace :: OptionalSpace
defaultOptSpace = OSpace {oSpace :: Doc
oSpace = Doc
space}

optSpaceDoc :: OptionalSpace -> Doc
optSpaceDoc :: OptionalSpace -> Doc
optSpaceDoc OSpace {oSpace :: OptionalSpace -> Doc
oSpace = Doc
sp} = Doc
sp

-- ControlStatements --

-- 1st parameter is a Doc function to use on the render of each condition (i.e. parens)
-- 2nd parameter is the syntax for starting a block in an if-condition
-- 3rd parameter is the keyword for an else-if statement
-- 4th parameter is the syntax for ending a block in an if-condition
-- 5th parameter is the syntax for ending an if-statement
ifCond
  :: (RC.BodyElim r bod, RenderStatement r stmt, ValueElim r val)
  => (Doc -> Doc)
  -> Doc
  -> OptionalSpace
  -> Doc
  -> Doc
  -> Doc
  -> [(VS (r val), MS (r bod))]
  -> MS (r bod)
  -> MS (r stmt)
ifCond :: forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(VS (r val), MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
ifCond Doc -> Doc
_ Doc
_ OptionalSpace
_ Doc
_ Doc
_ Doc
_ [] MS (r bod)
_ = ClassName -> MS (r stmt)
forall a. HasCallStack => ClassName -> a
error ClassName
"if condition created with no cases"
ifCond Doc -> Doc
f Doc
ifStart OptionalSpace
os Doc
elif Doc
bEnd Doc
ifEnd ((VS (r val), MS (r bod))
c:[(VS (r val), MS (r bod))]
cs) MS (r bod)
eBody =
    let ifSect :: (VS (r val), MS (r bod)) -> State MethodState Doc
ifSect (VS (r val)
v, MS (r bod)
b) = (r val -> r bod -> Doc)
-> State MethodState (r val) -> MS (r bod) -> State MethodState Doc
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\r val
val r bod
bd -> [Doc] -> Doc
vcat [
          Doc
ifLabel Doc -> Doc -> Doc
<+> Doc -> Doc
f (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
val) Doc -> Doc -> Doc
<> OptionalSpace -> Doc
optSpaceDoc OptionalSpace
os Doc -> Doc -> Doc
<> Doc
ifStart,
          Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
bd,
          Doc
bEnd]) (LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> VS (r val) -> State MethodState (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r val)
v) MS (r bod)
b
        elseIfSect :: (VS (r val), MS (r bod)) -> State MethodState Doc
elseIfSect (VS (r val)
v, MS (r bod)
b) = (r val -> r bod -> Doc)
-> State MethodState (r val) -> MS (r bod) -> State MethodState Doc
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\r val
val r bod
bd -> [Doc] -> Doc
vcat [
          Doc
elif Doc -> Doc -> Doc
<+> Doc -> Doc
f (r val -> Doc
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Doc
RC.value r val
val) Doc -> Doc -> Doc
<> OptionalSpace -> Doc
optSpaceDoc OptionalSpace
os Doc -> Doc -> Doc
<> Doc
ifStart,
          Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
bd,
          Doc
bEnd]) (LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
-> VS (r val) -> State MethodState (r val)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r val))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r val) ValueState)
-> MethodState -> Focusing Identity (r val) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r val)
v) MS (r bod)
b
        elseSect :: State MethodState Doc
elseSect = (r bod -> Doc) -> MS (r bod) -> State MethodState Doc
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\r bod
bd -> Doc -> Doc -> Doc
emptyIfEmpty (r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
bd) ([Doc] -> Doc
vcat [
          Doc
elseLabel Doc -> Doc -> Doc
<> OptionalSpace -> Doc
optSpaceDoc OptionalSpace
os Doc -> Doc -> Doc
<> Doc
ifStart,
          Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
bd,
          Doc
bEnd]) Doc -> Doc -> Doc
$+$ Doc
ifEnd) MS (r bod)
eBody
    in [State MethodState Doc] -> StateT MethodState Identity [Doc]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence ((VS (r val), MS (r bod)) -> State MethodState Doc
ifSect (VS (r val), MS (r bod))
c State MethodState Doc
-> [State MethodState Doc] -> [State MethodState Doc]
forall a. a -> [a] -> [a]
: ((VS (r val), MS (r bod)) -> State MethodState Doc)
-> [(VS (r val), MS (r bod))] -> [State MethodState Doc]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (VS (r val), MS (r bod)) -> State MethodState Doc
elseIfSect [(VS (r val), MS (r bod))]
cs [State MethodState Doc]
-> [State MethodState Doc] -> [State MethodState Doc]
forall a. Semigroup a => a -> a -> a
P.<> [State MethodState Doc
elseSect])
      StateT MethodState Identity [Doc]
-> ([Doc] -> MS (r stmt)) -> MS (r stmt)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Doc -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd (Doc -> MS (r stmt)) -> ([Doc] -> Doc) -> [Doc] -> MS (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc] -> Doc
vcat)

tryCatch :: (RenderStatement r stmt) => (r bod -> r bod -> Doc) ->
  MS (r bod) -> MS (r bod) -> MS (r stmt)
tryCatch :: forall {k} (r :: k -> *) (stmt :: k) (bod :: k).
RenderStatement r stmt =>
(r bod -> r bod -> Doc) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
tryCatch r bod -> r bod -> Doc
f = (r bod -> r bod -> StateT MethodState Identity (r stmt))
-> StateT MethodState Identity (r bod)
-> StateT MethodState Identity (r bod)
-> StateT MethodState Identity (r stmt)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\r bod
tb1 r bod
tb2 -> Doc -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd (r bod -> r bod -> Doc
f r bod
tb1 r bod
tb2))

-- Methods --

construct :: (Monad r) => Label -> MS (r TypeData)
construct :: forall (r :: * -> *). Monad r => ClassName -> MS (r TypeData)
construct ClassName
n = 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
$ CodeType
-> ClassName -> Doc -> StateT ValueState Identity (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> ClassName -> Doc -> VS (r TypeData)
typeFromData (ClassName -> CodeType
Object ClassName
n) ClassName
n Doc
empty

param
  :: (RenderParam r param var, VariableElim r var typ)
  => (r var -> Doc) -> VS (r var) -> MS (r param)
param :: forall {k} (r :: k -> *) (param :: k) (var :: k) (typ :: k).
(RenderParam r param var, VariableElim r var typ) =>
(r var -> Doc) -> VS (r var) -> MS (r param)
param r var -> Doc
f VS (r var)
v' = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
v'
  let n = r var -> ClassName
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> ClassName
variableName r var
v
  modify $ addParameter n
  modify $ useVarName n
  paramFromData v' $ f v

method
  :: (MethodTypeSym r typ, OORenderMethod r mthd attch vis param bod typ)
  => Label
  -> r vis
  -> r attch
  -> VS (r typ)
  -> [MS (r param)]
  -> MS (r bod)
  -> MS (r mthd)
method :: forall {k} (r :: k -> *) (typ :: k) (mthd :: k) (attch :: k)
       (vis :: k) (param :: k) (bod :: k).
(MethodTypeSym r typ,
 OORenderMethod r mthd attch vis param bod typ) =>
ClassName
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method ClassName
n r vis
s r attch
p VS (r typ)
t = Bool
-> ClassName
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (typ :: k).
OORenderMethod r mthd attch vis param bod typ =>
Bool
-> ClassName
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
intMethod Bool
False ClassName
n r vis
s r attch
p (VS (r typ) -> MS (r typ)
forall {k} (r :: k -> *) (typ :: k).
MethodTypeSym r typ =>
VS (r typ) -> MS (r typ)
mType VS (r typ)
t)

getMethod
  :: (OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => VS (r var) -> MS (r mthd)
getMethod :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
VS (r var) -> MS (r mthd)
getMethod VS (r var)
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
v StateT MethodState Identity (r var)
-> (r var -> StateT MethodState Identity (r mthd))
-> StateT MethodState Identity (r mthd)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\r var
vr -> ClassName
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> StateT MethodState Identity (r mthd)
forall {k} (r :: k -> *) (typ :: k) (mthd :: k) (attch :: k)
       (vis :: k) (param :: k) (bod :: k).
(MethodTypeSym r typ,
 OORenderMethod r mthd attch vis param bod typ) =>
ClassName
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method (ClassName -> ClassName
getterName (ClassName -> ClassName) -> ClassName -> ClassName
forall a b. (a -> b) -> a -> b
$ r var -> ClassName
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> ClassName
variableName
  r var
vr) r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel (r typ -> VS (r typ)
forall a s. a -> State s a
toState (r typ -> VS (r typ)) -> r typ -> VS (r typ)
forall a b. (a -> b) -> a -> b
$ r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
vr) [] MS (r bod)
getBody)
  where getBody :: MS (r bod)
getBody = MS (r stmt) -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (r stmt) -> MS (r bod)) -> MS (r stmt) -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r stmt)
IC.returnStmt (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf (VS (r var) -> VS (r val)) -> VS (r var) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(OOVariableSym r var val typ, SelfSym r var,
 VariableValue r var val) =>
VS (r var) -> VS (r var)
IG.instanceVarSelf VS (r var)
v)

setMethod
  :: (OORenderSym r file mod cls stvr mthd attch vis param bod block stmt var scope val binder typ)
  => VS (r var) -> MS (r mthd)
setMethod :: forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
VS (r var) -> MS (r mthd)
setMethod VS (r var)
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS VS (r var)
v StateT MethodState Identity (r var)
-> (r var -> StateT MethodState Identity (r mthd))
-> StateT MethodState Identity (r mthd)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\r var
vr -> ClassName
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> StateT MethodState Identity (r mthd)
forall {k} (r :: k -> *) (typ :: k) (mthd :: k) (attch :: k)
       (vis :: k) (param :: k) (bod :: k).
(MethodTypeSym r typ,
 OORenderMethod r mthd attch vis param bod typ) =>
ClassName
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method (ClassName -> ClassName
setterName (ClassName -> ClassName) -> ClassName -> ClassName
forall a b. (a -> b) -> a -> b
$ r var -> ClassName
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> ClassName
variableName
  r var
vr) r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.void [VS (r var) -> MS (r param)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
IC.param VS (r var)
v] MS (r bod)
setBody)
  where setBody :: MS (r bod)
setBody = MS (r stmt) -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (r stmt) -> MS (r bod)) -> MS (r stmt) -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(OOVariableSym r var val typ, SelfSym r var,
 VariableValue r var val) =>
VS (r var) -> VS (r var)
IG.instanceVarSelf VS (r var)
v VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf VS (r var)
v

initStmts
  ::
    ( OOVariableSym r var val typ
    , VariableValue r var val
    , SelfSym r var
    , AssignStatement r stmt var val
    , BlockSym r block stmt
    , BodySym r bod block
    )
  => Initializers r var val -> MS (r bod)
initStmts :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k)
       (stmt :: k) (block :: k) (bod :: k).
(OOVariableSym r var val typ, VariableValue r var val,
 SelfSym r var, AssignStatement r stmt var val,
 BlockSym r block stmt, BodySym r bod block) =>
Initializers r var val -> MS (r bod)
initStmts = [MS (r stmt)] -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements ([MS (r stmt)] -> MS (r bod))
-> (Initializers r var val -> [MS (r stmt)])
-> Initializers r var val
-> MS (r bod)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((VS (r var), VS (r val)) -> MS (r stmt))
-> Initializers r var val -> [MS (r stmt)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(VS (r var)
vr, VS (r val)
vl) -> VS (r var) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(OOVariableSym r var val typ, SelfSym r var,
 VariableValue r var val) =>
VS (r var) -> VS (r var)
IG.instanceVarSelf VS (r var)
vr VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (r val)
vl)

function
  ::
    ( AttachmentSym r attch
    , MethodTypeSym r typ
    , OORenderMethod r mthd attch vis param bod typ
    )
  => Label -> r vis -> VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd)
function :: forall {k} (r :: k -> *) (attch :: k) (typ :: k) (mthd :: k)
       (vis :: k) (param :: k) (bod :: k).
(AttachmentSym r attch, MethodTypeSym r typ,
 OORenderMethod r mthd attch vis param bod typ) =>
ClassName
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function ClassName
n r vis
s VS (r typ)
t = Bool
-> ClassName
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (typ :: k).
OORenderMethod r mthd attch vis param bod typ =>
Bool
-> ClassName
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
RO.intFunc Bool
False ClassName
n r vis
s r attch
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel (VS (r typ) -> MS (r typ)
forall {k} (r :: k -> *) (typ :: k).
MethodTypeSym r typ =>
VS (r typ) -> MS (r typ)
mType VS (r typ)
t)

docFuncRepr
  :: (BlockCommentSym r, RenderMethod r mthd)
  => FuncDocRenderer
  -> String
  -> [String]
  -> [String]
  -> MS (r mthd)
  -> MS (r mthd)
docFuncRepr :: forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> ClassName
-> [ClassName]
-> [ClassName]
-> MS (r mthd)
-> MS (r mthd)
docFuncRepr FuncDocRenderer
f ClassName
desc [ClassName]
pComms [ClassName]
rComms = MS (r Doc) -> MS (r mthd) -> MS (r mthd)
forall (r :: * -> *) mthd.
RenderMethod r mthd =>
MS (r Doc) -> MS (r mthd) -> MS (r mthd)
commentedFunc (State MethodState [ClassName] -> MS (r Doc)
forall a. State a [ClassName] -> State a (r Doc)
forall (r :: * -> *) a.
BlockCommentSym r =>
State a [ClassName] -> State a (r Doc)
docComment (State MethodState [ClassName] -> MS (r Doc))
-> State MethodState [ClassName] -> MS (r Doc)
forall a b. (a -> b) -> a -> b
$ ([ClassName] -> [ClassName])
-> State MethodState [ClassName] -> State MethodState [ClassName]
forall a b s. (a -> b) -> State s a -> State s b
onStateValue
  (\[ClassName]
ps -> FuncDocRenderer
f ClassName
desc ([ClassName] -> [ClassName] -> [(ClassName, ClassName)]
forall a b. [a] -> [b] -> [(a, b)]
zip [ClassName]
ps [ClassName]
pComms) [ClassName]
rComms) State MethodState [ClassName]
getParameters)

docFunc
  :: (BlockCommentSym r, RenderMethod r mthd)
  => FuncDocRenderer
  -> String
  -> [String]
  -> Maybe String
  -> MS (r mthd)
  -> MS (r mthd)
docFunc :: forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> ClassName
-> [ClassName]
-> Maybe ClassName
-> MS (r mthd)
-> MS (r mthd)
docFunc FuncDocRenderer
f ClassName
desc [ClassName]
pComms Maybe ClassName
rComm = FuncDocRenderer
-> ClassName
-> [ClassName]
-> [ClassName]
-> MS (r mthd)
-> MS (r mthd)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> ClassName
-> [ClassName]
-> [ClassName]
-> MS (r mthd)
-> MS (r mthd)
docFuncRepr FuncDocRenderer
f ClassName
desc [ClassName]
pComms (Maybe ClassName -> [ClassName]
forall a. Maybe a -> [a]
maybeToList Maybe ClassName
rComm)

-- Classes --

buildClass
  :: (RenderClass r cls stvr mthd vis, VisibilitySym r vis)
  => Maybe Label
  -> [CSStateVar r stvr]
  -> [MS (r mthd)]
  -> [MS (r mthd)]
  -> CS (r cls)
buildClass :: forall (r :: * -> *) cls stvr mthd vis.
(RenderClass r cls stvr mthd vis, VisibilitySym r vis) =>
Maybe ClassName
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
buildClass Maybe ClassName
p [CSStateVar r stvr]
stVars [MS (r mthd)]
constructors [MS (r mthd)]
methods = do
  n <- LensLike'
  (Zoomed (StateT FileState Identity) ClassName) ClassState FileState
-> StateT FileState Identity ClassName
-> StateT ClassState Identity ClassName
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) ClassState FileState
-> StateT FileState 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 FileState Identity) ClassName) ClassState FileState
(FileState -> Focusing Identity ClassName FileState)
-> ClassState -> Focusing Identity ClassName ClassState
Lens' ClassState FileState
lensCStoFS StateT FileState Identity ClassName
getModuleName
  RO.intClass n public (inherit p) stVars constructors methods

implementingClass
  :: (RenderClass r cls stvr mthd vis, VisibilitySym r vis)
  => Label
  -> [Label]
  -> [CSStateVar r stvr]
  -> [MS (r mthd)]
  -> [MS (r mthd)]
  -> CS (r cls)
implementingClass :: forall (r :: * -> *) cls stvr mthd vis.
(RenderClass r cls stvr mthd vis, VisibilitySym r vis) =>
ClassName
-> [ClassName]
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
implementingClass ClassName
n [ClassName]
is = ClassName
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
forall (r :: * -> *) cls stvr mthd vis.
RenderClass r cls stvr mthd vis =>
ClassName
-> r vis
-> r Doc
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
RO.intClass ClassName
n r vis
forall {k} (r :: k -> *) (vis :: k). VisibilitySym r vis => r vis
public ([ClassName] -> r Doc
forall (r :: * -> *) cls stvr mthd vis.
RenderClass r cls stvr mthd vis =>
[ClassName] -> r Doc
implements [ClassName]
is)

docClass
  :: (BlockCommentSym r, RenderClass r cls stvr mthd vis)
  => ClassDocRenderer -> String -> CS (r cls) -> CS (r cls)
docClass :: forall (r :: * -> *) cls stvr mthd vis.
(BlockCommentSym r, RenderClass r cls stvr mthd vis) =>
ClassDocRenderer -> ClassName -> CS (r cls) -> CS (r cls)
docClass ClassDocRenderer
cdr ClassName
d = CS (r Doc) -> CS (r cls) -> CS (r cls)
forall (r :: * -> *) cls stvr mthd vis.
RenderClass r cls stvr mthd vis =>
CS (r Doc) -> CS (r cls) -> CS (r cls)
RO.commentedClass (State ClassState [ClassName] -> CS (r Doc)
forall a. State a [ClassName] -> State a (r Doc)
forall (r :: * -> *) a.
BlockCommentSym r =>
State a [ClassName] -> State a (r Doc)
docComment (State ClassState [ClassName] -> CS (r Doc))
-> State ClassState [ClassName] -> CS (r Doc)
forall a b. (a -> b) -> a -> b
$ [ClassName] -> State ClassState [ClassName]
forall a s. a -> State s a
toState ([ClassName] -> State ClassState [ClassName])
-> [ClassName] -> State ClassState [ClassName]
forall a b. (a -> b) -> a -> b
$ ClassDocRenderer
cdr ClassName
d)

commentedClass
  :: (RC.BlockCommentElim r, RO.ClassElim r cls, Monad r)
  => CS (r Doc) -> CS (r cls) -> CS (r Doc)
commentedClass :: forall (r :: * -> *) cls.
(BlockCommentElim r, ClassElim r cls, Monad r) =>
CS (r Doc) -> CS (r cls) -> CS (r Doc)
commentedClass = (r Doc -> r cls -> r Doc)
-> State ClassState (r Doc)
-> State ClassState (r cls)
-> State ClassState (r Doc)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\r Doc
cmt r cls
cs -> 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 -> Doc -> Doc
R.commentedItem
  (r Doc -> Doc
forall (r :: * -> *). BlockCommentElim r => r Doc -> Doc
RC.blockComment' r Doc
cmt) (r cls -> Doc
forall {k} (r :: k -> *) (cls :: k).
ClassElim r cls =>
r cls -> Doc
RO.class' r cls
cs))

-- Modules --

modFromData :: Label -> (Doc -> r mod) -> FS Doc -> FS (r mod)
modFromData :: forall {k} (r :: k -> *) (mod :: k).
ClassName -> (Doc -> r mod) -> FS Doc -> FS (r mod)
modFromData ClassName
n Doc -> r mod
f FS Doc
d = (FileState -> FileState) -> StateT FileState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (ClassName -> FileState -> FileState
setModuleName ClassName
n) StateT FileState Identity ()
-> StateT FileState Identity (r mod)
-> StateT FileState Identity (r mod)
forall a b.
StateT FileState Identity a
-> StateT FileState Identity b -> StateT FileState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Doc -> r mod) -> FS Doc -> StateT FileState Identity (r mod)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue Doc -> r mod
f FS Doc
d

-- Files --

fileDoc
  :: (RC.BlockElim r block, RenderMod r mod, RenderFile r file mod)
  => String -> (r mod -> r block) -> r block -> FS (r mod) -> FS (r file)
fileDoc :: forall (r :: * -> *) block mod file.
(BlockElim r block, RenderMod r mod, RenderFile r file mod) =>
ClassName
-> (r mod -> r block) -> r block -> FS (r mod) -> FS (r file)
fileDoc ClassName
ext r mod -> r block
topb r block
botb FS (r mod)
mdl = do
  m <- FS (r mod)
mdl
  nm <- getModuleName
  let fp = ClassName -> ClassName -> ClassName
addExt ClassName
ext ClassName
nm
      updm = (Doc -> Doc) -> r mod -> r mod
forall {k} (r :: k -> *) (mod :: k).
RenderMod r mod =>
(Doc -> Doc) -> r mod -> r mod
updateModuleDoc (\Doc
d -> Doc -> Doc -> Doc
emptyIfEmpty Doc
d
        (Doc -> Doc -> Doc -> Doc
R.file (r block -> Doc
forall {k} (r :: k -> *) (block :: k).
BlockElim r block =>
r block -> Doc
RC.block (r block -> Doc) -> r block -> Doc
forall a b. (a -> b) -> a -> b
$ r mod -> r block
topb r mod
m) Doc
d (r block -> Doc
forall {k} (r :: k -> *) (block :: k).
BlockElim r block =>
r block -> Doc
RC.block r block
botb))) r mod
m
  RO.fileFromData fp (toState updm)

-- | Generates a file for a documented module.
--   mdr is a function that takes description, author, and module name and
--                                                     returns a doc comment
--   e is the file extension
--   d is the description (I think)
--   a is a list of authors
--   dt is the date
--   fl is the file
docMod
  :: (BlockCommentSym r, RenderFile r file mod)
  => ModuleDocRenderer
  -> String
  -> String
  -> String
  -> [String]
  -> String
  -> FS (r file)
  -> FS (r file)
docMod :: forall (r :: * -> *) file mod.
(BlockCommentSym r, RenderFile r file mod) =>
ModuleDocRenderer
-> ClassName
-> ClassName
-> ClassName
-> [ClassName]
-> ClassName
-> FS (r file)
-> FS (r file)
docMod ModuleDocRenderer
mdr ClassName
e ClassName
wm ClassName
d [ClassName]
a ClassName
dt FS (r file)
fl = FS (r file) -> FS (r Doc) -> FS (r file)
forall (r :: * -> *) file mod.
RenderFile r file mod =>
FS (r file) -> FS (r Doc) -> FS (r file)
commentedMod FS (r file)
fl (State FileState [ClassName] -> FS (r Doc)
forall a. State a [ClassName] -> State a (r Doc)
forall (r :: * -> *) a.
BlockCommentSym r =>
State a [ClassName] -> State a (r Doc)
docComment (State FileState [ClassName] -> FS (r Doc))
-> State FileState [ClassName] -> FS (r Doc)
forall a b. (a -> b) -> a -> b
$ ModuleDocRenderer
mdr ClassName
wm ClassName
d [ClassName]
a ClassName
dt ClassDocRenderer -> (ClassName -> ClassName) -> ClassDocRenderer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ClassName -> ClassName -> ClassName
addExt ClassName
e
  ClassDocRenderer
-> StateT FileState Identity ClassName
-> State FileState [ClassName]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT FileState Identity ClassName
getModuleName)

fileFromData
  :: (RO.ModuleElim r mod)
  => (FilePath -> r mod -> r file) -> FilePath -> FS (r mod) -> FS (r file)
fileFromData :: forall {k} (r :: k -> *) (mod :: k) (file :: k).
ModuleElim r mod =>
(ClassName -> r mod -> r file)
-> ClassName -> FS (r mod) -> FS (r file)
fileFromData ClassName -> r mod -> r file
f ClassName
fpath FS (r mod)
mdl' = do
  -- Add this file to list of files as long as it is not empty
  mdl <- FS (r mod)
mdl'
  modify (\FileState
s -> if Doc -> Bool
isEmpty (r mod -> Doc
forall {k} (r :: k -> *) (mod :: k).
ModuleElim r mod =>
r mod -> Doc
RO.module' r mod
mdl)
    then FileState
s
    else ASetter FileState FileState GOOLState GOOLState
-> (GOOLState -> GOOLState) -> FileState -> FileState
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter FileState FileState GOOLState GOOLState
Lens' FileState GOOLState
lensFStoGS (FileType -> ClassName -> GOOLState -> GOOLState
addFile (FileState
s FileState -> Getting FileType FileState FileType -> FileType
forall s a. s -> Getting a s a -> a
^. Getting FileType FileState FileType
Lens' FileState FileType
currFileType) ClassName
fpath) (FileState -> FileState) -> FileState -> FileState
forall a b. (a -> b) -> a -> b
$
      -- If this is the main source file, set it as the main module in the state
      if FileState
s FileState -> Getting Bool FileState Bool -> Bool
forall s a. s -> Getting a s a -> a
^. Getting Bool FileState Bool
Lens' FileState Bool
currMain Bool -> Bool -> Bool
&& FileType -> Bool
isSource (FileState
s FileState -> Getting FileType FileState FileType -> FileType
forall s a. s -> Getting a s a -> a
^. Getting FileType FileState FileType
Lens' FileState FileType
currFileType)
        then ASetter FileState FileState GOOLState GOOLState
-> (GOOLState -> GOOLState) -> FileState -> FileState
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
over ASetter FileState FileState GOOLState GOOLState
Lens' FileState GOOLState
lensFStoGS (ClassName -> GOOLState -> GOOLState
setMainMod ClassName
fpath) FileState
s
        else FileState
s)
  pure $ f fpath mdl

-- Helper functions

setEmpty :: (RenderStatement r stmt, StatementElim r stmt) => MS (r stmt) -> MS (r stmt)
setEmpty :: forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
setEmpty MS (r stmt)
s' = MS (r stmt)
s' MS (r stmt) -> (r stmt -> MS (r stmt)) -> MS (r stmt)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Doc -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Doc -> MS (r stmt)
mkStmtNoEnd (Doc -> MS (r stmt)) -> (r stmt -> Doc) -> r stmt -> MS (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r stmt -> Doc
forall {k} (r :: k -> *) (stmt :: k).
StatementElim r stmt =>
r stmt -> Doc
RC.statement