{-# 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, SVariable,
  Value, SValue, 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(..), FunctionSym, FuncAppStatement(..), CommentStatement(..),
  BinderSym(..), BinderElim(..), ControlStatement(..), ScopeSym(..),
  ParameterSym(..), MethodSym(..))
import Drasil.GOOL.InterfaceGOOL (OOProg, StateVar, ProgramSym(..), FileSym(..),
  ModuleSym(..), ClassSym(..), OOTypeSym(..), OOVariableSym(..), SelfSym(..),
  StateVarSym(..), AttachmentSym(..), OOValueSym, OOVariableValue,
  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)
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 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 Doc (Doc, Terminator) MethodData StateVar Doc ProgData FileData ModData Body Block

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 Doc (Doc, Terminator) MethodData Body Block
instance OORenderSym CSharpCode Doc (Doc, Terminator) MethodData StateVar Doc FileData ModData Body Block

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 Doc)
-> CSharpCode Doc
-> 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 Doc
forall (r :: * -> *) file mod.
RenderFile r file mod =>
r mod -> r Doc
top CSharpCode Doc
forall (r :: * -> *) file mod. RenderFile r file mod => r Doc
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.
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 Doc
top CSharpCode ModData
_ = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty
  bottom :: CSharpCode Doc
bottom = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty

  commentedMod :: FS (CSharpCode FileData)
-> FS (CSharpCode Doc) -> FS (CSharpCode FileData)
commentedMod = (CSharpCode FileData -> CSharpCode Doc -> CSharpCode FileData)
-> FS (CSharpCode FileData)
-> FS (CSharpCode Doc)
-> FS (CSharpCode FileData)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((FileData -> Doc -> FileData)
-> CSharpCode FileData -> CSharpCode Doc -> CSharpCode FileData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues FileData -> Doc -> 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 Doc
langImport = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> CSharpCode Doc)
-> (String -> Doc) -> String -> CSharpCode Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc
csImport
  modImport :: String -> CSharpCode Doc
modImport = String -> CSharpCode Doc
forall (r :: * -> *). ImportSym r => String -> r Doc
langImport

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

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

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

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

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

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

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

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

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

instance TypeSym CSharpCode 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, 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, 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, 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 (r :: * -> *).
(TypeElim r, OOTypeSym r) =>
VS (r TypeData) -> VS (r TypeData)
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 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 where
  obj :: String -> VS (CSharpCode TypeData)
obj = String -> VS (CSharpCode TypeData)
forall (r :: * -> *). Monad r => String -> VS (r TypeData)
G.obj

instance RenderType CSharpCode 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 -> Doc
uOp = OpData -> Doc
opDoc (OpData -> Doc)
-> (CSharpCode OpData -> OpData) -> CSharpCode OpData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode OpData -> OpData
forall a. CSharpCode a -> a
unCSC
  bOp :: CSharpCode OpData -> Doc
bOp = OpData -> Doc
opDoc (OpData -> Doc)
-> (CSharpCode OpData -> OpData) -> CSharpCode OpData -> Doc
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 where
  global :: CSharpCode ScopeData
global = CSharpCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
CP.global
  mainFn :: CSharpCode ScopeData
mainFn = CSharpCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local
  local :: CSharpCode ScopeData
local = CSharpCode ScopeData
forall (r :: * -> *). Monad r => r ScopeData
G.local

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

instance VariableSym CSharpCode where
  var :: String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
var         = String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
forall (r :: * -> *).
RenderVariable r =>
String -> VS (r TypeData) -> SVariable r
G.var
  constant :: String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
constant    = String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
var
  extVar :: String
-> String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
extVar      = String
-> String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
forall (r :: * -> *).
RenderVariable r =>
String -> String -> VS (r TypeData) -> SVariable r
CS.extVar

instance OOVariableSym CSharpCode where
  classVar :: String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
classVar = String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
forall (r :: * -> *).
RenderVariable r =>
String -> VS (r TypeData) -> SVariable r
G.classVar
  classConst :: String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
classConst = String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
forall (r :: * -> *).
OOVariableSym r =>
String -> VS (r TypeData) -> SVariable r
classVar
  classVarAccess :: VS (CSharpCode TypeData)
-> SVariable CSharpCode -> SVariable CSharpCode
classVarAccess = (Doc -> Doc -> Doc)
-> VS (CSharpCode TypeData)
-> SVariable CSharpCode
-> SVariable CSharpCode
forall (r :: * -> *).
(InternalVarElim r, RenderVariable r, UnRepr r TypeData,
 VariableElim r) =>
(Doc -> Doc -> Doc)
-> VS (r TypeData) -> SVariable r -> SVariable r
CP.classVarAccess Doc -> Doc -> Doc
R.classVarAccess
  extClassVarAccess :: VS (CSharpCode TypeData)
-> SVariable CSharpCode -> SVariable CSharpCode
extClassVarAccess = VS (CSharpCode TypeData)
-> SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
OOVariableSym r =>
VS (r TypeData) -> SVariable r -> SVariable r
classVarAccess
  instanceVarAccess :: SValue CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
instanceVarAccess = SValue CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
(InternalVarElim r, RenderVariable r, ValueElim r,
 VariableElim r) =>
SValue r -> SVariable r -> SVariable r
G.instanceVarAccess

instance SelfSym CSharpCode where
  self :: SVariable CSharpCode
self = SVariable CSharpCode
forall (r :: * -> *).
(OOTypeSym r, RenderVariable r) =>
SVariable r
C.self

instance VariableElim CSharpCode 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 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 -> Doc
variable = Variable -> Doc
varDoc (Variable -> Doc)
-> (CSharpCode Variable -> Variable) -> CSharpCode Variable -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Variable -> Variable
forall a. CSharpCode a -> a
unCSC

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

instance ValueSym CSharpCode 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 OOValueSym CSharpCode

instance Argument CSharpCode where
  pointerArg :: SValue CSharpCode -> SValue CSharpCode
pointerArg = SValue CSharpCode -> SValue CSharpCode
forall a. a -> a
id

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

instance MathConstant CSharpCode where
  pi :: SValue CSharpCode
pi = SValue CSharpCode
forall (r :: * -> *). (RenderValue r, TypeSym r) => SValue r
CP.pi

instance VariableValue CSharpCode where
  valueOf :: SVariable CSharpCode -> SValue CSharpCode
valueOf = SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(InternalVarElim r, RenderValue r, VariableElim r) =>
SVariable r -> SValue r
G.valueOf

instance OOVariableValue CSharpCode

instance CommandLineArgs CSharpCode where
  arg :: Integer -> SValue CSharpCode
arg Integer
n = SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(RenderValue r, TypeSym r, ValueElim r) =>
SValue r -> SValue r -> SValue r
G.arg (Integer -> SValue CSharpCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n) SValue CSharpCode
forall (r :: * -> *). CommandLineArgs r => SValue r
argsList
  argsList :: SValue CSharpCode
argsList = String -> SValue CSharpCode
forall (r :: * -> *).
(RenderValue r, TypeSym r) =>
String -> SValue r
G.argsList String
args
  argExists :: Integer -> SValue CSharpCode
argExists Integer
i = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). List r => SValue r -> SValue r
listSize SValue CSharpCode
forall (r :: * -> *). CommandLineArgs r => SValue r
argsList SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
Comparison r =>
SValue r -> SValue r -> SValue r
?> Integer -> SValue CSharpCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt (Integer -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i)

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

  log :: SValue CSharpCode -> SValue CSharpCode
log = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
logOp
  ln :: SValue CSharpCode -> SValue CSharpCode
ln = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
lnOp
  exp :: SValue CSharpCode -> SValue CSharpCode
exp = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
expOp
  sin :: SValue CSharpCode -> SValue CSharpCode
sin = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sinOp
  cos :: SValue CSharpCode -> SValue CSharpCode
cos = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
cosOp
  tan :: SValue CSharpCode -> SValue CSharpCode
tan = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
tanOp
  csc :: SValue CSharpCode -> SValue CSharpCode
csc = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(Literal r, NumericExpression r, TypeElim r) =>
SValue r -> SValue r
G.csc
  sec :: SValue CSharpCode -> SValue CSharpCode
sec = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(Literal r, NumericExpression r, TypeElim r) =>
SValue r -> SValue r
G.sec
  cot :: SValue CSharpCode -> SValue CSharpCode
cot = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(Literal r, NumericExpression r, TypeElim r) =>
SValue r -> SValue r
G.cot
  arcsin :: SValue CSharpCode -> SValue CSharpCode
arcsin = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
asinOp
  arccos :: SValue CSharpCode -> SValue CSharpCode
arccos = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
acosOp
  arctan :: SValue CSharpCode -> SValue CSharpCode
arctan = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, TypeElim r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExprNumDbl VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
atanOp
  floor :: SValue CSharpCode -> SValue CSharpCode
floor = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
floorOp
  ceil :: SValue CSharpCode -> SValue CSharpCode
ceil = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OpElim r, RenderValue r, ValueElim r, ValueSym r) =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
ceilOp

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

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

instance ValueExpression CSharpCode where
  inlineIf :: SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
inlineIf = SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(RenderValue r, ValueElim r, ValueSym r) =>
SValue r -> SValue r -> SValue r -> SValue r
C.inlineIf

  funcAppMixedArgs :: MixedCall CSharpCode
funcAppMixedArgs = MixedCall CSharpCode
forall (r :: * -> *). RenderValue r => MixedCall r
G.funcAppMixedArgs
  extFuncAppMixedArgs :: String -> MixedCall CSharpCode
extFuncAppMixedArgs = String -> MixedCall CSharpCode
forall (r :: * -> *). RenderValue r => String -> MixedCall r
CS.extFuncAppMixedArgs
  libFuncAppMixedArgs :: String -> MixedCall CSharpCode
libFuncAppMixedArgs = String -> MixedCall CSharpCode
forall (r :: * -> *). ValueExpression r => String -> MixedCall r
C.libFuncAppMixedArgs

  lambda :: [VSBinder CSharpCode] -> SValue CSharpCode -> SValue CSharpCode
lambda = ([CSharpCode BinderD] -> CSharpCode Value -> Doc)
-> [VSBinder CSharpCode] -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(BinderElim r, RenderValue r, ValueSym r) =>
([r BinderD] -> r Value -> Doc)
-> [VSBinder r] -> SValue r -> SValue r
G.lambda [CSharpCode BinderD] -> CSharpCode Value -> Doc
csLambda

  notNull :: SValue CSharpCode -> SValue CSharpCode
notNull = String -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(Comparison r, VariableValue r) =>
String -> SValue r -> SValue r
CP.notNull String
nullLabel

instance OOValueExpression CSharpCode where
  newObjMixedArgs :: MixedCtorCall CSharpCode
newObjMixedArgs = MixedCall CSharpCode
forall (r :: * -> *).
(RenderValue r, UnRepr r TypeData) =>
String -> MixedCtorCall r
G.newObjMixedArgs (String
new String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" ")
  extNewObjMixedArgs :: MixedCall CSharpCode
extNewObjMixedArgs String
_ = MixedCtorCall CSharpCode
forall (r :: * -> *). OOValueExpression r => MixedCtorCall r
newObjMixedArgs
  libNewObjMixedArgs :: MixedCall CSharpCode
libNewObjMixedArgs = MixedCall CSharpCode
forall (r :: * -> *).
OOValueExpression r =>
String -> MixedCtorCall r
C.libNewObjMixedArgs

instance RenderValue CSharpCode where
  inputFunc :: SValue CSharpCode
inputFunc = SValue CSharpCode -> SValue CSharpCode
forall a. VS a -> VS a
addSystemImport SValue CSharpCode
csReadLineFunc
  printFunc :: SValue CSharpCode
printFunc = SValue CSharpCode -> SValue CSharpCode
forall a. VS a -> VS a
addSystemImport (SValue CSharpCode -> SValue CSharpCode)
-> SValue CSharpCode -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode TypeData) -> Doc -> SValue CSharpCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void (String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String
csConsole String -> String -> String
`access`
    String
csWrite)
  printLnFunc :: SValue CSharpCode
printLnFunc = SValue CSharpCode -> SValue CSharpCode
forall a. VS a -> VS a
addSystemImport (SValue CSharpCode -> SValue CSharpCode)
-> SValue CSharpCode -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode TypeData) -> Doc -> SValue CSharpCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void (String -> Doc
text (String -> Doc) -> String -> Doc
forall a b. (a -> b) -> a -> b
$ String
csConsole String -> String -> String
`access`
    String
csWriteLine)
  printFileFunc :: SValue CSharpCode -> SValue CSharpCode
printFileFunc SValue CSharpCode
w' = (CSharpCode Value -> CSharpCode TypeData -> SValue CSharpCode)
-> SValue CSharpCode
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
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 -> Doc -> SValue CSharpCode
forall (r :: * -> *).
RenderValue r =>
r TypeData -> Doc -> SValue r
mkVal CSharpCode TypeData
vt (Doc -> SValue CSharpCode)
-> (CSharpCode Value -> Doc)
-> CSharpCode Value
-> SValue CSharpCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
csWrite (Doc -> Doc)
-> (CSharpCode Value -> Doc) -> CSharpCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value (CSharpCode Value -> SValue CSharpCode)
-> CSharpCode Value -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ CSharpCode Value
w) SValue CSharpCode
w' VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void
  printFileLnFunc :: SValue CSharpCode -> SValue CSharpCode
printFileLnFunc SValue CSharpCode
w' = (CSharpCode Value -> CSharpCode TypeData -> SValue CSharpCode)
-> SValue CSharpCode
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
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 -> Doc -> SValue CSharpCode
forall (r :: * -> *).
RenderValue r =>
r TypeData -> Doc -> SValue r
mkVal CSharpCode TypeData
vt (Doc -> SValue CSharpCode)
-> (CSharpCode Value -> Doc)
-> CSharpCode Value
-> SValue CSharpCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
csWriteLine (Doc -> Doc)
-> (CSharpCode Value -> Doc) -> CSharpCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value (CSharpCode Value -> SValue CSharpCode)
-> CSharpCode Value -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ CSharpCode Value
w) SValue CSharpCode
w' VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void

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

  call :: Maybe String -> Maybe Doc -> MixedCall CSharpCode
call = Doc -> Maybe String -> Maybe Doc -> MixedCall CSharpCode
forall (r :: * -> *).
(InternalVarElim r, RenderValue r, ValueElim r) =>
Doc -> Maybe String -> Maybe Doc -> MixedCall r
G.call Doc
csNamedArgSep

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

instance ValueElim CSharpCode 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 -> Doc
value = Value -> Doc
val (Value -> Doc)
-> (CSharpCode Value -> Value) -> CSharpCode Value -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode Value -> Value
forall a. CSharpCode a -> a
unCSC

instance InternalValueExp CSharpCode where
  objMethodCallMixedArgs' :: String
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
-> [SValue CSharpCode]
-> NamedArgs CSharpCode
-> SValue CSharpCode
objMethodCallMixedArgs' = String
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
-> [SValue CSharpCode]
-> NamedArgs CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
(RenderValue r, ValueElim r) =>
String
-> VS (r TypeData)
-> SValue r
-> [SValue r]
-> NamedArgs r
-> SValue r
G.objMethodCall
  classMethodCallMixedArgs' :: String -> VS (CSharpCode TypeData) -> MixedCtorCall CSharpCode
classMethodCallMixedArgs' = String -> VS (CSharpCode TypeData) -> MixedCtorCall CSharpCode
forall (r :: * -> *).
(RenderValue r, UnRepr r TypeData) =>
String
-> VS (r TypeData)
-> VS (r TypeData)
-> [SValue r]
-> NamedArgs r
-> SValue r
CG.classMethodCall

instance FunctionSym CSharpCode where

instance OOFunctionSym CSharpCode where
  func :: String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> VS (CSharpCode FuncData)
func = String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> VS (CSharpCode FuncData)
forall (r :: * -> *).
(RenderFunction r, ValueElim r, ValueExpression r) =>
String -> VS (r TypeData) -> [SValue r] -> VS (r FuncData)
G.func
  objAccess :: SValue CSharpCode -> VS (CSharpCode FuncData) -> SValue CSharpCode
objAccess = SValue CSharpCode -> VS (CSharpCode FuncData) -> SValue CSharpCode
forall (r :: * -> *).
(FunctionElim r, RenderValue r, ValueElim r) =>
SValue r -> VS (r FuncData) -> SValue r
G.objAccess

instance GetSet CSharpCode where
  get :: SValue CSharpCode -> SVariable CSharpCode -> SValue CSharpCode
get = SValue CSharpCode -> SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(InternalGetSet r, OOFunctionSym r) =>
SValue r -> SVariable r -> SValue r
G.get
  set :: SValue CSharpCode
-> SVariable CSharpCode -> SValue CSharpCode -> SValue CSharpCode
set = SValue CSharpCode
-> SVariable CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(InternalGetSet r, OOFunctionSym r) =>
SValue r -> SVariable r -> SValue r -> SValue r
G.set

instance IndexTranslator CSharpCode where
  intToIndex :: SValue CSharpCode -> SValue CSharpCode
intToIndex = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). SValue r -> SValue r
CP.intToIndex
  indexToInt :: SValue CSharpCode -> SValue CSharpCode
indexToInt = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). SValue r -> SValue r
CP.indexToInt

instance Reference CSharpCode where
  makeRef :: SValue CSharpCode -> SValue CSharpCode
makeRef = SValue CSharpCode -> SValue CSharpCode
forall a. a -> a
id
  maybeDeref :: SValue CSharpCode -> SValue CSharpCode
maybeDeref = SValue CSharpCode -> SValue CSharpCode
forall a. a -> a
id

instance Array CSharpCode where
  arrayElem :: SValue CSharpCode -> SValue CSharpCode -> SVariable CSharpCode
arrayElem = SValue CSharpCode -> SValue CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
(IndexTranslator r, RenderVariable r, ValueElim r) =>
SValue r -> SValue r -> SVariable r
G.arrayElem
  arrayLength :: SValue CSharpCode -> SValue CSharpCode
arrayLength SValue CSharpCode
arr = SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf (SVariable CSharpCode -> SValue CSharpCode)
-> SVariable CSharpCode -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ SValue CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
OOVariableSym r =>
SValue r -> SVariable r -> SVariable r
instanceVarAccess SValue CSharpCode
arr (String -> VS (CSharpCode TypeData) -> SVariable CSharpCode
forall (r :: * -> *).
VariableSym r =>
String -> VS (r TypeData) -> SVariable r
var String
"Length" VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
int)
  arrayCopy :: SValue CSharpCode -> SValue CSharpCode
arrayCopy SValue CSharpCode
arr = let
    arrTp :: VS (CSharpCode TypeData)
arrTp = (CSharpCode Value -> CSharpCode TypeData)
-> SValue CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Value -> CSharpCode TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType SValue CSharpCode
arr
    in VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> SValue r -> SValue r
cast VS (CSharpCode TypeData)
arrTp (VS (CSharpCode TypeData)
-> SValue CSharpCode
-> String
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *).
InternalValueExp r =>
VS (r TypeData) -> SValue r -> String -> [SValue r] -> SValue r
objMethodCall VS (CSharpCode TypeData)
arrTp SValue CSharpCode
arr String
"Clone" [])

instance List CSharpCode where
  listSize :: SValue CSharpCode -> SValue CSharpCode
listSize = String -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(OOVariableSym r, VariableValue r) =>
String -> SValue r -> SValue r
C.listSize' String
csListSize
  listAccess :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
listAccess = SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(IndexTranslator r, InternalListFunc r, FunctionElim r,
 RenderFunction r, RenderValue r, TypeElim r, ValueElim r) =>
SValue r -> SValue r -> SValue r
G.listAccess
  indexOf :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
indexOf = String
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
(IndexTranslator r, OOFunctionSym r) =>
String -> SValue r -> SValue r -> SValue r
CP.indexOf String
csIndex

instance ListStatement CSharpCode (Doc, Terminator) where
  listAdd :: SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
listAdd = String
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(IndexTranslator r, InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> SValue r -> SValue r -> MS (r stmt)
CG.listAdd String
csListAdd
  listAppend :: SValue CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
listAppend = String
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> SValue r -> MS (r stmt)
CG.listAppend String
csListAppend
  listSet :: SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
listSet = SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(AssignStatement r stmt, IndexTranslator r, RenderVariable r,
 ValueElim r) =>
SValue r -> SValue r -> SValue r -> MS (r stmt)
CP.listSet

instance Set CSharpCode where
  contains :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
contains = String
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
OOFunctionSym r =>
String -> SValue r -> SValue r -> SValue r
CP.contains String
csContains
  setAdd :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
setAdd = String
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
csListAppend
  setRemove :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
setRemove = String
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
csListRemove
  setUnion :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
setUnion = String
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
InternalValueExp r =>
String -> SValue r -> SValue r -> SValue r
CP.setMethodCall String
csUnionWith

instance InternalList CSharpCode Block where
  listSlice' :: Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode Doc)
listSlice' = Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode Doc)
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, EmptyStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, Literal r, BooleanExpression r,
 Comparison r, NumericExpression r, ValueExpression r,
 VariableValue r, List r, ListStatement r stmt, ValueElim r,
 VariableElim r) =>
Maybe (SValue r)
-> Maybe (SValue r)
-> Maybe (SValue r)
-> SVariable r
-> SValue r
-> MS (r block)
M.listSlice

instance InternalGetSet CSharpCode where
  getFunc :: SVariable CSharpCode -> VS (CSharpCode FuncData)
getFunc = SVariable CSharpCode -> VS (CSharpCode FuncData)
forall (r :: * -> *).
(OOFunctionSym r, VariableElim r) =>
SVariable r -> VS (r FuncData)
G.getFunc
  setFunc :: VS (CSharpCode TypeData)
-> SVariable CSharpCode
-> SValue CSharpCode
-> VS (CSharpCode FuncData)
setFunc = VS (CSharpCode TypeData)
-> SVariable CSharpCode
-> SValue CSharpCode
-> VS (CSharpCode FuncData)
forall (r :: * -> *).
(OOFunctionSym r, VariableElim r) =>
VS (r TypeData) -> SVariable r -> SValue r -> VS (r FuncData)
G.setFunc

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

instance BinderSym CSharpCode where
  binder :: String -> VS (CSharpCode TypeData) -> VSBinder CSharpCode
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) -> VSBinder CSharpCode
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> VS (CSharpCode TypeData)
tp

instance BinderElim CSharpCode 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 where
  binderElim :: CSharpCode BinderD -> Doc
binderElim = String -> Doc
text (String -> Doc)
-> (CSharpCode BinderD -> String) -> CSharpCode BinderD -> Doc
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 where
  funcFromData :: Doc -> VS (CSharpCode TypeData) -> VS (CSharpCode FuncData)
funcFromData Doc
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 -> Doc -> FuncData
`fd` Doc
d))

instance FunctionElim CSharpCode 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 -> Doc
function = FuncData -> Doc
funcDoc (FuncData -> Doc)
-> (CSharpCode FuncData -> FuncData) -> CSharpCode FuncData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode FuncData -> FuncData
forall a. CSharpCode a -> a
unCSC

instance InternalAssignStmt CSharpCode (Doc, Terminator) where
  multiAssign :: [SVariable CSharpCode]
-> [SValue CSharpCode] -> MS (CSharpCode (Doc, Terminator))
multiAssign [SVariable CSharpCode]
_ [SValue CSharpCode]
_ = String -> MS (CSharpCode (Doc, Terminator))
forall a. HasCallStack => String -> a
error (String -> MS (CSharpCode (Doc, Terminator)))
-> String -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiAssignError String
csName

instance InternalIOStmt CSharpCode (Doc, Terminator) where
  printSt :: Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
printSt Bool
_ Maybe (SValue CSharpCode)
_ = SValue CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
SValue r -> SValue r -> MS (r stmt)
CP.printSt

instance InternalControlStmt CSharpCode (Doc, Terminator) where
  multiReturn :: [SValue CSharpCode] -> MS (CSharpCode (Doc, Terminator))
multiReturn [SValue CSharpCode]
_ = String -> MS (CSharpCode (Doc, Terminator))
forall a. HasCallStack => String -> a
error (String -> MS (CSharpCode (Doc, Terminator)))
-> String -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiReturnError String
csName

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

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

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

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

instance ValueStatement CSharpCode (Doc, Terminator) where
  valStmt :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
valStmt = Terminator
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
Terminator -> SValue r -> MS (r stmt)
G.valStmt Terminator
Semi

instance AssignStatement CSharpCode (Doc, Terminator) where
  assign :: SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
assign = Terminator
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt, ValueElim r) =>
Terminator -> SVariable r -> SValue r -> MS (r stmt)
G.assign Terminator
Semi
  &-= :: SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
(&-=) = Terminator
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt, ValueElim r) =>
Terminator -> SVariable r -> SValue r -> MS (r stmt)
G.subAssign Terminator
Semi
  &+= :: SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
(&+=) = SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt, ValueElim r) =>
SVariable r -> SValue r -> MS (r stmt)
C.increment
  &++ :: SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
(&++) = SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt) =>
SVariable r -> MS (r stmt)
C.increment1
  &-- :: SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
(&--) = SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalVarElim r, RenderStatement r stmt) =>
SVariable r -> MS (r stmt)
C.decrement1

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

instance OODeclStatement CSharpCode (Doc, Terminator) Body where
  objDecDef :: SVariable CSharpCode
-> CSharpCode ScopeData
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
objDecDef = SVariable CSharpCode
-> CSharpCode ScopeData
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> SValue r -> MS (r stmt)
varDecDef
  objDecNew :: SVariable CSharpCode
-> CSharpCode ScopeData
-> [SValue CSharpCode]
-> MS (CSharpCode (Doc, Terminator))
objDecNew = SVariable CSharpCode
-> CSharpCode ScopeData
-> [SValue CSharpCode]
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, OOValueExpression r, VariableElim r) =>
SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
G.objDecNew
  extObjDecNew :: String
-> SVariable CSharpCode
-> CSharpCode ScopeData
-> [SValue CSharpCode]
-> MS (CSharpCode (Doc, Terminator))
extObjDecNew = String
-> SVariable CSharpCode
-> CSharpCode ScopeData
-> [SValue CSharpCode]
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, OOValueExpression r, VariableElim r) =>
String -> SVariable r -> r ScopeData -> [SValue r] -> MS (r stmt)
C.extObjDecNew

instance PrintConsole CSharpCode (Doc, Terminator) where
  print :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
print      = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
False Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc
  printLn :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
printLn    = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
True  Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc
  printStr :: String -> MS (CSharpCode (Doc, Terminator))
printStr   = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
False Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc   (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> (String -> SValue CSharpCode)
-> String
-> MS (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue CSharpCode
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printStrLn :: String -> MS (CSharpCode (Doc, Terminator))
printStrLn = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
True  Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> (String -> SValue CSharpCode)
-> String
-> MS (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue CSharpCode
forall (r :: * -> *). Literal r => String -> SValue r
litString

instance ReadConsole CSharpCode (Doc, Terminator) where
  getInput :: SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
getInput SVariable CSharpCode
v = SVariable CSharpCode
v SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
csInput ((CSharpCode Variable -> CSharpCode TypeData)
-> SVariable CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable CSharpCode
v) SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc
  discardInput :: MS (CSharpCode (Doc, Terminator))
discardInput = SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
csDiscardInput SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc

instance FileHandling CSharpCode (Doc, Terminator) where
  openFileR :: SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
openFileR = (SValue CSharpCode
 -> VS (CSharpCode TypeData) -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
(SValue r -> VS (r TypeData) -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
CP.openFileR SValue CSharpCode -> VS (CSharpCode TypeData) -> SValue CSharpCode
forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r
csOpenFileR
  openFileW :: SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
openFileW = (SValue CSharpCode
 -> VS (CSharpCode TypeData)
 -> SValue CSharpCode
 -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(AssignStatement r stmt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
CP.openFileW SValue CSharpCode
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r -> SValue r
csOpenFileWorA
  openFileA :: SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
openFileA = (SValue CSharpCode
 -> VS (CSharpCode TypeData)
 -> SValue CSharpCode
 -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(AssignStatement r stmt, Literal r) =>
(SValue r -> VS (r TypeData) -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MS (r stmt)
CP.openFileA SValue CSharpCode
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r -> SValue r
csOpenFileWorA
  closeFile :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
closeFile = String -> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> MS (r stmt)
G.closeFile String
csClose

instance PrintFile CSharpCode (Doc, Terminator) where
  printFile :: SValue CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
printFile SValue CSharpCode
f      = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
False (SValue CSharpCode -> Maybe (SValue CSharpCode)
forall a. a -> Maybe a
Just SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue CSharpCode
f)
  printFileLn :: SValue CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
printFileLn SValue CSharpCode
f    = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
True  (SValue CSharpCode -> Maybe (SValue CSharpCode)
forall a. a -> Maybe a
Just SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue CSharpCode
f)
  printFileStr :: SValue CSharpCode -> String -> MS (CSharpCode (Doc, Terminator))
printFileStr SValue CSharpCode
f   = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
False (SValue CSharpCode -> Maybe (SValue CSharpCode)
forall a. a -> Maybe a
Just SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue CSharpCode
f)   (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> (String -> SValue CSharpCode)
-> String
-> MS (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue CSharpCode
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printFileStrLn :: SValue CSharpCode -> String -> MS (CSharpCode (Doc, Terminator))
printFileStrLn SValue CSharpCode
f = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
True  (SValue CSharpCode -> Maybe (SValue CSharpCode)
forall a. a -> Maybe a
Just SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue CSharpCode
f) (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> (String -> SValue CSharpCode)
-> String
-> MS (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> SValue CSharpCode
forall (r :: * -> *). Literal r => String -> SValue r
litString

instance ReadFile CSharpCode (Doc, Terminator) where
  getFileInput :: SValue CSharpCode
-> SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
getFileInput SValue CSharpCode
f SVariable CSharpCode
v = SVariable CSharpCode
v SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
&= VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
csInput ((CSharpCode Variable -> CSharpCode TypeData)
-> SVariable CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable CSharpCode
v) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). InternalValueExp r => SValue r -> SValue r
csFileInput SValue CSharpCode
f)
  discardFileInput :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
discardFileInput SValue CSharpCode
f = SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). InternalValueExp r => SValue r -> SValue r
csFileInput SValue CSharpCode
f
  getFileInputLine :: SValue CSharpCode
-> SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
getFileInputLine = SValue CSharpCode
-> SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ReadFile r stmt =>
SValue r -> SVariable r -> MS (r stmt)
getFileInput
  discardFileLine :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
discardFileLine = String -> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(InternalValueExp r, ValueStatement r stmt) =>
String -> SValue r -> MS (r stmt)
CP.discardFileLine String
csReadLine
  getFileInputAll :: SValue CSharpCode
-> SVariable CSharpCode -> MS (CSharpCode (Doc, Terminator))
getFileInputAll SValue CSharpCode
f SVariable CSharpCode
v = SValue CSharpCode
-> MS (CSharpCode Doc) -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r bod) -> MS (r stmt)
while ((SValue CSharpCode
f SValue CSharpCode -> VS (CSharpCode FuncData) -> SValue CSharpCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. Doc -> VS (CSharpCode TypeData) -> VS (CSharpCode FuncData)
forall (r :: * -> *).
RenderFunction r =>
Doc -> VS (r TypeData) -> VS (r FuncData)
funcFromData (Doc
dot Doc -> Doc -> Doc
<> String -> Doc
text String
csEOS) VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool) SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). BooleanExpression r => SValue r -> SValue r
?!)
    (MS (CSharpCode (Doc, Terminator)) -> MS (CSharpCode Doc)
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 (Doc, Terminator)) -> MS (CSharpCode Doc))
-> MS (CSharpCode (Doc, Terminator)) -> MS (CSharpCode Doc)
forall a b. (a -> b) -> a -> b
$ SValue CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ListStatement r stmt =>
SValue r -> SValue r -> MS (r stmt)
listAppend (SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable CSharpCode
v) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). InternalValueExp r => SValue r -> SValue r
csFileInput SValue CSharpCode
f))

instance StringStatement CSharpCode (Doc, Terminator) where
  stringSplit :: Char
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
stringSplit Char
d SVariable CSharpCode
vnew SValue CSharpCode
s = SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign SVariable CSharpCode
vnew (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ VS (CSharpCode TypeData)
-> [SValue CSharpCode] -> SValue CSharpCode
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall (r :: * -> *).
TypeSym r =>
VS (r TypeData) -> VS (r TypeData)
listType VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string)
    [SValue CSharpCode
s SValue CSharpCode -> VS (CSharpCode FuncData) -> SValue CSharpCode
forall (r :: * -> *).
OOFunctionSym r =>
SValue r -> VS (r FuncData) -> SValue r
$. Char -> VS (CSharpCode FuncData)
csSplitFunc Char
d]

  stringListVals :: [SVariable CSharpCode]
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
stringListVals = [SVariable CSharpCode]
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(MultiStatement r stmt, AssignStatement r stmt, List r, Literal r,
 RenderValue r, TypeElim r, VariableElim r) =>
[SVariable r] -> SValue r -> MS (r stmt)
M.stringListVals
  stringListLists :: [SVariable CSharpCode]
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
stringListLists = [SVariable CSharpCode]
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt,
 ControlStatement r stmt bod, Literal r, NumericExpression r,
 VariableValue r, List r, ListStatement r stmt, TypeElim r,
 VariableElim r, RenderValue r) =>
[SVariable r] -> SValue r -> MS (r stmt)
M.stringListLists

instance FuncAppStatement CSharpCode (Doc, Terminator) where
  inOutCall :: InOutCall CSharpCode (Doc, Terminator)
inOutCall = (String
 -> VS (CSharpCode TypeData)
 -> [SValue CSharpCode]
 -> SValue CSharpCode)
-> InOutCall CSharpCode (Doc, Terminator)
csInOutCall String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp
  extInOutCall :: String -> InOutCall CSharpCode (Doc, Terminator)
extInOutCall String
m = (String
 -> VS (CSharpCode TypeData)
 -> [SValue CSharpCode]
 -> SValue CSharpCode)
-> InOutCall CSharpCode (Doc, Terminator)
csInOutCall (String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
m)

instance OOFuncAppStatement CSharpCode (Doc, Terminator) where
  selfInOutCall :: InOutCall CSharpCode (Doc, Terminator)
selfInOutCall = (String
 -> VS (CSharpCode TypeData)
 -> [SValue CSharpCode]
 -> SValue CSharpCode)
-> InOutCall CSharpCode (Doc, Terminator)
csInOutCall String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *).
(InternalValueExp r, VariableValue r, SelfSym r) =>
PosCall r
selfMethodCall

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

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

  returnStmt :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
returnStmt = Terminator
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(RenderStatement r stmt, ValueElim r) =>
Terminator -> SValue r -> MS (r stmt)
G.returnStmt Terminator
Semi

  throw :: String -> MS (CSharpCode (Doc, Terminator))
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 -> Doc)
-> Terminator -> String -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
(Literal r, RenderStatement r stmt) =>
(r Value -> Doc) -> Terminator -> String -> MS (r stmt)
G.throw CSharpCode Value -> Doc
csThrowDoc Terminator
Semi String
msg

  ifCond :: [(SValue CSharpCode, MS (CSharpCode Doc))]
-> MS (CSharpCode Doc) -> MS (CSharpCode (Doc, Terminator))
ifCond = (Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(SValue CSharpCode, MS (CSharpCode Doc))]
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, ValueElim r) =>
(Doc -> Doc)
-> Doc
-> OptionalSpace
-> Doc
-> Doc
-> Doc
-> [(SValue r, MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
G.ifCond Doc -> Doc
parens Doc
bodyStart OptionalSpace
G.defaultOptSpace Doc
elseIfLabel Doc
bodyEnd Doc
empty
  switch :: SValue CSharpCode
-> [(SValue CSharpCode, MS (CSharpCode Doc))]
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
switch = (Doc -> Doc)
-> MS (CSharpCode (Doc, Terminator))
-> SValue CSharpCode
-> [(SValue CSharpCode, MS (CSharpCode Doc))]
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, StatementElim r stmt,
 ValueElim r) =>
(Doc -> Doc)
-> MS (r stmt)
-> SValue r
-> [(SValue r, MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
C.switch Doc -> Doc
parens MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
MS (r stmt)
break

  ifExists :: SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
ifExists = SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(ControlStatement r stmt bod, ValueExpression r) =>
SValue r -> MS (r bod) -> MS (r bod) -> MS (r stmt)
M.ifExists

  for :: MS (CSharpCode (Doc, Terminator))
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
for = Doc
-> Doc
-> MS (CSharpCode (Doc, Terminator))
-> SValue CSharpCode
-> MS (CSharpCode (Doc, Terminator))
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, StatementElim r stmt,
 ValueElim r) =>
Doc
-> Doc
-> MS (r stmt)
-> SValue r
-> MS (r stmt)
-> MS (r bod)
-> MS (r stmt)
C.for Doc
bodyStart Doc
bodyEnd
  forRange :: SVariable CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forRange = SVariable CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
(DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, Comparison r, VariableValue r) =>
SVariable r
-> SValue r -> SValue r -> SValue r -> MS (r bod) -> MS (r stmt)
M.forRange
  forEach :: SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forEach = Doc
-> Doc
-> Doc
-> Doc
-> SVariable CSharpCode
-> SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, InternalVarElim r, RenderStatement r stmt,
 UnRepr r TypeData, ValueElim r, VariableElim r) =>
Doc
-> Doc
-> Doc
-> Doc
-> SVariable r
-> SValue r
-> MS (r bod)
-> MS (r stmt)
CP.forEach Doc
bodyStart Doc
bodyEnd Doc
csForEach Doc
inLabel
  while :: SValue CSharpCode
-> MS (CSharpCode Doc) -> MS (CSharpCode (Doc, Terminator))
while = (Doc -> Doc)
-> Doc
-> Doc
-> SValue CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod stmt.
(BodyElim r bod, RenderStatement r stmt, ValueElim r) =>
(Doc -> Doc) -> Doc -> Doc -> SValue r -> MS (r bod) -> MS (r stmt)
C.while Doc -> Doc
parens Doc
bodyStart Doc
bodyEnd

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

  assert :: SValue CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
assert SValue CSharpCode
condition SValue CSharpCode
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
-> SValue CSharpCode
-> 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 SValue CSharpCode
condition
    errMsg <- zoom lensMStoVS errorMessage
    mkStmtNoEnd (csAssert cond errMsg)

instance ObserverPattern CSharpCode (Doc, Terminator) where
  notifyObservers :: VS (CSharpCode FuncData)
-> VS (CSharpCode TypeData) -> MS (CSharpCode (Doc, Terminator))
notifyObservers = VS (CSharpCode FuncData)
-> VS (CSharpCode TypeData) -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Literal r,
 VariableValue r, Comparison r, List r, ValueStatement r stmt,
 DeclStatement r stmt bod, AssignStatement r stmt,
 ControlStatement r stmt bod, OOFunctionSym r) =>
VS (r FuncData) -> VS (r TypeData) -> MS (r stmt)
M.notifyObservers

instance StrategyPattern CSharpCode Body Block where
  runStrategy :: String
-> [(String, MS (CSharpCode Doc))]
-> Maybe (SValue CSharpCode)
-> Maybe (SVariable CSharpCode)
-> MS (CSharpCode Doc)
runStrategy = String
-> [(String, MS (CSharpCode Doc))]
-> Maybe (SValue CSharpCode)
-> Maybe (SVariable CSharpCode)
-> MS (CSharpCode Doc)
forall (r :: * -> *) stmt bod.
(EmptyStatement r stmt, AssignStatement r stmt, BodyElim r bod,
 Monad r, RenderStatement r stmt, StatementElim r stmt) =>
String
-> [(String, MS (r bod))]
-> Maybe (SValue r)
-> Maybe (SVariable r)
-> MS (r Doc)
M.runStrategy

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

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

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

instance MethodTypeSym CSharpCode where
  mType :: VS (CSharpCode TypeData) -> MSMthdType CSharpCode
mType = LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode TypeData))
  MethodState
  ValueState
-> VS (CSharpCode TypeData) -> MSMthdType CSharpCode
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 where
  construct :: String -> MSMthdType CSharpCode
construct = String -> MSMthdType CSharpCode
forall (r :: * -> *). Monad r => String -> MS (r TypeData)
G.construct

instance ParameterSym CSharpCode where
  param :: SVariable CSharpCode -> MS (CSharpCode ParamData)
param = (CSharpCode Variable -> Doc)
-> SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
(RenderParam r, VariableElim r) =>
(r Variable -> Doc) -> SVariable r -> MS (r ParamData)
G.param CSharpCode Variable -> Doc
forall (r :: * -> *).
(InternalVarElim r, UnRepr r TypeData, VariableElim r) =>
r Variable -> Doc
renderParam
  pointerParam :: SVariable CSharpCode -> MS (CSharpCode ParamData)
pointerParam = SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param

instance RenderParam CSharpCode where
  paramFromData :: SVariable CSharpCode -> Doc -> MS (CSharpCode ParamData)
paramFromData SVariable CSharpCode
v' Doc
d = do
    v <- LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
-> SVariable CSharpCode
-> 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 SVariable CSharpCode
v'
    toState $ on2CodeValues pd v (toCode d)

instance ParamElim CSharpCode where
  parameterName :: CSharpCode ParamData -> String
parameterName = CSharpCode Variable -> String
forall (r :: * -> *). VariableElim r => r Variable -> 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 (r :: * -> *). VariableElim r => r Variable -> r TypeData
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 -> Doc
parameter = ParamData -> Doc
paramDoc (ParamData -> Doc)
-> (CSharpCode ParamData -> ParamData)
-> CSharpCode ParamData
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ParamData -> ParamData
forall a. CSharpCode a -> a
unCSC

instance MethodSym CSharpCode Doc MethodData Body where
  docMain :: MS (CSharpCode Doc) -> MS (CSharpCode MethodData)
docMain = MS (CSharpCode Doc) -> MS (CSharpCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
MS (r bod) -> MS (r mthd)
CP.docMain
  function :: String
-> CSharpCode Doc
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
function = String
-> CSharpCode Doc
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) attch vis mthd bod.
(AttachmentSym r attch, OORenderMethod r vis mthd attch bod) =>
String
-> r vis
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
G.function
  mainFunction :: MS (CSharpCode Doc) -> MS (CSharpCode MethodData)
mainFunction = VS (CSharpCode TypeData)
-> String -> MS (CSharpCode Doc) -> MS (CSharpCode MethodData)
forall (r :: * -> *) attch vis mthd bod.
(AttachmentSym r attch, OORenderMethod r vis mthd attch bod,
 ParameterSym r, UnRepr r TypeData, Monad r, VisibilitySym r vis) =>
VS (r TypeData) -> String -> MS (r bod) -> MS (r mthd)
CP.mainFunction VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
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.
RenderMethod r mthd =>
String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
CP.doxFunc

  inOutFunc :: String -> CSharpCode Doc -> InOutFunc CSharpCode MethodData Doc
inOutFunc String
n CSharpCode Doc
s = (VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Doc)
 -> MS (CSharpCode MethodData))
-> InOutFunc CSharpCode MethodData Doc
forall mthd.
(VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Doc)
 -> MS (CSharpCode mthd))
-> [SVariable CSharpCode]
-> [SVariable CSharpCode]
-> [SVariable CSharpCode]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
csInOut (String
-> CSharpCode Doc
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) vis mthd bod.
MethodSym r vis mthd bod =>
String
-> r vis
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
function String
n CSharpCode Doc
s)
  docInOutFunc :: String -> CSharpCode Doc -> DocInOutFunc CSharpCode MethodData Doc
docInOutFunc String
n CSharpCode Doc
s = InOutFunc CSharpCode MethodData Doc
-> DocInOutFunc CSharpCode MethodData Doc
forall (r :: * -> *) mthd bod.
RenderMethod r mthd =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc (String -> CSharpCode Doc -> InOutFunc CSharpCode MethodData Doc
forall (r :: * -> *) vis mthd bod.
MethodSym r vis mthd bod =>
String -> r vis -> InOutFunc r mthd bod
inOutFunc String
n CSharpCode Doc
s)

instance OOMethodSym CSharpCode Doc MethodData Doc Body where
  method :: String
-> CSharpCode Doc
-> CSharpCode Doc
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
method = String
-> CSharpCode Doc
-> CSharpCode Doc
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) vis mthd attch bod.
OORenderMethod r vis mthd attch bod =>
String
-> r vis
-> r attch
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
G.method
  getMethod :: SVariable CSharpCode -> MS (CSharpCode MethodData)
getMethod = SVariable CSharpCode -> MS (CSharpCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
SVariable r -> MS (r mthd)
G.getMethod
  setMethod :: SVariable CSharpCode -> MS (CSharpCode MethodData)
setMethod = SVariable CSharpCode -> MS (CSharpCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
SVariable r -> MS (r mthd)
G.setMethod
  constructor :: [MS (CSharpCode ParamData)]
-> NamedArgs CSharpCode
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
constructor [MS (CSharpCode ParamData)]
ps NamedArgs CSharpCode
is MS (CSharpCode Doc)
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
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
OORenderSym r vis stmt mthd stvr attch file mod bod block =>
String
-> [MS (r ParamData)]
-> Initializers r
-> MS (r bod)
-> MS (r mthd)
CP.constructor String
n [MS (CSharpCode ParamData)]
ps NamedArgs CSharpCode
is MS (CSharpCode Doc)
b)

  inOutMethod :: String
-> CSharpCode Doc
-> CSharpCode Doc
-> InOutFunc CSharpCode MethodData Doc
inOutMethod String
n CSharpCode Doc
s CSharpCode Doc
p = (VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Doc)
 -> MS (CSharpCode MethodData))
-> InOutFunc CSharpCode MethodData Doc
forall mthd.
(VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Doc)
 -> MS (CSharpCode mthd))
-> [SVariable CSharpCode]
-> [SVariable CSharpCode]
-> [SVariable CSharpCode]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
csInOut (String
-> CSharpCode Doc
-> CSharpCode Doc
-> VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) vis mthd attch bod.
OOMethodSym r vis mthd attch bod =>
String
-> r vis
-> r attch
-> VS (r TypeData)
-> [MS (r ParamData)]
-> MS (r bod)
-> MS (r mthd)
method String
n CSharpCode Doc
s CSharpCode Doc
p)
  docInOutMethod :: String
-> CSharpCode Doc
-> CSharpCode Doc
-> DocInOutFunc CSharpCode MethodData Doc
docInOutMethod String
n CSharpCode Doc
s CSharpCode Doc
p = InOutFunc CSharpCode MethodData Doc
-> DocInOutFunc CSharpCode MethodData Doc
forall (r :: * -> *) mthd bod.
RenderMethod r mthd =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc (String
-> CSharpCode Doc
-> CSharpCode Doc
-> InOutFunc CSharpCode MethodData Doc
forall (r :: * -> *) vis mthd attch bod.
OOMethodSym r vis mthd attch bod =>
String -> r vis -> r attch -> InOutFunc r mthd bod
inOutMethod String
n CSharpCode Doc
s CSharpCode Doc
p)

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

  mthdFromData :: VisibilityTag -> Doc -> MS (CSharpCode MethodData)
mthdFromData VisibilityTag
_ Doc
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 -> Doc -> MethodData
mthd String
"" Doc
d

instance OORenderMethod CSharpCode Doc MethodData Doc Body where
  intMethod :: Bool
-> String
-> CSharpCode Doc
-> CSharpCode Doc
-> MSMthdType CSharpCode
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
intMethod Bool
m String
n CSharpCode Doc
s CSharpCode Doc
p MSMthdType CSharpCode
t [MS (CSharpCode ParamData)]
ps MS (CSharpCode Doc)
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 <- MSMthdType CSharpCode
t
    pms <- sequence ps
    toCode . mthd n . renderMethod n s p tp pms <$> b
  intFunc :: Bool
-> String
-> CSharpCode Doc
-> CSharpCode Doc
-> MSMthdType CSharpCode
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
intFunc = Bool
-> String
-> CSharpCode Doc
-> CSharpCode Doc
-> MSMthdType CSharpCode
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode MethodData)
forall (r :: * -> *) vis mthd attch bod.
OORenderMethod r vis mthd attch bod =>
Bool
-> String
-> r vis
-> r attch
-> MSMthdType r
-> [MS (r ParamData)]
-> 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 -> Doc
method = MethodData -> Doc
mthdDoc (MethodData -> Doc)
-> (CSharpCode MethodData -> MethodData)
-> CSharpCode MethodData
-> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode MethodData -> MethodData
forall a. CSharpCode a -> a
unCSC

instance StateVarSym CSharpCode Doc StateVar Doc where
  stateVar :: CSharpCode Doc
-> CSharpCode Doc
-> SVariable CSharpCode
-> CSStateVar CSharpCode Doc
stateVar = CSharpCode Doc
-> CSharpCode Doc
-> SVariable CSharpCode
-> CSStateVar CSharpCode Doc
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(Monad r,
 OORenderSym r vis stmt mthd stvr attch file mod bod block) =>
r vis -> r attch -> SVariable r -> CS (r Doc)
CP.stateVar
  stateVarDef :: CSharpCode Doc
-> CSharpCode Doc
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode Doc
stateVarDef = CSharpCode Doc
-> CSharpCode Doc
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode Doc
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(OORenderSym r vis stmt mthd stvr attch file mod bod block,
 Monad r) =>
r vis -> r attch -> SVariable r -> SValue r -> CS (r Doc)
CP.stateVarDef
  constVar :: CSharpCode Doc
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode Doc
constVar = Doc
-> CSharpCode Doc
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode Doc
forall (r :: * -> *) vis stmt mthd bod block.
(CommonRenderSym r vis stmt mthd bod block, Monad r) =>
Doc -> r vis -> SVariable r -> SValue r -> CS (r Doc)
CP.constVar Doc
empty

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

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

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

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

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

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

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

instance ModuleSym CSharpCode ModData MethodData where
  buildModule :: String
-> [String]
-> [MS (CSharpCode MethodData)]
-> [CSStateVar CSharpCode Doc]
-> FS (CSharpCode ModData)
buildModule String
n = String
-> (String -> CSharpCode Doc)
-> [String]
-> [MS (CSharpCode MethodData)]
-> [CSStateVar CSharpCode Doc]
-> FS (CSharpCode ModData)
forall (r :: * -> *) vis stmt mthd stvr attch file mod bod block.
(OORenderSym r vis stmt mthd stvr attch file mod bod block,
 UnRepr r Doc) =>
String
-> (String -> r Doc)
-> [String]
-> [MS (r mthd)]
-> [CS (r Doc)]
-> FS (r mod)
CP.buildModule' String
n String -> CSharpCode Doc
forall (r :: * -> *). ImportSym r => String -> r Doc
langImport

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

instance ModuleElim CSharpCode ModData where
  module' :: CSharpCode ModData -> Doc
module' = ModData -> Doc
modDoc (ModData -> Doc)
-> (CSharpCode ModData -> ModData) -> CSharpCode ModData -> Doc
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 Doc
blockComment [String]
lns = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> CSharpCode Doc) -> Doc -> CSharpCode Doc
forall a b. (a -> b) -> a -> b
$ [String] -> Doc -> Doc -> Doc
R.blockCmt [String]
lns Doc
blockCmtStart Doc
blockCmtEnd
  docComment :: forall a. State a [String] -> State a (CSharpCode Doc)
docComment = ([String] -> CSharpCode Doc)
-> State a [String] -> State a (CSharpCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\[String]
lns -> Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> CSharpCode Doc) -> Doc -> CSharpCode Doc
forall a b. (a -> b) -> a -> b
$ [String] -> Doc -> Doc -> Doc
R.docCmt [String]
lns Doc
docCmtStart
    Doc
blockCmtEnd)

instance BlockCommentElim CSharpCode where
  blockComment' :: CSharpCode Doc -> Doc
blockComment' = CSharpCode Doc -> Doc
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 -> Doc
csImport String
n = String -> Doc
text (String
"using " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
n) Doc -> Doc -> Doc
<> Doc
endStatement

csBoolType :: (Monad r) => VS (r TypeData)
csBoolType :: forall (r :: * -> *). Monad r => VS (r TypeData)
csBoolType = CodeType -> String -> Doc -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
Boolean String
csBool (String -> Doc
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 (map getCodeType pts) (getCodeType rt))
    (csFunc `containing` intercalate listSep (map getTypeString $ pts ++ [rt]))
    (text csFunc <> angles (hicat listSep' $ map renderType $ pts ++ [rt]))

csForEach, csNamedArgSep, csLambdaSep :: Doc
csForEach :: Doc
csForEach = String -> Doc
text String
"foreach"
csNamedArgSep :: Doc
csNamedArgSep = Doc
colon Doc -> Doc -> Doc
<> Doc
space
csLambdaSep :: Doc
csLambdaSep = String -> Doc
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 -> Doc -> StateT ValueState Identity (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
InFile String
csReader (String -> Doc
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 -> Doc -> StateT ValueState Identity (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Doc -> VS (r TypeData)
typeFromData CodeType
OutFile String
csWriter (String -> Doc
text String
csWriter)

csLitList :: (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)) ->
  VS (CSharpCode TypeData) -> [SValue CSharpCode] -> SValue CSharpCode
csLitList :: (VS (CSharpCode TypeData) -> VS (CSharpCode TypeData))
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
csLitList VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
f VS (CSharpCode TypeData)
t' [SValue CSharpCode]
es' = do
  es <- [SValue CSharpCode]
-> 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 [SValue CSharpCode]
es'
  lt <- f t'
  mkVal lt (new' <+> renderType lt
    <+> braces (valueList es))

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

csReadLineFunc :: SValue CSharpCode
csReadLineFunc :: SValue CSharpCode
csReadLineFunc = String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
csConsole String
csReadLine VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string []

csIntParse :: SValue CSharpCode -> SValue CSharpCode
csIntParse :: SValue CSharpCode -> SValue CSharpCode
csIntParse SValue CSharpCode
v = String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
csInt String
csParse VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
int [SValue CSharpCode
v]

csFloatParse :: SValue CSharpCode -> SValue CSharpCode
csFloatParse :: SValue CSharpCode -> SValue CSharpCode
csFloatParse SValue CSharpCode
v = String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
csFloat String
csParse VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
float [SValue CSharpCode
v]

csDblParse :: SValue CSharpCode -> SValue CSharpCode
csDblParse :: SValue CSharpCode -> SValue CSharpCode
csDblParse SValue CSharpCode
v = String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
CP.doubleRender String
csParse VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
double [SValue CSharpCode
v]

csBoolParse :: SValue CSharpCode -> SValue CSharpCode
csBoolParse :: SValue CSharpCode -> SValue CSharpCode
csBoolParse SValue CSharpCode
v = String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
csBool String
csParse VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
bool [SValue CSharpCode
v]

csCharParse :: SValue CSharpCode -> SValue CSharpCode
csCharParse :: SValue CSharpCode -> SValue CSharpCode
csCharParse SValue CSharpCode
v = String
-> String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
csChar String
csParse VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
char [SValue CSharpCode
v]

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

csCast :: VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
csCast :: VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
csCast = StateT ValueState Identity (SValue CSharpCode) -> SValue CSharpCode
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT ValueState Identity (SValue CSharpCode)
 -> SValue CSharpCode)
-> (VS (CSharpCode TypeData)
    -> SValue CSharpCode
    -> StateT ValueState Identity (SValue CSharpCode))
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
-> SValue CSharpCode
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.: (CSharpCode TypeData -> CSharpCode Value -> SValue CSharpCode)
-> VS (CSharpCode TypeData)
-> SValue CSharpCode
-> StateT ValueState Identity (SValue CSharpCode)
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
-> SValue CSharpCode
csCast' (CSharpCode TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType CSharpCode TypeData
t) (CSharpCode TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType (CSharpCode TypeData -> CodeType)
-> CSharpCode TypeData -> CodeType
forall a b. (a -> b) -> a -> b
$
  CSharpCode Value -> CSharpCode TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
valueType CSharpCode Value
v) CSharpCode TypeData
t CSharpCode Value
v)
  where csCast' :: CodeType
-> CodeType
-> CSharpCode TypeData
-> CSharpCode Value
-> SValue CSharpCode
csCast' CodeType
Double CodeType
String CSharpCode TypeData
_ CSharpCode Value
v = SValue CSharpCode -> SValue CSharpCode
csDblParse (CSharpCode Value -> SValue CSharpCode
forall a s. a -> State s a
toState CSharpCode Value
v)
        csCast' CodeType
Float CodeType
String CSharpCode TypeData
_ CSharpCode Value
v = SValue CSharpCode -> SValue CSharpCode
csFloatParse (CSharpCode Value -> SValue CSharpCode
forall a s. a -> State s a
toState CSharpCode Value
v)
        csCast' CodeType
_ CodeType
_ CSharpCode TypeData
t CSharpCode Value
v = VS (CSharpCode TypeData) -> Doc -> SValue CSharpCode
forall (r :: * -> *).
RenderValue r =>
VS (r TypeData) -> Doc -> SValue r
mkStateVal (CSharpCode TypeData -> VS (CSharpCode TypeData)
forall a s. a -> State s a
toState CSharpCode TypeData
t) (Doc -> Doc -> Doc
R.castObj (Doc -> Doc
R.cast
          (CSharpCode TypeData -> Doc
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Doc
renderType CSharpCode TypeData
t)) (CSharpCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
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 :: SVariable CSharpCode -> CSharpCode ScopeData ->
  [SVariable CSharpCode] -> MS (CSharpCode Body) -> MS (CSharpCode (Doc, Terminator))
csFuncDecDef :: SVariable CSharpCode
-> CSharpCode ScopeData
-> [SVariable CSharpCode]
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
csFuncDecDef SVariable CSharpCode
v CSharpCode ScopeData
scp [SVariable CSharpCode]
ps MS (CSharpCode Doc)
bod = do
  vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode Variable))
  MethodState
  ValueState
-> SVariable CSharpCode
-> 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 SVariable CSharpCode
v
  modify $ useVarName $ variableName vr
  modify $ setVarScope (variableName vr) (scopeData scp)
  pms <- mapM (zoom lensMStoVS) ps
  t <- zoom lensMStoVS $ funcType (map (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 -> Doc
csThrowDoc CSharpCode Value
errMsg = Doc
throwLabel Doc -> Doc -> Doc
<+> Doc
new' Doc -> Doc -> Doc
<+> Doc
exceptionObj' Doc -> Doc -> Doc
<>
  Doc -> Doc
parens (CSharpCode Value -> Doc
forall (r :: * -> *). ValueElim r => r Value -> Doc
RC.value CSharpCode Value
errMsg)

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

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

csDiscardInput :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
csDiscardInput :: SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
csDiscardInput = SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt

csFileInput :: (InternalValueExp r) => SValue r -> SValue r
csFileInput :: forall (r :: * -> *). InternalValueExp r => SValue r -> SValue r
csFileInput SValue r
f = VS (r TypeData) -> SValue r -> String -> SValue r
forall (r :: * -> *).
InternalValueExp r =>
VS (r TypeData) -> SValue r -> String -> SValue r
objMethodCallNoParams VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string SValue r
f String
csReadLine

csInput :: VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
csInput :: VS (CSharpCode TypeData) -> SValue CSharpCode -> SValue CSharpCode
csInput VS (CSharpCode TypeData)
tp SValue CSharpCode
inFn = do
  t <- VS (CSharpCode TypeData)
tp
  csInputImport (getCodeType t) (csInput' (getCodeType t) inFn)
  where csInput' :: CodeType -> SValue CSharpCode -> SValue CSharpCode
csInput' CodeType
Integer = SValue CSharpCode -> SValue CSharpCode
csIntParse
        csInput' CodeType
Float = SValue CSharpCode -> SValue CSharpCode
csFloatParse
        csInput' CodeType
Double = SValue CSharpCode -> SValue CSharpCode
csDblParse
        csInput' CodeType
Boolean = SValue CSharpCode -> SValue CSharpCode
csBoolParse
        csInput' CodeType
String = SValue CSharpCode -> SValue CSharpCode
forall a. a -> a
id
        csInput' CodeType
Char = SValue CSharpCode -> SValue CSharpCode
csCharParse
        csInput' CodeType
_ = String -> SValue CSharpCode -> SValue CSharpCode
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) => SValue r -> VS (r TypeData) -> SValue r
csOpenFileR :: forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r
csOpenFileR SValue r
n VS (r TypeData)
r = PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
r [SValue r
n]

csOpenFileWorA :: (OOValueExpression r) => SValue r ->
  VS (r TypeData) -> SValue r -> SValue r
csOpenFileWorA :: forall (r :: * -> *).
OOValueExpression r =>
SValue r -> VS (r TypeData) -> SValue r -> SValue r
csOpenFileWorA SValue r
n VS (r TypeData)
w SValue r
a = PosCtorCall r
forall (r :: * -> *). OOValueExpression r => PosCtorCall r
newObj VS (r TypeData)
w [SValue r
n, SValue r
a]

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

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

csInOutCall :: (Label -> VS (CSharpCode TypeData) -> [SValue CSharpCode] ->
  SValue CSharpCode) -> Label -> [SValue CSharpCode] -> [SVariable CSharpCode]
  -> [SVariable CSharpCode] -> MS (CSharpCode (Doc, Terminator))
csInOutCall :: (String
 -> VS (CSharpCode TypeData)
 -> [SValue CSharpCode]
 -> SValue CSharpCode)
-> InOutCall CSharpCode (Doc, Terminator)
csInOutCall String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
f String
n [SValue CSharpCode]
ins [SVariable CSharpCode
out] [] = SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign SVariable CSharpCode
out (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
f String
n ((CSharpCode Variable -> CSharpCode TypeData)
-> SVariable CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable CSharpCode
out)
  [SValue CSharpCode]
ins
csInOutCall String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
f String
n [SValue CSharpCode]
ins [] [SVariable CSharpCode
out] = SVariable CSharpCode
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
AssignStatement r stmt =>
SVariable r -> SValue r -> MS (r stmt)
assign SVariable CSharpCode
out (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
f String
n ((CSharpCode Variable -> CSharpCode TypeData)
-> SVariable CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable CSharpCode
out)
  (SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable CSharpCode
out SValue CSharpCode -> [SValue CSharpCode] -> [SValue CSharpCode]
forall a. a -> [a] -> [a]
: [SValue CSharpCode]
ins)
csInOutCall String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
f String
n [SValue CSharpCode]
ins [SVariable CSharpCode]
outs [SVariable CSharpCode]
both = SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt.
ValueStatement r stmt =>
SValue r -> MS (r stmt)
valStmt (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ String
-> VS (CSharpCode TypeData)
-> [SValue CSharpCode]
-> SValue CSharpCode
f String
n VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void ((SVariable CSharpCode -> SValue CSharpCode)
-> [SVariable CSharpCode] -> [SValue CSharpCode]
forall a b. (a -> b) -> [a] -> [b]
map ((CSharpCode Value -> CSharpCode Value)
-> SValue CSharpCode -> SValue CSharpCode
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 ((Doc -> Doc) -> Value -> Value
updateValDoc Doc -> Doc
csRef)) (SValue CSharpCode -> SValue CSharpCode)
-> (SVariable CSharpCode -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf) [SVariable CSharpCode]
both [SValue CSharpCode] -> [SValue CSharpCode] -> [SValue CSharpCode]
forall a. [a] -> [a] -> [a]
++ [SValue CSharpCode]
ins [SValue CSharpCode] -> [SValue CSharpCode] -> [SValue CSharpCode]
forall a. [a] -> [a] -> [a]
++ (SVariable CSharpCode -> SValue CSharpCode)
-> [SVariable CSharpCode] -> [SValue CSharpCode]
forall a b. (a -> b) -> [a] -> [b]
map
  ((CSharpCode Value -> CSharpCode Value)
-> SValue CSharpCode -> SValue CSharpCode
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 ((Doc -> Doc) -> Value -> Value
updateValDoc Doc -> Doc
csOut)) (SValue CSharpCode -> SValue CSharpCode)
-> (SVariable CSharpCode -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf) [SVariable CSharpCode]
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)) ->
  [SVariable CSharpCode] -> [SVariable CSharpCode] -> [SVariable CSharpCode] ->
  MS (CSharpCode Body) -> MS (CSharpCode mthd)
csInOut :: forall mthd.
(VS (CSharpCode TypeData)
 -> [MS (CSharpCode ParamData)]
 -> MS (CSharpCode Doc)
 -> MS (CSharpCode mthd))
-> [SVariable CSharpCode]
-> [SVariable CSharpCode]
-> [SVariable CSharpCode]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
csInOut VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
f [SVariable CSharpCode]
ins [SVariable CSharpCode
v] [] MS (CSharpCode Doc)
b = VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
f ((CSharpCode Variable -> CSharpCode TypeData)
-> SVariable CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable CSharpCode
v) ((SVariable CSharpCode -> MS (CSharpCode ParamData))
-> [SVariable CSharpCode] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param [SVariable CSharpCode]
ins)
  ((CSharpCode (Doc, Terminator)
 -> CSharpCode Doc
 -> CSharpCode (Doc, Terminator)
 -> CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
-> MS (CSharpCode Doc)
forall a b c d s.
(a -> b -> c -> d)
-> State s a -> State s b -> State s c -> State s d
on3StateValues (((Doc, Terminator) -> Doc -> (Doc, Terminator) -> Doc)
-> CSharpCode (Doc, Terminator)
-> CSharpCode Doc
-> CSharpCode (Doc, Terminator)
-> CSharpCode Doc
forall (r :: * -> *) a b c d.
Applicative r =>
(a -> b -> c -> d) -> r a -> r b -> r c -> r d
on3CodeValues (Doc, Terminator) -> Doc -> (Doc, Terminator) -> Doc
surroundBody) (SVariable CSharpCode
-> CSharpCode ScopeData -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
DeclStatement r stmt bod =>
SVariable r -> r ScopeData -> MS (r stmt)
varDec SVariable CSharpCode
v CSharpCode ScopeData
forall (r :: * -> *). ScopeSym r => r ScopeData
local) MS (CSharpCode Doc)
b (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$
  SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable CSharpCode
v))
csInOut VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
f [SVariable CSharpCode]
ins [] [SVariable CSharpCode
v] MS (CSharpCode Doc)
b = VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
f ((CSharpCode Variable -> CSharpCode TypeData)
-> SVariable CSharpCode -> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode Variable -> CSharpCode TypeData
forall (r :: * -> *). VariableElim r => r Variable -> r TypeData
variableType SVariable CSharpCode
v)
  ((SVariable CSharpCode -> MS (CSharpCode ParamData))
-> [SVariable CSharpCode] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param ([SVariable CSharpCode] -> [MS (CSharpCode ParamData)])
-> [SVariable CSharpCode] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> a -> b
$ SVariable CSharpCode
v SVariable CSharpCode
-> [SVariable CSharpCode] -> [SVariable CSharpCode]
forall a. a -> [a] -> [a]
: [SVariable CSharpCode]
ins) ((CSharpCode Doc -> CSharpCode (Doc, Terminator) -> CSharpCode Doc)
-> MS (CSharpCode Doc)
-> MS (CSharpCode (Doc, Terminator))
-> MS (CSharpCode Doc)
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues ((Doc -> (Doc, Terminator) -> Doc)
-> CSharpCode Doc -> CSharpCode (Doc, Terminator) -> CSharpCode Doc
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues Doc -> (Doc, Terminator) -> Doc
appendToBody) MS (CSharpCode Doc)
b
  (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall (r :: * -> *) stmt bod.
ControlStatement r stmt bod =>
SValue r -> MS (r stmt)
returnStmt (SValue CSharpCode -> MS (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode -> MS (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable CSharpCode
v))
csInOut VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
f [SVariable CSharpCode]
ins [SVariable CSharpCode]
outs [SVariable CSharpCode]
both MS (CSharpCode Doc)
b = VS (CSharpCode TypeData)
-> [MS (CSharpCode ParamData)]
-> MS (CSharpCode Doc)
-> MS (CSharpCode mthd)
f VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
void ((SVariable CSharpCode -> MS (CSharpCode ParamData))
-> [SVariable CSharpCode] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map ((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
  ((Doc -> Doc) -> ParamData -> ParamData
updateParam Doc -> Doc
csRef)) (MS (CSharpCode ParamData) -> MS (CSharpCode ParamData))
-> (SVariable CSharpCode -> MS (CSharpCode ParamData))
-> SVariable CSharpCode
-> MS (CSharpCode ParamData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param) [SVariable CSharpCode]
both [MS (CSharpCode ParamData)]
-> [MS (CSharpCode ParamData)] -> [MS (CSharpCode ParamData)]
forall a. [a] -> [a] -> [a]
++ (SVariable CSharpCode -> MS (CSharpCode ParamData))
-> [SVariable CSharpCode] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param [SVariable CSharpCode]
ins [MS (CSharpCode ParamData)]
-> [MS (CSharpCode ParamData)] -> [MS (CSharpCode ParamData)]
forall a. [a] -> [a] -> [a]
++ (SVariable CSharpCode -> MS (CSharpCode ParamData))
-> [SVariable CSharpCode] -> [MS (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map ((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 ((Doc -> Doc) -> ParamData -> ParamData
updateParam Doc -> Doc
csOut)) (MS (CSharpCode ParamData) -> MS (CSharpCode ParamData))
-> (SVariable CSharpCode -> MS (CSharpCode ParamData))
-> SVariable CSharpCode
-> MS (CSharpCode ParamData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SVariable CSharpCode -> MS (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MS (r ParamData)
param) [SVariable CSharpCode]
outs) MS (CSharpCode Doc)
b

csPrint
  ::
    ( BodySym r bod block
    , BlockSym r block stmt
    , Comparison r
    , Literal r
    , NumericExpression r
    , ValueExpression r
    , VariableValue r
    , List r
    , MultiStatement r stmt
    , DeclStatement r stmt bod
    , AssignStatement r stmt
    , ControlStatement r stmt bod
    , PrintConsole r stmt
    , PrintFile r stmt
    , InternalIOStmt r stmt
    , TypeElim r
    )
  => Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint :: forall (r :: * -> *) bod block stmt.
(BodySym r bod block, BlockSym r block stmt, Comparison r,
 Literal r, NumericExpression r, ValueExpression r, VariableValue r,
 List r, MultiStatement r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod,
 PrintConsole r stmt, PrintFile r stmt, InternalIOStmt r stmt,
 TypeElim r) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
csPrint Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v = LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
-> SValue r -> StateT MethodState Identity (r Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (r Value) ValueState)
-> MethodState -> Focusing Identity (r Value) MethodState
Lens' MethodState ValueState
lensMStoVS SValue r
v StateT MethodState Identity (r Value)
-> (r Value -> 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 Value -> CodeType)
-> r Value
-> StateT MethodState Identity (r stmt)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r TypeData -> CodeType
forall (r :: * -> *). TypeElim r => r TypeData -> CodeType
getCodeType (r TypeData -> CodeType)
-> (r Value -> r TypeData) -> r Value -> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r Value -> r TypeData
forall (r :: * -> *). ValueSym r => r Value -> r TypeData
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 (r :: * -> *) stmt.
PrintConsole r stmt =>
String -> MS (r stmt)
printStr String
"[",
          SValue r -> StateT MethodState Identity (r stmt)
forall (r :: * -> *) stmt.
PrintConsole r stmt =>
SValue r -> MS (r stmt)
print (SValue r -> StateT MethodState Identity (r stmt))
-> SValue r -> StateT MethodState Identity (r stmt)
forall a b. (a -> b) -> a -> b
$ String -> PosCall r
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
"string" String
"Join" VS (r TypeData)
forall (r :: * -> *). TypeSym r => VS (r TypeData)
string [String -> SValue r
forall (r :: * -> *). Literal r => String -> SValue r
litString String
", ", SValue r
v],
          SValue r -> StateT MethodState Identity (r stmt)
printMaybeNewLn (SValue r -> StateT MethodState Identity (r stmt))
-> SValue r -> StateT MethodState Identity (r stmt)
forall a b. (a -> b) -> a -> b
$ String -> SValue r
forall (r :: * -> *). Literal r => String -> SValue r
litString String
"]"]
        csPrint' CodeType
_ = Bool
-> Maybe (SValue r)
-> SValue r
-> SValue r
-> StateT MethodState Identity (r stmt)
forall (r :: * -> *) block stmt bod.
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 PrintConsole r stmt, PrintFile r stmt, DeclStatement r stmt bod,
 AssignStatement r stmt, ControlStatement r stmt bod, Literal r,
 NumericExpression r, Comparison r, VariableValue r, List r,
 TypeElim r, InternalIOStmt r stmt) =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MS (r stmt)
G.print Bool
newLn Maybe (SValue r)
f SValue r
printFn SValue r
v
        printMaybeNewLn :: SValue r -> StateT MethodState Identity (r stmt)
printMaybeNewLn = if Bool
newLn then SValue r -> StateT MethodState Identity (r stmt)
forall (r :: * -> *) stmt.
PrintConsole r stmt =>
SValue r -> MS (r stmt)
printLn else SValue r -> StateT MethodState Identity (r stmt)
forall (r :: * -> *) stmt.
PrintConsole r stmt =>
SValue r -> MS (r stmt)
print