{-# LANGUAGE PostfixOperators #-}

-- | Implementations for C-like renderers are defined here.
module GOOL.Drasil.LanguageRenderer.CLike (charRender, float, double, char, 
  listType, void, notOp, andOp, orOp, self, litTrue, litFalse, litFloat, 
  inlineIf, libFuncAppMixedArgs, libNewObjMixedArgs, listSize, increment1, 
  decrement1, varDec, varDecDef, listDec, extObjDecNew, switch, for, while, 
  intFunc, multiAssignError, multiReturnError, multiTypeError
) where

import Utils.Drasil (indent)

import GOOL.Drasil.CodeType (CodeType(..))
import GOOL.Drasil.ClassInterface (Label, Library, MSBody, VSType, SVariable, 
  SValue, MSStatement, MSParameter, SMethod, MixedCall, MixedCtorCall, 
  PermanenceSym(..), TypeElim(getType, getTypeString), 
  VariableElim(variableType), ValueSym(Value, valueType), extNewObj, ($.), 
  ScopeSym(..))
import qualified GOOL.Drasil.ClassInterface as S (TypeSym(bool, float, obj),
  ValueExpression(funcAppMixedArgs, newObjMixedArgs), 
  DeclStatement(varDec, varDecDef))
import GOOL.Drasil.RendererClasses (MSMthdType, RenderSym, RenderType(..),
  InternalVarElim(variableBind), RenderValue(valFromData), 
  ValueElim(valuePrec), RenderMethod(intMethod))
import qualified GOOL.Drasil.RendererClasses as S (
  InternalListFunc(listSizeFunc), RenderStatement(stmt, loopStmt))
import qualified GOOL.Drasil.RendererClasses as RC (PermElim(..), BodyElim(..), 
  InternalTypeElim(..), InternalVarElim(variable), ValueElim(value), 
  StatementElim(statement))
import GOOL.Drasil.AST (Binding(..), Terminator(..))
import GOOL.Drasil.Helpers (angles, toState, onStateValue)
import GOOL.Drasil.LanguageRenderer (forLabel, whileLabel, containing)
import qualified GOOL.Drasil.LanguageRenderer as R (switch, increment, 
  decrement, this', this)
import GOOL.Drasil.LanguageRenderer.Constructors (mkStmt, mkStmtNoEnd, 
  mkStateVal, mkStateVar, VSOp, unOpPrec, andPrec, orPrec)
import GOOL.Drasil.State (lensMStoVS, lensVStoMS, addLibImportVS, getClassName)

import Prelude hiding (break,(<>))
import Control.Applicative ((<|>))
import Control.Monad.State (modify)
import Control.Lens.Zoom (zoom)
import Text.PrettyPrint.HughesPJ (Doc, text, (<>), (<+>), parens, vcat, semi, 
  equals, empty)
import qualified Text.PrettyPrint.HughesPJ as D (float)

-- Types --

floatRender, doubleRender, charRender, voidRender :: String
floatRender :: String
floatRender = "float"
doubleRender :: String
doubleRender = "double"
charRender :: String
charRender = "char"
voidRender :: String
voidRender = "void"

float :: (RenderSym r) => VSType r
float :: VSType r
float = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Float String
floatRender (String -> Doc
text String
floatRender)

double :: (RenderSym r) => VSType r
double :: VSType r
double = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Double String
doubleRender (String -> Doc
text String
doubleRender)

char :: (RenderSym r) => VSType r
char :: VSType r
char = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Char String
charRender (String -> Doc
text String
charRender)

listType :: (RenderSym r) => String -> VSType r -> VSType r
listType :: String -> VSType r -> VSType r
listType lst :: String
lst t' :: VSType r
t' = do 
  r (Type r)
t <- VSType r
t'
  CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData (CodeType -> CodeType
List (r (Type r) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType r (Type r)
t)) (String
lst 
    String -> String -> String
`containing` r (Type r) -> String
forall (r :: * -> *). TypeElim r => r (Type r) -> String
getTypeString r (Type r)
t) (Doc -> VSType r) -> Doc -> VSType r
forall a b. (a -> b) -> a -> b
$ String -> Doc
text String
lst Doc -> Doc -> Doc
<> Doc -> Doc
angles (r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' r (Type r)
t) 

void :: (RenderSym r) => VSType r
void :: VSType r
void = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Void String
voidRender (String -> Doc
text String
voidRender)

-- Unary Operators --

notOp :: (Monad r) => VSOp r
notOp :: VSOp r
notOp = String -> VSOp r
forall (r :: * -> *). Monad r => String -> VSOp r
unOpPrec "!"

-- Binary Operators --

andOp :: (Monad r) => VSOp r
andOp :: VSOp r
andOp = String -> VSOp r
forall (r :: * -> *). Monad r => String -> VSOp r
andPrec "&&"

orOp :: (Monad r) => VSOp r
orOp :: VSOp r
orOp = String -> VSOp r
forall (r :: * -> *). Monad r => String -> VSOp r
orPrec "||"

-- Variables --

self :: (RenderSym r) => SVariable r
self :: SVariable r
self = do 
  String
l <- LensLike'
  (Zoomed (StateT MethodState Identity) String)
  ValueState
  MethodState
-> StateT MethodState Identity String
-> StateT ValueState Identity String
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT MethodState Identity) String)
  ValueState
  MethodState
Lens' ValueState MethodState
lensVStoMS StateT MethodState Identity String
getClassName 
  String -> VSType r -> Doc -> SVariable r
forall (r :: * -> *).
RenderSym r =>
String -> VSType r -> Doc -> SVariable r
mkStateVar String
R.this (String -> VSType r
forall (r :: * -> *). TypeSym r => String -> VSType r
S.obj String
l) Doc
R.this'

-- Values --

litTrue :: (RenderSym r) => SValue r
litTrue :: SValue r
litTrue = VSType r -> Doc -> SValue r
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal VSType r
forall (r :: * -> *). TypeSym r => VSType r
S.bool (String -> Doc
text "true")

litFalse :: (RenderSym r) => SValue r
litFalse :: SValue r
litFalse = VSType r -> Doc -> SValue r
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal VSType r
forall (r :: * -> *). TypeSym r => VSType r
S.bool (String -> Doc
text "false")

litFloat :: (RenderSym r) => Float -> SValue r
litFloat :: Float -> SValue r
litFloat f :: Float
f = VSType r -> Doc -> SValue r
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal VSType r
forall (r :: * -> *). TypeSym r => VSType r
S.float (Float -> Doc
D.float Float
f Doc -> Doc -> Doc
<> String -> Doc
text "f")

inlineIf :: (RenderSym r) => SValue r -> SValue r -> SValue r -> SValue r
inlineIf :: SValue r -> SValue r -> SValue r -> SValue r
inlineIf c' :: SValue r
c' v1' :: SValue r
v1' v2' :: SValue r
v2' = do
  r (Value r)
c <- SValue r
c'
  r (Value r)
v1 <- SValue r
v1'
  r (Value r)
v2 <- SValue r
v2' 
  Maybe Int -> VSType r -> Doc -> SValue r
forall (r :: * -> *).
RenderValue r =>
Maybe Int -> VSType r -> Doc -> SValue r
valFromData (r (Value r) -> Maybe Int
forall (r :: * -> *). ValueElim r => r (Value r) -> Maybe Int
prec r (Value r)
c) (r (Type r) -> VSType r
forall a s. a -> State s a
toState (r (Type r) -> VSType r) -> r (Type r) -> VSType r
forall a b. (a -> b) -> a -> b
$ r (Value r) -> r (Type r)
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
valueType r (Value r)
v1) 
    (r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
c Doc -> Doc -> Doc
<+> String -> Doc
text "?" Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
v1 Doc -> Doc -> Doc
<+> String -> Doc
text ":" Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
v2) 
  where prec :: r (Value r) -> Maybe Int
prec cd :: r (Value r)
cd = r (Value r) -> Maybe Int
forall (r :: * -> *). ValueElim r => r (Value r) -> Maybe Int
valuePrec r (Value r)
cd Maybe Int -> Maybe Int -> Maybe Int
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> Int -> Maybe Int
forall a. a -> Maybe a
Just 0

libFuncAppMixedArgs :: (RenderSym r) => Library -> MixedCall r
libFuncAppMixedArgs :: String -> MixedCall r
libFuncAppMixedArgs l :: String
l n :: String
n t :: VSType r
t vs :: [SValue r]
vs ns :: NamedArgs r
ns = (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLibImportVS String
l) StateT ValueState Identity () -> SValue r -> SValue r
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> 
  MixedCall r
forall (r :: * -> *). ValueExpression r => MixedCall r
S.funcAppMixedArgs String
n VSType r
t [SValue r]
vs NamedArgs r
ns
  
libNewObjMixedArgs :: (RenderSym r) => Library -> MixedCtorCall r
libNewObjMixedArgs :: String -> MixedCtorCall r
libNewObjMixedArgs l :: String
l tp :: VSType r
tp vs :: [SValue r]
vs ns :: NamedArgs r
ns = (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLibImportVS String
l) StateT ValueState Identity () -> SValue r -> SValue r
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> 
  MixedCtorCall r
forall (r :: * -> *). ValueExpression r => MixedCtorCall r
S.newObjMixedArgs VSType r
tp [SValue r]
vs NamedArgs r
ns

-- Functions --

listSize :: (RenderSym r) => SValue r -> SValue r
listSize :: SValue r -> SValue r
listSize v :: SValue r
v = SValue r
v SValue r -> VSFunction r -> SValue r
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. VSFunction r
forall (r :: * -> *). InternalListFunc r => VSFunction r
S.listSizeFunc

-- Statements --

increment1 :: (RenderSym r) => SVariable r -> MSStatement r
increment1 :: SVariable r -> MSStatement r
increment1 vr' :: SVariable r
vr' = do 
  r (Variable r)
vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SVariable r
vr'
  (Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement r)
-> (r (Variable r) -> Doc) -> r (Variable r) -> MSStatement r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Variable r) -> Doc
forall (r :: * -> *). RenderSym r => r (Variable r) -> Doc
R.increment) r (Variable r)
vr

decrement1 :: (RenderSym r) => SVariable r -> MSStatement r
decrement1 :: SVariable r -> MSStatement r
decrement1 vr' :: SVariable r
vr' = do 
  r (Variable r)
vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SVariable r
vr'
  (Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement r)
-> (r (Variable r) -> Doc) -> r (Variable r) -> MSStatement r
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Variable r) -> Doc
forall (r :: * -> *). RenderSym r => r (Variable r) -> Doc
R.decrement) r (Variable r)
vr

varDec :: (RenderSym r) => r (Permanence r) -> r (Permanence r) -> Doc -> 
  SVariable r -> MSStatement r
varDec :: r (Permanence r)
-> r (Permanence r) -> Doc -> SVariable r -> MSStatement r
varDec s :: r (Permanence r)
s d :: r (Permanence r)
d pdoc :: Doc
pdoc v' :: SVariable r
v' = do 
  r (Variable r)
v <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SVariable r
v' 
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (r (Permanence r) -> Doc
forall (r :: * -> *). PermElim r => r (Permanence r) -> Doc
RC.perm (Binding -> r (Permanence r)
bind (Binding -> r (Permanence r)) -> Binding -> r (Permanence r)
forall a b. (a -> b) -> a -> b
$ r (Variable r) -> Binding
forall (r :: * -> *).
InternalVarElim r =>
r (Variable r) -> Binding
variableBind r (Variable r)
v)
    Doc -> Doc -> Doc
<+> r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' (r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType r (Variable r)
v) Doc -> Doc -> Doc
<+> (CodeType -> Doc
ptrdoc (r (Type r) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType (r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType r (Variable r)
v)) Doc -> Doc -> Doc
<> 
    r (Variable r) -> Doc
forall (r :: * -> *). InternalVarElim r => r (Variable r) -> Doc
RC.variable r (Variable r)
v))
  where bind :: Binding -> r (Permanence r)
bind Static = r (Permanence r)
s
        bind Dynamic = r (Permanence r)
d
        ptrdoc :: CodeType -> Doc
ptrdoc (List _) = Doc
pdoc
        ptrdoc _ = Doc
empty

varDecDef :: (RenderSym r) => Terminator -> SVariable r -> SValue r -> 
  MSStatement r
varDecDef :: Terminator -> SVariable r -> SValue r -> MSStatement r
varDecDef t :: Terminator
t vr :: SVariable r
vr vl' :: SValue r
vl' = do 
  r (Statement r)
vd <- SVariable r -> MSStatement r
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> MSStatement r
S.varDec SVariable r
vr
  r (Value r)
vl <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SValue r
vl'
  let stmtCtor :: Terminator -> Doc -> MS (r (Statement r))
stmtCtor Empty = Doc -> MS (r (Statement r))
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmtNoEnd
      stmtCtor Semi = Doc -> MS (r (Statement r))
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt
  Terminator -> Doc -> MSStatement r
forall (r :: * -> *).
RenderSym r =>
Terminator -> Doc -> MS (r (Statement r))
stmtCtor Terminator
t (r (Statement r) -> Doc
forall (r :: * -> *). StatementElim r => r (Statement r) -> Doc
RC.statement r (Statement r)
vd Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
vl)

listDec :: (RenderSym r) => (r (Value r) -> Doc) -> SValue r -> SVariable r -> 
  MSStatement r
listDec :: (r (Value r) -> Doc) -> SValue r -> SVariable r -> MSStatement r
listDec f :: r (Value r) -> Doc
f vl :: SValue r
vl v :: SVariable r
v = do 
  r (Value r)
sz <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SValue r
vl
  r (Statement r)
vd <- SVariable r -> MSStatement r
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> MSStatement r
S.varDec SVariable r
v
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (r (Statement r) -> Doc
forall (r :: * -> *). StatementElim r => r (Statement r) -> Doc
RC.statement r (Statement r)
vd Doc -> Doc -> Doc
<> r (Value r) -> Doc
f r (Value r)
sz)
  
extObjDecNew :: (RenderSym r) => Library -> SVariable r -> [SValue r] -> 
  MSStatement r
extObjDecNew :: String -> SVariable r -> [SValue r] -> MSStatement r
extObjDecNew l :: String
l v :: SVariable r
v vs :: [SValue r]
vs = SVariable r -> SValue r -> MSStatement r
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> SValue r -> MSStatement r
S.varDecDef SVariable r
v (String -> PosCtorCall r
forall (r :: * -> *). ValueExpression r => String -> PosCtorCall r
extNewObj String
l ((r (Variable r) -> r (Type r))
-> SVariable r -> State ValueState (r (Type r))
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType SVariable r
v)
  [SValue r]
vs)

-- 1st parameter is a Doc function to apply to the render of the control value (i.e. parens)
-- 2nd parameter is a statement to end every case with
switch :: (RenderSym r) => (Doc -> Doc) -> MSStatement r -> SValue r -> 
  [(SValue r, MSBody r)] -> MSBody r -> MSStatement r
switch :: (Doc -> Doc)
-> MSStatement r
-> SValue r
-> [(SValue r, MSBody r)]
-> MSBody r
-> MSStatement r
switch f :: Doc -> Doc
f st :: MSStatement r
st v :: SValue r
v cs :: [(SValue r, MSBody r)]
cs bod :: MSBody r
bod = do
  r (Statement r)
s <- MSStatement r -> MSStatement r
forall (r :: * -> *).
RenderStatement r =>
MSStatement r -> MSStatement r
S.stmt MSStatement r
st
  r (Value r)
val <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SValue r
v
  [r (Value r)]
vals <- ((SValue r, MSBody r) -> StateT MethodState Identity (r (Value r)))
-> [(SValue r, MSBody r)]
-> StateT MethodState Identity [r (Value r)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS (SValue r -> StateT MethodState Identity (r (Value r)))
-> ((SValue r, MSBody r) -> SValue r)
-> (SValue r, MSBody r)
-> StateT MethodState Identity (r (Value r))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SValue r, MSBody r) -> SValue r
forall a b. (a, b) -> a
fst) [(SValue r, MSBody r)]
cs
  [r (Body r)]
bods <- ((SValue r, MSBody r) -> MSBody r)
-> [(SValue r, MSBody r)]
-> StateT MethodState Identity [r (Body r)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (SValue r, MSBody r) -> MSBody r
forall a b. (a, b) -> b
snd [(SValue r, MSBody r)]
cs
  r (Body r)
dflt <- MSBody r
bod
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement r) -> Doc -> MSStatement r
forall a b. (a -> b) -> a -> b
$ (Doc -> Doc)
-> r (Statement r)
-> r (Value r)
-> r (Body r)
-> [(r (Value r), r (Body r))]
-> Doc
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc)
-> r (Statement r)
-> r (Value r)
-> r (Body r)
-> [(r (Value r), r (Body r))]
-> Doc
R.switch Doc -> Doc
f r (Statement r)
s r (Value r)
val r (Body r)
dflt ([r (Value r)] -> [r (Body r)] -> [(r (Value r), r (Body r))]
forall a b. [a] -> [b] -> [(a, b)]
zip [r (Value r)]
vals [r (Body r)]
bods)

for :: (RenderSym r) => Doc -> Doc -> MSStatement r -> SValue r -> 
  MSStatement r -> MSBody r -> MSStatement r
for :: Doc
-> Doc
-> MSStatement r
-> SValue r
-> MSStatement r
-> MSBody r
-> MSStatement r
for bStart :: Doc
bStart bEnd :: Doc
bEnd sInit :: MSStatement r
sInit vGuard :: SValue r
vGuard sUpdate :: MSStatement r
sUpdate b :: MSBody r
b = do
  r (Statement r)
initl <- MSStatement r -> MSStatement r
forall (r :: * -> *).
RenderStatement r =>
MSStatement r -> MSStatement r
S.loopStmt MSStatement r
sInit
  r (Value r)
guard <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SValue r
vGuard
  r (Statement r)
upd <- MSStatement r -> MSStatement r
forall (r :: * -> *).
RenderStatement r =>
MSStatement r -> MSStatement r
S.loopStmt MSStatement r
sUpdate
  r (Body r)
bod <- MSBody r
b
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmtNoEnd (Doc -> MSStatement r) -> Doc -> MSStatement r
forall a b. (a -> b) -> a -> b
$ [Doc] -> Doc
vcat [
    Doc
forLabel Doc -> Doc -> Doc
<+> Doc -> Doc
parens (r (Statement r) -> Doc
forall (r :: * -> *). StatementElim r => r (Statement r) -> Doc
RC.statement r (Statement r)
initl Doc -> Doc -> Doc
<> Doc
semi Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
guard Doc -> Doc -> Doc
<> 
      Doc
semi Doc -> Doc -> Doc
<+> r (Statement r) -> Doc
forall (r :: * -> *). StatementElim r => r (Statement r) -> Doc
RC.statement r (Statement r)
upd) Doc -> Doc -> Doc
<+> Doc
bStart,
    Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
bod,
    Doc
bEnd]
  
-- Doc function parameter is applied to the render of the while-condition
while :: (RenderSym r) => (Doc -> Doc) -> Doc -> Doc -> SValue r -> MSBody r -> 
  MSStatement r
while :: (Doc -> Doc) -> Doc -> Doc -> SValue r -> MSBody r -> MSStatement r
while f :: Doc -> Doc
f bStart :: Doc
bStart bEnd :: Doc
bEnd v' :: SValue r
v' b' :: MSBody r
b'= do 
  r (Value r)
v <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r (Value r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Value r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SValue r
v'
  r (Body r)
b <- MSBody r
b'
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmtNoEnd ([Doc] -> Doc
vcat [Doc
whileLabel Doc -> Doc -> Doc
<+> Doc -> Doc
f (r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
v) Doc -> Doc -> Doc
<+> Doc
bStart, 
    Doc -> Doc
indent (Doc -> Doc) -> Doc -> Doc
forall a b. (a -> b) -> a -> b
$ r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
b, 
    Doc
bEnd]) 

-- Methods --

intFunc :: (RenderSym r) => Bool -> Label -> r (Scope r) -> r (Permanence r) -> 
  MSMthdType r -> [MSParameter r] -> MSBody r -> SMethod r
intFunc :: Bool
-> String
-> r (Scope r)
-> r (Permanence r)
-> MSMthdType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
intFunc = Bool
-> String
-> r (Scope r)
-> r (Permanence r)
-> MSMthdType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
forall (r :: * -> *).
RenderMethod r =>
Bool
-> String
-> r (Scope r)
-> r (Permanence r)
-> MSMthdType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
intMethod

-- Error Messages --

multiAssignError :: String -> String
multiAssignError :: String -> String
multiAssignError l :: String
l = "No multiple assignment statements in " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
l

multiReturnError :: String -> String
multiReturnError :: String -> String
multiReturnError l :: String
l = "Cannot return multiple values in " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
l

multiTypeError :: String -> String
multiTypeError :: String -> String
multiTypeError l :: String
l = "Multi-types not supported in " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
l