{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE PostfixOperators #-}

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

import Utils.Drasil (indent)

import GOOL.Drasil.CodeType (CodeType(..))
import GOOL.Drasil.ClassInterface (Label, MSBody, VSType, SVariable, SValue, 
  VSFunction, MSStatement, MSParameter, SMethod, OOProg, ProgramSym(..), 
  FileSym(..), PermanenceSym(..), BodySym(..), oneLiner, BlockSym(..), 
  TypeSym(..), TypeElim(..), VariableSym(..), VariableElim(..), ValueSym(..), 
  Argument(..), Literal(..), MathConstant(..), VariableValue(..), 
  CommandLineArgs(..), NumericExpression(..), BooleanExpression(..), 
  Comparison(..), ValueExpression(..), funcApp, selfFuncApp, extFuncApp, 
  newObj, InternalValueExp(..), objMethodCallNoParams, FunctionSym(..), ($.), 
  GetSet(..), List(..), InternalList(..), StatementSym(..), 
  AssignStatement(..), (&=), DeclStatement(..), IOStatement(..), 
  StringStatement(..), FuncAppStatement(..), CommentStatement(..), 
  ControlStatement(..), StatePattern(..), ObserverPattern(..), 
  StrategyPattern(..), ScopeSym(..), ParameterSym(..), MethodSym(..), 
  StateVarSym(..), ClassSym(..), ModuleSym(..))
import GOOL.Drasil.RendererClasses (RenderSym, RenderFile(..), ImportSym(..), 
  ImportElim, PermElim(binding), RenderBody(..), BodyElim, RenderBlock(..), 
  BlockElim, RenderType(..), InternalTypeElim, UnaryOpSym(..), BinaryOpSym(..), 
  OpElim(uOpPrec, bOpPrec), RenderVariable(..), InternalVarElim(variableBind), 
  RenderValue(..), ValueElim(valuePrec), InternalGetSet(..), InternalListFunc(..), 
  RenderFunction(..), FunctionElim(functionType), InternalAssignStmt(..), 
  InternalIOStmt(..), InternalControlStmt(..), RenderStatement(..), 
  StatementElim(statementTerm), RenderScope(..), ScopeElim, MethodTypeSym(..), 
  RenderParam(..), ParamElim(parameterName, parameterType), RenderMethod(..), 
  MethodElim, StateVarElim, RenderClass(..), ClassElim, RenderMod(..), ModuleElim, 
  BlockCommentSym(..), BlockCommentElim)
import qualified GOOL.Drasil.RendererClasses as RC (import', perm, body, block,
  type', uOp, bOp, variable, value, function, statement, scope, parameter,
  method, stateVar, class', module', blockComment')
import GOOL.Drasil.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, appendToBody, surroundBody)
import qualified GOOL.Drasil.LanguageRenderer as R (class', multiStmt, body, 
  printFile, param, method, listDec, classVar, func, cast, listSetFunc, 
  castObj, static, dynamic, break, continue, private, public, blockCmt, docCmt, 
  addComments, commentedMod, commentedItem)
import GOOL.Drasil.LanguageRenderer.Constructors (mkStmt, 
  mkStateVal, mkVal, VSOp, unOpPrec, powerPrec, unExpr, unExpr', 
  unExprNumDbl, typeUnExpr, binExpr, binExprNumDbl', typeBinExpr)
import qualified GOOL.Drasil.LanguageRenderer.LanguagePolymorphic as G (
  multiBody, block, multiBlock, listInnerType, obj, csc, sec, cot, 
  negateOp, equalOp, notEqualOp, greaterOp, greaterEqualOp, lessOp, 
  lessEqualOp, plusOp, minusOp, multOp, divideOp, moduloOp, var, staticVar, 
  objVar, arrayElem, litChar, litDouble, litInt, litString, valueOf, arg, 
  argsList, objAccess, objMethodCall, call, funcAppMixedArgs, 
  selfFuncAppMixedArgs, newObjMixedArgs, lambda, func, get, set, listAdd, 
  listAppend, listAccess, listSet, getFunc, setFunc, listAppendFunc, stmt, 
  loopStmt, emptyStmt, assign, subAssign, increment, objDecNew, print, 
  closeFile, returnStmt, valStmt, comment, throw, ifCond, tryCatch, construct, 
  param, method, getMethod, setMethod, function, buildClass, implementingClass, 
  commentedClass, modFromData, fileDoc, fileFromData)
import qualified GOOL.Drasil.LanguageRenderer.CommonPseudoOO as CP (int,
  constructor, doxFunc, doxClass, doxMod, extVar, classVar, objVarSelf,
  extFuncAppMixedArgs, indexOf, listAddFunc, discardFileLine, intClass, 
  arrayType, pi, printSt, arrayDec, arrayDecDef, openFileA, forEach, docMain, 
  mainFunction, buildModule', string, constDecDef, docInOutFunc, bindingError, 
  notNull, listDecDef, destructorError, stateVarDef, constVar, listSetFunc, 
  extraClass, listAccessFunc, doubleRender, openFileR, openFileW, stateVar, 
  inherit, implements)
import qualified GOOL.Drasil.LanguageRenderer.CLike as C (float, double, char, 
  listType, void, notOp, andOp, orOp, self, litTrue, litFalse, litFloat, 
  inlineIf, libFuncAppMixedArgs, libNewObjMixedArgs, listSize, increment1, 
  decrement1, varDec, varDecDef, listDec, extObjDecNew, switch, for, while, 
  intFunc, multiAssignError, multiReturnError, multiTypeError)
import qualified GOOL.Drasil.LanguageRenderer.Macros as M (ifExists, 
  runStrategy, listSlice, stringListVals, stringListLists, forRange, 
  notifyObservers, checkState)
import GOOL.Drasil.AST (Terminator(..), FileType(..), FileData(..), fileD, 
  FuncData(..), fd, ModData(..), md, updateMod, MethodData(..), mthd, 
  updateMthd, OpData(..), ParamData(..), pd, updateParam, ProgData(..), progD, 
  TypeData(..), td, ValData(..), vd, updateValDoc, Binding(..), VarData(..), 
  vard)
import GOOL.Drasil.Helpers (angles, hicat, toCode, toState, onCodeValue, 
  onStateValue, on2CodeValues, on2StateValues, on3CodeValues, on3StateValues, 
  on2StateWrapped, onCodeList, onStateList)
import GOOL.Drasil.State (VS, lensGStoFS, lensMStoVS, modifyReturn, revFiles,
  addLangImport, addLangImportVS, setFileType, getClassName, setCurrMain)

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)

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

newtype CSharpCode a = CSC {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
/= :: CSharpCode a -> CSharpCode a -> Bool
$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
Eq

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

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

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

instance OOProg CSharpCode where

instance ProgramSym CSharpCode where
  type Program CSharpCode = ProgData
  prog :: String -> [SFile CSharpCode] -> GSProgram CSharpCode
prog n :: String
n files :: [SFile CSharpCode]
files = do
    [CSharpCode FileData]
fs <- (StateT FileState Identity (CSharpCode FileData)
 -> StateT GOOLState Identity (CSharpCode FileData))
-> [StateT FileState Identity (CSharpCode FileData)]
-> StateT GOOLState Identity [CSharpCode FileData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (LensLike'
  (Zoomed (StateT FileState Identity) (CSharpCode FileData))
  GOOLState
  FileState
-> StateT FileState Identity (CSharpCode FileData)
-> StateT GOOLState Identity (CSharpCode FileData)
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
Lens' GOOLState FileState
lensGStoFS) [StateT FileState Identity (CSharpCode FileData)]
[SFile CSharpCode]
files
    (GOOLState -> GOOLState) -> StateT GOOLState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify GOOLState -> GOOLState
revFiles
    CSharpCode ProgData
-> StateT GOOLState Identity (CSharpCode ProgData)
forall (m :: * -> *) a. Monad m => a -> m a
return (CSharpCode ProgData
 -> StateT GOOLState Identity (CSharpCode ProgData))
-> CSharpCode ProgData
-> StateT GOOLState Identity (CSharpCode ProgData)
forall a b. (a -> b) -> a -> b
$ ([FileData] -> ProgData)
-> [CSharpCode FileData] -> CSharpCode ProgData
forall (m :: * -> *) a b. Monad m => ([a] -> b) -> [m a] -> m b
onCodeList (String -> [FileData] -> ProgData
progD String
n) [CSharpCode FileData]
fs

instance RenderSym CSharpCode

instance FileSym CSharpCode where
  type File CSharpCode = FileData
  fileDoc :: FSModule CSharpCode -> SFile CSharpCode
fileDoc m :: FSModule CSharpCode
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 (Module CSharpCode)
    -> CSharpCode (Block CSharpCode))
-> CSharpCode (Block CSharpCode)
-> FSModule CSharpCode
-> SFile CSharpCode
forall (r :: * -> *).
RenderSym r =>
String
-> (r (Module r) -> r (Block r))
-> r (Block r)
-> FSModule r
-> SFile r
G.fileDoc String
csExt CSharpCode (Module CSharpCode) -> CSharpCode (Block CSharpCode)
forall (r :: * -> *). RenderFile r => r (Module r) -> r (Block r)
top CSharpCode (Block CSharpCode)
forall (r :: * -> *). RenderFile r => r (Block r)
bottom FSModule CSharpCode
m

  docMod :: String
-> [String] -> String -> SFile CSharpCode -> SFile CSharpCode
docMod = String
-> String
-> [String]
-> String
-> SFile CSharpCode
-> SFile CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> String -> [String] -> String -> SFile r -> SFile r
CP.doxMod String
csExt

instance RenderFile CSharpCode where
  top :: CSharpCode (Module CSharpCode) -> CSharpCode (Block CSharpCode)
top _ = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty
  bottom :: CSharpCode (Block CSharpCode)
bottom = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
empty

  commentedMod :: SFile CSharpCode
-> FS (CSharpCode (BlockComment CSharpCode)) -> SFile CSharpCode
commentedMod = (CSharpCode FileData -> CSharpCode Doc -> CSharpCode FileData)
-> StateT FileState Identity (CSharpCode FileData)
-> State FileState (CSharpCode Doc)
-> StateT FileState Identity (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 -> FSModule CSharpCode -> SFile CSharpCode
fileFromData = (String
 -> CSharpCode (Module CSharpCode) -> CSharpCode (File CSharpCode))
-> String -> FSModule CSharpCode -> SFile CSharpCode
forall (r :: * -> *).
RenderSym r =>
(String -> r (Module r) -> r (File r))
-> String -> FSModule r -> SFile r
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
  type Import CSharpCode = Doc
  langImport :: String -> CSharpCode (Import CSharpCode)
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 (Import CSharpCode)
modImport = String -> CSharpCode (Import CSharpCode)
forall (r :: * -> *). ImportSym r => String -> r (Import r)
langImport

instance ImportElim CSharpCode where
  import' :: CSharpCode (Import CSharpCode) -> Doc
import' = CSharpCode (Import CSharpCode) -> Doc
forall a. CSharpCode a -> a
unCSC

instance PermanenceSym CSharpCode where
  type Permanence CSharpCode = Doc
  static :: CSharpCode (Permanence CSharpCode)
static = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.static
  dynamic :: CSharpCode (Permanence CSharpCode)
dynamic = Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
R.dynamic

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

instance BodySym CSharpCode where
  type Body CSharpCode = Doc
  body :: [MSBlock CSharpCode] -> MSBody CSharpCode
body = ([CSharpCode Doc] -> CSharpCode Doc)
-> [State MethodState (CSharpCode Doc)]
-> State MethodState (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 -> MSBody CSharpCode -> MSBody CSharpCode
addComments s :: String
s = (CSharpCode Doc -> CSharpCode Doc)
-> State MethodState (CSharpCode Doc)
-> State MethodState (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 where
  multiBody :: [MSBody CSharpCode] -> MSBody CSharpCode
multiBody = [MSBody CSharpCode] -> MSBody CSharpCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
[MSBody r] -> MS (r Doc)
G.multiBody 

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

instance BlockSym CSharpCode where
  type Block CSharpCode = Doc
  block :: [MSStatement CSharpCode] -> MSBlock CSharpCode
block = [MSStatement CSharpCode] -> MSBlock CSharpCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
[MSStatement r] -> MS (r Doc)
G.block

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

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

instance TypeSym CSharpCode where
  type Type CSharpCode = TypeData
  bool :: VSType CSharpCode
bool = VS (CSharpCode TypeData) -> VS (CSharpCode TypeData)
forall a. VS a -> VS a
addSystemImport VS (CSharpCode TypeData)
forall (r :: * -> *). RenderSym r => VSType r
csBoolType
  int :: VSType CSharpCode
int = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
CP.int
  float :: VSType CSharpCode
float = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
C.float
  double :: VSType CSharpCode
double = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
C.double
  char :: VSType CSharpCode
char = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
C.char
  string :: VSType CSharpCode
string = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
CP.string
  infile :: VSType CSharpCode
infile = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
csInfileType
  outfile :: VSType CSharpCode
outfile = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
csOutfileType
  listType :: VSType CSharpCode -> VSType CSharpCode
listType t :: VSType CSharpCode
t = do
    (ValueState -> ValueState) -> StateT ValueState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> ValueState -> ValueState
addLangImportVS String
csGeneric) 
    String -> VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). RenderSym r => String -> VSType r -> VSType r
C.listType String
csList VSType CSharpCode
t
  arrayType :: VSType CSharpCode -> VSType CSharpCode
arrayType = VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r -> VSType r
CP.arrayType
  listInnerType :: VSType CSharpCode -> VSType CSharpCode
listInnerType = VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r -> VSType r
G.listInnerType
  obj :: String -> VSType CSharpCode
obj = String -> VSType CSharpCode
forall (r :: * -> *). RenderSym r => String -> VSType r
G.obj
  funcType :: [VSType CSharpCode] -> VSType CSharpCode -> VSType CSharpCode
funcType = [VSType CSharpCode] -> VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *).
RenderSym r =>
[VSType r] -> VSType r -> VSType r
csFuncType
  void :: VSType CSharpCode
void = VSType CSharpCode
forall (r :: * -> *). RenderSym r => VSType r
C.void

instance TypeElim CSharpCode where
  getType :: CSharpCode (Type CSharpCode) -> CodeType
getType = 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
  getTypeString :: CSharpCode (Type CSharpCode) -> String
getTypeString = TypeData -> String
typeString (TypeData -> String)
-> (CSharpCode TypeData -> TypeData)
-> CSharpCode TypeData
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode TypeData -> TypeData
forall a. CSharpCode a -> a
unCSC
  
instance RenderType CSharpCode where
  multiType :: [VSType CSharpCode] -> VSType CSharpCode
multiType _ = String -> VSType CSharpCode
forall a. HasCallStack => String -> a
error (String -> VSType CSharpCode) -> String -> VSType CSharpCode
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiTypeError String
csName
  typeFromData :: CodeType -> String -> Doc -> VSType CSharpCode
typeFromData t :: CodeType
t s :: String
s d :: Doc
d = CSharpCode TypeData -> VSType CSharpCode
forall a s. a -> State s a
toState (CSharpCode TypeData -> VSType CSharpCode)
-> CSharpCode TypeData -> VSType CSharpCode
forall a b. (a -> b) -> a -> b
$ TypeData -> CSharpCode TypeData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (TypeData -> CSharpCode TypeData)
-> TypeData -> CSharpCode TypeData
forall a b. (a -> b) -> a -> b
$ CodeType -> String -> Doc -> TypeData
td CodeType
t String
s Doc
d

instance InternalTypeElim CSharpCode where
  type' :: CSharpCode (Type CSharpCode) -> Doc
type' = TypeData -> Doc
typeDoc (TypeData -> Doc)
-> (CSharpCode TypeData -> TypeData) -> CSharpCode TypeData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode TypeData -> TypeData
forall a. CSharpCode a -> a
unCSC

instance UnaryOpSym CSharpCode where
  type UnaryOp CSharpCode = OpData
  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 -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Sqrt"
  absOp :: VSUnOp CSharpCode
absOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Abs"
  logOp :: VSUnOp CSharpCode
logOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Log10"
  lnOp :: VSUnOp CSharpCode
lnOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Log"
  expOp :: VSUnOp CSharpCode
expOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Exp"
  sinOp :: VSUnOp CSharpCode
sinOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Sin"
  cosOp :: VSUnOp CSharpCode
cosOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Cos"
  tanOp :: VSUnOp CSharpCode
tanOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Tan"
  asinOp :: VSUnOp CSharpCode
asinOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Asin"
  acosOp :: VSUnOp CSharpCode
acosOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Acos"
  atanOp :: VSUnOp CSharpCode
atanOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Atan"
  floorOp :: VSUnOp CSharpCode
floorOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Floor"
  ceilOp :: VSUnOp CSharpCode
ceilOp = String -> VSOp CSharpCode
forall (r :: * -> *). Monad r => String -> VSOp r
csUnaryMath "Ceiling"

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

instance OpElim CSharpCode where
  uOp :: CSharpCode (UnaryOp CSharpCode) -> 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 (BinaryOp CSharpCode) -> 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 (UnaryOp CSharpCode) -> 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 (BinaryOp CSharpCode) -> 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 VariableSym CSharpCode where
  type Variable CSharpCode = VarData
  var :: String -> VSType CSharpCode -> SVariable CSharpCode
var = String -> VSType CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> VSType r -> SVariable r
G.var
  staticVar :: String -> VSType CSharpCode -> SVariable CSharpCode
staticVar = String -> VSType CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> VSType r -> SVariable r
G.staticVar
  const :: String -> VSType CSharpCode -> SVariable CSharpCode
const = String -> VSType CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
VariableSym r =>
String -> VSType r -> SVariable r
var
  extVar :: String -> String -> VSType CSharpCode -> SVariable CSharpCode
extVar = String -> String -> VSType CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> String -> VSType r -> SVariable r
CP.extVar
  self :: SVariable CSharpCode
self = SVariable CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r
C.self
  classVar :: VSType CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
classVar = (Doc -> Doc -> Doc)
-> VSType CSharpCode
-> SVariable CSharpCode
-> SVariable CSharpCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc -> Doc) -> VSType r -> SVariable r -> SVariable r
CP.classVar Doc -> Doc -> Doc
R.classVar
  extClassVar :: VSType CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
extClassVar = VSType CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
VariableSym r =>
VSType r -> SVariable r -> SVariable r
classVar
  objVar :: SVariable CSharpCode
-> SVariable CSharpCode -> SVariable CSharpCode
objVar = SVariable CSharpCode
-> SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> SVariable r -> SVariable r
G.objVar
  objVarSelf :: SVariable CSharpCode -> SVariable CSharpCode
objVarSelf = SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> SVariable r
CP.objVarSelf
  arrayElem :: Integer -> SVariable CSharpCode -> SVariable CSharpCode
arrayElem i :: Integer
i = SValue CSharpCode -> SVariable CSharpCode -> SVariable CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SVariable r -> SVariable r
G.arrayElem (Integer -> SValue CSharpCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
i)

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

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

instance RenderVariable CSharpCode where
  varFromData :: Binding
-> String -> VSType CSharpCode -> Doc -> SVariable CSharpCode
varFromData b :: Binding
b n :: String
n t' :: VSType CSharpCode
t' d :: Doc
d = do 
    CSharpCode TypeData
t <- VS (CSharpCode TypeData)
VSType CSharpCode
t'
    CSharpCode VarData -> State ValueState (CSharpCode VarData)
forall a s. a -> State s a
toState (CSharpCode VarData -> State ValueState (CSharpCode VarData))
-> CSharpCode VarData -> State ValueState (CSharpCode VarData)
forall a b. (a -> b) -> a -> b
$ (TypeData -> Doc -> VarData)
-> CSharpCode TypeData -> CSharpCode Doc -> CSharpCode VarData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues (Binding -> String -> TypeData -> Doc -> VarData
vard Binding
b String
n) CSharpCode TypeData
t (Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
d)

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

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 :: * -> *). RenderSym r => SValue r
C.litTrue
  litFalse :: SValue CSharpCode
litFalse = SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r
C.litFalse
  litChar :: Char -> SValue CSharpCode
litChar = (Doc -> Doc) -> Char -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc) -> Char -> SValue r
G.litChar Doc -> Doc
quotes
  litDouble :: Double -> SValue CSharpCode
litDouble = Double -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => Double -> SValue r
G.litDouble
  litFloat :: Float -> SValue CSharpCode
litFloat = Float -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => Float -> SValue r
C.litFloat
  litInt :: Integer -> SValue CSharpCode
litInt = Integer -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => Integer -> SValue r
G.litInt
  litString :: String -> SValue CSharpCode
litString = String -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => String -> SValue r
G.litString
  litArray :: VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
litArray = (VSType CSharpCode -> VSType CSharpCode)
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
(VSType r -> VSType r) -> VSType r -> [SValue r] -> SValue r
csLitList VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
arrayType
  litList :: VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
litList = (VSType CSharpCode -> VSType CSharpCode)
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
(VSType r -> VSType r) -> VSType r -> [SValue r] -> SValue r
csLitList VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
listType

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

instance VariableValue CSharpCode where
  valueOf :: SVariable CSharpCode -> SValue CSharpCode
valueOf = SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> SValue r
G.valueOf

instance CommandLineArgs CSharpCode where
  arg :: Integer -> SValue CSharpCode
arg n :: Integer
n = SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym 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 :: * -> *). RenderSym r => String -> SValue r
G.argsList String
args
  argExists :: Integer -> SValue CSharpCode
argExists i :: 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
VSUnOp r -> SValue r -> SValue r
unExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
absOp
  #+ :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(#+) = VSBinOp CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp
  #- :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(#-) = VSBinOp CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
minusOp
  #* :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(#*) = VSBinOp CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp
  #/ :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(#/) = VSBinOp CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
divideOp
  #% :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(#%) = VSBinOp CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
moduloOp
  #^ :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(#^) = VSBinOp CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> SValue r -> SValue r -> SValue r
binExprNumDbl' VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp

  log :: SValue CSharpCode -> SValue CSharpCode
log = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *). RenderSym r => SValue r -> SValue r
G.csc
  sec :: SValue CSharpCode -> SValue CSharpCode
sec = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
G.sec
  cot :: SValue CSharpCode -> SValue CSharpCode
cot = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
G.cot
  arcsin :: SValue CSharpCode -> SValue CSharpCode
arcsin = VSUnOp CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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 :: * -> *).
RenderSym 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
-> VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSUnOp r -> VSType r -> SValue r -> SValue r
typeUnExpr VSUnOp CSharpCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
notOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?&& :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?&&) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
andOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?|| :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?||) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
orOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool

instance Comparison CSharpCode where
  ?< :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?<) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?<= :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?<=) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
lessEqualOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?> :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?>) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?>= :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?>=) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
greaterEqualOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?== :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?==) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
equalOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool
  ?!= :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
(?!=) = VSBinOp CSharpCode
-> VSType CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSBinOp r -> VSType r -> SValue r -> SValue r -> SValue r
typeBinExpr VSBinOp CSharpCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
notEqualOp VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
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 :: * -> *).
RenderSym r =>
SValue r -> SValue r -> SValue r -> SValue r
C.inlineIf

  funcAppMixedArgs :: MixedCall CSharpCode
funcAppMixedArgs = MixedCall CSharpCode
forall (r :: * -> *). RenderSym r => MixedCall r
G.funcAppMixedArgs
  selfFuncAppMixedArgs :: MixedCall CSharpCode
selfFuncAppMixedArgs = Doc -> SVariable CSharpCode -> MixedCall CSharpCode
forall (r :: * -> *).
RenderSym r =>
Doc -> SVariable r -> MixedCall r
G.selfFuncAppMixedArgs Doc
dot SVariable CSharpCode
forall (r :: * -> *). VariableSym r => SVariable r
self
  extFuncAppMixedArgs :: String -> MixedCall CSharpCode
extFuncAppMixedArgs = String -> MixedCall CSharpCode
forall (r :: * -> *). RenderSym r => String -> MixedCall r
CP.extFuncAppMixedArgs
  libFuncAppMixedArgs :: String -> MixedCall CSharpCode
libFuncAppMixedArgs = String -> MixedCall CSharpCode
forall (r :: * -> *). RenderSym r => String -> MixedCall r
C.libFuncAppMixedArgs
  newObjMixedArgs :: MixedCtorCall CSharpCode
newObjMixedArgs = MixedCall CSharpCode
forall (r :: * -> *). RenderSym r => MixedCall r
G.newObjMixedArgs (String
new String -> String -> String
forall a. [a] -> [a] -> [a]
++ " ")
  extNewObjMixedArgs :: MixedCall CSharpCode
extNewObjMixedArgs _ = MixedCtorCall CSharpCode
forall (r :: * -> *). ValueExpression r => MixedCtorCall r
newObjMixedArgs
  libNewObjMixedArgs :: MixedCall CSharpCode
libNewObjMixedArgs = MixedCall CSharpCode
forall (r :: * -> *). RenderSym r => MixedCall r
C.libNewObjMixedArgs

  lambda :: [SVariable CSharpCode] -> SValue CSharpCode -> SValue CSharpCode
lambda = ([CSharpCode (Variable CSharpCode)]
 -> CSharpCode (Value CSharpCode) -> Doc)
-> [SVariable CSharpCode] -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
([r (Variable r)] -> r (Value r) -> Doc)
-> [SVariable r] -> SValue r -> SValue r
G.lambda [CSharpCode (Variable CSharpCode)]
-> CSharpCode (Value CSharpCode) -> Doc
forall (r :: * -> *).
RenderSym r =>
[r (Variable r)] -> r (Value r) -> Doc
csLambda

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

instance RenderValue CSharpCode where
  inputFunc :: SValue CSharpCode
inputFunc = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
forall a. VS a -> VS a
addSystemImport VS (CSharpCode ValData)
SValue CSharpCode
csReadLineFunc
  printFunc :: SValue CSharpCode
printFunc = VS (CSharpCode ValData) -> SValue CSharpCode
forall a. VS a -> VS a
addSystemImport (VS (CSharpCode ValData) -> SValue CSharpCode)
-> VS (CSharpCode ValData) -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ VSType CSharpCode -> Doc -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
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 = VS (CSharpCode ValData) -> SValue CSharpCode
forall a. VS a -> VS a
addSystemImport (VS (CSharpCode ValData) -> SValue CSharpCode)
-> VS (CSharpCode ValData) -> SValue CSharpCode
forall a b. (a -> b) -> a -> b
$ VSType CSharpCode -> Doc -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => VSType r -> Doc -> SValue r
mkStateVal VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
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 w' :: SValue CSharpCode
w' = (CSharpCode ValData
 -> CSharpCode TypeData -> VS (CSharpCode ValData))
-> VS (CSharpCode ValData)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode ValData)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\w :: CSharpCode ValData
w vt :: CSharpCode TypeData
vt -> 
    CSharpCode (Type CSharpCode) -> Doc -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => r (Type r) -> Doc -> SValue r
mkVal CSharpCode TypeData
CSharpCode (Type CSharpCode)
vt (Doc -> VS (CSharpCode ValData))
-> (CSharpCode ValData -> Doc)
-> CSharpCode ValData
-> VS (CSharpCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
csWrite (Doc -> Doc)
-> (CSharpCode ValData -> Doc) -> CSharpCode ValData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ValData -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value (CSharpCode ValData -> VS (CSharpCode ValData))
-> CSharpCode ValData -> VS (CSharpCode ValData)
forall a b. (a -> b) -> a -> b
$ CSharpCode ValData
w) VS (CSharpCode ValData)
SValue CSharpCode
w' VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VSType r
void
  printFileLnFunc :: SValue CSharpCode -> SValue CSharpCode
printFileLnFunc w' :: SValue CSharpCode
w' = (CSharpCode ValData
 -> CSharpCode TypeData -> VS (CSharpCode ValData))
-> VS (CSharpCode ValData)
-> VS (CSharpCode TypeData)
-> VS (CSharpCode ValData)
forall (m :: * -> *) a b c.
Monad m =>
(a -> b -> m c) -> m a -> m b -> m c
on2StateWrapped (\w :: CSharpCode ValData
w vt :: CSharpCode TypeData
vt -> 
    CSharpCode (Type CSharpCode) -> Doc -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => r (Type r) -> Doc -> SValue r
mkVal CSharpCode TypeData
CSharpCode (Type CSharpCode)
vt (Doc -> VS (CSharpCode ValData))
-> (CSharpCode ValData -> Doc)
-> CSharpCode ValData
-> VS (CSharpCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc -> Doc
R.printFile String
csWriteLine (Doc -> Doc)
-> (CSharpCode ValData -> Doc) -> CSharpCode ValData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ValData -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value (CSharpCode ValData -> VS (CSharpCode ValData))
-> CSharpCode ValData -> VS (CSharpCode ValData)
forall a b. (a -> b) -> a -> b
$ CSharpCode ValData
w) VS (CSharpCode ValData)
SValue CSharpCode
w' VS (CSharpCode TypeData)
forall (r :: * -> *). TypeSym r => VSType r
void
  
  cast :: VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
cast = VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csCast

  call :: Maybe String -> Maybe Doc -> MixedCall CSharpCode
call = Doc -> Maybe String -> Maybe Doc -> MixedCall CSharpCode
forall (r :: * -> *).
RenderSym r =>
Doc -> Maybe String -> Maybe Doc -> MixedCall r
G.call Doc
csNamedArgSep
  
  valFromData :: Maybe Int -> VSType CSharpCode -> Doc -> SValue CSharpCode
valFromData p :: Maybe Int
p t' :: VSType CSharpCode
t' d :: Doc
d = do 
    CSharpCode TypeData
t <- VS (CSharpCode TypeData)
VSType CSharpCode
t' 
    CSharpCode ValData -> VS (CSharpCode ValData)
forall a s. a -> State s a
toState (CSharpCode ValData -> VS (CSharpCode ValData))
-> CSharpCode ValData -> VS (CSharpCode ValData)
forall a b. (a -> b) -> a -> b
$ (TypeData -> Doc -> ValData)
-> CSharpCode TypeData -> CSharpCode Doc -> CSharpCode ValData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues (Maybe Int -> TypeData -> Doc -> ValData
vd Maybe Int
p) CSharpCode TypeData
t (Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
d)
  
instance ValueElim CSharpCode where
  valuePrec :: CSharpCode (Value CSharpCode) -> Maybe Int
valuePrec = ValData -> Maybe Int
valPrec (ValData -> Maybe Int)
-> (CSharpCode ValData -> ValData)
-> CSharpCode ValData
-> Maybe Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ValData -> ValData
forall a. CSharpCode a -> a
unCSC
  value :: CSharpCode (Value CSharpCode) -> Doc
value = ValData -> Doc
val (ValData -> Doc)
-> (CSharpCode ValData -> ValData) -> CSharpCode ValData -> Doc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CSharpCode ValData -> ValData
forall a. CSharpCode a -> a
unCSC
  
instance InternalValueExp CSharpCode where
  objMethodCallMixedArgs' :: String
-> VSType CSharpCode
-> SValue CSharpCode
-> [SValue CSharpCode]
-> NamedArgs CSharpCode
-> SValue CSharpCode
objMethodCallMixedArgs' = String
-> VSType CSharpCode
-> SValue CSharpCode
-> [SValue CSharpCode]
-> NamedArgs CSharpCode
-> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
String
-> VSType r -> SValue r -> [SValue r] -> NamedArgs r -> SValue r
G.objMethodCall

instance FunctionSym CSharpCode where
  type Function CSharpCode = FuncData
  func :: String
-> VSType CSharpCode
-> [SValue CSharpCode]
-> VSFunction CSharpCode
func = String
-> VSType CSharpCode
-> [SValue CSharpCode]
-> VSFunction CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> VSType r -> [SValue r] -> VSFunction r
G.func
  objAccess :: SValue CSharpCode -> VSFunction CSharpCode -> SValue CSharpCode
objAccess = SValue CSharpCode -> VSFunction CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> VSFunction r -> SValue r
G.objAccess

instance GetSet CSharpCode where
  get :: SValue CSharpCode -> SVariable CSharpCode -> SValue CSharpCode
get = SValue CSharpCode -> SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym 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 :: * -> *).
RenderSym r =>
SValue r -> SVariable r -> SValue r -> SValue r
G.set

instance List CSharpCode where
  listSize :: SValue CSharpCode -> SValue CSharpCode
listSize = SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
C.listSize
  listAdd :: SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
listAdd = SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SValue r -> SValue r -> SValue r
G.listAdd
  listAppend :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
listAppend = SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SValue r -> SValue r
G.listAppend
  listAccess :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
listAccess = SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SValue r -> SValue r
G.listAccess
  listSet :: SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
listSet = SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SValue r -> SValue r -> SValue r
G.listSet
  indexOf :: SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
indexOf = String
-> SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> SValue r -> SValue r
CP.indexOf String
csIndex
  
instance InternalList CSharpCode where
  listSlice' :: Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSBlock CSharpCode
listSlice' = Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> Maybe (SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSBlock CSharpCode
forall (r :: * -> *).
RenderSym r =>
Maybe (SValue r)
-> Maybe (SValue r)
-> Maybe (SValue r)
-> SVariable r
-> SValue r
-> MSBlock r
M.listSlice

instance InternalGetSet CSharpCode where
  getFunc :: SVariable CSharpCode -> VSFunction CSharpCode
getFunc = SVariable CSharpCode -> VSFunction CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> VSFunction r
G.getFunc
  setFunc :: VSType CSharpCode
-> SVariable CSharpCode
-> SValue CSharpCode
-> VSFunction CSharpCode
setFunc = VSType CSharpCode
-> SVariable CSharpCode
-> SValue CSharpCode
-> VSFunction CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSType r -> SVariable r -> SValue r -> VSFunction r
G.setFunc

instance InternalListFunc CSharpCode where
  listSizeFunc :: VSFunction CSharpCode
listSizeFunc = Doc -> VSType CSharpCode -> VSFunction CSharpCode
forall (r :: * -> *).
RenderFunction r =>
Doc -> VSType r -> VSFunction r
funcFromData (Doc -> Doc
R.func Doc
csListSize) VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
int
  listAddFunc :: SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> VSFunction CSharpCode
listAddFunc _ = String
-> SValue CSharpCode -> SValue CSharpCode -> VSFunction CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> SValue r -> VSFunction r
CP.listAddFunc String
csListAdd
  listAppendFunc :: SValue CSharpCode -> VSFunction CSharpCode
listAppendFunc = String -> SValue CSharpCode -> VSFunction CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> VSFunction r
G.listAppendFunc String
csListAppend
  listAccessFunc :: VSType CSharpCode -> SValue CSharpCode -> VSFunction CSharpCode
listAccessFunc = VSType CSharpCode -> SValue CSharpCode -> VSFunction CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSType r -> SValue r -> VSFunction r
CP.listAccessFunc
  listSetFunc :: SValue CSharpCode
-> SValue CSharpCode -> SValue CSharpCode -> VSFunction CSharpCode
listSetFunc = (Doc -> Doc -> Doc)
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> VSFunction CSharpCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc -> Doc)
-> SValue r -> SValue r -> SValue r -> VSFunction r
CP.listSetFunc Doc -> Doc -> Doc
R.listSetFunc
    
instance RenderFunction CSharpCode where
  funcFromData :: Doc -> VSType CSharpCode -> VSFunction CSharpCode
funcFromData d :: Doc
d = (CSharpCode TypeData -> CSharpCode FuncData)
-> VS (CSharpCode TypeData)
-> State ValueState (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 (Function CSharpCode) -> CSharpCode (Type CSharpCode)
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 (Function CSharpCode) -> 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 where
  multiAssign :: [SVariable CSharpCode]
-> [SValue CSharpCode] -> MSStatement CSharpCode
multiAssign _ _ = String -> MSStatement CSharpCode
forall a. HasCallStack => String -> a
error (String -> MSStatement CSharpCode)
-> String -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiAssignError String
csName

instance InternalIOStmt CSharpCode where
  printSt :: Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
printSt _ _ = SValue CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SValue r -> MSStatement r
CP.printSt
  
instance InternalControlStmt CSharpCode where
  multiReturn :: [SValue CSharpCode] -> MSStatement CSharpCode
multiReturn _ = String -> MSStatement CSharpCode
forall a. HasCallStack => String -> a
error (String -> MSStatement CSharpCode)
-> String -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ String -> String
C.multiReturnError String
csName 

instance RenderStatement CSharpCode where
  stmt :: MSStatement CSharpCode -> MSStatement CSharpCode
stmt = MSStatement CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => MSStatement r -> MSStatement r
G.stmt
  loopStmt :: MSStatement CSharpCode -> MSStatement CSharpCode
loopStmt = MSStatement CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => MSStatement r -> MSStatement r
G.loopStmt

  emptyStmt :: MSStatement CSharpCode
emptyStmt = MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => MSStatement r
G.emptyStmt
  
  stmtFromData :: Doc -> Terminator -> MSStatement CSharpCode
stmtFromData d :: Doc
d t :: Terminator
t = CSharpCode (Doc, Terminator) -> MSStatement CSharpCode
forall a s. a -> State s a
toState (CSharpCode (Doc, Terminator) -> MSStatement CSharpCode)
-> CSharpCode (Doc, Terminator) -> MSStatement CSharpCode
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 where
  statement :: CSharpCode (Statement CSharpCode) -> 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 (Statement CSharpCode) -> 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 StatementSym CSharpCode where
  type Statement CSharpCode = (Doc, Terminator)
  valStmt :: SValue CSharpCode -> MSStatement CSharpCode
valStmt = Terminator -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Terminator -> SValue r -> MSStatement r
G.valStmt Terminator
Semi
  multi :: [MSStatement CSharpCode] -> MSStatement CSharpCode
multi = ([CSharpCode (Doc, Terminator)] -> CSharpCode (Doc, Terminator))
-> [State MethodState (CSharpCode (Doc, Terminator))]
-> State MethodState (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 AssignStatement CSharpCode where
  assign :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
assign = Terminator
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Terminator -> SVariable r -> SValue r -> MSStatement r
G.assign Terminator
Semi
  &-= :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
(&-=) = Terminator
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Terminator -> SVariable r -> SValue r -> MSStatement r
G.subAssign Terminator
Semi
  &+= :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
(&+=) = SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> SValue r -> MSStatement r
G.increment
  &++ :: SVariable CSharpCode -> MSStatement CSharpCode
(&++) = SVariable CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> MSStatement r
C.increment1
  &-- :: SVariable CSharpCode -> MSStatement CSharpCode
(&--) = SVariable CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> MSStatement r
C.decrement1

instance DeclStatement CSharpCode where
  varDec :: SVariable CSharpCode -> MSStatement CSharpCode
varDec v :: SVariable CSharpCode
v = LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode VarData))
  MethodState
  ValueState
-> State ValueState (CSharpCode VarData)
-> StateT MethodState Identity (CSharpCode VarData)
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 VarData))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS State ValueState (CSharpCode VarData)
SVariable CSharpCode
v StateT MethodState Identity (CSharpCode VarData)
-> (CSharpCode VarData
    -> State MethodState (CSharpCode (Doc, Terminator)))
-> State MethodState (CSharpCode (Doc, Terminator))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\v' :: CSharpCode VarData
v' -> Binding -> MSStatement CSharpCode -> MSStatement CSharpCode
csVarDec (CSharpCode (Variable CSharpCode) -> Binding
forall (r :: * -> *).
InternalVarElim r =>
r (Variable r) -> Binding
variableBind CSharpCode VarData
CSharpCode (Variable CSharpCode)
v') (MSStatement CSharpCode
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> MSStatement CSharpCode
-> State MethodState (CSharpCode (Doc, Terminator))
forall a b. (a -> b) -> a -> b
$ 
    CSharpCode (Permanence CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> Doc
-> SVariable CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
r (Permanence r)
-> r (Permanence r) -> Doc -> SVariable r -> MSStatement r
C.varDec CSharpCode (Permanence CSharpCode)
forall (r :: * -> *). PermanenceSym r => r (Permanence r)
static CSharpCode (Permanence CSharpCode)
forall (r :: * -> *). PermanenceSym r => r (Permanence r)
dynamic Doc
empty SVariable CSharpCode
v)
  varDecDef :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
varDecDef = Terminator
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Terminator -> SVariable r -> SValue r -> MSStatement r
C.varDecDef Terminator
Semi
  listDec :: Integer -> SVariable CSharpCode -> MSStatement CSharpCode
listDec n :: Integer
n v :: SVariable CSharpCode
v = LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode VarData))
  MethodState
  ValueState
-> State ValueState (CSharpCode VarData)
-> StateT MethodState Identity (CSharpCode VarData)
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 VarData))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS State ValueState (CSharpCode VarData)
SVariable CSharpCode
v StateT MethodState Identity (CSharpCode VarData)
-> (CSharpCode VarData
    -> State MethodState (CSharpCode (Doc, Terminator)))
-> State MethodState (CSharpCode (Doc, Terminator))
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\v' :: CSharpCode VarData
v' -> (CSharpCode (Value CSharpCode) -> Doc)
-> SValue CSharpCode
-> SVariable CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(r (Value r) -> Doc) -> SValue r -> SVariable r -> MSStatement r
C.listDec (CSharpCode (Variable CSharpCode)
-> CSharpCode (Value CSharpCode) -> Doc
forall (r :: * -> *).
RenderSym r =>
r (Variable r) -> r (Value r) -> Doc
R.listDec CSharpCode VarData
CSharpCode (Variable CSharpCode)
v') 
    (Integer -> SValue CSharpCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n) SVariable CSharpCode
v)
  listDecDef :: SVariable CSharpCode
-> [SValue CSharpCode] -> MSStatement CSharpCode
listDecDef = SVariable CSharpCode
-> [SValue CSharpCode] -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SValue r] -> MSStatement r
CP.listDecDef
  arrayDec :: Integer -> SVariable CSharpCode -> MSStatement CSharpCode
arrayDec n :: Integer
n = SValue CSharpCode -> SVariable CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> SVariable r -> MSStatement r
CP.arrayDec (Integer -> SValue CSharpCode
forall (r :: * -> *). Literal r => Integer -> SValue r
litInt Integer
n)
  arrayDecDef :: SVariable CSharpCode
-> [SValue CSharpCode] -> MSStatement CSharpCode
arrayDecDef = SVariable CSharpCode
-> [SValue CSharpCode] -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SValue r] -> MSStatement r
CP.arrayDecDef
  objDecDef :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
objDecDef = SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> SValue r -> MSStatement r
varDecDef
  objDecNew :: SVariable CSharpCode
-> [SValue CSharpCode] -> MSStatement CSharpCode
objDecNew = SVariable CSharpCode
-> [SValue CSharpCode] -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SValue r] -> MSStatement r
G.objDecNew
  extObjDecNew :: String
-> SVariable CSharpCode
-> [SValue CSharpCode]
-> MSStatement CSharpCode
extObjDecNew = String
-> SVariable CSharpCode
-> [SValue CSharpCode]
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> SVariable r -> [SValue r] -> MSStatement r
C.extObjDecNew
  constDecDef :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
constDecDef = SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> SValue r -> MSStatement r
CP.constDecDef
  funcDecDef :: SVariable CSharpCode
-> [SVariable CSharpCode]
-> MSBody CSharpCode
-> MSStatement CSharpCode
funcDecDef = SVariable CSharpCode
-> [SVariable CSharpCode]
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r -> [SVariable r] -> MSBody r -> MSStatement r
csFuncDecDef

instance IOStatement CSharpCode where
  print :: SValue CSharpCode -> MSStatement CSharpCode
print      = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
False Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc
  printLn :: SValue CSharpCode -> MSStatement CSharpCode
printLn    = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
True  Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc
  printStr :: String -> MSStatement CSharpCode
printStr   = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
False Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printFunc   (VS (CSharpCode ValData)
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> (String -> VS (CSharpCode ValData))
-> String
-> State MethodState (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode ValData)
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printStrLn :: String -> MSStatement CSharpCode
printStrLn = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
True  Maybe (SValue CSharpCode)
forall a. Maybe a
Nothing SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
printLnFunc (VS (CSharpCode ValData)
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> (String -> VS (CSharpCode ValData))
-> String
-> State MethodState (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode ValData)
forall (r :: * -> *). Literal r => String -> SValue r
litString

  printFile :: SValue CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
printFile f :: SValue CSharpCode
f      = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
False (VS (CSharpCode ValData) -> Maybe (VS (CSharpCode ValData))
forall a. a -> Maybe a
Just VS (CSharpCode ValData)
SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue CSharpCode
f)
  printFileLn :: SValue CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
printFileLn f :: SValue CSharpCode
f    = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
True  (VS (CSharpCode ValData) -> Maybe (VS (CSharpCode ValData))
forall a. a -> Maybe a
Just VS (CSharpCode ValData)
SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue CSharpCode
f)
  printFileStr :: SValue CSharpCode -> String -> MSStatement CSharpCode
printFileStr f :: SValue CSharpCode
f   = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
False (VS (CSharpCode ValData) -> Maybe (VS (CSharpCode ValData))
forall a. a -> Maybe a
Just VS (CSharpCode ValData)
SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileFunc SValue CSharpCode
f)   (VS (CSharpCode ValData)
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> (String -> VS (CSharpCode ValData))
-> String
-> State MethodState (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode ValData)
forall (r :: * -> *). Literal r => String -> SValue r
litString
  printFileStrLn :: SValue CSharpCode -> String -> MSStatement CSharpCode
printFileStrLn f :: SValue CSharpCode
f = Bool
-> Maybe (SValue CSharpCode)
-> SValue CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool -> Maybe (SValue r) -> SValue r -> SValue r -> MSStatement r
G.print Bool
True  (VS (CSharpCode ValData) -> Maybe (VS (CSharpCode ValData))
forall a. a -> Maybe a
Just VS (CSharpCode ValData)
SValue CSharpCode
f) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r -> SValue r
printFileLnFunc SValue CSharpCode
f) (VS (CSharpCode ValData)
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> (String -> VS (CSharpCode ValData))
-> String
-> State MethodState (CSharpCode (Doc, Terminator))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (CSharpCode ValData)
forall (r :: * -> *). Literal r => String -> SValue r
litString

  getInput :: SVariable CSharpCode -> MSStatement CSharpCode
getInput v :: SVariable CSharpCode
v = SVariable CSharpCode
v SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csInput ((CSharpCode VarData -> CSharpCode TypeData)
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (CSharpCode VarData)
SVariable CSharpCode
v) SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc
  discardInput :: MSStatement CSharpCode
discardInput = SValue CSharpCode -> MSStatement CSharpCode
csDiscardInput SValue CSharpCode
forall (r :: * -> *). RenderValue r => SValue r
inputFunc
  getFileInput :: SValue CSharpCode -> SVariable CSharpCode -> MSStatement CSharpCode
getFileInput f :: SValue CSharpCode
f v :: SVariable CSharpCode
v = SVariable CSharpCode
v SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
&= VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csInput ((CSharpCode VarData -> CSharpCode TypeData)
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (CSharpCode VarData)
SVariable CSharpCode
v) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
csFileInput SValue CSharpCode
f)
  discardFileInput :: SValue CSharpCode -> MSStatement CSharpCode
discardFileInput f :: SValue CSharpCode
f = SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue CSharpCode -> MSStatement CSharpCode)
-> SValue CSharpCode -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
csFileInput SValue CSharpCode
f

  openFileR :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
openFileR = (SValue CSharpCode -> VSType CSharpCode -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(SValue r -> VSType r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileR SValue CSharpCode -> VSType CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> VSType r -> SValue r
csOpenFileR
  openFileW :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
openFileW = (SValue CSharpCode
 -> VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(SValue r -> VSType r -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileW SValue CSharpCode
-> VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> VSType r -> SValue r -> SValue r
csOpenFileWorA
  openFileA :: SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
openFileA = (SValue CSharpCode
 -> VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(SValue r -> VSType r -> SValue r -> SValue r)
-> SVariable r -> SValue r -> MSStatement r
CP.openFileA SValue CSharpCode
-> VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> VSType r -> SValue r -> SValue r
csOpenFileWorA
  closeFile :: SValue CSharpCode -> MSStatement CSharpCode
closeFile = String -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> MSStatement r
G.closeFile String
csClose

  getFileInputLine :: SValue CSharpCode -> SVariable CSharpCode -> MSStatement CSharpCode
getFileInputLine = SValue CSharpCode -> SVariable CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
IOStatement r =>
SValue r -> SVariable r -> MSStatement r
getFileInput
  discardFileLine :: SValue CSharpCode -> MSStatement CSharpCode
discardFileLine = String -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> SValue r -> MSStatement r
CP.discardFileLine String
csReadLine
  getFileInputAll :: SValue CSharpCode -> SVariable CSharpCode -> MSStatement CSharpCode
getFileInputAll f :: SValue CSharpCode
f v :: SVariable CSharpCode
v = SValue CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSBody r -> MSStatement r
while ((SValue CSharpCode
f SValue CSharpCode -> VSFunction CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. Doc -> VSType CSharpCode -> VSFunction CSharpCode
forall (r :: * -> *).
RenderFunction r =>
Doc -> VSType r -> VSFunction r
funcFromData (Doc
dot Doc -> Doc -> Doc
<> String -> Doc
text String
csEOS) VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
bool) SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). BooleanExpression r => SValue r -> SValue r
?!)
    (MSStatement CSharpCode -> MSBody CSharpCode
forall (r :: * -> *). BodySym r => MSStatement r -> MSBody r
oneLiner (MSStatement CSharpCode -> MSBody CSharpCode)
-> MSStatement CSharpCode -> MSBody CSharpCode
forall a b. (a -> b) -> a -> b
$ SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue CSharpCode -> MSStatement CSharpCode)
-> SValue CSharpCode -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ SValue CSharpCode -> SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). List r => SValue r -> SValue r -> SValue r
listAppend (SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable CSharpCode
v) (SValue CSharpCode -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => SValue r -> SValue r
csFileInput SValue CSharpCode
f))

instance StringStatement CSharpCode where
  stringSplit :: Char
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
stringSplit d :: Char
d vnew :: SVariable CSharpCode
vnew s :: SValue CSharpCode
s = SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign SVariable CSharpCode
vnew (SValue CSharpCode -> MSStatement CSharpCode)
-> SValue CSharpCode -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => PosCtorCall r
newObj (VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
listType VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
string) 
    [SValue CSharpCode
s SValue CSharpCode -> VSFunction CSharpCode -> SValue CSharpCode
forall (r :: * -> *).
FunctionSym r =>
SValue r -> VSFunction r -> SValue r
$. Char -> VSFunction CSharpCode
csSplitFunc Char
d]

  stringListVals :: [SVariable CSharpCode]
-> SValue CSharpCode -> MSStatement CSharpCode
stringListVals = [SVariable CSharpCode]
-> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
[SVariable r] -> SValue r -> MSStatement r
M.stringListVals
  stringListLists :: [SVariable CSharpCode]
-> SValue CSharpCode -> MSStatement CSharpCode
stringListLists = [SVariable CSharpCode]
-> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
[SVariable r] -> SValue r -> MSStatement r
M.stringListLists

instance FuncAppStatement CSharpCode where
  inOutCall :: InOutCall CSharpCode
inOutCall = (String
 -> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode)
-> InOutCall CSharpCode
csInOutCall String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => PosCall r
funcApp
  selfInOutCall :: InOutCall CSharpCode
selfInOutCall = (String
 -> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode)
-> InOutCall CSharpCode
csInOutCall String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => PosCall r
selfFuncApp
  extInOutCall :: String -> InOutCall CSharpCode
extInOutCall m :: String
m = (String
 -> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode)
-> InOutCall CSharpCode
csInOutCall (String
-> String
-> VSType CSharpCode
-> [SValue CSharpCode]
-> SValue CSharpCode
forall (r :: * -> *). ValueExpression r => String -> PosCall r
extFuncApp String
m)

instance CommentStatement CSharpCode where
  comment :: String -> MSStatement CSharpCode
comment = Doc -> String -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => Doc -> String -> MSStatement r
G.comment Doc
commentStart

instance ControlStatement CSharpCode where
  break :: MSStatement CSharpCode
break =  Doc -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt Doc
R.break
  continue :: MSStatement CSharpCode
continue =  Doc -> MSStatement CSharpCode
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt Doc
R.continue

  returnStmt :: SValue CSharpCode -> MSStatement CSharpCode
returnStmt = Terminator -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Terminator -> SValue r -> MSStatement r
G.returnStmt Terminator
Semi
  
  throw :: String -> MSStatement CSharpCode
throw msg :: 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 CSharpCode) -> Doc)
-> Terminator -> String -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(r (Value r) -> Doc) -> Terminator -> String -> MSStatement r
G.throw CSharpCode (Value CSharpCode) -> Doc
forall (r :: * -> *). RenderSym r => r (Value r) -> Doc
csThrowDoc Terminator
Semi String
msg

  ifCond :: [(SValue CSharpCode, MSBody CSharpCode)]
-> MSBody CSharpCode -> MSStatement CSharpCode
ifCond = (Doc -> Doc)
-> Doc
-> Doc
-> Doc
-> [(SValue CSharpCode, MSBody CSharpCode)]
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc)
-> Doc
-> Doc
-> Doc
-> [(SValue r, MSBody r)]
-> MSBody r
-> MSStatement r
G.ifCond Doc -> Doc
parens Doc
bodyStart Doc
elseIfLabel Doc
bodyEnd
  switch :: SValue CSharpCode
-> [(SValue CSharpCode, MSBody CSharpCode)]
-> MSBody CSharpCode
-> MSStatement CSharpCode
switch = (Doc -> Doc)
-> MSStatement CSharpCode
-> SValue CSharpCode
-> [(SValue CSharpCode, MSBody CSharpCode)]
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc)
-> MSStatement r
-> SValue r
-> [(SValue r, MSBody r)]
-> MSBody r
-> MSStatement r
C.switch Doc -> Doc
parens MSStatement CSharpCode
forall (r :: * -> *). ControlStatement r => MSStatement r
break

  ifExists :: SValue CSharpCode
-> MSBody CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
ifExists = SValue CSharpCode
-> MSBody CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SValue r -> MSBody r -> MSBody r -> MSStatement r
M.ifExists

  for :: MSStatement CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
-> MSBody CSharpCode
-> MSStatement CSharpCode
for = Doc
-> Doc
-> MSStatement CSharpCode
-> SValue CSharpCode
-> MSStatement CSharpCode
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Doc
-> Doc
-> MSStatement r
-> SValue r
-> MSStatement r
-> MSBody r
-> MSStatement r
C.for Doc
bodyStart Doc
bodyEnd
  forRange :: SVariable CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MSBody CSharpCode
-> MSStatement CSharpCode
forRange = SVariable CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> SValue CSharpCode
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
SVariable r
-> SValue r -> SValue r -> SValue r -> MSBody r -> MSStatement r
M.forRange
  forEach :: SVariable CSharpCode
-> SValue CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
forEach = Doc
-> Doc
-> Doc
-> Doc
-> SVariable CSharpCode
-> SValue CSharpCode
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
Doc
-> Doc
-> Doc
-> Doc
-> SVariable r
-> SValue r
-> MSBody r
-> MSStatement r
CP.forEach Doc
bodyStart Doc
bodyEnd Doc
csForEach Doc
inLabel 
  while :: SValue CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
while = (Doc -> Doc)
-> Doc
-> Doc
-> SValue CSharpCode
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(Doc -> Doc) -> Doc -> Doc -> SValue r -> MSBody r -> MSStatement r
C.while Doc -> Doc
parens Doc
bodyStart Doc
bodyEnd

  tryCatch :: MSBody CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
tryCatch = (CSharpCode (Body CSharpCode)
 -> CSharpCode (Body CSharpCode) -> Doc)
-> MSBody CSharpCode -> MSBody CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
(r (Body r) -> r (Body r) -> Doc)
-> MSBody r -> MSBody r -> MSStatement r
G.tryCatch CSharpCode (Body CSharpCode) -> CSharpCode (Body CSharpCode) -> Doc
forall (r :: * -> *).
RenderSym r =>
r (Body r) -> r (Body r) -> Doc
csTryCatch

instance StatePattern CSharpCode where 
  checkState :: String
-> [(SValue CSharpCode, MSBody CSharpCode)]
-> MSBody CSharpCode
-> MSStatement CSharpCode
checkState = String
-> [(SValue CSharpCode, MSBody CSharpCode)]
-> MSBody CSharpCode
-> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> [(SValue r, MSBody r)] -> MSBody r -> MSStatement r
M.checkState

instance ObserverPattern CSharpCode where
  notifyObservers :: VSFunction CSharpCode
-> VSType CSharpCode -> MSStatement CSharpCode
notifyObservers = VSFunction CSharpCode
-> VSType CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSFunction r -> VSType r -> MSStatement r
M.notifyObservers

instance StrategyPattern CSharpCode where
  runStrategy :: String
-> [(String, MSBody CSharpCode)]
-> Maybe (SValue CSharpCode)
-> Maybe (SVariable CSharpCode)
-> MSBlock CSharpCode
runStrategy = String
-> [(String, MSBody CSharpCode)]
-> Maybe (SValue CSharpCode)
-> Maybe (SVariable CSharpCode)
-> MSBlock CSharpCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
String
-> [(String, MSBody r)]
-> Maybe (SValue r)
-> Maybe (SVariable r)
-> MS (r Doc)
M.runStrategy

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

instance RenderScope CSharpCode where
  scopeFromData :: ScopeTag -> Doc -> CSharpCode (Scope CSharpCode)
scopeFromData _ = Doc -> CSharpCode (Scope CSharpCode)
forall (r :: * -> *) a. Monad r => a -> r a
toCode
  
instance ScopeElim CSharpCode where
  scope :: CSharpCode (Scope CSharpCode) -> Doc
scope = CSharpCode (Scope CSharpCode) -> Doc
forall a. CSharpCode a -> a
unCSC

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

instance ParameterSym CSharpCode where
  type Parameter CSharpCode = ParamData
  param :: SVariable CSharpCode -> MSParameter CSharpCode
param = (CSharpCode (Variable CSharpCode) -> Doc)
-> SVariable CSharpCode -> MSParameter CSharpCode
forall (r :: * -> *).
RenderSym r =>
(r (Variable r) -> Doc) -> SVariable r -> MSParameter r
G.param CSharpCode (Variable CSharpCode) -> Doc
forall (r :: * -> *). RenderSym r => r (Variable r) -> Doc
R.param
  pointerParam :: SVariable CSharpCode -> MSParameter CSharpCode
pointerParam = SVariable CSharpCode -> MSParameter CSharpCode
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param

instance RenderParam CSharpCode where
  paramFromData :: SVariable CSharpCode -> Doc -> MSParameter CSharpCode
paramFromData v' :: SVariable CSharpCode
v' d :: Doc
d = do 
    CSharpCode VarData
v <- LensLike'
  (Zoomed (StateT ValueState Identity) (CSharpCode VarData))
  MethodState
  ValueState
-> State ValueState (CSharpCode VarData)
-> StateT MethodState Identity (CSharpCode VarData)
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 VarData))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS State ValueState (CSharpCode VarData)
SVariable CSharpCode
v' 
    CSharpCode ParamData -> State MethodState (CSharpCode ParamData)
forall a s. a -> State s a
toState (CSharpCode ParamData -> State MethodState (CSharpCode ParamData))
-> CSharpCode ParamData -> State MethodState (CSharpCode ParamData)
forall a b. (a -> b) -> a -> b
$ (VarData -> Doc -> ParamData)
-> CSharpCode VarData -> CSharpCode Doc -> CSharpCode ParamData
forall (r :: * -> *) a b c.
Applicative r =>
(a -> b -> c) -> r a -> r b -> r c
on2CodeValues VarData -> Doc -> ParamData
pd CSharpCode VarData
v (Doc -> CSharpCode Doc
forall (r :: * -> *) a. Monad r => a -> r a
toCode Doc
d)

instance ParamElim CSharpCode where
  parameterName :: CSharpCode (Parameter CSharpCode) -> String
parameterName = CSharpCode VarData -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName (CSharpCode VarData -> String)
-> (CSharpCode ParamData -> CSharpCode VarData)
-> CSharpCode ParamData
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> VarData)
-> CSharpCode ParamData -> CSharpCode VarData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> VarData
paramVar
  parameterType :: CSharpCode (Parameter CSharpCode) -> CSharpCode (Type CSharpCode)
parameterType = CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType (CSharpCode VarData -> CSharpCode TypeData)
-> (CSharpCode ParamData -> CSharpCode VarData)
-> CSharpCode ParamData
-> CSharpCode TypeData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ParamData -> VarData)
-> CSharpCode ParamData -> CSharpCode VarData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ParamData -> VarData
paramVar
  parameter :: CSharpCode (Parameter CSharpCode) -> 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 where
  type Method CSharpCode = MethodData
  method :: String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
method = String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
RenderSym r =>
String
-> r (Scope r)
-> r (Permanence r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
G.method
  getMethod :: SVariable CSharpCode -> SMethod CSharpCode
getMethod = SVariable CSharpCode -> SMethod CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> SMethod r
G.getMethod
  setMethod :: SVariable CSharpCode -> SMethod CSharpCode
setMethod = SVariable CSharpCode -> SMethod CSharpCode
forall (r :: * -> *). RenderSym r => SVariable r -> SMethod r
G.setMethod
  constructor :: [MSParameter CSharpCode]
-> NamedArgs CSharpCode -> MSBody CSharpCode -> SMethod CSharpCode
constructor ps :: [MSParameter CSharpCode]
ps is :: NamedArgs CSharpCode
is b :: MSBody CSharpCode
b = MS String
getClassName MS String
-> (String -> StateT MethodState Identity (CSharpCode MethodData))
-> StateT MethodState Identity (CSharpCode MethodData)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\n :: String
n -> String
-> [MSParameter CSharpCode]
-> NamedArgs CSharpCode
-> MSBody CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
RenderSym r =>
String
-> [MSParameter r] -> Initializers r -> MSBody r -> SMethod r
CP.constructor String
n [MSParameter CSharpCode]
ps NamedArgs CSharpCode
is MSBody CSharpCode
b)

  docMain :: MSBody CSharpCode -> SMethod CSharpCode
docMain = MSBody CSharpCode -> SMethod CSharpCode
forall (r :: * -> *). RenderSym r => MSBody r -> SMethod r
CP.docMain
 
  function :: String
-> CSharpCode (Scope CSharpCode)
-> VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
function = String
-> CSharpCode (Scope CSharpCode)
-> VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
RenderSym r =>
String
-> r (Scope r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
G.function
  mainFunction :: MSBody CSharpCode -> SMethod CSharpCode
mainFunction = VSType CSharpCode
-> String -> MSBody CSharpCode -> SMethod CSharpCode
forall (r :: * -> *).
RenderSym r =>
VSType r -> String -> MSBody r -> SMethod r
CP.mainFunction VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
string String
csMain

  docFunc :: String
-> [String]
-> Maybe String
-> SMethod CSharpCode
-> SMethod CSharpCode
docFunc = String
-> [String]
-> Maybe String
-> SMethod CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> [String] -> Maybe String -> SMethod r -> SMethod r
CP.doxFunc

  inOutMethod :: String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> InOutFunc CSharpCode
inOutMethod n :: String
n s :: CSharpCode (Scope CSharpCode)
s p :: CSharpCode (Permanence CSharpCode)
p = (VSType CSharpCode
 -> [MSParameter CSharpCode]
 -> MSBody CSharpCode
 -> SMethod CSharpCode)
-> InOutFunc CSharpCode
csInOut (String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
MethodSym r =>
String
-> r (Scope r)
-> r (Permanence r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
method String
n CSharpCode (Scope CSharpCode)
s CSharpCode (Permanence CSharpCode)
p)

  docInOutMethod :: String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> DocInOutFunc CSharpCode
docInOutMethod n :: String
n s :: CSharpCode (Scope CSharpCode)
s p :: CSharpCode (Permanence CSharpCode)
p = InOutFunc CSharpCode -> DocInOutFunc CSharpCode
forall (r :: * -> *).
RenderSym r =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r)
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MSBody r
-> SMethod r
CP.docInOutFunc (String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> InOutFunc CSharpCode
forall (r :: * -> *).
MethodSym r =>
String -> r (Scope r) -> r (Permanence r) -> InOutFunc r
inOutMethod String
n CSharpCode (Scope CSharpCode)
s CSharpCode (Permanence CSharpCode)
p)

  inOutFunc :: String -> CSharpCode (Scope CSharpCode) -> InOutFunc CSharpCode
inOutFunc n :: String
n s :: CSharpCode (Scope CSharpCode)
s = (VSType CSharpCode
 -> [MSParameter CSharpCode]
 -> MSBody CSharpCode
 -> SMethod CSharpCode)
-> InOutFunc CSharpCode
csInOut (String
-> CSharpCode (Scope CSharpCode)
-> VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
MethodSym r =>
String
-> r (Scope r)
-> VSType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
function String
n CSharpCode (Scope CSharpCode)
s)

  docInOutFunc :: String -> CSharpCode (Scope CSharpCode) -> DocInOutFunc CSharpCode
docInOutFunc n :: String
n s :: CSharpCode (Scope CSharpCode)
s = InOutFunc CSharpCode -> DocInOutFunc CSharpCode
forall (r :: * -> *).
RenderSym r =>
([SVariable r]
 -> [SVariable r] -> [SVariable r] -> MSBody r -> SMethod r)
-> String
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> [(String, SVariable r)]
-> MSBody r
-> SMethod r
CP.docInOutFunc (String -> CSharpCode (Scope CSharpCode) -> InOutFunc CSharpCode
forall (r :: * -> *).
MethodSym r =>
String -> r (Scope r) -> InOutFunc r
inOutFunc String
n CSharpCode (Scope CSharpCode)
s)

instance RenderMethod CSharpCode where
  intMethod :: Bool
-> String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> MSMthdType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
intMethod m :: Bool
m n :: String
n s :: CSharpCode (Scope CSharpCode)
s p :: CSharpCode (Permanence CSharpCode)
p t :: MSMthdType CSharpCode
t ps :: [MSParameter CSharpCode]
ps b :: MSBody CSharpCode
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)
    CSharpCode TypeData
tp <- StateT MethodState Identity (CSharpCode TypeData)
MSMthdType CSharpCode
t
    [CSharpCode ParamData]
pms <- [State MethodState (CSharpCode ParamData)]
-> StateT MethodState Identity [CSharpCode ParamData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [State MethodState (CSharpCode ParamData)]
[MSParameter CSharpCode]
ps
    MethodData -> CSharpCode MethodData
forall (r :: * -> *) a. Monad r => a -> r a
toCode (MethodData -> CSharpCode MethodData)
-> (CSharpCode Doc -> MethodData)
-> CSharpCode Doc
-> CSharpCode MethodData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc -> MethodData
mthd (Doc -> MethodData)
-> (CSharpCode Doc -> Doc) -> CSharpCode Doc -> MethodData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> CSharpCode (Type CSharpCode)
-> [CSharpCode (Parameter CSharpCode)]
-> CSharpCode (Body CSharpCode)
-> Doc
forall (r :: * -> *).
RenderSym r =>
String
-> r (Scope r)
-> r (Permanence r)
-> r (Type r)
-> [r (Parameter r)]
-> r (Body r)
-> Doc
R.method String
n CSharpCode (Scope CSharpCode)
s CSharpCode (Permanence CSharpCode)
p CSharpCode TypeData
CSharpCode (Type CSharpCode)
tp [CSharpCode ParamData]
[CSharpCode (Parameter CSharpCode)]
pms (CSharpCode Doc -> CSharpCode MethodData)
-> State MethodState (CSharpCode Doc)
-> StateT MethodState Identity (CSharpCode MethodData)
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> State MethodState (CSharpCode Doc)
MSBody CSharpCode
b
  intFunc :: Bool
-> String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> MSMthdType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
intFunc = Bool
-> String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> MSMthdType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
forall (r :: * -> *).
RenderSym r =>
Bool
-> String
-> r (Scope r)
-> r (Permanence r)
-> MSMthdType r
-> [MSParameter r]
-> MSBody r
-> SMethod r
C.intFunc
  commentedFunc :: MS (CSharpCode (BlockComment CSharpCode))
-> SMethod CSharpCode -> SMethod CSharpCode
commentedFunc cmt :: MS (CSharpCode (BlockComment CSharpCode))
cmt m :: SMethod CSharpCode
m = (CSharpCode MethodData
 -> CSharpCode (Doc -> Doc) -> CSharpCode MethodData)
-> StateT MethodState Identity (CSharpCode MethodData)
-> State MethodState (CSharpCode (Doc -> Doc))
-> StateT MethodState Identity (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) StateT MethodState Identity (CSharpCode MethodData)
SMethod CSharpCode
m 
    ((CSharpCode Doc -> CSharpCode (Doc -> Doc))
-> State MethodState (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) State MethodState (CSharpCode Doc)
MS (CSharpCode (BlockComment CSharpCode))
cmt)
    
  destructor :: [CSStateVar CSharpCode] -> SMethod CSharpCode
destructor _ = String -> SMethod CSharpCode
forall a. HasCallStack => String -> a
error (String -> SMethod CSharpCode) -> String -> SMethod CSharpCode
forall a b. (a -> b) -> a -> b
$ String -> String
CP.destructorError String
csName
  
  mthdFromData :: ScopeTag -> Doc -> SMethod CSharpCode
mthdFromData _ d :: Doc
d = CSharpCode MethodData -> SMethod CSharpCode
forall a s. a -> State s a
toState (CSharpCode MethodData -> SMethod CSharpCode)
-> CSharpCode MethodData -> SMethod CSharpCode
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
$ Doc -> MethodData
mthd Doc
d
  
instance MethodElim CSharpCode where
  method :: CSharpCode (Method CSharpCode) -> 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 where
  type StateVar CSharpCode = Doc
  stateVar :: CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> SVariable CSharpCode
-> CSStateVar CSharpCode
stateVar = CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> SVariable CSharpCode
-> CSStateVar CSharpCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
r (Scope r) -> r (Permanence r) -> SVariable r -> CS (r Doc)
CP.stateVar
  stateVarDef :: CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode
stateVarDef = CSharpCode (Scope CSharpCode)
-> CSharpCode (Permanence CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
r (Scope r)
-> r (Permanence r) -> SVariable r -> SValue r -> CS (r Doc)
CP.stateVarDef
  constVar :: CSharpCode (Scope CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> CSStateVar CSharpCode
constVar = Doc
-> CSharpCode (Scope CSharpCode)
-> SVariable CSharpCode
-> SValue CSharpCode
-> CS (CSharpCode Doc)
forall (r :: * -> *).
(RenderSym r, Monad r) =>
Doc -> r (Scope r) -> SVariable r -> SValue r -> CS (r Doc)
CP.constVar Doc
empty
  
instance StateVarElim CSharpCode where
  stateVar :: CSharpCode (StateVar CSharpCode) -> Doc
stateVar = CSharpCode (StateVar CSharpCode) -> Doc
forall a. CSharpCode a -> a
unCSC

instance ClassSym CSharpCode where
  type Class CSharpCode = Doc
  buildClass :: Maybe String
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
buildClass = Maybe String
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
forall (r :: * -> *).
RenderSym r =>
Maybe String -> [CSStateVar r] -> [SMethod r] -> SClass r
G.buildClass
  extraClass :: String
-> Maybe String
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
extraClass = String
-> Maybe String
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> Maybe String -> [CSStateVar r] -> [SMethod r] -> SClass r
CP.extraClass 
  implementingClass :: String
-> [String]
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
implementingClass = String
-> [String]
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
forall (r :: * -> *).
RenderSym r =>
String -> [String] -> [CSStateVar r] -> [SMethod r] -> SClass r
G.implementingClass

  docClass :: String -> SClass CSharpCode -> SClass CSharpCode
docClass = String -> SClass CSharpCode -> SClass CSharpCode
forall (r :: * -> *). RenderSym r => String -> SClass r -> SClass r
CP.doxClass

instance RenderClass CSharpCode where
  intClass :: String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode Doc
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> SClass CSharpCode
intClass = (String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> CSharpCode (Scope CSharpCode)
-> CSharpCode Doc
-> [CSStateVar CSharpCode]
-> [SMethod CSharpCode]
-> CS (CSharpCode Doc)
forall (r :: * -> *).
(RenderSym r, Monad r) =>
(String -> Doc -> Doc -> Doc -> Doc -> Doc)
-> String
-> r (Scope r)
-> r Doc
-> [CSStateVar r]
-> [SMethod r]
-> 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 :: CS (CSharpCode (BlockComment CSharpCode))
-> SClass CSharpCode -> SClass CSharpCode
commentedClass = CS (CSharpCode (BlockComment CSharpCode))
-> SClass CSharpCode -> SClass CSharpCode
forall (r :: * -> *).
(RenderSym r, Monad r) =>
CS (r (BlockComment r)) -> SClass r -> CS (r Doc)
G.commentedClass
  
instance ClassElim CSharpCode where
  class' :: CSharpCode (Class CSharpCode) -> Doc
class' = CSharpCode (Class CSharpCode) -> Doc
forall a. CSharpCode a -> a
unCSC

instance ModuleSym CSharpCode where
  type Module CSharpCode = ModData
  buildModule :: String
-> [String]
-> [SMethod CSharpCode]
-> [SClass CSharpCode]
-> FSModule CSharpCode
buildModule n :: String
n = String
-> (String -> CSharpCode (Import CSharpCode))
-> [String]
-> [SMethod CSharpCode]
-> [SClass CSharpCode]
-> FSModule CSharpCode
forall (r :: * -> *).
RenderSym r =>
String
-> (String -> r (Import r))
-> [String]
-> [SMethod r]
-> [SClass r]
-> FSModule r
CP.buildModule' String
n String -> CSharpCode (Import CSharpCode)
forall (r :: * -> *). ImportSym r => String -> r (Import r)
langImport
  
instance RenderMod CSharpCode where
  modFromData :: String -> FS Doc -> FSModule CSharpCode
modFromData n :: String
n = String
-> (Doc -> CSharpCode (Module CSharpCode))
-> FS Doc
-> FSModule CSharpCode
forall (r :: * -> *).
String -> (Doc -> r (Module r)) -> FS Doc -> FSModule r
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 (Module CSharpCode) -> CSharpCode (Module CSharpCode)
updateModuleDoc f :: 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 where
  module' :: CSharpCode (Module CSharpCode) -> 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
  type BlockComment CSharpCode = Doc
  blockComment :: [String] -> CSharpCode (BlockComment CSharpCode)
blockComment lns :: [String]
lns = Doc -> CSharpCode (BlockComment CSharpCode)
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Doc -> CSharpCode (BlockComment CSharpCode))
-> Doc -> CSharpCode (BlockComment CSharpCode)
forall a b. (a -> b) -> a -> b
$ [String] -> Doc -> Doc -> Doc
R.blockCmt [String]
lns Doc
blockCmtStart Doc
blockCmtEnd
  docComment :: State a [String] -> State a (CSharpCode (BlockComment CSharpCode))
docComment = ([String] -> CSharpCode Doc)
-> State a [String] -> State a (CSharpCode Doc)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue (\lns :: [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 (BlockComment CSharpCode) -> Doc
blockComment' = CSharpCode (BlockComment CSharpCode) -> Doc
forall a. CSharpCode a -> a
unCSC

addSystemImport :: VS a -> VS a
addSystemImport :: VS a -> VS a
addSystemImport = StateT ValueState Identity () -> VS a -> VS a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
(>>) (StateT ValueState Identity () -> VS a -> VS a)
-> StateT ValueState Identity () -> VS a -> VS 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 = "C#"
csVersion :: String
csVersion = "6.0"

csImport :: Label -> Doc
csImport :: String -> Doc
csImport n :: String
n = String -> Doc
text ("using " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
n) Doc -> Doc -> Doc
<> Doc
endStatement

csBoolType :: (RenderSym r) => VSType r
csBoolType :: VSType r
csBoolType = CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData CodeType
Boolean String
csBool (String -> Doc
text String
csBool)

csFuncType :: (RenderSym r) => [VSType r] -> VSType r -> VSType r
csFuncType :: [VSType r] -> VSType r -> VSType r
csFuncType ps :: [VSType r]
ps r :: VSType r
r = do
  [r (Type r)]
pts <- [VSType r] -> StateT ValueState Identity [r (Type r)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [VSType r]
ps
  r (Type r)
rt <- VSType r
r
  CodeType -> String -> Doc -> VSType r
forall (r :: * -> *).
RenderType r =>
CodeType -> String -> Doc -> VSType r
typeFromData ([CodeType] -> CodeType -> CodeType
Func ((r (Type r) -> CodeType) -> [r (Type r)] -> [CodeType]
forall a b. (a -> b) -> [a] -> [b]
map r (Type r) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType [r (Type r)]
pts) (r (Type r) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType r (Type r)
rt))
    (String
csFunc String -> String -> String
`containing` String -> [String] -> String
forall a. [a] -> [[a]] -> [a]
intercalate String
listSep ((r (Type r) -> String) -> [r (Type r)] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map r (Type r) -> String
forall (r :: * -> *). TypeElim r => r (Type r) -> String
getTypeString ([r (Type r)] -> [String]) -> [r (Type r)] -> [String]
forall a b. (a -> b) -> a -> b
$ [r (Type r)]
pts [r (Type r)] -> [r (Type r)] -> [r (Type r)]
forall a. [a] -> [a] -> [a]
++ [r (Type r)
rt]))
    (String -> Doc
text String
csFunc Doc -> Doc -> Doc
<> Doc -> Doc
angles (Doc -> [Doc] -> Doc
hicat Doc
listSep' ([Doc] -> Doc) -> [Doc] -> Doc
forall a b. (a -> b) -> a -> b
$ (r (Type r) -> Doc) -> [r (Type r)] -> [Doc]
forall a b. (a -> b) -> [a] -> [b]
map r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' ([r (Type r)] -> [Doc]) -> [r (Type r)] -> [Doc]
forall a b. (a -> b) -> a -> b
$ [r (Type r)]
pts [r (Type r)] -> [r (Type r)] -> [r (Type r)]
forall a. [a] -> [a] -> [a]
++ [r (Type r)
rt]))

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

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

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

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

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

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

csLitList :: (RenderSym r) => (VSType r -> VSType r) -> VSType r -> [SValue r] 
  -> SValue r
csLitList :: (VSType r -> VSType r) -> VSType r -> [SValue r] -> SValue r
csLitList f :: VSType r -> VSType r
f t' :: VSType r
t' es' :: [SValue r]
es' = do 
  [r (Value r)]
es <- [SValue r] -> StateT ValueState Identity [r (Value r)]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [SValue r]
es' 
  r (Type r)
lt <- VSType r -> VSType r
f VSType r
t'
  r (Type r) -> Doc -> SValue r
forall (r :: * -> *). RenderSym r => r (Type r) -> Doc -> SValue r
mkVal r (Type r)
lt (Doc
new' Doc -> Doc -> Doc
<+> r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' r (Type r)
lt
    Doc -> Doc -> Doc
<+> Doc -> Doc
braces ([r (Value r)] -> Doc
forall (r :: * -> *). RenderSym r => [r (Value r)] -> Doc
valueList [r (Value r)]
es))

csLambda :: (RenderSym r) => [r (Variable r)] -> r (Value r) -> Doc
csLambda :: [r (Variable r)] -> r (Value r) -> Doc
csLambda ps :: [r (Variable r)]
ps ex :: r (Value r)
ex = Doc -> Doc
parens ([r (Variable r)] -> Doc
forall (r :: * -> *). RenderSym r => [r (Variable r)] -> Doc
variableList [r (Variable r)]
ps) Doc -> Doc -> Doc
<+> Doc
csLambdaSep Doc -> Doc -> Doc
<+> r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
ex

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

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

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

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

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

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

csSplitFunc :: Char -> VSFunction CSharpCode
csSplitFunc :: Char -> VSFunction CSharpCode
csSplitFunc d :: Char
d = String
-> VSType CSharpCode
-> [SValue CSharpCode]
-> VSFunction CSharpCode
forall (r :: * -> *).
FunctionSym r =>
String -> VSType r -> [SValue r] -> VSFunction r
func String
csSplit (VSType CSharpCode -> VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r -> VSType r
listType VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
string) [Char -> SValue CSharpCode
forall (r :: * -> *). Literal r => Char -> SValue r
litChar Char
d]

csCast :: VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csCast :: VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csCast = StateT ValueState Identity (VS (CSharpCode ValData))
-> VS (CSharpCode ValData)
forall (m :: * -> *) a. Monad m => m (m a) -> m a
join (StateT ValueState Identity (VS (CSharpCode ValData))
 -> VS (CSharpCode ValData))
-> (VS (CSharpCode TypeData)
    -> VS (CSharpCode ValData)
    -> StateT ValueState Identity (VS (CSharpCode ValData)))
-> VS (CSharpCode TypeData)
-> VS (CSharpCode ValData)
-> VS (CSharpCode ValData)
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.: (CSharpCode TypeData
 -> CSharpCode ValData -> VS (CSharpCode ValData))
-> VS (CSharpCode TypeData)
-> VS (CSharpCode ValData)
-> StateT ValueState Identity (VS (CSharpCode ValData))
forall a b c s.
(a -> b -> c) -> State s a -> State s b -> State s c
on2StateValues (\t :: CSharpCode TypeData
t v :: CSharpCode ValData
v -> CodeType
-> CodeType
-> CSharpCode TypeData
-> CSharpCode ValData
-> VS (CSharpCode ValData)
csCast' (CSharpCode (Type CSharpCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType CSharpCode TypeData
CSharpCode (Type CSharpCode)
t) (CSharpCode (Type CSharpCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType (CSharpCode (Type CSharpCode) -> CodeType)
-> CSharpCode (Type CSharpCode) -> CodeType
forall a b. (a -> b) -> a -> b
$ 
  CSharpCode (Value CSharpCode) -> CSharpCode (Type CSharpCode)
forall (r :: * -> *). ValueSym r => r (Value r) -> r (Type r)
valueType CSharpCode ValData
CSharpCode (Value CSharpCode)
v) CSharpCode TypeData
t CSharpCode ValData
v)
  where csCast' :: CodeType
-> CodeType
-> CSharpCode TypeData
-> CSharpCode ValData
-> VS (CSharpCode ValData)
csCast' Double String _ v :: CSharpCode ValData
v = SValue CSharpCode -> SValue CSharpCode
csDblParse (CSharpCode ValData -> VS (CSharpCode ValData)
forall a s. a -> State s a
toState CSharpCode ValData
v)
        csCast' Float String _ v :: CSharpCode ValData
v = SValue CSharpCode -> SValue CSharpCode
csFloatParse (CSharpCode ValData -> VS (CSharpCode ValData)
forall a s. a -> State s a
toState CSharpCode ValData
v)
        csCast' _ _ t :: CSharpCode TypeData
t v :: CSharpCode ValData
v = VSType CSharpCode -> Doc -> SValue CSharpCode
forall (r :: * -> *). RenderSym r => VSType r -> 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 (Type CSharpCode) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' CSharpCode TypeData
CSharpCode (Type CSharpCode)
t)) (CSharpCode (Value CSharpCode) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value CSharpCode ValData
CSharpCode (Value CSharpCode)
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 :: (RenderSym r) => SVariable r -> [SVariable r] -> MSBody r -> 
  MSStatement r
csFuncDecDef :: SVariable r -> [SVariable r] -> MSBody r -> MSStatement r
csFuncDecDef v :: SVariable r
v ps :: [SVariable r]
ps bod :: MSBody r
bod = do
  r (Variable r)
vr <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS SVariable r
v
  [r (Variable r)]
pms <- (SVariable r -> StateT MethodState Identity (r (Variable r)))
-> [SVariable r] -> StateT MethodState Identity [r (Variable r)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
-> SVariable r -> StateT MethodState Identity (r (Variable r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Variable r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS) [SVariable r]
ps
  r (Type r)
t <- LensLike'
  (Zoomed (StateT ValueState Identity) (r (Type r)))
  MethodState
  ValueState
-> StateT ValueState Identity (r (Type r))
-> StateT MethodState Identity (r (Type r))
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (r (Type r)))
  MethodState
  ValueState
Lens' MethodState ValueState
lensMStoVS (StateT ValueState Identity (r (Type r))
 -> StateT MethodState Identity (r (Type r)))
-> StateT ValueState Identity (r (Type r))
-> StateT MethodState Identity (r (Type r))
forall a b. (a -> b) -> a -> b
$ [StateT ValueState Identity (r (Type r))]
-> StateT ValueState Identity (r (Type r))
-> StateT ValueState Identity (r (Type r))
forall (r :: * -> *).
TypeSym r =>
[VSType r] -> VSType r -> VSType r
funcType ((r (Variable r) -> StateT ValueState Identity (r (Type r)))
-> [r (Variable r)] -> [StateT ValueState Identity (r (Type r))]
forall a b. (a -> b) -> [a] -> [b]
map (r (Type r) -> StateT ValueState Identity (r (Type r))
forall (m :: * -> *) a. Monad m => a -> m a
return (r (Type r) -> StateT ValueState Identity (r (Type r)))
-> (r (Variable r) -> r (Type r))
-> r (Variable r)
-> StateT ValueState Identity (r (Type r))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType) [r (Variable r)]
pms) 
    (r (Type r) -> StateT ValueState Identity (r (Type r))
forall (m :: * -> *) a. Monad m => a -> m a
return (r (Type r) -> StateT ValueState Identity (r (Type r)))
-> r (Type r) -> StateT ValueState Identity (r (Type r))
forall a b. (a -> b) -> a -> b
$ r (Variable r) -> r (Type r)
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType r (Variable r)
vr)
  r (Body r)
b <- MSBody r
bod
  (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> MethodState -> MethodState
addLangImport String
csSystem)
  Doc -> MSStatement r
forall (r :: * -> *). RenderSym r => Doc -> MSStatement r
mkStmt (Doc -> MSStatement r) -> Doc -> MSStatement r
forall a b. (a -> b) -> a -> b
$ r (Type r) -> Doc
forall (r :: * -> *). InternalTypeElim r => r (Type r) -> Doc
RC.type' r (Type r)
t Doc -> Doc -> Doc
<+> String -> Doc
text (r (Variable r) -> String
forall (r :: * -> *). VariableElim r => r (Variable r) -> String
variableName r (Variable r)
vr) Doc -> Doc -> Doc
<+> Doc
equals Doc -> Doc -> Doc
<+>
    Doc -> Doc
parens ([r (Variable r)] -> Doc
forall (r :: * -> *). RenderSym r => [r (Variable r)] -> Doc
variableList [r (Variable r)]
pms) Doc -> Doc -> Doc
<+> Doc
csLambdaSep Doc -> Doc -> Doc
<+> Doc
bodyStart Doc -> Doc -> Doc
$$ 
    Doc -> Doc
indent (r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
b) Doc -> Doc -> Doc
$$ Doc
bodyEnd 

csThrowDoc :: (RenderSym r) => r (Value r) -> Doc
csThrowDoc :: r (Value r) -> Doc
csThrowDoc errMsg :: r (Value r)
errMsg = Doc
throwLabel Doc -> Doc -> Doc
<+> Doc
new' Doc -> Doc -> Doc
<+> Doc
exceptionObj' Doc -> Doc -> Doc
<> 
  Doc -> Doc
parens (r (Value r) -> Doc
forall (r :: * -> *). ValueElim r => r (Value r) -> Doc
RC.value r (Value r)
errMsg)

csTryCatch :: (RenderSym r) => r (Body r) -> r (Body r) -> Doc
csTryCatch :: r (Body r) -> r (Body r) -> Doc
csTryCatch tb :: r (Body r)
tb cb :: r (Body r)
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
$ r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
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
$ r (Body r) -> Doc
forall (r :: * -> *). BodyElim r => r (Body r) -> Doc
RC.body r (Body r)
cb,
  Doc
rbrace]

csDiscardInput :: SValue CSharpCode -> MSStatement CSharpCode
csDiscardInput :: SValue CSharpCode -> MSStatement CSharpCode
csDiscardInput = SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt

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

csInput :: VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csInput :: VSType CSharpCode -> SValue CSharpCode -> SValue CSharpCode
csInput tp :: VSType CSharpCode
tp inFn :: SValue CSharpCode
inFn = do
  CSharpCode TypeData
t <- VS (CSharpCode TypeData)
VSType CSharpCode
tp
  CodeType -> VS (CSharpCode ValData) -> VS (CSharpCode ValData)
forall a. CodeType -> VS a -> VS a
csInputImport (CSharpCode (Type CSharpCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType CSharpCode TypeData
CSharpCode (Type CSharpCode)
t) (CodeType -> VS (CSharpCode ValData) -> VS (CSharpCode ValData)
csInput' (CSharpCode (Type CSharpCode) -> CodeType
forall (r :: * -> *). TypeElim r => r (Type r) -> CodeType
getType CSharpCode TypeData
CSharpCode (Type CSharpCode)
t) VS (CSharpCode ValData)
SValue CSharpCode
inFn)
  where csInput' :: CodeType -> VS (CSharpCode ValData) -> VS (CSharpCode ValData)
csInput' Integer = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
SValue CSharpCode -> SValue CSharpCode
csIntParse
        csInput' Float = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
SValue CSharpCode -> SValue CSharpCode
csFloatParse
        csInput' Double = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
SValue CSharpCode -> SValue CSharpCode
csDblParse
        csInput' Boolean = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
SValue CSharpCode -> SValue CSharpCode
csBoolParse
        csInput' String = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
forall a. a -> a
id
        csInput' Char = VS (CSharpCode ValData) -> VS (CSharpCode ValData)
SValue CSharpCode -> SValue CSharpCode
csCharParse
        csInput' _ = String -> VS (CSharpCode ValData) -> VS (CSharpCode ValData)
forall a. HasCallStack => String -> a
error "Attempt to read value of unreadable type"
        csInputImport :: CodeType -> VS a -> VS a
csInputImport t :: CodeType
t = if CodeType
t CodeType -> [CodeType] -> 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 :: (RenderSym r) => SValue r -> VSType r -> SValue r
csOpenFileR :: SValue r -> VSType r -> SValue r
csOpenFileR n :: SValue r
n r :: VSType r
r = PosCtorCall r
forall (r :: * -> *). ValueExpression r => PosCtorCall r
newObj VSType r
r [SValue r
n]

csOpenFileWorA :: (RenderSym r) => SValue r -> VSType r -> SValue r -> SValue r
csOpenFileWorA :: SValue r -> VSType r -> SValue r -> SValue r
csOpenFileWorA n :: SValue r
n w :: VSType r
w a :: SValue r
a = PosCtorCall r
forall (r :: * -> *). ValueExpression r => PosCtorCall r
newObj VSType r
w [SValue r
n, SValue r
a] 

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

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

csInOutCall :: (Label -> VSType CSharpCode -> [SValue CSharpCode] -> 
  SValue CSharpCode) -> Label -> [SValue CSharpCode] -> [SVariable CSharpCode] 
  -> [SVariable CSharpCode] -> MSStatement CSharpCode
csInOutCall :: (String
 -> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode)
-> InOutCall CSharpCode
csInOutCall f :: String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
f n :: String
n ins :: [SValue CSharpCode]
ins [out :: SVariable CSharpCode
out] [] = SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign SVariable CSharpCode
out (SValue CSharpCode -> MSStatement CSharpCode)
-> SValue CSharpCode -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
f String
n ((CSharpCode VarData -> CSharpCode TypeData)
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (CSharpCode VarData)
SVariable CSharpCode
out) 
  [SValue CSharpCode]
ins
csInOutCall f :: String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
f n :: String
n ins :: [SValue CSharpCode]
ins [] [out :: SVariable CSharpCode
out] = SVariable CSharpCode -> SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *).
AssignStatement r =>
SVariable r -> SValue r -> MSStatement r
assign SVariable CSharpCode
out (SValue CSharpCode -> MSStatement CSharpCode)
-> SValue CSharpCode -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
f String
n ((CSharpCode VarData -> CSharpCode TypeData)
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (CSharpCode VarData)
SVariable CSharpCode
out) 
  (SVariable CSharpCode -> SValue CSharpCode
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf SVariable CSharpCode
out VS (CSharpCode ValData)
-> [VS (CSharpCode ValData)] -> [VS (CSharpCode ValData)]
forall a. a -> [a] -> [a]
: [VS (CSharpCode ValData)]
[SValue CSharpCode]
ins)
csInOutCall f :: String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
f n :: String
n ins :: [SValue CSharpCode]
ins outs :: [SVariable CSharpCode]
outs both :: [SVariable CSharpCode]
both = SValue CSharpCode -> MSStatement CSharpCode
forall (r :: * -> *). StatementSym r => SValue r -> MSStatement r
valStmt (SValue CSharpCode -> MSStatement CSharpCode)
-> SValue CSharpCode -> MSStatement CSharpCode
forall a b. (a -> b) -> a -> b
$ String
-> VSType CSharpCode -> [SValue CSharpCode] -> SValue CSharpCode
f String
n VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
void ((State ValueState (CSharpCode VarData) -> VS (CSharpCode ValData))
-> [State ValueState (CSharpCode VarData)]
-> [VS (CSharpCode ValData)]
forall a b. (a -> b) -> [a] -> [b]
map ((CSharpCode ValData -> CSharpCode ValData)
-> VS (CSharpCode ValData) -> VS (CSharpCode ValData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue 
  ((ValData -> ValData) -> CSharpCode ValData -> CSharpCode ValData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Doc -> Doc) -> ValData -> ValData
updateValDoc Doc -> Doc
csRef)) (VS (CSharpCode ValData) -> VS (CSharpCode ValData))
-> (State ValueState (CSharpCode VarData)
    -> VS (CSharpCode ValData))
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State ValueState (CSharpCode VarData) -> VS (CSharpCode ValData)
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf) [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
both [VS (CSharpCode ValData)]
-> [VS (CSharpCode ValData)] -> [VS (CSharpCode ValData)]
forall a. [a] -> [a] -> [a]
++ [VS (CSharpCode ValData)]
[SValue CSharpCode]
ins [VS (CSharpCode ValData)]
-> [VS (CSharpCode ValData)] -> [VS (CSharpCode ValData)]
forall a. [a] -> [a] -> [a]
++ (State ValueState (CSharpCode VarData) -> VS (CSharpCode ValData))
-> [State ValueState (CSharpCode VarData)]
-> [VS (CSharpCode ValData)]
forall a b. (a -> b) -> [a] -> [b]
map 
  ((CSharpCode ValData -> CSharpCode ValData)
-> VS (CSharpCode ValData) -> VS (CSharpCode ValData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue ((ValData -> ValData) -> CSharpCode ValData -> CSharpCode ValData
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
onCodeValue ((Doc -> Doc) -> ValData -> ValData
updateValDoc Doc -> Doc
csOut)) (VS (CSharpCode ValData) -> VS (CSharpCode ValData))
-> (State ValueState (CSharpCode VarData)
    -> VS (CSharpCode ValData))
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode ValData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State ValueState (CSharpCode VarData) -> VS (CSharpCode ValData)
forall (r :: * -> *). VariableValue r => SVariable r -> SValue r
valueOf) [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
outs)

csVarDec :: Binding -> MSStatement CSharpCode -> MSStatement CSharpCode
csVarDec :: Binding -> MSStatement CSharpCode -> MSStatement CSharpCode
csVarDec Static _ = String -> State MethodState (CSharpCode (Doc, Terminator))
forall a. HasCallStack => String -> a
error "Static variables can't be declared locally to a function in C#. Use stateVar to make a static state variable instead."
csVarDec Dynamic d :: MSStatement CSharpCode
d = MSStatement CSharpCode
d

csInOut :: (VSType CSharpCode -> [MSParameter CSharpCode] -> MSBody CSharpCode -> 
    SMethod CSharpCode) -> 
  [SVariable CSharpCode] -> [SVariable CSharpCode] -> [SVariable CSharpCode] -> 
  MSBody CSharpCode -> SMethod CSharpCode
csInOut :: (VSType CSharpCode
 -> [MSParameter CSharpCode]
 -> MSBody CSharpCode
 -> SMethod CSharpCode)
-> InOutFunc CSharpCode
csInOut f :: VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
f ins :: [SVariable CSharpCode]
ins [v :: SVariable CSharpCode
v] [] b :: MSBody CSharpCode
b = VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
f ((CSharpCode VarData -> CSharpCode TypeData)
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (CSharpCode VarData)
SVariable CSharpCode
v) ((State ValueState (CSharpCode VarData)
 -> State MethodState (CSharpCode ParamData))
-> [State ValueState (CSharpCode VarData)]
-> [State MethodState (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
ins)
  ((CSharpCode (Doc, Terminator)
 -> CSharpCode Doc
 -> CSharpCode (Doc, Terminator)
 -> CSharpCode Doc)
-> State MethodState (CSharpCode (Doc, Terminator))
-> State MethodState (CSharpCode Doc)
-> State MethodState (CSharpCode (Doc, Terminator))
-> State MethodState (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 -> MSStatement CSharpCode
forall (r :: * -> *).
DeclStatement r =>
SVariable r -> MSStatement r
varDec SVariable CSharpCode
v) State MethodState (CSharpCode Doc)
MSBody CSharpCode
b (SValue CSharpCode
-> State MethodState (CSharpCode (Doc, Terminator))
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue CSharpCode
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode
-> State MethodState (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 f :: VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
f ins :: [SVariable CSharpCode]
ins [] [v :: SVariable CSharpCode
v] b :: MSBody CSharpCode
b = VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
f ((CSharpCode VarData -> CSharpCode TypeData)
-> State ValueState (CSharpCode VarData)
-> VS (CSharpCode TypeData)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue CSharpCode VarData -> CSharpCode TypeData
forall (r :: * -> *).
VariableElim r =>
r (Variable r) -> r (Type r)
variableType State ValueState (CSharpCode VarData)
SVariable CSharpCode
v) 
  ((State ValueState (CSharpCode VarData)
 -> State MethodState (CSharpCode ParamData))
-> [State ValueState (CSharpCode VarData)]
-> [State MethodState (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param ([State ValueState (CSharpCode VarData)]
 -> [MSParameter CSharpCode])
-> [State ValueState (CSharpCode VarData)]
-> [MSParameter CSharpCode]
forall a b. (a -> b) -> a -> b
$ State ValueState (CSharpCode VarData)
SVariable CSharpCode
v State ValueState (CSharpCode VarData)
-> [State ValueState (CSharpCode VarData)]
-> [State ValueState (CSharpCode VarData)]
forall a. a -> [a] -> [a]
: [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
ins) ((CSharpCode Doc -> CSharpCode (Doc, Terminator) -> CSharpCode Doc)
-> State MethodState (CSharpCode Doc)
-> State MethodState (CSharpCode (Doc, Terminator))
-> State MethodState (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) State MethodState (CSharpCode Doc)
MSBody CSharpCode
b 
  (SValue CSharpCode
-> State MethodState (CSharpCode (Doc, Terminator))
forall (r :: * -> *).
ControlStatement r =>
SValue r -> MSStatement r
returnStmt (SValue CSharpCode
 -> State MethodState (CSharpCode (Doc, Terminator)))
-> SValue CSharpCode
-> State MethodState (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 f :: VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
f ins :: [SVariable CSharpCode]
ins outs :: [SVariable CSharpCode]
outs both :: [SVariable CSharpCode]
both b :: MSBody CSharpCode
b = VSType CSharpCode
-> [MSParameter CSharpCode]
-> MSBody CSharpCode
-> SMethod CSharpCode
f VSType CSharpCode
forall (r :: * -> *). TypeSym r => VSType r
void ((State ValueState (CSharpCode VarData)
 -> State MethodState (CSharpCode ParamData))
-> [State ValueState (CSharpCode VarData)]
-> [State MethodState (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map ((CSharpCode ParamData -> CSharpCode ParamData)
-> State MethodState (CSharpCode ParamData)
-> State MethodState (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)) (State MethodState (CSharpCode ParamData)
 -> State MethodState (CSharpCode ParamData))
-> (State ValueState (CSharpCode VarData)
    -> State MethodState (CSharpCode ParamData))
-> State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param) [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
both [State MethodState (CSharpCode ParamData)]
-> [State MethodState (CSharpCode ParamData)]
-> [State MethodState (CSharpCode ParamData)]
forall a. [a] -> [a] -> [a]
++ (State ValueState (CSharpCode VarData)
 -> State MethodState (CSharpCode ParamData))
-> [State ValueState (CSharpCode VarData)]
-> [State MethodState (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
ins [State MethodState (CSharpCode ParamData)]
-> [State MethodState (CSharpCode ParamData)]
-> [State MethodState (CSharpCode ParamData)]
forall a. [a] -> [a] -> [a]
++ (State ValueState (CSharpCode VarData)
 -> State MethodState (CSharpCode ParamData))
-> [State ValueState (CSharpCode VarData)]
-> [State MethodState (CSharpCode ParamData)]
forall a b. (a -> b) -> [a] -> [b]
map ((CSharpCode ParamData -> CSharpCode ParamData)
-> State MethodState (CSharpCode ParamData)
-> State MethodState (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)) (State MethodState (CSharpCode ParamData)
 -> State MethodState (CSharpCode ParamData))
-> (State ValueState (CSharpCode VarData)
    -> State MethodState (CSharpCode ParamData))
-> State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. State ValueState (CSharpCode VarData)
-> State MethodState (CSharpCode ParamData)
forall (r :: * -> *).
ParameterSym r =>
SVariable r -> MSParameter r
param) [State ValueState (CSharpCode VarData)]
[SVariable CSharpCode]
outs) MSBody CSharpCode
b