-- | Language-polymorphic functions that are defined by GOOL code
module Drasil.Shared.LanguageRenderer.Macros (
  ifExists, decrement1, increment, increment1, runStrategy,
  listSlice, makeSetterVal, stringListVals, stringListLists, forRange,
  notifyObservers, notifyObservers', arrayDecAsList
) where

import Drasil.Shared.CodeType (CodeType(..))
import Drasil.Shared.InterfaceCommon (Label, bodyStatements, oneLiner,
  VariableSym, VariableElim(..), getCodeType, listOf, ValueSym(valueType),
  NumericExpression((#+), (#-), (#*), (#/)), Comparison(..),
  BooleanExpression((?&&), (?||)), List, at, EmptyStatement(emptyStmt),
  MultiStatement(multi), ValueStatement(valStmt),
  AssignStatement((&+=), (&-=), (&++)), (&=), convScope, VariableValue, BodySym,
  ControlStatement, DeclStatement, Literal)
import qualified Drasil.Shared.InterfaceCommon as IC
import Drasil.GOOL.InterfaceGOOL (($.), observerListName, OOFunctionSym)
import Drasil.Shared.RendererClassesCommon (RenderValue(cast),
  ValueElim(valueInt))
import qualified Drasil.Shared.RendererClassesCommon as S (
  RenderStatement(stmt), RenderValue)
import qualified Drasil.Shared.RendererClassesCommon as RC (BodyElim(..),
  StatementElim(statement))
import Drasil.Shared.Helpers (toCode, onStateValue, on2StateValues)
import Drasil.Shared.State (MS, VS, MS, lensMStoVS, genVarName, genLoopIndex,
  genVarNameIf, getVarScope)
import Drasil.Shared.AST (ScopeData, FuncData)

import Data.Maybe (fromMaybe, isNothing)
import Data.Functor ((<&>))
import Control.Lens.Zoom (zoom)
import Text.PrettyPrint.HughesPJ (Doc, vcat)

ifExists
  ::
    ( IC.ControlStatement r bod stmt var val
    , IC.ValueExpression r var val binder typ
    )
  => VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
ifExists :: forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k) (binder :: k) (typ :: k).
(ControlStatement r bod stmt var val,
 ValueExpression r var val binder typ) =>
VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
ifExists VS (r val)
v MS (r bod)
ifBody = [(VS (r val), MS (r bod))] -> 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 val), MS (r bod))] -> MS (r bod) -> MS (r stmt)
IC.ifCond [(VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
VS (r val) -> VS (r val)
IC.notNull VS (r val)
v, MS (r bod)
ifBody)]

decrement1
  :: (IC.AssignStatement r stmt var val, IC.Literal r val typ)
  => VS (r var) -> MS (r stmt)
decrement1 :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, Literal r val typ) =>
VS (r var) -> MS (r stmt)
decrement1 VS (r var)
v = 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)
&-= Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1

increment
  ::
    ( IC.AssignStatement r stmt var val
    , IC.NumericExpression r val
    , IC.VariableValue r var val
    )
  => VS (r var) -> VS (r val) -> MS (r stmt)
increment :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
(AssignStatement r stmt var val, NumericExpression r val,
 VariableValue r var val) =>
VS (r var) -> VS (r val) -> MS (r stmt)
increment VS (r var)
vr VS (r val)
vl = VS (r var)
vr VS (r var) -> VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (r 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)
vr 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)
vl

increment1
  :: (IC.AssignStatement r stmt var val, IC.Literal r val typ)
  => VS (r var) -> MS (r stmt)
increment1 :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, Literal r val typ) =>
VS (r var) -> MS (r stmt)
increment1 VS (r var)
vr = 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)
&+= Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1

strat
  :: (RC.BodyElim r bod, Monad r, RC.StatementElim r stmt)
  => MS (r stmt) -> MS (r bod) -> MS (r Doc)
strat :: forall (r :: * -> *) bod stmt.
(BodyElim r bod, Monad r, StatementElim r stmt) =>
MS (r stmt) -> MS (r bod) -> MS (r Doc)
strat = (r stmt -> r bod -> r Doc)
-> State MethodState (r stmt)
-> State MethodState (r bod)
-> State MethodState (r Doc)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\r stmt
result r bod
b -> 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
vcat [r bod -> Doc
forall {k} (r :: k -> *) (bod :: k). BodyElim r bod => r bod -> Doc
RC.body r bod
b,
  r stmt -> Doc
forall {k} (r :: k -> *) (stmt :: k).
StatementElim r stmt =>
r stmt -> Doc
RC.statement r stmt
result])

runStrategy
  :: ( EmptyStatement r stmt
     , IC.AssignStatement r stmt var val
     , RC.BodyElim r bod
     , Monad r
     , S.RenderStatement r stmt
     , RC.StatementElim r stmt
     )
  => Label
  -> [(Label, MS (r bod))]
  -> Maybe (VS (r val))
  -> Maybe (VS (r var))
  -> MS (r Doc)
runStrategy :: forall (r :: * -> *) stmt var val bod.
(EmptyStatement r stmt, AssignStatement r stmt var val,
 BodyElim r bod, Monad r, RenderStatement r stmt,
 StatementElim r stmt) =>
Label
-> [(Label, MS (r bod))]
-> Maybe (VS (r val))
-> Maybe (VS (r var))
-> MS (r Doc)
runStrategy Label
l [(Label, MS (r bod))]
strats Maybe (VS (r val))
rv Maybe (VS (r var))
av = MS (r Doc)
-> (MS (r bod) -> MS (r Doc)) -> Maybe (MS (r bod)) -> MS (r Doc)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe
  (Label -> Label -> MS (r Doc)
forall {a}. Label -> Label -> a
strError Label
l Label
"RunStrategy called on non-existent strategy")
  (MS (r stmt) -> MS (r bod) -> MS (r Doc)
forall (r :: * -> *) bod stmt.
(BodyElim r bod, Monad r, StatementElim r stmt) =>
MS (r stmt) -> MS (r bod) -> MS (r Doc)
strat (MS (r stmt) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
S.stmt MS (r stmt)
resultState)) (Label -> [(Label, MS (r bod))] -> Maybe (MS (r bod))
forall a b. Eq a => a -> [(a, b)] -> Maybe b
lookup Label
l [(Label, MS (r bod))]
strats)
  where resultState :: MS (r stmt)
resultState = MS (r stmt)
-> (VS (r var) -> MS (r stmt)) -> Maybe (VS (r var)) -> MS (r stmt)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt VS (r var) -> MS (r stmt)
asgState Maybe (VS (r var))
av
        asgState :: VS (r var) -> MS (r stmt)
asgState VS (r var)
v = MS (r stmt)
-> (VS (r val) -> MS (r stmt)) -> Maybe (VS (r val)) -> MS (r stmt)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Label -> Label -> MS (r stmt)
forall {a}. Label -> Label -> a
strError Label
l
          Label
"Attempt to assign null return to a Value") (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)
&=) Maybe (VS (r val))
rv
        strError :: Label -> Label -> a
strError Label
n Label
s = Label -> a
forall a. HasCallStack => Label -> a
error (Label -> a) -> Label -> a
forall a b. (a -> b) -> a -> b
$ Label
"Strategy '" Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
<> Label
n Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
<> Label
"': " Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
<> Label
s Label -> Label -> Label
forall a. Semigroup a => a -> a -> a
<> Label
"."

listSlice
  ::
    ( BodySym r bod block
    , IC.BlockSym r block stmt
    , EmptyStatement r stmt
    , IC.ScopeSym r ScopeData
    , IC.DeclStatement r bod stmt var ScopeData val
    , AssignStatement r stmt var val
    , IC.ControlStatement r bod stmt var val
    , IC.TypeSym r typ
    , IC.Literal r val typ
    , BooleanExpression r val
    , Comparison r val
    , NumericExpression r val
    , IC.ValueExpression r var val binder typ
    , VariableSym r var typ
    , IC.VariableValue r var val
    , IC.IndexTranslator r val
    , IC.List r val
    , IC.ListStatement r stmt val
    , ValueElim r val
    , VariableElim r var typ
    )
  => Maybe (VS (r val))
  -> Maybe (VS (r val))
  -> Maybe (VS (r val))
  -> VS (r var)
  -> VS (r val)
  -> MS (r block)
listSlice :: forall (r :: * -> *) bod block stmt var val typ binder.
(BodySym r bod block, BlockSym r block stmt, EmptyStatement r stmt,
 ScopeSym r ScopeData, DeclStatement r bod stmt var ScopeData val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, TypeSym r typ,
 Literal r val typ, BooleanExpression r val, Comparison r val,
 NumericExpression r val, ValueExpression r var val binder typ,
 VariableSym r var typ, VariableValue r var val,
 IndexTranslator r val, List r val, ListStatement r stmt val,
 ValueElim r val, VariableElim r var typ) =>
Maybe (VS (r val))
-> Maybe (VS (r val))
-> Maybe (VS (r val))
-> VS (r var)
-> VS (r val)
-> MS (r block)
listSlice Maybe (VS (r val))
beg Maybe (VS (r val))
end Maybe (VS (r val))
step VS (r var)
vnew VS (r val)
vold = do

  l_temp <- [Label] -> Label -> MS Label
genVarName [] Label
"temp"
  l_i <- genLoopIndex
  vn <- zoom lensMStoVS vnew
  scpData <- getVarScope $ variableName vn
  let scp = ScopeData -> r ScopeData
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeData -> r scope
convScope ScopeData
scpData
      var_temp = Label -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
IC.var Label
l_temp ((r var -> r typ) -> VS (r var) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (r var)
vnew)
      v_temp = 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)
var_temp
      var_i = Label -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
IC.var Label
l_i VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int
      v_i = 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)
var_i

  let step' = VS (r val) -> Maybe (VS (r val)) -> VS (r val)
forall a. a -> Maybe a -> a
fromMaybe (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1) Maybe (VS (r val))
step
  stepV <- zoom lensMStoVS step'
  let mbStepV = r val -> Maybe Integer
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Maybe Integer
valueInt r val
stepV

  -- Generate fresh variable names if required
  begName <- genVarNameIf (isNothing beg && isNothing mbStepV) "begIdx"
  endName <- genVarNameIf (isNothing end && isNothing mbStepV) "endIdx"

  let (setBeg, begVal) = makeSetterVal begName step' mbStepV beg (IC.litInt 0)    (IC.listSize vold #- IC.litInt 1) scp
      (setEnd, endVal) = makeSetterVal endName step' mbStepV end (IC.listSize vold) (IC.litInt (-1)) scp

  mbBegV <- case beg of
        Maybe (VS (r val))
Nothing -> Maybe Integer -> StateT MethodState Identity (Maybe Integer)
forall a. a -> StateT MethodState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Integer
forall a. Maybe a
Nothing
        (Just VS (r val)
b) -> 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)
b StateT MethodState Identity (r val)
-> (r val -> Maybe Integer)
-> StateT MethodState Identity (Maybe Integer)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> r val -> Maybe Integer
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Maybe Integer
valueInt
  mbEndV <- case end of
        Maybe (VS (r val))
Nothing -> Maybe Integer -> StateT MethodState Identity (Maybe Integer)
forall a. a -> StateT MethodState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Integer
forall a. Maybe a
Nothing
        (Just VS (r val)
e) -> 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)
e StateT MethodState Identity (r val)
-> (r val -> Maybe Integer)
-> StateT MethodState Identity (Maybe Integer)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> r val -> Maybe Integer
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Maybe Integer
valueInt
  -- Get the condition for the for-loop
  let cond = case Maybe Integer
mbStepV of
              -- If step is a litInt, do a one-sided check
              (Just Integer
s) -> if Integer
s Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
0 then VS (r val)
v_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)
endVal else VS (r val)
v_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)
endVal
              Maybe Integer
Nothing -> case (Maybe Integer
mbBegV, Maybe Integer
mbEndV) of
                -- If both bounds are litInt's, do a two-sided check.
                -- Also, make sure step is in same direction as check.
                (Just Integer
b, Just Integer
e) -> if Integer
e Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
>= Integer
b
                    then VS (r val)
begVal 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)
v_i VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
v_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)
endVal VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
step' 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
                    else VS (r val)
endVal 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)
v_i VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
v_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)
begVal VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
step' 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
                -- If bounds are not litInt's, do both two-sided checks
                (Maybe Integer, Maybe Integer)
_ ->  VS (r val)
begVal 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)
v_i VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
v_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)
endVal VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
step' 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 VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?||
                      VS (r val)
endVal 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)
v_i VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
v_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)
begVal VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val) -> VS (r val)
?&& VS (r val)
step' 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

  IC.block [
    IC.listDec 0 var_temp scp,
    setBeg, setEnd,
    IC.for (IC.varDecDef var_i IC.local begVal) cond
      (maybe (var_i &++) (var_i &+=) step)
      (oneLiner $ IC.listAppend v_temp (IC.listAccess vold v_i)),
    vnew &= v_temp]

-- Java, C#, C++, and Swift --
-- | Gets the expression and code for setting bounds in a list slice
--   Input:
--   - String: var name for bound (to be created if necessary),
--   - VS val: step value
--   - Maybe Integer: literal value of step, if exists
--   - Maybe VS val: given value of bound
--   - VS val: value of bound if bound not given and step is positive
--   - VS val: value of bound if bound not given and step is negative
--   Output: (VS val): (setter, value) of bound
makeSetterVal
  ::
    ( EmptyStatement r stmt
    , VariableSym r var typ
    , IC.DeclStatement r bod stmt var scope val
    , IC.TypeSym r typ
    , Comparison r val
    , IC.IndexTranslator r val
    , IC.Literal r val typ
    , IC.ValueExpression r var val binder typ
    , IC.VariableValue r var val
    )
  => Label
  -> VS (r val)
  -> Maybe Integer
  -> Maybe (VS (r val))
  -> VS (r val)
  -> VS (r val)
  -> r scope
  -> (MS (r stmt), VS (r val))
makeSetterVal :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (typ :: k)
       (bod :: k) (scope :: k) (val :: k) (binder :: k).
(EmptyStatement r stmt, VariableSym r var typ,
 DeclStatement r bod stmt var scope val, TypeSym r typ,
 Comparison r val, IndexTranslator r val, Literal r val typ,
 ValueExpression r var val binder typ, VariableValue r var val) =>
Label
-> VS (r val)
-> Maybe Integer
-> Maybe (VS (r val))
-> VS (r val)
-> VS (r val)
-> r scope
-> (MS (r stmt), VS (r val))
makeSetterVal Label
_     VS (r val)
_    Maybe Integer
_      (Just VS (r val)
v) VS (r val)
_  VS (r val)
_  r scope
_   = (MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt, VS (r val)
v)
makeSetterVal Label
_     VS (r val)
_   (Just Integer
s) Maybe (VS (r val))
_       VS (r val)
lb VS (r val)
rb r scope
_   = (MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt, if Integer
s Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0 then VS (r val)
lb else VS (r val)
rb)
makeSetterVal Label
vName VS (r val)
step Maybe Integer
_       Maybe (VS (r val))
_       VS (r val)
lb VS (r val)
rb  r scope
scp =
  let theVar :: VS (r var)
theVar = Label -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
IC.var Label
vName VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int
      theSetter :: MS (r stmt)
theSetter = 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)
theVar r scope
scp (VS (r val) -> MS (r stmt)) -> VS (r val) -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
IC.inlineIf (VS (r val)
step 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) VS (r val)
lb VS (r val)
rb
  in (MS (r stmt)
theSetter, 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) -> VS (r val)) -> VS (r val) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf VS (r var)
theVar)

stringListVals
  :: ( MultiStatement r stmt
     , IC.AssignStatement r stmt var val
     , IC.List r val
     , ValueSym r val typ
     , IC.Literal r val typ
     , RenderValue r var val typ
     , IC.TypeElim r typ
     , VariableElim r var typ
     )
  => [VS (r var)] -> VS (r val) -> MS (r stmt)
stringListVals :: forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(MultiStatement r stmt, AssignStatement r stmt var val, List r val,
 ValueSym r val typ, Literal r val typ, RenderValue r var val typ,
 TypeElim r typ, VariableElim r var typ) =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
stringListVals [VS (r var)]
vars VS (r val)
sl = 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)
sl 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
>>= (\r val
slst -> [StateT MethodState Identity (r stmt)]
-> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k).
MultiStatement r stmt =>
[MS (r stmt)] -> MS (r stmt)
multi ([StateT MethodState Identity (r stmt)]
 -> StateT MethodState Identity (r stmt))
-> [StateT MethodState Identity (r stmt)]
-> StateT MethodState Identity (r stmt)
forall a b. (a -> b) -> a -> b
$ CodeType -> [StateT MethodState Identity (r stmt)]
checkList
  (r typ -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (r typ -> CodeType) -> r typ -> CodeType
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
slst))
  where checkList :: CodeType -> [StateT MethodState Identity (r stmt)]
checkList (List CodeType
String) = [VS (r var)] -> Integer -> [StateT MethodState Identity (r stmt)]
assignVals [VS (r var)]
vars Integer
0
        checkList CodeType
_ = Label -> [StateT MethodState Identity (r stmt)]
forall a. HasCallStack => Label -> a
error
          Label
"Value passed to stringListVals must be a list of strings"
        assignVals :: [VS (r var)] -> Integer -> [StateT MethodState Identity (r stmt)]
assignVals [] Integer
_ = []
        assignVals (VS (r var)
v:[VS (r var)]
vs) Integer
n = VS (r var) -> VS (r val) -> StateT MethodState Identity (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)
IC.assign VS (r var)
v (VS (r typ) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast ((r var -> r typ) -> VS (r var) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (r var)
v)
          (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)
sl (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
n))) StateT MethodState Identity (r stmt)
-> [StateT MethodState Identity (r stmt)]
-> [StateT MethodState Identity (r stmt)]
forall a. a -> [a] -> [a]
: [VS (r var)] -> Integer -> [StateT MethodState Identity (r stmt)]
assignVals [VS (r var)]
vs (Integer
nInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)

stringListLists
  ::
    ( BodySym r bod block
    , IC.BlockSym r block stmt
    , IC.ControlStatement r bod stmt var val
    , IC.TypeSym r typ
    , ValueSym r val typ
    , IC.Literal r val typ
    , NumericExpression r val
    , VariableSym r var typ
    , IC.VariableValue r var val
    , IC.List r val
    , IC.ListStatement r stmt val
    , IC.TypeElim r typ
    , VariableElim r var typ
    , S.RenderValue r var val typ
    )
  => [VS (r var)] -> VS (r val) -> MS (r stmt)
stringListLists :: forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (val :: k) (typ :: k).
(BodySym r bod block, BlockSym r block stmt,
 ControlStatement r bod stmt var val, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 VariableSym r var typ, VariableValue r var val, List r val,
 ListStatement r stmt val, TypeElim r typ, VariableElim r var typ,
 RenderValue r var val typ) =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
stringListLists [VS (r var)]
lsts VS (r val)
sl = do
  slst <- 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)
sl
  l_i <- genLoopIndex
  let
    checkList (List CodeType
String) = (VS (r var) -> StateT MethodState Identity (r var))
-> [VS (r var)] -> StateT MethodState Identity [r var]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
-> VS (r var) -> StateT MethodState Identity (r var)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r var))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r var) ValueState)
-> MethodState -> Focusing Identity (r var) MethodState
Lens' MethodState ValueState
lensMStoVS) [VS (r var)]
lsts StateT MethodState Identity [r var]
-> ([r var] -> 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)
listVals ([CodeType] -> StateT MethodState Identity (r stmt))
-> ([r var] -> [CodeType])
-> [r var]
-> StateT MethodState Identity (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (r var -> CodeType) -> [r var] -> [CodeType]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (r typ -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (r typ -> CodeType) -> (r var -> r typ) -> r var -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType)
    checkList CodeType
_ = Label -> StateT MethodState Identity (r stmt)
forall a. HasCallStack => Label -> a
error
      Label
"Value passed to stringListLists must be a list of strings"
    listVals [] = StateT MethodState Identity (r stmt)
loop
    listVals (List CodeType
_:[CodeType]
vs) = [CodeType] -> StateT MethodState Identity (r stmt)
listVals [CodeType]
vs
    listVals [CodeType]
_ = Label -> StateT MethodState Identity (r stmt)
forall a. HasCallStack => Label -> a
error
      Label
"All values passed to stringListLists must have list types"
    loop = VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> StateT MethodState Identity (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)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
IC.forRange VS (r var)
var_i (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 val) -> VS (r val)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
IC.listSize VS (r val)
sl 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)
numLists)
      (Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
1) ([StateT MethodState Identity (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 ([StateT MethodState Identity (r stmt)] -> MS (r bod))
-> [StateT MethodState Identity (r stmt)] -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ [VS (r val)] -> Integer -> [StateT MethodState Identity (r stmt)]
appendLists (VS (r var) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
IC.valueOf (VS (r var) -> VS (r val)) -> [VS (r var)] -> [VS (r val)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [VS (r var)]
lsts) Integer
0)
    appendLists [] Integer
_ = []
    appendLists (VS (r val)
v:[VS (r val)]
vs) Integer
n = VS (r val) -> VS (r val) -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
IC.listAppend VS (r val)
v (VS (r typ) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast
      (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 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 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)
sl ((VS (r val)
v_i 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)
numLists) 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
n)))
      StateT MethodState Identity (r stmt)
-> [StateT MethodState Identity (r stmt)]
-> [StateT MethodState Identity (r stmt)]
forall a. a -> [a] -> [a]
: [VS (r val)] -> Integer -> [StateT MethodState Identity (r stmt)]
appendLists [VS (r val)]
vs (Integer
nInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
+Integer
1)
    numLists = Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt (Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Int -> Integer) -> Int -> Integer
forall a b. (a -> b) -> a -> b
$ [VS (r var)] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [VS (r var)]
lsts)
    var_i = Label -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
IC.var Label
l_i VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int
    v_i = 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)
var_i
  checkList (getCodeType $ valueType slst)

forRange
  ::
    ( IC.ScopeSym r scope
    , IC.DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , IC.ControlStatement r bod stmt var val
    , Comparison r val
    , IC.VariableValue r var val
    )
  => VS (r var)
  -> VS (r val)
  -> VS (r val)
  -> VS (r val)
  -> MS (r bod)
  -> MS (r stmt)
forRange :: forall {k} (r :: k -> *) (scope :: k) (bod :: k) (stmt :: k)
       (var :: k) (val :: k).
(ScopeSym r scope, DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, Comparison r val,
 VariableValue r var val) =>
VS (r var)
-> VS (r val)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
forRange VS (r var)
i VS (r val)
initv VS (r val)
finalv VS (r val)
stepv = 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 VS (r val)
initv)
  (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)
finalv) (VS (r var)
i 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)
stepv)

observerIndex :: (IC.TypeSym r typ, VariableSym r var typ) => VS (r var)
observerIndex :: forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
observerIndex = Label -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
Label -> VS (r typ) -> VS (r var)
IC.var Label
"observerIndex" VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
IC.int

observerIdxVal
  :: (IC.TypeSym r typ, VariableSym r var typ, IC.VariableValue r var val)
  => VS (r val)
observerIdxVal :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
observerIdxVal = 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)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
observerIndex

obsList
  :: (IC.TypeSym r typ, VariableSym r var typ, IC.VariableValue r var val)
  => VS (r typ) -> VS (r val)
obsList :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r typ) -> VS (r val)
obsList VS (r typ)
t = 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
$ Label -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
Label -> VS (r typ) -> VS (r var)
listOf Label
observerListName VS (r typ)
t

notify
  ::
    ( ValueStatement r stmt val
    , IC.TypeSym r typ
    , VariableSym r var typ
    , VariableValue r var val
    , List r val
    , OOFunctionSym r val typ
    , BodySym r bod block
    , IC.BlockSym r block stmt
    )
  => VS (r typ) -> VS (r FuncData) -> MS (r bod)
notify :: forall (r :: * -> *) stmt val typ var bod block.
(ValueStatement r stmt val, TypeSym r typ, VariableSym r var typ,
 VariableValue r var val, List r val, OOFunctionSym r val typ,
 BodySym r bod block, BlockSym r block stmt) =>
VS (r typ) -> VS (r FuncData) -> MS (r bod)
notify VS (r typ)
t VS (r FuncData)
f = MS (r stmt) -> MS (r bod)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (r stmt) -> MS (r bod)) -> MS (r stmt) -> MS (r bod)
forall a b. (a -> b) -> a -> b
$ VS (r val) -> MS (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (r val) -> MS (r stmt)) -> VS (r val) -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ VS (r 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)
at (VS (r typ) -> VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r typ) -> VS (r val)
obsList VS (r typ)
t) VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
observerIdxVal 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 FuncData)
f

notifyObservers
  ::
    ( BodySym r bod block
    , IC.BlockSym r block stmt
    , IC.TypeSym r typ
    , Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , Comparison r val
    , List r val
    , ValueStatement r stmt val
    , IC.ScopeSym r scope
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , OOFunctionSym r val typ
    )
  => VS (r FuncData) -> VS (r typ) -> MS (r stmt)
notifyObservers :: forall (r :: * -> *) bod block stmt typ val var scope.
(BodySym r bod block, BlockSym r block stmt, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 Comparison r val, List r val, ValueStatement r stmt val,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, OOFunctionSym r val typ) =>
VS (r FuncData) -> VS (r typ) -> MS (r stmt)
notifyObservers VS (r FuncData)
f VS (r typ)
t = 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 MS (r stmt)
initv (VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r val)
observerIdxVal 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 typ) -> VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r typ) -> VS (r val)
obsList VS (r typ)
t))
  (VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
observerIndex 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)
&++) (VS (r typ) -> VS (r FuncData) -> MS (r bod)
forall (r :: * -> *) stmt val typ var bod block.
(ValueStatement r stmt val, TypeSym r typ, VariableSym r var typ,
 VariableValue r var val, List r val, OOFunctionSym r val typ,
 BodySym r bod block, BlockSym r block stmt) =>
VS (r typ) -> VS (r FuncData) -> MS (r bod)
notify VS (r typ)
t VS (r FuncData)
f)
  where initv :: MS (r stmt)
initv = 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)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
observerIndex r scope
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
IC.local (VS (r val) -> MS (r stmt)) -> VS (r val) -> MS (r stmt)
forall a b. (a -> b) -> a -> b
$ Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
0

notifyObservers'
  ::
    ( BodySym r bod block
    , IC.BlockSym r block stmt
    , ValueStatement r stmt val
    , IC.TypeSym r typ
    , Literal r val typ
    , VariableSym r var typ
    , VariableValue r var val
    , List r val
    , ControlStatement r bod stmt var val
    , OOFunctionSym r val typ
    )
  => VS (r FuncData) -> VS (r typ) -> MS (r stmt)
notifyObservers' :: forall (r :: * -> *) bod block stmt val typ var.
(BodySym r bod block, BlockSym r block stmt,
 ValueStatement r stmt val, TypeSym r typ, Literal r val typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ControlStatement r bod stmt var val, OOFunctionSym r val typ) =>
VS (r FuncData) -> VS (r typ) -> MS (r stmt)
notifyObservers' VS (r FuncData)
f VS (r typ)
t = VS (r var)
-> VS (r val)
-> VS (r val)
-> 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)
-> VS (r val)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
IC.forRange VS (r var)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(TypeSym r typ, VariableSym r var typ) =>
VS (r var)
observerIndex VS (r val)
initv (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) -> VS (r val)) -> VS (r val) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ VS (r typ) -> VS (r val)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, VariableValue r var val) =>
VS (r typ) -> VS (r val)
obsList VS (r typ)
t )
    (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 typ) -> VS (r FuncData) -> MS (r bod)
forall (r :: * -> *) stmt val typ var bod block.
(ValueStatement r stmt val, TypeSym r typ, VariableSym r var typ,
 VariableValue r var val, List r val, OOFunctionSym r val typ,
 BodySym r bod block, BlockSym r block stmt) =>
VS (r typ) -> VS (r FuncData) -> MS (r bod)
notify VS (r typ)
t VS (r FuncData)
f)
    where initv :: VS (r val)
initv = Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
IC.litInt Integer
0

arrayDecAsList
  ::
    ( BodySym r bod block
    , IC.BlockSym r block stmt
    , MultiStatement r stmt
    , IC.DeclStatement r bod stmt var scope val
    , IC.ControlStatement r bod stmt var val
    , IC.TypeSym r typ
    , IC.Literal r val typ
    , VariableSym r var typ
    , IC.VariableValue r var val
    , IC.ListStatement r stmt val
    , VariableElim r var typ
    )
  => Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
arrayDecAsList :: forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (scope :: k) (val :: k) (typ :: k).
(BodySym r bod block, BlockSym r block stmt, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 ListStatement r stmt val, VariableElim r var typ) =>
Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
arrayDecAsList Integer
len VS (r val)
dflt VS (r var)
vr r scope
scp = 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
  let innerTp = 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 var -> r typ
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType r var
vr'
  i <- genVarName [] "i"
  multi [
    IC.varDecDef vr scp (IC.litList innerTp []),
    IC.forRange (IC.var i IC.int) (IC.litInt 0) (IC.litInt len) (IC.litInt 1)
      (oneLiner $ IC.listAppend (IC.valueOf vr) dflt)]