{-# LANGUAGE TypeFamilies #-}
-- | The logic to render C# code is contained in this module
module Drasil.GOOL.LanguageRenderer.CSharpRenderer (
  -- * C# Code Configuration -- defines syntax of all C# code
  CSharpCode(..), csName, csVersion
) where

import Drasil.FileHandling.Legacy (indent)

import Drasil.Shared.CodeType (CodeType(..))
import Drasil.Shared.InterfaceCommon (UnRepr(..), Label, Body, Block, Variable,
  Value, BodySym(..), oneLiner, BlockSym(..), TypeSym(..), TypeElim(..),
  getTypeString, VariableSym(..), VisibilitySym(..), VariableElim(..),
  ValueSym(..), Argument(..), Literal(..), MathConstant(..), VariableValue(..),
  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..),
  Comparison(..), ValueExpression(..), funcApp, extFuncApp, IndexTranslator(..),
  Reference(..), Array(..), List(..), ListStatement(..), Set(..),
  InternalList(..), EmptyStatement(..), MultiStatement(..), ValueStatement(..),
  AssignStatement(..), (&=), DeclStatement(..), PrintConsole(..),
  ReadConsole(..), FileHandling(..), PrintFile(..), ReadFile(..),
  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
  BinderSym(..), BinderElim(..), ControlStatement(..), ScopeSym(..),
  ParameterSym(..), MethodSym(..))
import Drasil.GOOL.InterfaceGOOL (OOProg, Class, StateVar, ProgramSym(..),
  FileSym(..), ModuleSym(..), ClassSym(..), OOTypeSym(..), OOVariableSym(..),
  SelfSym(..), StateVarSym(..), AttachmentSym(..), OOValueExpression(..),
  selfMethodCall, newObj, InternalValueExp(..), objMethodCall,
  objMethodCallNoParams, OOFunctionSym(..), ($.), GetSet(..),
  OODeclStatement(..), OOFuncAppStatement(..), ObserverPattern(..),
  StrategyPattern(..), OOMethodSym(..))
import Drasil.Shared.RendererClassesCommon (CommonRenderSym, ImportSym(..),
  RenderBody(..), BodyElim, RenderBlock(..), BlockElim, RenderType(..),
  UnaryOpSym(..), BinaryOpSym(..), OpElim(uOpPrec, bOpPrec), RenderVariable(..),
  InternalVarElim(variableBind), RenderValue(..), ValueElim(valuePrec, valueInt),
  InternalListFunc(..), RenderFunction(..), FunctionElim(functionType),
  InternalAssignStmt(..), InternalIOStmt(..), InternalControlStmt(..),
  RenderStatement(..), StatementElim(statementTerm), RenderVisibility(..),
  VisibilityElim, MethodTypeSym(..), RenderParam(..),
  ParamElim(parameterName, parameterType), RenderMethod(..), MethodElim,
  BlockCommentSym(..), BlockCommentElim, ScopeElim(..), InternalBinderElim(..))
import qualified Drasil.Shared.RendererClassesCommon as RC (body, block, uOp,
  bOp, variable, value, function, statement, visibility, parameter, method,
  blockComment')
import Drasil.GOOL.RendererClassesOO (OORenderSym, RenderFile(..),
  PermElim(binding), InternalGetSet(..), OOMethodTypeSym(..),
  OORenderMethod(..), StateVarElim, RenderClass(..), ClassElim, RenderMod(..),
  ModuleElim)
import qualified Drasil.GOOL.RendererClassesOO as RC (perm, stateVar, class',
  module')
import Drasil.GOOL.Renderers (renderType, renderParam, renderMethod,
  renderListDec)
import Drasil.Shared.LanguageRenderer (new, dot, blockCmtStart, blockCmtEnd,
  docCmtStart, bodyStart, bodyEnd, endStatement, commentStart, elseIfLabel,
  inLabel, tryLabel, catchLabel, throwLabel, exceptionObj', new', listSep',
  args, nullLabel, listSep, access, containing, mathFunc, valueList,
  variableList, binderList, appendToBody, surroundBody)
import qualified Drasil.Shared.LanguageRenderer as R (class', multiStmt, body,
  printFile, classVarAccess, cast, castObj, classLevel,
  instanceLevel, break, continue, private, public, blockCmt, docCmt, addComments,
  commentedMod, commentedItem)
import Drasil.Shared.LanguageRenderer.Constructors (mkStmt,  mkStmtNoEnd,
  mkStateVal, mkVal, typeFromData, VSOp, unOpPrec, powerPrec, unExpr, unExpr',
  unExprNumDbl, typeUnExpr, binExpr, binExprNumDbl', typeBinExpr)
import qualified Drasil.Shared.LanguageRenderer.LanguagePolymorphic as G (
  multiBody, block, multiBlock, obj, csc, sec, cot, negateOp, equalOp,
  notEqualOp, greaterOp, greaterEqualOp, lessOp, lessEqualOp, plusOp, minusOp,
  multOp, divideOp, moduloOp, var, classVar, instanceVarAccess, arrayElem,
  litChar, litDouble, litInt, litString, valueOf, arg, argsList, objAccess,
  objMethodCall, call, funcAppMixedArgs, newObjMixedArgs, lambda, 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, function, buildClass,
  implementingClass, commentedClass, modFromData, fileDoc, fileFromData,
  defaultOptSpace, local)
import qualified Drasil.Shared.LanguageRenderer.CommonPseudoOO as CP (
  arrayDec, arrayDecDef, arrayType, bindingError, buildModule', classVarAccess,
  constVar, constructor, contains, destructorError, discardFileLine, docInOutFunc,
  docMain, doubleRender, doxClass, doxFunc, doxMod, extraClass, forEach, global,
  implements, indexOf, indexToInt, inherit, int, intClass, intToIndex,
  listDecDef, listSet, mainFunction, notNull, openFileA, openFileR, openFileW,
  pi, printSt, setMethodCall, stateVar, stateVarDef, string)
import qualified Drasil.GOOL.LanguageRenderer.CommonGOOL as CG (constDecDef,
  classMethodCall, listAppend, listAdd, innerType)

import qualified Drasil.Shared.LanguageRenderer.CLike as C (setType, float,
  double, char, listType, void, notOp, andOp, orOp, self, litTrue, litFalse,
  litFloat, inlineIf, libFuncAppMixedArgs, libNewObjMixedArgs, listSize',
  increment, increment1, decrement1, varDec, varDecDef, listDec, extObjDecNew,
  switch, for, while, multiAssignError, multiReturnError, multiTypeError)
import qualified Drasil.Shared.LanguageRenderer.Macros as M (ifExists,
  runStrategy, listSlice, stringListVals, stringListLists, forRange,
  notifyObservers)
import Drasil.Shared.AST (Terminator(..), FileType(..), fileD, FuncData(..), fd,
  ModData(..), md, updateMod, MethodData(..), mthd, updateMthd, OpData(..),
  ParamData(..), pd, updateParam, ProgData(..), progD, TypeData(..), ValData(..),
  vd, updateValDoc, AttachmentTag(..), VarData(..), vard, ScopeData, BinderD(..),
  bindFormD, FileData, Statement)
import Drasil.Shared.Helpers (angles, hicat, toCode, toState, onCodeValue,
  onStateValue, on2CodeValues, on2StateValues, on3CodeValues, on3StateValues,
  on2StateWrapped, onCodeList, onStateList)
import Drasil.Shared.State (MS, VS, lensGStoFS, lensMStoVS, modifyReturn,
  revFiles, addLangImport, addLangImportVS, setFileType, getClassName,
  setCurrMain, useVarName, setVarScope)

import Prelude hiding (break,print,(<>),sin,cos,tan,floor)
import qualified Prelude as P ((<>))
import Control.Lens.Zoom (zoom)
import Control.Monad (join)
import Control.Monad.State (modify)
import Data.Composition ((.:))
import Data.List (intercalate)
import Text.PrettyPrint.HughesPJ (Doc, text, (<>), (<+>), ($$), parens, empty,
  equals, vcat, lbrace, rbrace, braces, colon, space, quotes, semi)
import qualified Drasil.Shared.LanguageRenderer.Common as CS (
  extFuncAppMixedArgs, extVar, listAccessFunc)

csExt :: String
csExt :: String
csExt = String
"cs"

newtype CSharpCode a = CSC {forall a. CSharpCode a -> a
unCSC :: a} deriving CSharpCode a -> CSharpCode a -> Bool
(CSharpCode a -> CSharpCode a -> Bool)
-> (CSharpCode a -> CSharpCode a -> Bool) -> Eq (CSharpCode a)
forall a. Eq a => CSharpCode a -> CSharpCode a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => CSharpCode a -> CSharpCode a -> Bool
== :: CSharpCode a -> CSharpCode a -> Bool
$c/= :: forall a. Eq a => CSharpCode a -> CSharpCode a -> Bool
/= :: CSharpCode a -> CSharpCode a -> Bool
Eq

instance Functor CSharpCode where
  fmap :: forall a b. (a -> b) -> CSharpCode a -> CSharpCode b
fmap a -> b
f (CSC a
x) = b -> CSharpCode b
forall a. a -> CSharpCode a
CSC (a -> b
f a
x)

instance Applicative CSharpCode where
  pure :: forall a. a -> CSharpCode a
pure = a -> CSharpCode a
forall a. a -> CSharpCode a
CSC
  (CSC a -> b
f) <*> :: forall a b. CSharpCode (a -> b) -> CSharpCode a -> CSharpCode b
<*> (CSC a
x) = b -> CSharpCode b
forall a. a -> CSharpCode a
CSC (a -> b
f a
x)

instance Monad CSharpCode where
  CSC a
x >>= :: forall a b. CSharpCode a -> (a -> CSharpCode b) -> CSharpCode b
>>= a -> CSharpCode b
f = a -> CSharpCode b
f a
x

instance OOProg CSharpCode ProgData FileData ModData Class StateVar MethodData Doc Doc ParamData Body Block Statement Variable ScopeData Value BinderD TypeData

instance ProgramSym CSharpCode ProgData FileData where
  prog :: String
-> String
-> [FS (CSharpCode FileData)]
-> GSProgram CSharpCode ProgData
prog String
n String
st [FS (CSharpCode FileData)]
files = do
    fs <- (FS (CSharpCode FileData)
 -> StateT GOOLState Identity (CSharpCode FileData))
-> [FS (CSharpCode FileData)]
-> StateT GOOLState Identity [CSharpCode FileData]
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 FileState Identity) (CSharpCode FileData))
  GOOLState
  FileState
-> FS (CSharpCode FileData)
-> StateT GOOLState Identity (CSharpCode FileData)
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) GOOLState FileState
-> StateT FileState Identity c -> StateT GOOLState 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) (CSharpCode FileData))
  GOOLState
  FileState
(FileState -> Focusing Identity (CSharpCode FileData) FileState)
-> GOOLState -> Focusing Identity (CSharpCode FileData) GOOLState
Lens' GOOLState FileState
lensGStoFS) [FS (CSharpCode FileData)]
files
    modify revFiles
    pure $ onCodeList (progD n st) fs

instance CommonRenderSym CSharpCode MethodData Doc ParamData Body Block Statement Variable ScopeData Value BinderD TypeData
instance OORenderSym CSharpCode FileData ModData Class StateVar MethodData Doc Doc ParamData Body Block Statement Variable ScopeData Value BinderD TypeData

instance UnRepr CSharpCode contents where
  unRepr :: CSharpCode contents -> contents
unRepr = CSharpCode contents -> contents
forall a. CSharpCode a -> a
unCSC

instance FileSym CSharpCode FileData ModData where
  fileDoc :: FS (CSharpCode ModData) -> FS (CSharpCode FileData)
fileDoc FS (CSharpCode ModData)
m = do
    (FileState -> FileState) -> StateT FileState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (FileType -> FileState -> FileState
setFileType FileType
Combined)
    String
-> (CSharpCode ModData -> CSharpCode Body)
-> CSharpCode Body
-> FS (CSharpCode ModData)
-> FS (CSharpCode FileData)
forall (r :: * -> *) block mod file.
(BlockElim r block, RenderMod r mod, RenderFile r file mod) =>
String
-> (r mod -> r block) -> r block -> FS (r mod) -> FS (r file)
G.fileDoc String
csExt CSharpCode ModData -> CSharpCode Body
forall (r :: * -> *) file mod.
RenderFile r file mod =>
r mod -> r Body
top CSharpCode Body
forall (r :: * -> *) file mod. RenderFile r file mod => r Body
bottom FS (CSharpCode ModData)
m

  docMod :: String
-> String
-> [String]
-> String
-> FS (CSharpCode FileData)
-> FS (CSharpCode FileData)
docMod = String
-> String
-> String
-> [String]
-> String
-> FS (CSharpCode FileData)
-> FS (CSharpCode FileData)
forall (r :: * -> *) file mod.
(BlockCommentSym r, RenderFile r file mod) =>
String
-> String
-> String
-> [String]
-> String
-> FS (r file)
-> FS (r file)
CP.doxMod String
csExt

instance RenderFile CSharpCode FileData ModData where
  top :: CSharpCode ModData -> CSharpCode Body
top CSharpCode ModData
_ = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode Body
empty
  bottom :: CSharpCode Body
bottom = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode Body
empty

  commentedMod :: FS (CSharpCode FileData)
-> FS (CSharpCode Body) -> FS (CSharpCode FileData)
commentedMod = (CSharpCode FileData -> CSharpCode Body -> CSharpCode FileData)
-> FS (CSharpCode FileData)
-> FS (CSharpCode Body)
-> FS (CSharpCode FileData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((FileData -> Body -> FileData)
-> CSharpCode FileData -> CSharpCode Body -> CSharpCode FileData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues FileData -> Body -> FileData
R.commentedMod)

  fileFromData :: String -> FS (CSharpCode ModData) -> FS (CSharpCode FileData)
fileFromData = (String -> CSharpCode ModData -> CSharpCode FileData)
-> String -> FS (CSharpCode ModData) -> FS (CSharpCode FileData)
forall {k} (r :: k -> *) (mod :: k) (file :: k).
ModuleElim r mod =>
(String -> r mod -> r file) -> String -> FS (r mod) -> FS (r file)
G.fileFromData ((ModData -> FileData) -> CSharpCode ModData -> CSharpCode FileData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((ModData -> FileData)
 -> CSharpCode ModData -> CSharpCode FileData)
-> (String -> ModData -> FileData)
-> String
-> CSharpCode ModData
-> CSharpCode FileData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ModData -> FileData
fileD)

instance ImportSym CSharpCode where
  langImport :: String -> CSharpCode Body
langImport = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Body -> CSharpCode Body)
-> (String -> Body) -> String -> CSharpCode Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Body
csImport
  modImport :: String -> CSharpCode Body
modImport = String -> CSharpCode Body
forall (r :: * -> *). ImportSym r => String -> r Body
langImport

instance AttachmentSym CSharpCode Doc where
  classLevel :: CSharpCode Body
classLevel = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode Body
R.classLevel
  instanceLevel :: CSharpCode Body
instanceLevel = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode Body
R.instanceLevel

instance PermElim CSharpCode Doc where
  perm :: CSharpCode Body -> Body
perm = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC
  binding :: CSharpCode Body -> AttachmentTag
binding = String -> CSharpCode Body -> AttachmentTag
forall a. HasCallStack => String -> a
error (String -> CSharpCode Body -> AttachmentTag)
-> String -> CSharpCode Body -> AttachmentTag
forall a b. (a -> b) -> a -> b
$ String -> String
CP.bindingError String
csName

instance BodySym CSharpCode Body Block where
  body :: [MS (CSharpCode Body)] -> MS (CSharpCode Body)
body = ([CSharpCode Body] -> CSharpCode Body)
-> [MS (CSharpCode Body)] -> MS (CSharpCode Body)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (([Body] -> Body) -> [CSharpCode Body] -> CSharpCode Body
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList [Body] -> Body
R.body)

  addComments :: String -> MS (CSharpCode Body) -> MS (CSharpCode Body)
addComments String
s = (CSharpCode Body -> CSharpCode Body)
-> MS (CSharpCode Body) -> MS (CSharpCode Body)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Body -> Body) -> CSharpCode Body -> CSharpCode Body
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (String -> Body -> Body -> Body
R.addComments String
s Body
commentStart))

instance RenderBody CSharpCode Body where
  multiBody :: [MS (CSharpCode Body)] -> MS (CSharpCode Body)
multiBody = [MS (CSharpCode Body)] -> MS (CSharpCode Body)
forall (r :: * -> *) bod.
(BodyElim r bod, Monad r) =>
[MS (r bod)] -> MS (r Body)
G.multiBody

instance BodyElim CSharpCode Body where
  body :: CSharpCode Body -> Body
body = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC

instance BlockSym CSharpCode Block Statement where
  block :: [MS (CSharpCode Statement)] -> MS (CSharpCode Body)
block = [MS (CSharpCode Statement)] -> MS (CSharpCode Body)
forall (r :: * -> *) stmt.
(Monad r, RenderStatement r stmt, StatementElim r stmt) =>
[MS (r stmt)] -> MS (r Body)
G.block

instance RenderBlock CSharpCode Block where
  multiBlock :: [MS (CSharpCode Body)] -> MS (CSharpCode Body)
multiBlock = [MS (CSharpCode Body)] -> MS (CSharpCode Body)
forall (r :: * -> *) block.
(BlockElim r block, Monad r) =>
[MS (r block)] -> MS (r Body)
G.multiBlock

instance BlockElim CSharpCode Block where
  block :: CSharpCode Body -> Body
block = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC

instance TypeSym CSharpCode TypeData where
  bool :: VS (CSharpCode TypeData)
bool = VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall a. VS a -> VS a
addSystemImport VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
csBoolType
  int :: VS (CSharpCode TypeData)
int = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.int
  float :: VS (CSharpCode TypeData)
float = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.float
  double :: VS (CSharpCode TypeData)
double = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.double
  char :: VS (CSharpCode TypeData)
char = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.char
  string :: VS (CSharpCode TypeData)
string = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.string
  infile :: VS (CSharpCode TypeData)
infile = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
csInfileType
  outfile :: VS (CSharpCode TypeData)
outfile = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
csOutfileType
  referenceType :: VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
referenceType = VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall a. a -> a
id -- Ignore reference types in "high-level" langauges for now; later on think about using boxed/unboxed types
  listType :: VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
listType VS (CSharpCode TypeData)
t = do
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS String
csGeneric)
    String -> VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.listType String
csList VS (CSharpCode TypeData)
t
  arrayType :: VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
arrayType = VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall (r :: * -> *).
(TypeElim r TypeData, Monad r, UnRepr r TypeData) =>
VS (r TypeData) -> VS (r TypeData)
CP.arrayType
  setType :: VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
setType VS (CSharpCode TypeData)
t = do
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS String
csGeneric)
    String -> VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall (r :: * -> *).
(Monad r, TypeElim r TypeData, UnRepr r TypeData) =>
String -> VS (r TypeData) -> VS (r TypeData)
C.setType String
csSet VS (CSharpCode TypeData)
t
  innerType :: VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
innerType = VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
(TypeElim r typ, TypeSym r typ, OOTypeSym r typ) =>
VS (r typ) -> VS (r typ)
CG.innerType
  funcType :: [VS (CSharpCode TypeData)]
-> VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
funcType = [VS (CSharpCode TypeData)]
-> VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
csFuncType
  void :: VS (CSharpCode TypeData)
void = VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
C.void

instance TypeElim CSharpCode TypeData where
  getCodeType :: CSharpCode TypeData -> CodeType
getCodeType = TypeData -> CodeType
cType (TypeData -> CodeType)
-> (CSharpCode TypeData -> TypeData)
-> CSharpCode TypeData
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode TypeData -> TypeData
forall a. CSharpCode a -> a
unCSC

instance OOTypeSym CSharpCode TypeData where
  obj :: String -> VS (CSharpCode TypeData)
obj = String -> VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => String -> VS (r TypeData)
G.obj

instance RenderType CSharpCode TypeData where
  multiType :: [VS (CSharpCode TypeData)] -> VS (CSharpCode TypeData)
multiType [VS (CSharpCode TypeData)]
_ = String -> VS (CSharpCode TypeData)
forall a. HasCallStack => String -> a
error (String -> VS (CSharpCode TypeData))
-> String -> VS (CSharpCode TypeData)
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiTypeError String
csName

instance UnaryOpSym CSharpCode where
  notOp :: VSUnOp CSharpCode
notOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
C.notOp
  negateOp :: VSUnOp CSharpCode
negateOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.negateOp
  sqrtOp :: VSUnOp CSharpCode
sqrtOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Sqrt"
  absOp :: VSUnOp CSharpCode
absOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Abs"
  logOp :: VSUnOp CSharpCode
logOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Log10"
  lnOp :: VSUnOp CSharpCode
lnOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Log"
  expOp :: VSUnOp CSharpCode
expOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Exp"
  sinOp :: VSUnOp CSharpCode
sinOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Sin"
  cosOp :: VSUnOp CSharpCode
cosOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Cos"
  tanOp :: VSUnOp CSharpCode
tanOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Tan"
  asinOp :: VSUnOp CSharpCode
asinOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Asin"
  acosOp :: VSUnOp CSharpCode
acosOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Acos"
  atanOp :: VSUnOp CSharpCode
atanOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Atan"
  floorOp :: VSUnOp CSharpCode
floorOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Floor"
  ceilOp :: VSUnOp CSharpCode
ceilOp = String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath String
"Ceiling"

instance BinaryOpSym CSharpCode where
  equalOp :: VSUnOp CSharpCode
equalOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.equalOp
  notEqualOp :: VSUnOp CSharpCode
notEqualOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.notEqualOp
  greaterOp :: VSUnOp CSharpCode
greaterOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.greaterOp
  greaterEqualOp :: VSUnOp CSharpCode
greaterEqualOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.greaterEqualOp
  lessOp :: VSUnOp CSharpCode
lessOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.lessOp
  lessEqualOp :: VSUnOp CSharpCode
lessEqualOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.lessEqualOp
  plusOp :: VSUnOp CSharpCode
plusOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.plusOp
  minusOp :: VSUnOp CSharpCode
minusOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.minusOp
  multOp :: VSUnOp CSharpCode
multOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.multOp
  divideOp :: VSUnOp CSharpCode
divideOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.divideOp
  powerOp :: VSUnOp CSharpCode
powerOp = VSUnOp CSharpCode -> VSUnOp CSharpCode
forall a. VS a -> VS a
addSystemImport (VSUnOp CSharpCode -> VSUnOp CSharpCode)
-> VSUnOp CSharpCode -> VSUnOp CSharpCode
forall a b. (a -> b) -> a -> b
$ String -> VSUnOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
powerPrec (String -> VSUnOp CSharpCode) -> String -> VSUnOp CSharpCode
forall a b. (a -> b) -> a -> b
$ String -> String
mathFunc String
"Pow"
  moduloOp :: VSUnOp CSharpCode
moduloOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
G.moduloOp
  andOp :: VSUnOp CSharpCode
andOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
C.andOp
  orOp :: VSUnOp CSharpCode
orOp = VSUnOp CSharpCode
forall (r :: * -> *). Monad r => VSOp r
C.orOp

instance OpElim CSharpCode where
  uOp :: CSharpCode OpData -> Body
uOp = OpData -> Body
opDoc (OpData -> Body)
-> (CSharpCode OpData -> OpData) -> CSharpCode OpData -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode OpData -> OpData
forall a. CSharpCode a -> a
unCSC
  bOp :: CSharpCode OpData -> Body
bOp = OpData -> Body
opDoc (OpData -> Body)
-> (CSharpCode OpData -> OpData) -> CSharpCode OpData -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode OpData -> OpData
forall a. CSharpCode a -> a
unCSC
  uOpPrec :: CSharpCode OpData -> Int
uOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (CSharpCode OpData -> OpData) -> CSharpCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode OpData -> OpData
forall a. CSharpCode a -> a
unCSC
  bOpPrec :: CSharpCode OpData -> Int
bOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (CSharpCode OpData -> OpData) -> CSharpCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode OpData -> OpData
forall a. CSharpCode a -> a
unCSC

instance ScopeSym CSharpCode ScopeData where
  global :: CSharpCode ScopeData
global = CSharpCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
CP.global
  mainFn :: CSharpCode ScopeData
mainFn = CSharpCode ScopeData
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
local
  local :: CSharpCode ScopeData
local = CSharpCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
G.local

instance ScopeElim CSharpCode ScopeData where
  scopeData :: CSharpCode ScopeData -> ScopeData
scopeData = CSharpCode ScopeData -> ScopeData
forall a. CSharpCode a -> a
unCSC

instance VariableSym CSharpCode Variable TypeData where
  var :: String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
var         = String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
String -> VS (r typ) -> VS (r var)
G.var
  constant :: String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
constant    = String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var
  extVar :: String
-> String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
extVar      = String
-> String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
String -> String -> VS (r typ) -> VS (r var)
CS.extVar

instance OOVariableSym CSharpCode Variable Value TypeData where
  classVar :: String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
classVar = String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
String -> VS (r typ) -> VS (r var)
G.classVar
  classConst :: String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
classConst = String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
String -> VS (r typ) -> VS (r var)
classVar
  classVarAccess :: VS (CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode Variable)
classVarAccess = (Body -> Body -> Body)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Variable)
-> VS (CSharpCode Variable)
forall (r :: * -> *) var.
(InternalVarElim r var, RenderVariable r var TypeData,
 UnRepr r TypeData, VariableElim r var TypeData) =>
(Body -> Body -> Body)
-> VS (r TypeData) -> VS (r var) -> VS (r var)
CP.classVarAccess Body -> Body -> Body
R.classVarAccess
  extClassVarAccess :: VS (CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode Variable)
extClassVarAccess = VS (CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r typ) -> VS (r var) -> VS (r var)
classVarAccess
  instanceVarAccess :: VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> VS (CSharpCode Variable)
instanceVarAccess = VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> VS (CSharpCode Variable)
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)
G.instanceVarAccess

instance SelfSym CSharpCode Variable where
  self :: VS (CSharpCode Variable)
self = VS (CSharpCode Variable)
forall {k} (r :: k -> *) (typ :: k) (var :: k).
(OOTypeSym r typ, RenderVariable r var typ) =>
VS (r var)
C.self

instance VariableElim CSharpCode Variable TypeData where
  variableName :: CSharpCode Variable -> String
variableName = Variable -> String
varName (Variable -> String)
-> (CSharpCode Variable -> Variable)
-> CSharpCode Variable
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Variable -> Variable
forall a. CSharpCode a -> a
unCSC
  variableType :: CSharpCode Variable -> CSharpCode TypeData
variableType = (Variable -> TypeData)
-> CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Variable -> TypeData
varType

instance InternalVarElim CSharpCode Variable where
  variableBind :: CSharpCode Variable -> AttachmentTag
variableBind = Variable -> AttachmentTag
varBind (Variable -> AttachmentTag)
-> (CSharpCode Variable -> Variable)
-> CSharpCode Variable
-> AttachmentTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Variable -> Variable
forall a. CSharpCode a -> a
unCSC
  variable :: CSharpCode Variable -> Body
variable = Variable -> Body
varDoc (Variable -> Body)
-> (CSharpCode Variable -> Variable) -> CSharpCode Variable -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Variable -> Variable
forall a. CSharpCode a -> a
unCSC

instance RenderVariable CSharpCode Variable TypeData where
  varFromData :: AttachmentTag
-> String
-> VS (CSharpCode TypeData)
-> Body
-> VS (CSharpCode Variable)
varFromData AttachmentTag
b String
n VS (CSharpCode TypeData)
t' Body
d = do
    t <- VS (CSharpCode TypeData)
t'
    toState $ on2CodeValues (vard b n) t (toCode d)

instance ValueSym CSharpCode Value TypeData where
  valueType :: CSharpCode Value -> CSharpCode TypeData
valueType = (Value -> TypeData) -> CSharpCode Value -> CSharpCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Value -> TypeData
valType

instance Argument CSharpCode Value where
  pointerArg :: VS (CSharpCode Value) -> VS (CSharpCode Value)
pointerArg = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. a -> a
id

instance Literal CSharpCode Value TypeData where
  litTrue :: VS (CSharpCode Value)
litTrue = VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
C.litTrue
  litFalse :: VS (CSharpCode Value)
litFalse = VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
C.litFalse
  litChar :: Char -> VS (CSharpCode Value)
litChar = (Body -> Body) -> Char -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
(Body -> Body) -> Char -> VS (r val)
G.litChar Body -> Body
quotes
  litDouble :: Double -> VS (CSharpCode Value)
litDouble = Double -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Double -> VS (r val)
G.litDouble
  litFloat :: Float -> VS (CSharpCode Value)
litFloat = Float -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Float -> VS (r val)
C.litFloat
  litInt :: Integer -> VS (CSharpCode Value)
litInt = Integer -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
G.litInt
  litString :: String -> VS (CSharpCode Value)
litString = String -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
String -> VS (r val)
G.litString
  litArray :: VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)] -> VS (CSharpCode Value)
litArray = (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData))
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
csLitList VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
arrayType
  litSet :: VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)] -> VS (CSharpCode Value)
litSet = (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData))
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
csLitList VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
setType
  litList :: VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)] -> VS (CSharpCode Value)
litList = (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData))
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
csLitList VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType

instance MathConstant CSharpCode Value where
  pi :: VS (CSharpCode Value)
pi = VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
CP.pi

instance VariableValue CSharpCode Variable Value where
  valueOf :: VS (CSharpCode Variable) -> VS (CSharpCode Value)
valueOf = VS (CSharpCode Variable) -> VS (CSharpCode Value)
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)
G.valueOf

instance CommandLineArgs CSharpCode Value where
  arg :: Integer -> VS (CSharpCode Value)
arg Integer
n = VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
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)
G.arg (Integer -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
n) VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
argsList
  argsList :: VS (CSharpCode Value)
argsList = String -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
String -> VS (r val)
G.argsList String
args
  argExists :: Integer -> VS (CSharpCode Value)
argExists Integer
i = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
argsList VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt (Integer -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i)

instance NumericExpression CSharpCode Value where
  #~ :: VS (CSharpCode Value) -> VS (CSharpCode Value)
(#~) = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr' VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
negateOp
  #/^ :: VS (CSharpCode Value) -> VS (CSharpCode Value)
(#/^) = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sqrtOp
  #| :: VS (CSharpCode Value) -> VS (CSharpCode Value)
(#|) = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
absOp
  #+ :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(#+) = VSUnOp CSharpCode
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp
  #- :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(#-) = VSUnOp CSharpCode
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
minusOp
  #* :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(#*) = VSUnOp CSharpCode
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp
  #/ :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(#/) = VSUnOp CSharpCode
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
divideOp
  #% :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(#%) = VSUnOp CSharpCode
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
moduloOp
  #^ :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(#^) = VSUnOp CSharpCode
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExprNumDbl' VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp

  log :: VS (CSharpCode Value) -> VS (CSharpCode Value)
log = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
logOp
  ln :: VS (CSharpCode Value) -> VS (CSharpCode Value)
ln = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
lnOp
  exp :: VS (CSharpCode Value) -> VS (CSharpCode Value)
exp = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
expOp
  sin :: VS (CSharpCode Value) -> VS (CSharpCode Value)
sin = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sinOp
  cos :: VS (CSharpCode Value) -> VS (CSharpCode Value)
cos = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
cosOp
  tan :: VS (CSharpCode Value) -> VS (CSharpCode Value)
tan = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
tanOp
  csc :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csc = VS (CSharpCode Value) -> VS (CSharpCode Value)
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)
G.csc
  sec :: VS (CSharpCode Value) -> VS (CSharpCode Value)
sec = VS (CSharpCode Value) -> VS (CSharpCode Value)
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)
G.sec
  cot :: VS (CSharpCode Value) -> VS (CSharpCode Value)
cot = VS (CSharpCode Value) -> VS (CSharpCode Value)
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)
G.cot
  arcsin :: VS (CSharpCode Value) -> VS (CSharpCode Value)
arcsin = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
asinOp
  arccos :: VS (CSharpCode Value) -> VS (CSharpCode Value)
arccos = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
acosOp
  arctan :: VS (CSharpCode Value) -> VS (CSharpCode Value)
arctan = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeSym r typ,
 TypeElim r typ, ValueElim r val, ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
atanOp
  floor :: VS (CSharpCode Value) -> VS (CSharpCode Value)
floor = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
floorOp
  ceil :: VS (CSharpCode Value) -> VS (CSharpCode Value)
ceil = VSUnOp CSharpCode -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
ceilOp

instance BooleanExpression CSharpCode Value where
  ?! :: VS (CSharpCode Value) -> VS (CSharpCode Value)
(?!) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSUnOp r -> VS (r typ) -> VS (r val) -> VS (r val)
typeUnExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
notOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?&& :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?&&) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
andOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?|| :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?||) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
orOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool

instance Comparison CSharpCode Value where
  ?< :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?<) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?<= :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?<=) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessEqualOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?> :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?>) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?>= :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?>=) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterEqualOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?== :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?==) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
equalOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool
  ?!= :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
(?!=) = VSUnOp CSharpCode
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val) =>
VSBinOp r -> VS (r typ) -> VS (r val) -> VS (r val) -> VS (r val)
typeBinExpr VSUnOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
notEqualOp VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool

instance ValueExpression CSharpCode Variable Value BinderD TypeData where
  inlineIf :: VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
inlineIf = VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
C.inlineIf

  funcAppMixedArgs :: MixedCall CSharpCode Variable Value TypeData
funcAppMixedArgs = MixedCall CSharpCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
MixedCall r var val typ
G.funcAppMixedArgs
  extFuncAppMixedArgs :: String -> MixedCall CSharpCode Variable Value TypeData
extFuncAppMixedArgs = String -> MixedCall CSharpCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
String -> MixedCall r var val typ
CS.extFuncAppMixedArgs
  libFuncAppMixedArgs :: String -> MixedCall CSharpCode Variable Value TypeData
libFuncAppMixedArgs = String -> MixedCall CSharpCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> MixedCall r var val typ
C.libFuncAppMixedArgs

  lambda :: [VS (CSharpCode BinderD)]
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
lambda = ([CSharpCode BinderD] -> CSharpCode Value -> Body)
-> [VS (CSharpCode BinderD)]
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
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 -> Body)
-> [VS (r binder)] -> VS (r val) -> VS (r val)
G.lambda [CSharpCode BinderD] -> CSharpCode Value -> Body
csLambda

  notNull :: VS (CSharpCode Value) -> VS (CSharpCode Value)
notNull = String -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k).
(ValueSym r val typ, Comparison r val, VariableSym r var typ,
 VariableValue r var val) =>
String -> VS (r val) -> VS (r val)
CP.notNull String
nullLabel

instance OOValueExpression CSharpCode Variable Value TypeData where
  newObjMixedArgs :: MixedCtorCall CSharpCode Variable Value TypeData
newObjMixedArgs = MixedCall CSharpCode Variable Value TypeData
forall (r :: * -> *) var val.
(RenderValue r var val TypeData, UnRepr r TypeData) =>
String -> MixedCtorCall r var val TypeData
G.newObjMixedArgs (String
new String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
" ")
  extNewObjMixedArgs :: MixedCall CSharpCode Variable Value TypeData
extNewObjMixedArgs String
_ = MixedCtorCall CSharpCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
MixedCtorCall r var val typ
newObjMixedArgs
  libNewObjMixedArgs :: MixedCall CSharpCode Variable Value TypeData
libNewObjMixedArgs = MixedCall CSharpCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
String -> MixedCtorCall r var val typ
C.libNewObjMixedArgs

instance RenderValue CSharpCode Variable Value TypeData where
  inputFunc :: VS (CSharpCode Value)
inputFunc = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. VS a -> VS a
addSystemImport VS (CSharpCode Value)
csReadLineFunc
  printFunc :: VS (CSharpCode Value)
printFunc = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. VS a -> VS a
addSystemImport (VS (CSharpCode Value) -> VS (CSharpCode Value))
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode TypeData) -> Body -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Body -> VS (r val)
mkStateVal VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void (String -> Body
text (String -> Body) -> String -> Body
forall a b. (a -> b) -> a -> b
$ String
csConsole String -> String -> String
`access`
    String
csWrite)
  printLnFunc :: VS (CSharpCode Value)
printLnFunc = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. VS a -> VS a
addSystemImport (VS (CSharpCode Value) -> VS (CSharpCode Value))
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode TypeData) -> Body -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Body -> VS (r val)
mkStateVal VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void (String -> Body
text (String -> Body) -> String -> Body
forall a b. (a -> b) -> a -> b
$ String
csConsole String -> String -> String
`access`
    String
csWriteLine)
  printFileFunc :: VS (CSharpCode Value) -> VS (CSharpCode Value)
printFileFunc VS (CSharpCode Value)
w' = (CSharpCode Value -> CSharpCode TypeData -> VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\CSharpCode Value
w CSharpCode TypeData
vt ->
    CSharpCode TypeData -> Body -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
r typ -> Body -> VS (r val)
mkVal CSharpCode TypeData
vt (Body -> VS (CSharpCode Value))
-> (CSharpCode Value -> Body)
-> CSharpCode Value
-> VS (CSharpCode Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Body -> Body
R.printFile String
csWrite (Body -> Body)
-> (CSharpCode Value -> Body) -> CSharpCode Value -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value (CSharpCode Value -> VS (CSharpCode Value))
-> CSharpCode Value -> VS (CSharpCode Value)
forall a b. (a -> b) -> a -> b
$ CSharpCode Value
w) VS (CSharpCode Value)
w' VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void
  printFileLnFunc :: VS (CSharpCode Value) -> VS (CSharpCode Value)
printFileLnFunc VS (CSharpCode Value)
w' = (CSharpCode Value -> CSharpCode TypeData -> VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\CSharpCode Value
w CSharpCode TypeData
vt ->
    CSharpCode TypeData -> Body -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
r typ -> Body -> VS (r val)
mkVal CSharpCode TypeData
vt (Body -> VS (CSharpCode Value))
-> (CSharpCode Value -> Body)
-> CSharpCode Value
-> VS (CSharpCode Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Body -> Body
R.printFile String
csWriteLine (Body -> Body)
-> (CSharpCode Value -> Body) -> CSharpCode Value -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value (CSharpCode Value -> VS (CSharpCode Value))
-> CSharpCode Value -> VS (CSharpCode Value)
forall a b. (a -> b) -> a -> b
$ CSharpCode Value
w) VS (CSharpCode Value)
w' VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void

  cast :: VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
cast = VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
csCast

  call :: Maybe String
-> Maybe Body -> MixedCall CSharpCode Variable Value TypeData
call = Body
-> Maybe String
-> Maybe Body
-> MixedCall CSharpCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 ValueElim r val) =>
Body -> Maybe String -> Maybe Body -> MixedCall r var val typ
G.call Body
csNamedArgSep

  valFromData :: Maybe Int
-> Maybe Integer
-> VS (CSharpCode TypeData)
-> Body
-> VS (CSharpCode Value)
valFromData Maybe Int
p Maybe Integer
i VS (CSharpCode TypeData)
t' Body
d = do
    t <- VS (CSharpCode TypeData)
t'
    toState $ on2CodeValues (vd p i) t (toCode d)

instance ValueElim CSharpCode Value where
  valuePrec :: CSharpCode Value -> Maybe Int
valuePrec = Value -> Maybe Int
valPrec (Value -> Maybe Int)
-> (CSharpCode Value -> Value) -> CSharpCode Value -> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Value
forall a. CSharpCode a -> a
unCSC
  valueInt :: CSharpCode Value -> Maybe Integer
valueInt = Value -> Maybe Integer
valInt (Value -> Maybe Integer)
-> (CSharpCode Value -> Value) -> CSharpCode Value -> Maybe Integer
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Value
forall a. CSharpCode a -> a
unCSC
  value :: CSharpCode Value -> Body
value = Value -> Body
val (Value -> Body)
-> (CSharpCode Value -> Value) -> CSharpCode Value -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Value
forall a. CSharpCode a -> a
unCSC

instance InternalValueExp CSharpCode Variable Value TypeData where
  objMethodCallMixedArgs' :: String
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> [VS (CSharpCode Value)]
-> NamedArgs CSharpCode Variable Value
-> VS (CSharpCode Value)
objMethodCallMixedArgs' = String
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> [VS (CSharpCode Value)]
-> NamedArgs CSharpCode Variable Value
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val) =>
String
-> VS (r typ)
-> VS (r val)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
G.objMethodCall
  classMethodCallMixedArgs' :: String
-> VS (CSharpCode TypeData)
-> MixedCtorCall CSharpCode Variable Value TypeData
classMethodCallMixedArgs' = String
-> VS (CSharpCode TypeData)
-> MixedCtorCall CSharpCode Variable Value TypeData
forall (r :: * -> *) var val.
(RenderValue r var val TypeData, UnRepr r TypeData) =>
String
-> VS (r TypeData)
-> VS (r TypeData)
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
CG.classMethodCall

instance OOFunctionSym CSharpCode Value TypeData where
  func :: String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode FuncData)
func = String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode FuncData)
forall (r :: * -> *) typ val var binder.
(RenderFunction r typ, ValueElim r val,
 ValueExpression r var val binder typ) =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
G.func
  objAccess :: VS (CSharpCode Value)
-> VS (CSharpCode FuncData) -> VS (CSharpCode Value)
objAccess = VS (CSharpCode Value)
-> VS (CSharpCode FuncData) -> VS (CSharpCode Value)
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)
G.objAccess

instance GetSet CSharpCode Variable Value where
  get :: VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> VS (CSharpCode Value)
get = VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall (r :: * -> *) var val typ.
(InternalGetSet r var val typ, OOFunctionSym r val typ) =>
VS (r val) -> VS (r var) -> VS (r val)
G.get
  set :: VS (CSharpCode Value)
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
set = VS (CSharpCode Value)
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
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)
G.set

instance IndexTranslator CSharpCode Value where
  intToIndex :: VS (CSharpCode Value) -> VS (CSharpCode Value)
intToIndex = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k). VS (r val) -> VS (r val)
CP.intToIndex
  indexToInt :: VS (CSharpCode Value) -> VS (CSharpCode Value)
indexToInt = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k). VS (r val) -> VS (r val)
CP.indexToInt

instance Reference CSharpCode Value where
  makeRef :: VS (CSharpCode Value) -> VS (CSharpCode Value)
makeRef = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. a -> a
id
  maybeDeref :: VS (CSharpCode Value) -> VS (CSharpCode Value)
maybeDeref = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. a -> a
id

instance Array CSharpCode Variable Value where
  arrayElem :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Variable)
arrayElem = VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Variable)
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)
G.arrayElem
  arrayLength :: VS (CSharpCode Value) -> VS (CSharpCode Value)
arrayLength VS (CSharpCode Value)
arr = VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf (VS (CSharpCode Variable) -> VS (CSharpCode Value))
-> VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r val) -> VS (r var) -> VS (r var)
instanceVarAccess VS (CSharpCode Value)
arr (String -> VS (CSharpCode TypeData) -> VS (CSharpCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"Length" VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int)
  arrayCopy :: VS (CSharpCode Value) -> VS (CSharpCode Value)
arrayCopy VS (CSharpCode Value)
arr = let
    arrTp :: VS (CSharpCode TypeData)
arrTp = (CSharpCode Value -> CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Value -> CSharpCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType VS (CSharpCode Value)
arr
    in VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
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 (CSharpCode TypeData)
arrTp (VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> String
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> [VS (r val)] -> VS (r val)
objMethodCall VS (CSharpCode TypeData)
arrTp VS (CSharpCode Value)
arr String
"Clone" [])

instance List CSharpCode Value where
  listSize :: VS (CSharpCode Value) -> VS (CSharpCode Value)
listSize = String -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val) =>
String -> VS (r val) -> VS (r val)
C.listSize' String
csListSize
  listAccess :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
listAccess = VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
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)
G.listAccess
  indexOf :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
indexOf = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) typ val.
(TypeSym r typ, IndexTranslator r val, OOFunctionSym r val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.indexOf String
csIndex

instance ListStatement CSharpCode Statement Value where
  listAdd :: VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
listAdd = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (stmt :: k).
(TypeSym r typ, IndexTranslator r val,
 InternalValueExp r var val typ, ValueStatement r stmt val) =>
String -> VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
CG.listAdd String
csListAdd
  listAppend :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
listAppend = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (stmt :: k).
(TypeSym r typ, InternalValueExp r var val typ,
 ValueStatement r stmt val) =>
String -> VS (r val) -> VS (r val) -> MS (r stmt)
CG.listAppend String
csListAppend
  listSet :: VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
listSet = VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, ValueSym r val typ,
 IndexTranslator r val, RenderVariable r var typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
CP.listSet

instance Set CSharpCode Value where
  contains :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
contains = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall (r :: * -> *) typ val.
(TypeSym r typ, OOFunctionSym r val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.contains String
csContains
  setAdd :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
setAdd = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.setMethodCall String
csListAppend
  setRemove :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
setRemove = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.setMethodCall String
csListRemove
  setUnion :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
setUnion = String
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.setMethodCall String
csUnionWith

instance InternalList CSharpCode Block Variable Value where
  listSlice' :: Maybe (VS (CSharpCode Value))
-> Maybe (VS (CSharpCode Value))
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
listSlice' = Maybe (VS (CSharpCode Value))
-> Maybe (VS (CSharpCode Value))
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
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)
M.listSlice

instance InternalGetSet CSharpCode Variable Value TypeData where
  getFunc :: VS (CSharpCode Variable) -> VS (CSharpCode FuncData)
getFunc = VS (CSharpCode Variable) -> VS (CSharpCode FuncData)
forall (r :: * -> *) val typ var.
(OOFunctionSym r val typ, VariableElim r var typ) =>
VS (r var) -> VS (r FuncData)
G.getFunc
  setFunc :: VS (CSharpCode TypeData)
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> VS (CSharpCode FuncData)
setFunc = VS (CSharpCode TypeData)
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> VS (CSharpCode FuncData)
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)
G.setFunc

instance InternalListFunc CSharpCode Value TypeData where
  listAccessFunc :: VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode FuncData)
listAccessFunc = VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode FuncData)
forall (r :: * -> *) typ val.
(RenderFunction r typ, TypeElim r typ, ValueElim r val,
 ValueSym r val typ) =>
VS (r typ) -> VS (r val) -> VS (r FuncData)
CS.listAccessFunc

instance BinderSym CSharpCode BinderD TypeData where
  binder :: String -> VS (CSharpCode TypeData) -> VS (CSharpCode BinderD)
binder String
nm VS (CSharpCode TypeData)
tp = (TypeData -> BinderD) -> CSharpCode TypeData -> CSharpCode BinderD
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (String -> TypeData -> BinderD
bindFormD String
nm) (CSharpCode TypeData -> CSharpCode BinderD)
-> VS (CSharpCode TypeData) -> VS (CSharpCode BinderD)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> VS (CSharpCode TypeData)
tp

instance BinderElim CSharpCode BinderD TypeData where
  binderName :: CSharpCode BinderD -> String
binderName = BinderD -> String
bindName (BinderD -> String)
-> (CSharpCode BinderD -> BinderD) -> CSharpCode BinderD -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode BinderD -> BinderD
forall a. CSharpCode a -> a
unCSC
  binderType :: CSharpCode BinderD -> CSharpCode TypeData
binderType = (BinderD -> TypeData) -> CSharpCode BinderD -> CSharpCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue BinderD -> TypeData
bindType

instance InternalBinderElim CSharpCode BinderD where
  binderElim :: CSharpCode BinderD -> Body
binderElim = String -> Body
text (String -> Body)
-> (CSharpCode BinderD -> String) -> CSharpCode BinderD -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinderD -> String
bindName (BinderD -> String)
-> (CSharpCode BinderD -> BinderD) -> CSharpCode BinderD -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode BinderD -> BinderD
forall a. CSharpCode a -> a
unCSC

instance RenderFunction CSharpCode TypeData where
  funcFromData :: Body -> VS (CSharpCode TypeData) -> VS (CSharpCode FuncData)
funcFromData Body
d = (CSharpCode TypeData -> CSharpCode FuncData)
-> VS (CSharpCode TypeData) -> VS (CSharpCode FuncData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((TypeData -> FuncData)
-> CSharpCode TypeData -> CSharpCode FuncData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue (TypeData -> Body -> FuncData
`fd` Body
d))

instance FunctionElim CSharpCode TypeData where
  functionType :: CSharpCode FuncData -> CSharpCode TypeData
functionType = (FuncData -> TypeData)
-> CSharpCode FuncData -> CSharpCode TypeData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue FuncData -> TypeData
fType
  function :: CSharpCode FuncData -> Body
function = FuncData -> Body
funcDoc (FuncData -> Body)
-> (CSharpCode FuncData -> FuncData) -> CSharpCode FuncData -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode FuncData -> FuncData
forall a. CSharpCode a -> a
unCSC

instance InternalAssignStmt CSharpCode Statement Variable Value where
  multiAssign :: [VS (CSharpCode Variable)]
-> [VS (CSharpCode Value)] -> MS (CSharpCode Statement)
multiAssign [VS (CSharpCode Variable)]
_ [VS (CSharpCode Value)]
_ = String -> MS (CSharpCode Statement)
forall a. HasCallStack => String -> a
error (String -> MS (CSharpCode Statement))
-> String -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiAssignError String
csName

instance InternalIOStmt CSharpCode Statement Value where
  printSt :: Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
printSt Bool
_ Maybe (VS (CSharpCode Value))
_ = VS (CSharpCode Value)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
VS (r val) -> VS (r val) -> MS (r stmt)
CP.printSt

instance InternalControlStmt CSharpCode Statement Value where
  multiReturn :: [VS (CSharpCode Value)] -> MS (CSharpCode Statement)
multiReturn [VS (CSharpCode Value)]
_ = String -> MS (CSharpCode Statement)
forall a. HasCallStack => String -> a
error (String -> MS (CSharpCode Statement))
-> String -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiReturnError String
csName

instance RenderStatement CSharpCode Statement where
  stmt :: MS (CSharpCode Statement) -> MS (CSharpCode Statement)
stmt = MS (CSharpCode Statement) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
G.stmt
  loopStmt :: MS (CSharpCode Statement) -> MS (CSharpCode Statement)
loopStmt = MS (CSharpCode Statement) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
(RenderStatement r stmt, StatementElim r stmt) =>
MS (r stmt) -> MS (r stmt)
G.loopStmt
  stmtFromData :: Body -> Terminator -> MS (CSharpCode Statement)
stmtFromData Body
d Terminator
t = CSharpCode Statement -> MS (CSharpCode Statement)
forall a s. a -> State s a
toState (CSharpCode Statement -> MS (CSharpCode Statement))
-> CSharpCode Statement -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ Statement -> CSharpCode Statement
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Body
d, Terminator
t)

instance StatementElim CSharpCode Statement where
  statement :: CSharpCode Statement -> Body
statement = Statement -> Body
forall a b. (a, b) -> a
fst (Statement -> Body)
-> (CSharpCode Statement -> Statement)
-> CSharpCode Statement
-> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Statement -> Statement
forall a. CSharpCode a -> a
unCSC
  statementTerm :: CSharpCode Statement -> Terminator
statementTerm = Statement -> Terminator
forall a b. (a, b) -> b
snd (Statement -> Terminator)
-> (CSharpCode Statement -> Statement)
-> CSharpCode Statement
-> Terminator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Statement -> Statement
forall a. CSharpCode a -> a
unCSC

instance EmptyStatement CSharpCode Statement where
  emptyStmt :: MS (CSharpCode Statement)
emptyStmt = MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt)
G.emptyStmt

instance MultiStatement CSharpCode Statement where
  multi :: [MS (CSharpCode Statement)] -> MS (CSharpCode Statement)
multi = ([CSharpCode Statement] -> CSharpCode Statement)
-> [MS (CSharpCode Statement)] -> MS (CSharpCode Statement)
forall a b s. ([a] -> b) -> [State s a] -> State s b
onStateList (([Statement] -> Statement)
-> [CSharpCode Statement] -> CSharpCode Statement
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList [Statement] -> Statement
R.multiStmt)

instance ValueStatement CSharpCode Statement Value where
  valStmt :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
valStmt = Terminator -> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r val) -> MS (r stmt)
G.valStmt Terminator
Semi

instance AssignStatement CSharpCode Statement Variable Value where
  assign :: VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
assign = Terminator
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
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)
G.assign Terminator
Semi
  &-= :: VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
(&-=) = Terminator
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
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)
G.subAssign Terminator
Semi
  &+= :: VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
(&+=) = VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (var :: k) (stmt :: k) (val :: k).
(InternalVarElim r var, RenderStatement r stmt, ValueElim r val) =>
VS (r var) -> VS (r val) -> MS (r stmt)
C.increment
  &++ :: VS (CSharpCode Variable) -> MS (CSharpCode Statement)
(&++) = VS (CSharpCode Variable) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (var :: k) (stmt :: k).
(InternalVarElim r var, RenderStatement r stmt) =>
VS (r var) -> MS (r stmt)
C.increment1
  &-- :: VS (CSharpCode Variable) -> MS (CSharpCode Statement)
(&--) = VS (CSharpCode Variable) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (var :: k) (stmt :: k).
(InternalVarElim r var, RenderStatement r stmt) =>
VS (r var) -> MS (r stmt)
C.decrement1

instance DeclStatement CSharpCode Body Statement Variable ScopeData Value where
  varDec :: VS (CSharpCode Variable)
-> CSharpCode ScopeData -> MS (CSharpCode Statement)
varDec VS (CSharpCode Variable)
v CSharpCode ScopeData
scp = LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
-> VS (CSharpCode Variable)
-> StateT MethodState Identity (CSharpCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (CSharpCode Variable) ValueState)
-> MethodState
-> Focusing Identity (CSharpCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (CSharpCode Variable)
v StateT MethodState Identity (CSharpCode Variable)
-> (CSharpCode Variable -> MS (CSharpCode Statement))
-> MS (CSharpCode Statement)
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
>>= (\CSharpCode Variable
v' -> AttachmentTag
-> MS (CSharpCode Statement) -> MS (CSharpCode Statement)
forall stmt.
AttachmentTag -> MS (CSharpCode stmt) -> MS (CSharpCode stmt)
csVarDec (CSharpCode Variable -> AttachmentTag
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> AttachmentTag
variableBind CSharpCode Variable
v') (MS (CSharpCode Statement) -> MS (CSharpCode Statement))
-> MS (CSharpCode Statement) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$
    CSharpCode Body
-> CSharpCode Body
-> Body
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> MS (CSharpCode Statement)
forall (r :: * -> *) var attch stmt.
(InternalVarElim r var, PermElim r attch, RenderStatement r stmt,
 ScopeElim r ScopeData, UnRepr r TypeData, TypeElim r TypeData,
 VariableElim r var TypeData) =>
r attch
-> r attch -> Body -> VS (r var) -> r ScopeData -> MS (r stmt)
C.varDec CSharpCode Body
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel CSharpCode Body
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel Body
empty VS (CSharpCode Variable)
v CSharpCode ScopeData
scp)
  varDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
varDecDef = Terminator
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
C.varDecDef Terminator
Semi
  setDec :: VS (CSharpCode Variable)
-> CSharpCode ScopeData -> MS (CSharpCode Statement)
setDec = VS (CSharpCode Variable)
-> CSharpCode ScopeData -> MS (CSharpCode Statement)
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 -> MS (r stmt)
varDec
  setDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
setDecDef = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
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)
varDecDef
  listDec :: Integer
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> MS (CSharpCode Statement)
listDec Integer
n VS (CSharpCode Variable)
v CSharpCode ScopeData
scp = LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
-> VS (CSharpCode Variable)
-> StateT MethodState Identity (CSharpCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (CSharpCode Variable) ValueState)
-> MethodState
-> Focusing Identity (CSharpCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (CSharpCode Variable)
v StateT MethodState Identity (CSharpCode Variable)
-> (CSharpCode Variable -> MS (CSharpCode Statement))
-> MS (CSharpCode Statement)
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
>>= (\CSharpCode Variable
v' -> (CSharpCode Value -> Body)
-> VS (CSharpCode Value)
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt) =>
(r val -> Body)
-> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
C.listDec (CSharpCode Variable -> CSharpCode Value -> Body
forall (r :: * -> *) val var.
(UnRepr r TypeData, ValueElim r val,
 VariableElim r var TypeData) =>
r var -> r val -> Body
renderListDec CSharpCode Variable
v')
    (Integer -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
n) VS (CSharpCode Variable)
v CSharpCode ScopeData
scp)
  listDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
listDecDef = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val, TypeSym r typ,
 Literal r val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
CP.listDecDef
  arrayDec :: Integer
-> VS (CSharpCode Value)
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> MS (CSharpCode Statement)
arrayDec Integer
n VS (CSharpCode Value)
_ = VS (CSharpCode Value)
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> MS (CSharpCode Statement)
forall (r :: * -> *) var stmt val.
(TypeSym r TypeData, ScopeElim r ScopeData, UnRepr r TypeData,
 InternalVarElim r var, RenderStatement r stmt, ValueElim r val,
 VariableElim r var TypeData) =>
VS (r val) -> VS (r var) -> r ScopeData -> MS (r stmt)
CP.arrayDec (Integer -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
n)
  arrayDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
arrayDecDef = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r val) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
CP.arrayDecDef
  constDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
constDecDef = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall (r :: * -> *) var stmt val.
(InternalVarElim r var, RenderStatement r stmt,
 ScopeElim r ScopeData, UnRepr r TypeData, ValueElim r val,
 VariableElim r var TypeData) =>
VS (r var) -> r ScopeData -> VS (r val) -> MS (r stmt)
CG.constDecDef
  funcDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Variable)]
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
funcDecDef = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Variable)]
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
csFuncDecDef

instance OODeclStatement CSharpCode Statement Variable ScopeData Value where
  objDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
objDecDef = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
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)
varDecDef
  objDecNew :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
objDecNew = VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
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)
G.objDecNew
  extObjDecNew :: String
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
extObjDecNew = String
-> VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Value)]
-> MS (CSharpCode Statement)
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) =>
String -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
C.extObjDecNew

instance PrintConsole CSharpCode Statement Value where
  print :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
print      = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
False Maybe (VS (CSharpCode Value))
forall a. Maybe a
Nothing VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc
  printLn :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
printLn    = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
True  Maybe (VS (CSharpCode Value))
forall a. Maybe a
Nothing VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc
  printStr :: String -> MS (CSharpCode Statement)
printStr   = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
False Maybe (VS (CSharpCode Value))
forall a. Maybe a
Nothing VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc   (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> (String -> VS (CSharpCode Value))
-> String
-> MS (CSharpCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString
  printStrLn :: String -> MS (CSharpCode Statement)
printStrLn = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
True  Maybe (VS (CSharpCode Value))
forall a. Maybe a
Nothing VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> (String -> VS (CSharpCode Value))
-> String
-> MS (CSharpCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString

instance ReadConsole CSharpCode Statement Variable where
  getInput :: VS (CSharpCode Variable) -> MS (CSharpCode Statement)
getInput VS (CSharpCode Variable)
v = VS (CSharpCode Variable)
v VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
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 (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
csInput ((CSharpCode Variable -> CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (CSharpCode Variable)
v) VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
inputFunc
  discardInput :: MS (CSharpCode Statement)
discardInput = VS (CSharpCode Value) -> MS (CSharpCode Statement)
csDiscardInput VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
inputFunc

instance FileHandling CSharpCode Statement Variable Value where
  openFileR :: VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
openFileR = (VS (CSharpCode Value)
 -> VS (CSharpCode TypeData) -> VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, AssignStatement r stmt var val) =>
(VS (r val) -> VS (r typ) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
CP.openFileR VS (CSharpCode Value)
-> VS (CSharpCode TypeData) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
VS (r val) -> VS (r typ) -> VS (r val)
csOpenFileR
  openFileW :: VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
openFileW = (VS (CSharpCode Value)
 -> VS (CSharpCode TypeData)
 -> VS (CSharpCode Value)
 -> VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, TypeSym r typ,
 Literal r val typ) =>
(VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
CP.openFileW VS (CSharpCode Value)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
csOpenFileWorA
  openFileA :: VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
openFileA = (VS (CSharpCode Value)
 -> VS (CSharpCode TypeData)
 -> VS (CSharpCode Value)
 -> VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, TypeSym r typ,
 Literal r val typ) =>
(VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
CP.openFileA VS (CSharpCode Value)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
csOpenFileWorA
  closeFile :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
closeFile = String -> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (stmt :: k).
(TypeSym r typ, InternalValueExp r var val typ,
 ValueStatement r stmt val) =>
String -> VS (r val) -> MS (r stmt)
G.closeFile String
csClose

instance PrintFile CSharpCode Statement Value where
  printFile :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
printFile VS (CSharpCode Value)
f      = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
False (VS (CSharpCode Value) -> Maybe (VS (CSharpCode Value))
forall a. a -> Maybe a
Just VS (CSharpCode Value)
f) (VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileFunc VS (CSharpCode Value)
f)
  printFileLn :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
printFileLn VS (CSharpCode Value)
f    = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
True  (VS (CSharpCode Value) -> Maybe (VS (CSharpCode Value))
forall a. a -> Maybe a
Just VS (CSharpCode Value)
f) (VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileLnFunc VS (CSharpCode Value)
f)
  printFileStr :: VS (CSharpCode Value) -> String -> MS (CSharpCode Statement)
printFileStr VS (CSharpCode Value)
f   = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
False (VS (CSharpCode Value) -> Maybe (VS (CSharpCode Value))
forall a. a -> Maybe a
Just VS (CSharpCode Value)
f) (VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileFunc VS (CSharpCode Value)
f)   (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> (String -> VS (CSharpCode Value))
-> String
-> MS (CSharpCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString
  printFileStrLn :: VS (CSharpCode Value) -> String -> MS (CSharpCode Statement)
printFileStrLn VS (CSharpCode Value)
f = Bool
-> Maybe (VS (CSharpCode Value))
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint Bool
True  (VS (CSharpCode Value) -> Maybe (VS (CSharpCode Value))
forall a. a -> Maybe a
Just VS (CSharpCode Value)
f) (VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileLnFunc VS (CSharpCode Value)
f) (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> (String -> VS (CSharpCode Value))
-> String
-> MS (CSharpCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString

instance ReadFile CSharpCode Statement Variable Value where
  getFileInput :: VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> MS (CSharpCode Statement)
getFileInput VS (CSharpCode Value)
f VS (CSharpCode Variable)
v = VS (CSharpCode Variable)
v VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
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 (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
csInput ((CSharpCode Variable -> CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (CSharpCode Variable)
v) (VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) typ var.
(TypeSym r typ, InternalValueExp r var Value typ) =>
VS (r Value) -> VS (r Value)
csFileInput VS (CSharpCode Value)
f)
  discardFileInput :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
discardFileInput VS (CSharpCode Value)
f = VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) typ var.
(TypeSym r typ, InternalValueExp r var Value typ) =>
VS (r Value) -> VS (r Value)
csFileInput VS (CSharpCode Value)
f
  getFileInputLine :: VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> MS (CSharpCode Statement)
getFileInputLine = VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
ReadFile r stmt var val =>
VS (r val) -> VS (r var) -> MS (r stmt)
getFileInput
  discardFileLine :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
discardFileLine = String -> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (stmt :: k).
(TypeSym r typ, InternalValueExp r var val typ,
 ValueStatement r stmt val) =>
String -> VS (r val) -> MS (r stmt)
CP.discardFileLine String
csReadLine
  getFileInputAll :: VS (CSharpCode Value)
-> VS (CSharpCode Variable) -> MS (CSharpCode Statement)
getFileInputAll VS (CSharpCode Value)
f VS (CSharpCode Variable)
v = VS (CSharpCode Value)
-> MS (CSharpCode Body) -> MS (CSharpCode Statement)
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 stmt)
while ((VS (CSharpCode Value)
f VS (CSharpCode Value)
-> VS (CSharpCode FuncData) -> VS (CSharpCode Value)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. Body -> VS (CSharpCode TypeData) -> VS (CSharpCode FuncData)
forall (r :: * -> *) typ.
RenderFunction r typ =>
Body -> VS (r typ) -> VS (r FuncData)
funcFromData (Body
dot Body -> Body -> Body
<> String -> Body
text String
csEOS) VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool) VS (CSharpCode Value) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k).
BooleanExpression r val =>
VS (r val) -> VS (r val)
?!)
    (MS (CSharpCode Statement) -> MS (CSharpCode Body)
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 (CSharpCode Statement) -> MS (CSharpCode Body))
-> MS (CSharpCode Statement) -> MS (CSharpCode Body)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode Value)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ListStatement r stmt val =>
VS (r val) -> VS (r val) -> MS (r stmt)
listAppend (VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (CSharpCode Variable)
v) (VS (CSharpCode Value) -> VS (CSharpCode Value)
forall (r :: * -> *) typ var.
(TypeSym r typ, InternalValueExp r var Value typ) =>
VS (r Value) -> VS (r Value)
csFileInput VS (CSharpCode Value)
f))

instance StringStatement CSharpCode Statement Variable Value where
  stringSplit :: Char
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
stringSplit Char
d VS (CSharpCode Variable)
vnew VS (CSharpCode Value)
s = VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
assign VS (CSharpCode Variable)
vnew (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)] -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
PosCtorCall r val typ
newObj (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)
    [VS (CSharpCode Value)
s VS (CSharpCode Value)
-> VS (CSharpCode FuncData) -> VS (CSharpCode Value)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. Char -> VS (CSharpCode FuncData)
csSplitFunc Char
d]

  stringListVals :: [VS (CSharpCode Variable)]
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
stringListVals = [VS (CSharpCode Variable)]
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
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)
M.stringListVals
  stringListLists :: [VS (CSharpCode Variable)]
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
stringListLists = [VS (CSharpCode Variable)]
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
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)
M.stringListLists

instance FuncAppStatement CSharpCode Statement Variable Value where
  inOutCall :: InOutCall CSharpCode Statement Variable Value
inOutCall = (String
 -> VS (CSharpCode TypeData)
 -> [VS (CSharpCode Value)]
 -> VS (CSharpCode Value))
-> InOutCall CSharpCode Statement Variable Value
csInOutCall String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp
  extInOutCall :: String -> InOutCall CSharpCode Statement Variable Value
extInOutCall String
m = (String
 -> VS (CSharpCode TypeData)
 -> [VS (CSharpCode Value)]
 -> VS (CSharpCode Value))
-> InOutCall CSharpCode Statement Variable Value
csInOutCall (String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
m)

instance OOFuncAppStatement CSharpCode Statement Variable Value where
  selfInOutCall :: InOutCall CSharpCode Statement Variable Value
selfInOutCall = (String
 -> VS (CSharpCode TypeData)
 -> [VS (CSharpCode Value)]
 -> VS (CSharpCode Value))
-> InOutCall CSharpCode Statement Variable Value
csInOutCall String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, VariableValue r var val,
 SelfSym r var) =>
PosCall r val typ
selfMethodCall

instance CommentStatement CSharpCode Statement where
  comment :: String -> MS (CSharpCode Statement)
comment = Body -> String -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Body -> String -> MS (r stmt)
G.comment Body
commentStart

instance ControlStatement CSharpCode Body Statement Variable Value where
  break :: MS (CSharpCode Statement)
break =  Body -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Body -> MS (r stmt)
mkStmt Body
R.break
  continue :: MS (CSharpCode Statement)
continue =  Body -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
Body -> MS (r stmt)
mkStmt Body
R.continue

  returnStmt :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
returnStmt = Terminator -> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
(RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r val) -> MS (r stmt)
G.returnStmt Terminator
Semi

  throw :: String -> MS (CSharpCode Statement)
throw String
msg = do
    (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> MethodState -> MethodState
addLangImport String
csSystem)
    (CSharpCode Value -> Body)
-> Terminator -> String -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (stmt :: k).
(Literal r val typ, RenderStatement r stmt) =>
(r val -> Body) -> Terminator -> String -> MS (r stmt)
G.throw CSharpCode Value -> Body
csThrowDoc Terminator
Semi String
msg

  ifCond :: [(VS (CSharpCode Value), MS (CSharpCode Body))]
-> MS (CSharpCode Body) -> MS (CSharpCode Statement)
ifCond = (Body -> Body)
-> Body
-> OptionalSpace
-> Body
-> Body
-> Body
-> [(VS (CSharpCode Value), MS (CSharpCode Body))]
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Body -> Body)
-> Body
-> OptionalSpace
-> Body
-> Body
-> Body
-> [(VS (r val), MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
G.ifCond Body -> Body
parens Body
bodyStart OptionalSpace
G.defaultOptSpace Body
elseIfLabel Body
bodyEnd Body
empty
  switch :: VS (CSharpCode Value)
-> [(VS (CSharpCode Value), MS (CSharpCode Body))]
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
switch = (Body -> Body)
-> MS (CSharpCode Statement)
-> VS (CSharpCode Value)
-> [(VS (CSharpCode Value), MS (CSharpCode Body))]
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, StatementElim r stmt,
 ValueElim r val) =>
(Body -> Body)
-> MS (r stmt)
-> VS (r val)
-> [(VS (r val), MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
C.switch Body -> Body
parens MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r stmt)
break

  ifExists :: VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
ifExists = VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
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)
M.ifExists

  for :: MS (CSharpCode Statement)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
for = Body
-> Body
-> MS (CSharpCode Statement)
-> VS (CSharpCode Value)
-> MS (CSharpCode Statement)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, StatementElim r stmt,
 ValueElim r val) =>
Body
-> Body
-> MS (r stmt)
-> VS (r val)
-> MS (r stmt)
-> MS (r bod)
-> MS (r stmt)
C.for Body
bodyStart Body
bodyEnd
  forRange :: VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forRange = VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
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)
M.forRange
  forEach :: VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forEach = Body
-> Body
-> Body
-> Body
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forall (r :: * -> *) bod var stmt val.
(BodyElim r bod, InternalVarElim r var, RenderStatement r stmt,
 UnRepr r TypeData, ValueElim r val, VariableElim r var TypeData) =>
Body
-> Body
-> Body
-> Body
-> VS (r var)
-> VS (r val)
-> MS (r bod)
-> MS (r stmt)
CP.forEach Body
bodyStart Body
bodyEnd Body
csForEach Body
inLabel
  while :: VS (CSharpCode Value)
-> MS (CSharpCode Body) -> MS (CSharpCode Statement)
while = (Body -> Body)
-> Body
-> Body
-> VS (CSharpCode Value)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Body -> Body)
-> Body -> Body -> VS (r val) -> MS (r bod) -> MS (r stmt)
C.while Body -> Body
parens Body
bodyStart Body
bodyEnd

  tryCatch :: MS (CSharpCode Body)
-> MS (CSharpCode Body) -> MS (CSharpCode Statement)
tryCatch = (CSharpCode Body -> CSharpCode Body -> Body)
-> MS (CSharpCode Body)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (bod :: k).
RenderStatement r stmt =>
(r bod -> r bod -> Body) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
G.tryCatch CSharpCode Body -> CSharpCode Body -> Body
csTryCatch

  assert :: VS (CSharpCode Value)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
assert VS (CSharpCode Value)
condition VS (CSharpCode Value)
errorMessage = do
    (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> MethodState -> MethodState
addLangImport String
csDiagnostics)
    cond <- LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Value))
  MethodState
  ValueState
-> VS (CSharpCode Value)
-> StateT MethodState Identity (CSharpCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (CSharpCode Value) ValueState)
-> MethodState -> Focusing Identity (CSharpCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS VS (CSharpCode Value)
condition
    errMsg <- zoom lensMStoVS errorMessage
    mkStmtNoEnd (csAssert cond errMsg)

instance ObserverPattern CSharpCode Statement TypeData where
  notifyObservers :: VS (CSharpCode FuncData)
-> VS (CSharpCode TypeData) -> MS (CSharpCode Statement)
notifyObservers = VS (CSharpCode FuncData)
-> VS (CSharpCode TypeData) -> MS (CSharpCode Statement)
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)
M.notifyObservers

instance StrategyPattern CSharpCode Body Block Variable Value where
  runStrategy :: String
-> [(String, MS (CSharpCode Body))]
-> Maybe (VS (CSharpCode Value))
-> Maybe (VS (CSharpCode Variable))
-> MS (CSharpCode Body)
runStrategy = String
-> [(String, MS (CSharpCode Body))]
-> Maybe (VS (CSharpCode Value))
-> Maybe (VS (CSharpCode Variable))
-> MS (CSharpCode Body)
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) =>
String
-> [(String, MS (r bod))]
-> Maybe (VS (r val))
-> Maybe (VS (r var))
-> MS (r Body)
M.runStrategy

instance VisibilitySym CSharpCode Doc where
  private :: CSharpCode Body
private = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode Body
R.private
  public :: CSharpCode Body
public = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode Body
R.public

instance RenderVisibility CSharpCode Doc where
  visibilityFromData :: VisibilityTag -> Body -> CSharpCode Body
visibilityFromData VisibilityTag
_ = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode

instance VisibilityElim CSharpCode Doc where
  visibility :: CSharpCode Body -> Body
visibility = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC

instance MethodTypeSym CSharpCode TypeData where
  mType :: VS (CSharpCode TypeData) -> MS (CSharpCode TypeData)
mType = LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode TypeData))
  MethodState
  ValueState
-> VS (CSharpCode TypeData) -> MS (CSharpCode 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) (CSharpCode TypeData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (CSharpCode TypeData) ValueState)
-> MethodState
-> Focusing Identity (CSharpCode TypeData) MethodState
Lens' MethodState ValueState
lensMStoVS

instance OOMethodTypeSym CSharpCode TypeData where
  construct :: String -> MS (CSharpCode TypeData)
construct = String -> MS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => String -> MS (r TypeData)
G.construct

instance ParameterSym CSharpCode ParamData Variable where
  param :: VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
param = (CSharpCode Variable -> Body)
-> VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k) (typ :: k).
(RenderParam r param var, VariableElim r var typ) =>
(r var -> Body) -> VS (r var) -> MS (r param)
G.param CSharpCode Variable -> Body
forall (r :: * -> *) var.
(InternalVarElim r var, UnRepr r TypeData,
 VariableElim r var TypeData) =>
r var -> Body
renderParam
  pointerParam :: VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
pointerParam = VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param

instance RenderParam CSharpCode ParamData Variable where
  paramFromData :: VS (CSharpCode Variable) -> Body -> MS (CSharpCode ParamData)
paramFromData VS (CSharpCode Variable)
v' Body
d = do
    v <- LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
-> VS (CSharpCode Variable)
-> StateT MethodState Identity (CSharpCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (CSharpCode Variable) ValueState)
-> MethodState
-> Focusing Identity (CSharpCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (CSharpCode Variable)
v'
    toState $ on2CodeValues pd v (toCode d)

instance ParamElim CSharpCode ParamData TypeData where
  parameterName :: CSharpCode ParamData -> String
parameterName = CSharpCode Variable -> String
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> String
variableName (CSharpCode Variable -> String)
-> (CSharpCode ParamData -> CSharpCode Variable)
-> CSharpCode ParamData
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> Variable)
-> CSharpCode ParamData -> CSharpCode Variable
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> Variable
paramVar
  parameterType :: CSharpCode ParamData -> CSharpCode TypeData
parameterType = CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType (CSharpCode Variable -> CSharpCode TypeData)
-> (CSharpCode ParamData -> CSharpCode Variable)
-> CSharpCode ParamData
-> CSharpCode TypeData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> Variable)
-> CSharpCode ParamData -> CSharpCode Variable
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> Variable
paramVar
  parameter :: CSharpCode ParamData -> Body
parameter = ParamData -> Body
paramDoc (ParamData -> Body)
-> (CSharpCode ParamData -> ParamData)
-> CSharpCode ParamData
-> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ParamData -> ParamData
forall a. CSharpCode a -> a
unCSC

instance MethodSym CSharpCode MethodData Doc ParamData Body Variable TypeData where
  docMain :: MS (CSharpCode Body) -> MS (CSharpCode MethodData)
docMain = MS (CSharpCode Body) -> MS (CSharpCode MethodData)
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 =>
MS (r bod) -> MS (r mthd)
CP.docMain
  function :: String
-> CSharpCode Body
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
function = String
-> CSharpCode Body
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
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) =>
String
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
G.function
  mainFunction :: MS (CSharpCode Body) -> MS (CSharpCode MethodData)
mainFunction = VS (CSharpCode TypeData)
-> String -> MS (CSharpCode Body) -> MS (CSharpCode MethodData)
forall (r :: * -> *) attch var mthd vis param bod.
(AttachmentSym r attch, TypeSym r TypeData,
 VariableSym r var TypeData, MethodTypeSym r TypeData,
 OORenderMethod r mthd attch vis param bod TypeData,
 ParameterSym r param var, UnRepr r TypeData, Monad r,
 VisibilitySym r vis) =>
VS (r TypeData) -> String -> MS (r bod) -> MS (r mthd)
CP.mainFunction VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string String
csMain
  docFunc :: String
-> [String]
-> Maybe String
-> MS (CSharpCode MethodData)
-> MS (CSharpCode MethodData)
docFunc = String
-> [String]
-> Maybe String
-> MS (CSharpCode MethodData)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
CP.doxFunc

  inOutFunc :: String
-> CSharpCode Body -> InOutFunc CSharpCode MethodData Body Variable
inOutFunc String
n CSharpCode Body
s = (VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Body)
 -> MS (CSharpCode MethodData))
-> InOutFunc CSharpCode MethodData Body Variable
forall mthd.
(VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Body)
 -> MS (CSharpCode mthd))
-> [VS (CSharpCode Variable)]
-> [VS (CSharpCode Variable)]
-> [VS (CSharpCode Variable)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
csInOut (String
-> CSharpCode Body
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function String
n CSharpCode Body
s)
  docInOutFunc :: String
-> CSharpCode Body
-> DocInOutFunc CSharpCode MethodData Body Variable
docInOutFunc String
n CSharpCode Body
s = InOutFunc CSharpCode MethodData Body Variable
-> DocInOutFunc CSharpCode MethodData Body Variable
forall (r :: * -> *) mthd var bod.
(BlockCommentSym r, RenderMethod r mthd) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc (String
-> CSharpCode Body -> InOutFunc CSharpCode MethodData Body Variable
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String -> r vis -> InOutFunc r mthd bod var
inOutFunc String
n CSharpCode Body
s)

instance OOMethodSym CSharpCode MethodData Doc Doc ParamData Body Variable Value TypeData where
  method :: String
-> CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
method = String
-> CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
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) =>
String
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
G.method
  getMethod :: VS (CSharpCode Variable) -> MS (CSharpCode MethodData)
getMethod = VS (CSharpCode Variable) -> MS (CSharpCode MethodData)
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)
G.getMethod
  setMethod :: VS (CSharpCode Variable) -> MS (CSharpCode MethodData)
setMethod = VS (CSharpCode Variable) -> MS (CSharpCode MethodData)
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)
G.setMethod
  constructor :: [MS (CSharpCode ParamData)]
-> NamedArgs CSharpCode Variable Value
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
constructor [MS (CSharpCode ParamData)]
ps NamedArgs CSharpCode Variable Value
is MS (CSharpCode Body)
b = MS String
getClassName MS String
-> (String -> MS (CSharpCode MethodData))
-> MS (CSharpCode MethodData)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\String
n -> String
-> [MS (CSharpCode ParamData)]
-> NamedArgs CSharpCode Variable Value
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
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 =>
String
-> [MS (r param)]
-> Initializers r var val
-> MS (r bod)
-> MS (r mthd)
CP.constructor String
n [MS (CSharpCode ParamData)]
ps NamedArgs CSharpCode Variable Value
is MS (CSharpCode Body)
b)

  inOutMethod :: String
-> CSharpCode Body
-> CSharpCode Body
-> InOutFunc CSharpCode MethodData Body Variable
inOutMethod String
n CSharpCode Body
s CSharpCode Body
p = (VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Body)
 -> MS (CSharpCode MethodData))
-> InOutFunc CSharpCode MethodData Body Variable
forall mthd.
(VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Body)
 -> MS (CSharpCode mthd))
-> [VS (CSharpCode Variable)]
-> [VS (CSharpCode Variable)]
-> [VS (CSharpCode Variable)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
csInOut (String
-> CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method String
n CSharpCode Body
s CSharpCode Body
p)
  docInOutMethod :: String
-> CSharpCode Body
-> CSharpCode Body
-> DocInOutFunc CSharpCode MethodData Body Variable
docInOutMethod String
n CSharpCode Body
s CSharpCode Body
p = InOutFunc CSharpCode MethodData Body Variable
-> DocInOutFunc CSharpCode MethodData Body Variable
forall (r :: * -> *) mthd var bod.
(BlockCommentSym r, RenderMethod r mthd) =>
([VS (r var)]
 -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc (String
-> CSharpCode Body
-> CSharpCode Body
-> InOutFunc CSharpCode MethodData Body Variable
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String -> r vis -> r attch -> InOutFunc r mthd bod var
inOutMethod String
n CSharpCode Body
s CSharpCode Body
p)

instance RenderMethod CSharpCode MethodData where
  commentedFunc :: MS (CSharpCode Body)
-> MS (CSharpCode MethodData) -> MS (CSharpCode MethodData)
commentedFunc MS (CSharpCode Body)
cmt MS (CSharpCode MethodData)
m = (CSharpCode MethodData
 -> CSharpCode (Body -> Body) -> CSharpCode MethodData)
-> MS (CSharpCode MethodData)
-> State MethodState (CSharpCode (Body -> Body))
-> MS (CSharpCode MethodData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((MethodData -> (Body -> Body) -> MethodData)
-> CSharpCode MethodData
-> CSharpCode (Body -> Body)
-> CSharpCode MethodData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues MethodData -> (Body -> Body) -> MethodData
updateMthd) MS (CSharpCode MethodData)
m
    ((CSharpCode Body -> CSharpCode (Body -> Body))
-> MS (CSharpCode Body)
-> State MethodState (CSharpCode (Body -> Body))
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Body -> Body -> Body)
-> CSharpCode Body -> CSharpCode (Body -> Body)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue Body -> Body -> Body
R.commentedItem) MS (CSharpCode Body)
cmt)

  mthdFromData :: VisibilityTag -> Body -> MS (CSharpCode MethodData)
mthdFromData VisibilityTag
_ Body
d = CSharpCode MethodData -> MS (CSharpCode MethodData)
forall a s. a -> State s a
toState (CSharpCode MethodData -> MS (CSharpCode MethodData))
-> CSharpCode MethodData -> MS (CSharpCode MethodData)
forall a b. (a -> b) -> a -> b
$ MethodData -> CSharpCode MethodData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (MethodData -> CSharpCode MethodData)
-> MethodData -> CSharpCode MethodData
forall a b. (a -> b) -> a -> b
$ String -> Body -> MethodData
mthd String
"" Body
d

instance OORenderMethod CSharpCode MethodData Doc Doc ParamData Body TypeData where
  intMethod :: Bool
-> String
-> CSharpCode Body
-> CSharpCode Body
-> MS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
intMethod Bool
m String
n CSharpCode Body
s CSharpCode Body
p MS (CSharpCode TypeData)
t [MS (CSharpCode ParamData)]
ps MS (CSharpCode Body)
b = do
    (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (if Bool
m then MethodState -> MethodState
setCurrMain else MethodState -> MethodState
forall a. a -> a
id)
    tp <- MS (CSharpCode TypeData)
t
    pms <- sequence ps
    toCode . mthd n . renderMethod n s p tp pms <$> b
  intFunc :: Bool
-> String
-> CSharpCode Body
-> CSharpCode Body
-> MS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
intFunc = Bool
-> String
-> CSharpCode Body
-> CSharpCode Body
-> MS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode MethodData)
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
-> String
-> r vis
-> r attch
-> MS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
intMethod
  destructor :: forall stvr.
[CSStateVar CSharpCode stvr] -> MS (CSharpCode MethodData)
destructor [CSStateVar CSharpCode stvr]
_ = String -> MS (CSharpCode MethodData)
forall a. HasCallStack => String -> a
error (String -> MS (CSharpCode MethodData))
-> String -> MS (CSharpCode MethodData)
forall a b. (a -> b) -> a -> b
$ String -> String
CP.destructorError String
csName

instance MethodElim CSharpCode MethodData where
  method :: CSharpCode MethodData -> Body
method = MethodData -> Body
mthdDoc (MethodData -> Body)
-> (CSharpCode MethodData -> MethodData)
-> CSharpCode MethodData
-> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode MethodData -> MethodData
forall a. CSharpCode a -> a
unCSC

instance StateVarSym CSharpCode StateVar Doc Doc Variable Value where
  stateVar :: CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode Variable)
-> CSStateVar CSharpCode Body
stateVar = CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode Variable)
-> CSStateVar CSharpCode Body
forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
(Monad r,
 OORenderSym
   r
   file
   mod
   cls
   stvr
   mthd
   attch
   vis
   param
   bod
   block
   stmt
   var
   scope
   val
   binder
   typ) =>
r vis -> r attch -> VS (r var) -> CS (r Body)
CP.stateVar
  stateVarDef :: CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> CSStateVar CSharpCode Body
stateVarDef = CSharpCode Body
-> CSharpCode Body
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> CSStateVar CSharpCode Body
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,
 Monad r) =>
r vis -> r attch -> VS (r var) -> VS (r val) -> CS (r Body)
CP.stateVarDef
  constVar :: CSharpCode Body
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> CSStateVar CSharpCode Body
constVar = Body
-> CSharpCode Body
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
-> CSStateVar CSharpCode Body
forall (r :: * -> *) mthd vis param bod block stmt var scope val
       binder typ.
(CommonRenderSym
   r mthd vis param bod block stmt var scope val binder typ,
 Monad r) =>
Body -> r vis -> VS (r var) -> VS (r val) -> CS (r Body)
CP.constVar Body
empty

instance StateVarElim CSharpCode StateVar where
  stateVar :: CSharpCode Body -> Body
stateVar = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC

instance ClassSym CSharpCode Class StateVar MethodData where
  buildClass :: Maybe String
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
buildClass = Maybe String
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
forall (r :: * -> *) cls stvr mthd vis.
(RenderClass r cls stvr mthd vis, VisibilitySym r vis) =>
Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
G.buildClass
  extraClass :: String
-> Maybe String
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
extraClass = String
-> Maybe String
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
forall (r :: * -> *) cls stvr mthd vis.
(RenderClass r cls stvr mthd vis, VisibilitySym r vis) =>
String
-> Maybe String
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
CP.extraClass
  implementingClass :: String
-> [String]
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
implementingClass = String
-> [String]
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
forall (r :: * -> *) cls stvr mthd vis.
(RenderClass r cls stvr mthd vis, VisibilitySym r vis) =>
String
-> [String]
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r cls)
G.implementingClass

  docClass :: String -> CSStateVar CSharpCode Body -> CSStateVar CSharpCode Body
docClass = String -> CSStateVar CSharpCode Body -> CSStateVar CSharpCode Body
forall (r :: * -> *) cls stvr mthd vis.
(BlockCommentSym r, RenderClass r cls stvr mthd vis) =>
String -> CS (r cls) -> CS (r cls)
CP.doxClass

instance RenderClass CSharpCode Class StateVar MethodData Doc where
  intClass :: String
-> CSharpCode Body
-> CSharpCode Body
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
intClass = (String -> Body -> Body -> Body -> Body -> Body)
-> String
-> CSharpCode Body
-> CSharpCode Body
-> [CSStateVar CSharpCode Body]
-> [MS (CSharpCode MethodData)]
-> [MS (CSharpCode MethodData)]
-> CSStateVar CSharpCode Body
forall (r :: * -> *) mthd stvr vis.
(MethodElim r mthd, Monad r, StateVarElim r stvr,
 VisibilityElim r vis) =>
(String -> Body -> Body -> Body -> Body -> Body)
-> String
-> r vis
-> r Body
-> [CSStateVar r stvr]
-> [MS (r mthd)]
-> [MS (r mthd)]
-> CS (r Body)
CP.intClass String -> Body -> Body -> Body -> Body -> Body
R.class'

  inherit :: Maybe String -> CSharpCode Body
inherit = Maybe String -> CSharpCode Body
forall (r :: * -> *). Monad r => Maybe String -> r Body
CP.inherit
  implements :: [String] -> CSharpCode Body
implements = [String] -> CSharpCode Body
forall (r :: * -> *). Monad r => [String] -> r Body
CP.implements

  commentedClass :: CSStateVar CSharpCode Body
-> CSStateVar CSharpCode Body -> CSStateVar CSharpCode Body
commentedClass = CSStateVar CSharpCode Body
-> CSStateVar CSharpCode Body -> CSStateVar CSharpCode Body
forall (r :: * -> *) cls.
(BlockCommentElim r, ClassElim r cls, Monad r) =>
CS (r Body) -> CS (r cls) -> CS (r Body)
G.commentedClass

instance ClassElim CSharpCode Class where
  class' :: CSharpCode Body -> Body
class' = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC

instance ModuleSym CSharpCode ModData Class MethodData where
  buildModule :: String
-> [String]
-> [MS (CSharpCode MethodData)]
-> [CSStateVar CSharpCode Body]
-> FS (CSharpCode ModData)
buildModule String
n = String
-> (String -> CSharpCode Body)
-> [String]
-> [MS (CSharpCode MethodData)]
-> [CSStateVar CSharpCode Body]
-> FS (CSharpCode ModData)
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,
 UnRepr r Body) =>
String
-> (String -> r Body)
-> [String]
-> [MS (r mthd)]
-> [CS (r cls)]
-> FS (r mod)
CP.buildModule' String
n String -> CSharpCode Body
forall (r :: * -> *). ImportSym r => String -> r Body
langImport

instance RenderMod CSharpCode ModData where
  modFromData :: String -> FS Body -> FS (CSharpCode ModData)
modFromData String
n = String
-> (Body -> CSharpCode ModData)
-> FS Body
-> FS (CSharpCode ModData)
forall {k} (r :: k -> *) (mod :: k).
String -> (Body -> r mod) -> FS Body -> FS (r mod)
G.modFromData String
n (ModData -> CSharpCode ModData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (ModData -> CSharpCode ModData)
-> (Body -> ModData) -> Body -> CSharpCode ModData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Body -> ModData
md String
n)
  updateModuleDoc :: (Body -> Body) -> CSharpCode ModData -> CSharpCode ModData
updateModuleDoc Body -> Body
f = (ModData -> ModData) -> CSharpCode ModData -> CSharpCode ModData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Body -> Body) -> ModData -> ModData
updateMod Body -> Body
f)

instance ModuleElim CSharpCode ModData where
  module' :: CSharpCode ModData -> Body
module' = ModData -> Body
modDoc (ModData -> Body)
-> (CSharpCode ModData -> ModData) -> CSharpCode ModData -> Body
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ModData -> ModData
forall a. CSharpCode a -> a
unCSC

instance BlockCommentSym CSharpCode where
  blockComment :: [String] -> CSharpCode Body
blockComment [String]
lns = Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Body -> CSharpCode Body) -> Body -> CSharpCode Body
forall a b. (a -> b) -> a -> b
$ [String] -> Body -> Body -> Body
R.blockCmt [String]
lns Body
blockCmtStart Body
blockCmtEnd
  docComment :: forall a. State a [String] -> State a (CSharpCode Body)
docComment = ([String] -> CSharpCode Body)
-> State a [String] -> State a (CSharpCode Body)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\[String]
lns -> Body -> CSharpCode Body
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Body -> CSharpCode Body) -> Body -> CSharpCode Body
forall a b. (a -> b) -> a -> b
$ [String] -> Body -> Body -> Body
R.docCmt [String]
lns Body
docCmtStart
    Body
blockCmtEnd)

instance BlockCommentElim CSharpCode where
  blockComment' :: CSharpCode Body -> Body
blockComment' = CSharpCode Body -> Body
forall a. CSharpCode a -> a
unCSC

addSystemImport :: VS a -> VS a
addSystemImport :: forall a. VS a -> VS a
addSystemImport = StateT ValueState Identity ()
-> StateT ValueState Identity a -> StateT ValueState Identity a
forall a b.
StateT ValueState Identity a
-> StateT ValueState Identity b -> StateT ValueState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(>>) (StateT ValueState Identity ()
 -> StateT ValueState Identity a -> StateT ValueState Identity a)
-> StateT ValueState Identity ()
-> StateT ValueState Identity a
-> StateT ValueState Identity a
forall a b. (a -> b) -> a -> b
$ (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS String
csSystem)

csName, csVersion :: String
csName :: String
csName = String
"C#"
csVersion :: String
csVersion = String
"6.0"

csImport :: Label -> Doc
csImport :: String -> Body
csImport String
n = String -> Body
text (String
"using " String -> String -> String
forall a. Semigroup a => a -> a -> a
P.<> String
n) Body -> Body -> Body
<> Body
endStatement

csBoolType :: (Monad r) => VS (r TypeData)
csBoolType :: forall (r :: * -> *). Monad r => VS (r TypeData)
csBoolType = CodeType -> String -> Body -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Body -> VS (r TypeData)
typeFromData CodeType
Boolean String
csBool (String -> Body
text String
csBool)

csFuncType :: [VS (CSharpCode TypeData)] -> VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
csFuncType :: [VS (CSharpCode TypeData)]
-> VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
csFuncType [VS (CSharpCode TypeData)]
ps VS (CSharpCode TypeData)
r = do
  pts <- [VS (CSharpCode TypeData)]
-> StateT ValueState Identity [CSharpCode TypeData]
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 (CSharpCode TypeData)]
ps
  rt <- r
  typeFromData (Func (getCodeType <$> pts) (getCodeType rt))
    (csFunc `containing` intercalate listSep (getTypeString <$> pts P.<> [rt]))
    (text csFunc <> angles (hicat listSep' $ renderType <$> pts P.<> [rt]))

csForEach, csNamedArgSep, csLambdaSep :: Doc
csForEach :: Body
csForEach = String -> Body
text String
"foreach"
csNamedArgSep :: Body
csNamedArgSep = Body
colon Body -> Body -> Body
<> Body
space
csLambdaSep :: Body
csLambdaSep = String -> Body
text String
"=>"

csSystem, csConsole, csGeneric, csDiagnostics, csIO, csList, csSet, csInt, csFloat, csBool,
  csChar, csParse, csReader, csWriter, csReadLine, csWrite, csWriteLine,
  csIndex, csContains, csListAdd, csListSize, csListAppend, csListRemove,
  csClose, csEOS, csSplit, csMain, csFunc, csUnionWith :: String
csSystem :: String
csSystem = String
"System"
csConsole :: String
csConsole = String
"Console"
csGeneric :: String
csGeneric = String -> String
csSysAccess (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$ String
"Collections" String -> String -> String
`access` String
"Generic"
csDiagnostics :: String
csDiagnostics = String -> String
csSysAccess String
"Diagnostics"
csIO :: String
csIO = String -> String
csSysAccess String
"IO"
csList :: String
csList = String
"List"
csSet :: String
csSet = String
"HashSet"
csInt :: String
csInt = String
"Int32"
csFloat :: String
csFloat = String
"Single"
csBool :: String
csBool = String
"Boolean"
csChar :: String
csChar = String
"Char"
csParse :: String
csParse = String
"Parse"
csReader :: String
csReader = String
"StreamReader"
csWriter :: String
csWriter = String
"StreamWriter"
csReadLine :: String
csReadLine = String
"ReadLine"
csWrite :: String
csWrite = String
"Write"
csWriteLine :: String
csWriteLine = String
"WriteLine"
csIndex :: String
csIndex = String
"IndexOf"
csContains :: String
csContains = String
"Contains"
csListAdd :: String
csListAdd = String
"Insert"
csListSize :: String
csListSize = String
"Count"
csListAppend :: String
csListAppend = String
"Add"
csListRemove :: String
csListRemove = String
"Remove"
csClose :: String
csClose = String
"Close"
csEOS :: String
csEOS = String
"EndOfStream"
csSplit :: String
csSplit = String
"Split"
csMain :: String
csMain = String
"Main"
csFunc :: String
csFunc = String
"Func"
csUnionWith :: String
csUnionWith = String
"UnionWith"

csSysAccess :: String -> String
csSysAccess :: String -> String
csSysAccess = String -> String -> String
access String
csSystem

csUnaryMath :: (Monad r) => String -> VSOp r
csUnaryMath :: forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath = VS (r OpData) -> VS (r OpData)
forall a. VS a -> VS a
addSystemImport (VS (r OpData) -> VS (r OpData))
-> (String -> VS (r OpData)) -> String -> VS (r OpData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (r OpData)
forall (r :: * -> *). Monad r => String -> VSOp r
unOpPrec (String -> VS (r OpData))
-> (String -> String) -> String -> VS (r OpData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> String
mathFunc

csInfileType :: (Monad r) => VS (r TypeData)
csInfileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
csInfileType = StateT
  ValueState Identity (StateT ValueState Identity (r TypeData))
-> StateT ValueState Identity (r TypeData)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT
   ValueState Identity (StateT ValueState Identity (r TypeData))
 -> StateT ValueState Identity (r TypeData))
-> StateT
     ValueState Identity (StateT ValueState Identity (r TypeData))
-> StateT ValueState Identity (r TypeData)
forall a b. (a -> b) -> a -> b
$ (ValueState -> ValueState)
-> StateT ValueState Identity (r TypeData)
-> StateT
     ValueState Identity (StateT ValueState Identity (r TypeData))
forall s a. (s -> s) -> a -> State s a
modifyReturn (String -> ValueState -> ValueState
addLangImportVS String
csIO) (StateT ValueState Identity (r TypeData)
 -> StateT
      ValueState Identity (StateT ValueState Identity (r TypeData)))
-> StateT ValueState Identity (r TypeData)
-> StateT
     ValueState Identity (StateT ValueState Identity (r TypeData))
forall a b. (a -> b) -> a -> b
$
  CodeType
-> String -> Body -> StateT ValueState Identity (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Body -> VS (r TypeData)
typeFromData CodeType
InFile String
csReader (String -> Body
text String
csReader)

csOutfileType :: (Monad r) => VS (r TypeData)
csOutfileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
csOutfileType = StateT
  ValueState Identity (StateT ValueState Identity (r TypeData))
-> StateT ValueState Identity (r TypeData)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT
   ValueState Identity (StateT ValueState Identity (r TypeData))
 -> StateT ValueState Identity (r TypeData))
-> StateT
     ValueState Identity (StateT ValueState Identity (r TypeData))
-> StateT ValueState Identity (r TypeData)
forall a b. (a -> b) -> a -> b
$ (ValueState -> ValueState)
-> StateT ValueState Identity (r TypeData)
-> StateT
     ValueState Identity (StateT ValueState Identity (r TypeData))
forall s a. (s -> s) -> a -> State s a
modifyReturn (String -> ValueState -> ValueState
addLangImportVS String
csIO) (StateT ValueState Identity (r TypeData)
 -> StateT
      ValueState Identity (StateT ValueState Identity (r TypeData)))
-> StateT ValueState Identity (r TypeData)
-> StateT
     ValueState Identity (StateT ValueState Identity (r TypeData))
forall a b. (a -> b) -> a -> b
$
  CodeType
-> String -> Body -> StateT ValueState Identity (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Body -> VS (r TypeData)
typeFromData CodeType
OutFile String
csWriter (String -> Body
text String
csWriter)

csLitList
  :: (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData))
  -> VS (CSharpCode TypeData)
  -> [VS (CSharpCode Value)]
  -> VS (CSharpCode Value)
csLitList :: (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData))
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
csLitList VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
f VS (CSharpCode TypeData)
t' [VS (CSharpCode Value)]
es' = do
  es <- [VS (CSharpCode Value)]
-> StateT ValueState Identity [CSharpCode Value]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [VS (CSharpCode Value)]
es'
  lt <- f t'
  mkVal lt (new' <+> renderType lt
    <+> braces (valueList es))

csLambda :: [CSharpCode BinderD] -> CSharpCode Value -> Doc
csLambda :: [CSharpCode BinderD] -> CSharpCode Value -> Body
csLambda [CSharpCode BinderD]
ps CSharpCode Value
ex = Body -> Body
parens ([CSharpCode BinderD] -> Body
forall {k} (r :: k -> *) (binder :: k).
InternalBinderElim r binder =>
[r binder] -> Body
binderList [CSharpCode BinderD]
ps) Body -> Body -> Body
<+> Body
csLambdaSep Body -> Body -> Body
<+> CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value CSharpCode Value
ex

csReadLineFunc :: VS (CSharpCode Value)
csReadLineFunc :: VS (CSharpCode Value)
csReadLineFunc = String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
csConsole String
csReadLine VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string []

csIntParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csIntParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csIntParse VS (CSharpCode Value)
v = String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
csInt String
csParse VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int [VS (CSharpCode Value)
v]

csFloatParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csFloatParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csFloatParse VS (CSharpCode Value)
v = String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
csFloat String
csParse VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float [VS (CSharpCode Value)
v]

csDblParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csDblParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csDblParse VS (CSharpCode Value)
v = String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
CP.doubleRender String
csParse VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double [VS (CSharpCode Value)
v]

csBoolParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csBoolParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csBoolParse VS (CSharpCode Value)
v = String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
csBool String
csParse VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
bool [VS (CSharpCode Value)
v]

csCharParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csCharParse :: VS (CSharpCode Value) -> VS (CSharpCode Value)
csCharParse VS (CSharpCode Value)
v = String
-> String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
csChar String
csParse VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
char [VS (CSharpCode Value)
v]

csSplitFunc :: Char -> VS (CSharpCode FuncData)
csSplitFunc :: Char -> VS (CSharpCode FuncData)
csSplitFunc Char
d = String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode FuncData)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
func String
csSplit (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string) [Char -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Char -> VS (r val)
litChar Char
d]

csCast
  :: VS (CSharpCode TypeData) -> VS (CSharpCode Value) -> VS (CSharpCode Value)
csCast :: VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
csCast = StateT ValueState Identity (VS (CSharpCode Value))
-> VS (CSharpCode Value)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT ValueState Identity (VS (CSharpCode Value))
 -> VS (CSharpCode Value))
-> (VS (CSharpCode TypeData)
    -> VS (CSharpCode Value)
    -> StateT ValueState Identity (VS (CSharpCode Value)))
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> VS (CSharpCode Value)
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.: (CSharpCode TypeData -> CSharpCode Value -> VS (CSharpCode Value))
-> VS (CSharpCode TypeData)
-> VS (CSharpCode Value)
-> StateT ValueState Identity (VS (CSharpCode Value))
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\CSharpCode TypeData
t CSharpCode Value
v -> CodeType
-> CodeType
-> CSharpCode TypeData
-> CSharpCode Value
-> VS (CSharpCode Value)
csCast' (CSharpCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType CSharpCode TypeData
t) (CSharpCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (CSharpCode TypeData -> CodeType)
-> CSharpCode TypeData -> CodeType
forall a b. (a -> b) -> a -> b
$
  CSharpCode Value -> CSharpCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType CSharpCode Value
v) CSharpCode TypeData
t CSharpCode Value
v)
  where csCast' :: CodeType
-> CodeType
-> CSharpCode TypeData
-> CSharpCode Value
-> VS (CSharpCode Value)
csCast' CodeType
Double CodeType
String CSharpCode TypeData
_ CSharpCode Value
v = VS (CSharpCode Value) -> VS (CSharpCode Value)
csDblParse (CSharpCode Value -> VS (CSharpCode Value)
forall a s. a -> State s a
toState CSharpCode Value
v)
        csCast' CodeType
Float CodeType
String CSharpCode TypeData
_ CSharpCode Value
v = VS (CSharpCode Value) -> VS (CSharpCode Value)
csFloatParse (CSharpCode Value -> VS (CSharpCode Value)
forall a s. a -> State s a
toState CSharpCode Value
v)
        csCast' CodeType
_ CodeType
_ CSharpCode TypeData
t CSharpCode Value
v = VS (CSharpCode TypeData) -> Body -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Body -> VS (r val)
mkStateVal (CSharpCode TypeData -> VS (CSharpCode TypeData)
forall a s. a -> State s a
toState CSharpCode TypeData
t) (Body -> Body -> Body
R.castObj (Body -> Body
R.cast
          (CSharpCode TypeData -> Body
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Body
renderType CSharpCode TypeData
t)) (CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value CSharpCode Value
v))

-- This implementation generates a statement lambda to define the function.
-- C# 7 supports local functions, which would be a cleaner way to implement
-- this, but the mcs compiler used in our Travis builds does not yet support
-- all features of C# 7, so we cannot generate local functions.
-- If support for local functions is added to mcs in the future, this
-- should be re-written to generate a local function.
csFuncDecDef
  :: VS (CSharpCode Variable)
  -> CSharpCode ScopeData
  -> [VS (CSharpCode Variable)]
  -> MS (CSharpCode Body)
  -> MS (CSharpCode Statement)
csFuncDecDef :: VS (CSharpCode Variable)
-> CSharpCode ScopeData
-> [VS (CSharpCode Variable)]
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
csFuncDecDef VS (CSharpCode Variable)
v CSharpCode ScopeData
scp [VS (CSharpCode Variable)]
ps MS (CSharpCode Body)
bod = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
-> VS (CSharpCode Variable)
-> StateT MethodState Identity (CSharpCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (CSharpCode Variable) ValueState)
-> MethodState
-> Focusing Identity (CSharpCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (CSharpCode Variable)
v
  modify $ useVarName $ variableName vr
  modify $ setVarScope (variableName vr) (scopeData scp)
  pms <- mapM (zoom lensMStoVS) ps
  t <- zoom lensMStoVS $ funcType (pure . variableType <$> pms)
    (pure $ variableType vr)
  b <- bod
  modify (addLangImport csSystem)
  mkStmt $ renderType t <+> text (variableName vr) <+> equals <+>
    parens (variableList pms) <+> csLambdaSep <+> bodyStart $$
    indent (RC.body b) $$ bodyEnd

csThrowDoc :: CSharpCode Value -> Doc
csThrowDoc :: CSharpCode Value -> Body
csThrowDoc CSharpCode Value
errMsg = Body
throwLabel Body -> Body -> Body
<+> Body
new' Body -> Body -> Body
<+> Body
exceptionObj' Body -> Body -> Body
<>
  Body -> Body
parens (CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value CSharpCode Value
errMsg)

csTryCatch :: CSharpCode Body -> CSharpCode Body -> Doc
csTryCatch :: CSharpCode Body -> CSharpCode Body -> Body
csTryCatch CSharpCode Body
tb CSharpCode Body
cb = [Body] -> Body
vcat [
  Body
tryLabel Body -> Body -> Body
<+> Body
lbrace,
  Body -> Body
indent (Body -> Body) -> Body -> Body
forall a b. (a -> b) -> a -> b
$ CSharpCode Body -> Body
forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> Body
RC.body CSharpCode Body
tb,
  Body
rbrace Body -> Body -> Body
<+> Body
catchLabel Body -> Body -> Body
<+>
    Body
lbrace,
  Body -> Body
indent (Body -> Body) -> Body -> Body
forall a b. (a -> b) -> a -> b
$ CSharpCode Body -> Body
forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> Body
RC.body CSharpCode Body
cb,
  Body
rbrace]

csAssert :: CSharpCode Value -> CSharpCode Value -> Doc
csAssert :: CSharpCode Value -> CSharpCode Value -> Body
csAssert CSharpCode Value
condition CSharpCode Value
errorMessage = [Body] -> Body
vcat [
  String -> Body
text String
"Debug.Assert(" Body -> Body -> Body
<+> CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value CSharpCode Value
condition Body -> Body -> Body
<+> String -> Body
text String
"," Body -> Body -> Body
<+> CSharpCode Value -> Body
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Body
RC.value CSharpCode Value
errorMessage Body -> Body -> Body
<> String -> Body
text String
")" Body -> Body -> Body
<> Body
semi
  ]

csDiscardInput :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
csDiscardInput :: VS (CSharpCode Value) -> MS (CSharpCode Statement)
csDiscardInput = VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt

csFileInput
  :: (TypeSym r typ, InternalValueExp r var Value typ) => VS (r Value) -> VS (r Value)
csFileInput :: forall (r :: * -> *) typ var.
(TypeSym r typ, InternalValueExp r var Value typ) =>
VS (r Value) -> VS (r Value)
csFileInput VS (r Value)
f = VS (r typ) -> VS (r Value) -> String -> VS (r Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> VS (r val)
objMethodCallNoParams VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string VS (r Value)
f String
csReadLine

csInput
  :: VS (CSharpCode TypeData) -> VS (CSharpCode Value) -> VS (CSharpCode Value)
csInput :: VS (CSharpCode TypeData)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
csInput VS (CSharpCode TypeData)
tp VS (CSharpCode Value)
inFn = do
  t <- VS (CSharpCode TypeData)
tp
  csInputImport (getCodeType t) (csInput' (getCodeType t) inFn)
  where csInput' :: CodeType -> VS (CSharpCode Value) -> VS (CSharpCode Value)
csInput' CodeType
Integer = VS (CSharpCode Value) -> VS (CSharpCode Value)
csIntParse
        csInput' CodeType
Float = VS (CSharpCode Value) -> VS (CSharpCode Value)
csFloatParse
        csInput' CodeType
Double = VS (CSharpCode Value) -> VS (CSharpCode Value)
csDblParse
        csInput' CodeType
Boolean = VS (CSharpCode Value) -> VS (CSharpCode Value)
csBoolParse
        csInput' CodeType
String = VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. a -> a
id
        csInput' CodeType
Char = VS (CSharpCode Value) -> VS (CSharpCode Value)
csCharParse
        csInput' CodeType
_ = String -> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a. HasCallStack => String -> a
error String
"Attempt to read value of unreadable type"
        csInputImport :: CodeType -> VS a -> VS a
csInputImport CodeType
t = if CodeType
t CodeType -> [CodeType] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [CodeType
Integer, CodeType
Float, CodeType
Double, CodeType
Boolean, CodeType
Char]
          then VS a -> VS a
forall a. VS a -> VS a
addSystemImport else VS a -> VS a
forall a. a -> a
id

csOpenFileR
  :: (OOValueExpression r var val typ) => VS (r val) -> VS (r typ) -> VS (r val)
csOpenFileR :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
VS (r val) -> VS (r typ) -> VS (r val)
csOpenFileR VS (r val)
n VS (r typ)
r = PosCtorCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
PosCtorCall r val typ
newObj VS (r typ)
r [VS (r val)
n]

csOpenFileWorA
  :: (OOValueExpression r var val typ)
  => VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
csOpenFileWorA :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val)
csOpenFileWorA VS (r val)
n VS (r typ)
w VS (r val)
a = PosCtorCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
PosCtorCall r val typ
newObj VS (r typ)
w [VS (r val)
n, VS (r val)
a]

csRef :: Doc -> Doc
csRef :: Body -> Body
csRef Body
p = String -> Body
text String
"ref" Body -> Body -> Body
<+> Body
p

csOut :: Doc -> Doc
csOut :: Body -> Body
csOut Body
p = String -> Body
text String
"out" Body -> Body -> Body
<+> Body
p

csInOutCall
  :: (Label -> VS (CSharpCode TypeData) -> [VS (CSharpCode Value)] -> VS (CSharpCode Value))
  -> Label
  -> [VS (CSharpCode Value)]
  -> [VS (CSharpCode Variable)]
  -> [VS (CSharpCode Variable)]
  -> MS (CSharpCode Statement)
csInOutCall :: (String
 -> VS (CSharpCode TypeData)
 -> [VS (CSharpCode Value)]
 -> VS (CSharpCode Value))
-> InOutCall CSharpCode Statement Variable Value
csInOutCall String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
f String
n [VS (CSharpCode Value)]
ins [VS (CSharpCode Variable)
out] [] = VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
assign VS (CSharpCode Variable)
out (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
f String
n ((CSharpCode Variable -> CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (CSharpCode Variable)
out)
  [VS (CSharpCode Value)]
ins
csInOutCall String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
f String
n [VS (CSharpCode Value)]
ins [] [VS (CSharpCode Variable)
out] = VS (CSharpCode Variable)
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
assign VS (CSharpCode Variable)
out (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
f String
n ((CSharpCode Variable -> CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (CSharpCode Variable)
out)
  (VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (CSharpCode Variable)
out VS (CSharpCode Value)
-> [VS (CSharpCode Value)] -> [VS (CSharpCode Value)]
forall a. a -> [a] -> [a]
: [VS (CSharpCode Value)]
ins)
csInOutCall String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
f String
n [VS (CSharpCode Value)]
ins [VS (CSharpCode Variable)]
outs [VS (CSharpCode Variable)]
both = VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ String
-> VS (CSharpCode TypeData)
-> [VS (CSharpCode Value)]
-> VS (CSharpCode Value)
f String
n VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void ((VS (CSharpCode Variable) -> VS (CSharpCode Value))
-> [VS (CSharpCode Variable)] -> [VS (CSharpCode Value)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((CSharpCode Value -> CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue
  ((Value -> Value) -> CSharpCode Value -> CSharpCode Value
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Body -> Body) -> Value -> Value
updateValDoc Body -> Body
csRef)) (VS (CSharpCode Value) -> VS (CSharpCode Value))
-> (VS (CSharpCode Variable) -> VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf) [VS (CSharpCode Variable)]
both [VS (CSharpCode Value)]
-> [VS (CSharpCode Value)] -> [VS (CSharpCode Value)]
forall a. Semigroup a => a -> a -> a
P.<> [VS (CSharpCode Value)]
ins [VS (CSharpCode Value)]
-> [VS (CSharpCode Value)] -> [VS (CSharpCode Value)]
forall a. Semigroup a => a -> a -> a
P.<> (VS (CSharpCode Variable) -> VS (CSharpCode Value))
-> [VS (CSharpCode Variable)] -> [VS (CSharpCode Value)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap
  ((CSharpCode Value -> CSharpCode Value)
-> VS (CSharpCode Value) -> VS (CSharpCode Value)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((Value -> Value) -> CSharpCode Value -> CSharpCode Value
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Body -> Body) -> Value -> Value
updateValDoc Body -> Body
csOut)) (VS (CSharpCode Value) -> VS (CSharpCode Value))
-> (VS (CSharpCode Variable) -> VS (CSharpCode Value))
-> VS (CSharpCode Variable)
-> VS (CSharpCode Value)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf) [VS (CSharpCode Variable)]
outs)

csVarDec :: AttachmentTag -> MS (CSharpCode stmt) -> MS (CSharpCode stmt)
csVarDec :: forall stmt.
AttachmentTag -> MS (CSharpCode stmt) -> MS (CSharpCode stmt)
csVarDec AttachmentTag
ClassLevel MS (CSharpCode stmt)
_ = String -> MS (CSharpCode stmt)
forall a. HasCallStack => String -> a
error String
"ClassLevel variables can't be declared locally to a function in C#. Use stateVar to make a ClassLevel state variable instead."
csVarDec AttachmentTag
InstanceLevel MS (CSharpCode stmt)
d = MS (CSharpCode stmt)
d

csInOut
  :: (VS (CSharpCode TypeData) -> [MS (CSharpCode ParamData)] -> MS (CSharpCode Body) -> MS (CSharpCode mthd))
  -> [VS (CSharpCode Variable)]
  -> [VS (CSharpCode Variable)]
  -> [VS (CSharpCode Variable)]
  -> MS (CSharpCode Body)
  -> MS (CSharpCode mthd)
csInOut :: forall mthd.
(VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Body)
 -> MS (CSharpCode mthd))
-> [VS (CSharpCode Variable)]
-> [VS (CSharpCode Variable)]
-> [VS (CSharpCode Variable)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
csInOut VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
f [VS (CSharpCode Variable)]
ins [VS (CSharpCode Variable)
v] [] MS (CSharpCode Body)
b = VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
f ((CSharpCode Variable -> CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (CSharpCode Variable)
v) (VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param (VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> [VS (CSharpCode Variable)] -> [MS (CSharpCode ParamData)]
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> [VS (CSharpCode Variable)]
ins)
  ((CSharpCode Statement
 -> CSharpCode Body -> CSharpCode Statement -> CSharpCode Body)
-> MS (CSharpCode Statement)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
-> MS (CSharpCode Body)
forall a b c d s.
(a -> b -> c -> d)
-> State s a -> State s b -> State s c -> State s d
on3StateValues ((Statement -> Body -> Statement -> Body)
-> CSharpCode Statement
-> CSharpCode Body
-> CSharpCode Statement
-> CSharpCode Body
forall (r :: * -> *) a b c d.
Applicative r =>
(a -> b -> c -> d) -> r a -> r b -> r c -> r d
on3CodeValues Statement -> Body -> Statement -> Body
surroundBody) (VS (CSharpCode Variable)
-> CSharpCode ScopeData -> MS (CSharpCode Statement)
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 -> MS (r stmt)
varDec VS (CSharpCode Variable)
v CSharpCode ScopeData
forall {k} (r :: k -> *) (scope :: k). ScopeSym r scope => r scope
local) MS (CSharpCode Body)
b (VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r stmt)
returnStmt (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$
  VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (CSharpCode Variable)
v))
csInOut VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
f [VS (CSharpCode Variable)]
ins [] [VS (CSharpCode Variable)
v] MS (CSharpCode Body)
b = VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
f ((CSharpCode Variable -> CSharpCode TypeData)
-> VS (CSharpCode Variable) -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType VS (CSharpCode Variable)
v)
  (VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param (VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> [VS (CSharpCode Variable)] -> [MS (CSharpCode ParamData)]
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> VS (CSharpCode Variable)
v VS (CSharpCode Variable)
-> [VS (CSharpCode Variable)] -> [VS (CSharpCode Variable)]
forall a. a -> [a] -> [a]
: [VS (CSharpCode Variable)]
ins) ((CSharpCode Body -> CSharpCode Statement -> CSharpCode Body)
-> MS (CSharpCode Body)
-> MS (CSharpCode Statement)
-> MS (CSharpCode Body)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((Body -> Statement -> Body)
-> CSharpCode Body -> CSharpCode Statement -> CSharpCode Body
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues Body -> Statement -> Body
appendToBody) MS (CSharpCode Body)
b
  (VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r val) -> MS (r stmt)
returnStmt (VS (CSharpCode Value) -> MS (CSharpCode Statement))
-> VS (CSharpCode Value) -> MS (CSharpCode Statement)
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode Variable) -> VS (CSharpCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (CSharpCode Variable)
v))
csInOut VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
f [VS (CSharpCode Variable)]
ins [VS (CSharpCode Variable)]
outs [VS (CSharpCode Variable)]
both MS (CSharpCode Body)
b = VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Body)
-> MS (CSharpCode mthd)
f VS (CSharpCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void ((VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> [VS (CSharpCode Variable)] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((CSharpCode ParamData -> CSharpCode ParamData)
-> MS (CSharpCode ParamData) -> MS (CSharpCode ParamData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((ParamData -> ParamData)
-> CSharpCode ParamData -> CSharpCode ParamData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue
  ((Body -> Body) -> ParamData -> ParamData
updateParam Body -> Body
csRef)) (MS (CSharpCode ParamData) -> MS (CSharpCode ParamData))
-> (VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> VS (CSharpCode Variable)
-> MS (CSharpCode ParamData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param) [VS (CSharpCode Variable)]
both [MS (CSharpCode ParamData)]
-> [MS (CSharpCode ParamData)] -> [MS (CSharpCode ParamData)]
forall a. Semigroup a => a -> a -> a
P.<> (VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> [VS (CSharpCode Variable)] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param [VS (CSharpCode Variable)]
ins [MS (CSharpCode ParamData)]
-> [MS (CSharpCode ParamData)] -> [MS (CSharpCode ParamData)]
forall a. Semigroup a => a -> a -> a
P.<> (VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> [VS (CSharpCode Variable)] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((CSharpCode ParamData -> CSharpCode ParamData)
-> MS (CSharpCode ParamData) -> MS (CSharpCode ParamData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue
  ((ParamData -> ParamData)
-> CSharpCode ParamData -> CSharpCode ParamData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Body -> Body) -> ParamData -> ParamData
updateParam Body -> Body
csOut)) (MS (CSharpCode ParamData) -> MS (CSharpCode ParamData))
-> (VS (CSharpCode Variable) -> MS (CSharpCode ParamData))
-> VS (CSharpCode Variable)
-> MS (CSharpCode ParamData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. VS (CSharpCode Variable) -> MS (CSharpCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k).
ParameterSym r param var =>
VS (r var) -> MS (r param)
param) [VS (CSharpCode Variable)]
outs) MS (CSharpCode Body)
b

csPrint
  ::
    ( BodySym r bod block
    , BlockSym r block stmt
    , ValueSym r val typ
    , Comparison r val
    , Literal r val typ
    , NumericExpression r val
    , ValueExpression r var val binder typ
    , TypeSym r typ
    , VariableSym r var typ
    , VariableValue r var val
    , List r val
    , ScopeSym r scope
    , MultiStatement r stmt
    , DeclStatement r bod stmt var scope val
    , AssignStatement r stmt var val
    , ControlStatement r bod stmt var val
    , PrintConsole r stmt val
    , PrintFile r stmt val
    , InternalIOStmt r stmt val
    , TypeElim r typ
    )
  => Bool -> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint :: forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (val :: k) (typ :: k) (var :: k) (binder :: k) (scope :: k).
(BodySym r bod block, BlockSym r block stmt, ValueSym r val typ,
 Comparison r val, Literal r val typ, NumericExpression r val,
 ValueExpression r var val binder typ, TypeSym r typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ScopeSym r scope, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, PrintConsole r stmt val,
 PrintFile r stmt val, InternalIOStmt r stmt val, TypeElim r typ) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
csPrint 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)
csPrint' (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 csPrint' :: CodeType -> StateT MethodState Identity (r stmt)
csPrint' (Array CodeType
_) = [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 [String -> StateT MethodState Identity (r stmt)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
PrintConsole r stmt val =>
String -> MS (r stmt)
printStr String
"[",
          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)
print (VS (r val) -> StateT MethodState Identity (r stmt))
-> VS (r val) -> StateT MethodState Identity (r stmt)
forall a b. (a -> b) -> a -> b
$ String -> PosCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
"string" String
"Join" VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string [String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString String
", ", VS (r val)
v],
          VS (r val) -> StateT MethodState Identity (r stmt)
printMaybeNewLn (VS (r val) -> StateT MethodState Identity (r stmt))
-> VS (r val) -> StateT MethodState Identity (r stmt)
forall a b. (a -> b) -> a -> b
$ String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString String
"]"]
        csPrint' CodeType
_ = Bool
-> Maybe (VS (r val))
-> VS (r val)
-> VS (r val)
-> StateT MethodState Identity (r stmt)
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)
G.print Bool
newLn Maybe (VS (r val))
f VS (r val)
printFn VS (r val)
v
        printMaybeNewLn :: VS (r val) -> StateT MethodState Identity (r stmt)
printMaybeNewLn = if Bool
newLn then 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)
printLn else 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)
print