{-# LANGUAGE TypeFamilies #-}
-- | The logic to render Swift code is contained in this module
module Drasil.GOOL.LanguageRenderer.SwiftRenderer (
  -- * Swift Code Configuration -- defines syntax of all Swift code
  SwiftCode(..), swiftName, swiftVersion
) where

import Drasil.FileHandling.Legacy (indent)

import Drasil.Shared.CodeType (CodeType(..))
import Drasil.Shared.InterfaceCommon (UnRepr(..), Label, Body, Block, Variable,
  Value, BodySym(..), oneLiner, bodyStatements, BlockSym(..), TypeSym(..),
  TypeElim(..), getTypeString, VariableSym(..), VisibilitySym(..),
  VariableElim(..), ValueSym(..), Argument(..), Literal(..), MathConstant(..),
  VariableValue(..), CommandLineArgs(..), NumericExpression(..),
  BooleanExpression(..), Comparison(..), ValueExpression(..), funcApp,
  funcAppNamedArgs, extFuncApp, IndexTranslator(..), Reference(..), Array(..),
  List(..), ListStatement(..), Set(..), listSlice, InternalList(..),
  EmptyStatement(..), MultiStatement(..), ValueStatement(..),
  AssignStatement(..), (&=), DeclStatement(..), PrintConsole(..),
  ReadConsole(..), FileHandling(..), PrintFile(..), ReadFile(..),
  StringStatement(..), FuncAppStatement(..), CommentStatement(..),
  ControlStatement(..), ScopeSym(..), ParameterSym(..), BinderSym(..),
  BinderElim(..), MethodSym(..), convScope)
import Drasil.GOOL.InterfaceGOOL (OOProg, Class, StateVar, ProgramSym(..),
  FileSym(..), ModuleSym(..), ClassSym(..), OOTypeSym(..), OOVariableSym(..),
  SelfSym(..), StateVarSym(..), AttachmentSym(..), OOValueExpression(..),
  selfMethodCall, newObj, InternalValueExp(..), objMethodCall,
  objMethodCallMixedArgs, objMethodCallNamedArgs, objMethodCallNoParams,
  OOFunctionSym(..), ($.), GetSet(..), OODeclStatement(..),
  OOFuncAppStatement(..), ObserverPattern(..), StrategyPattern(..),
  OOMethodSym(..), Initializers, convTypeOO)
import Drasil.Shared.RendererClassesCommon (CommonRenderSym, ImportSym(..),
  RenderBody(..), BodyElim, RenderBlock(..), BlockElim, RenderType(..),
  UnaryOpSym(..), BinaryOpSym(..), OpElim(uOpPrec, bOpPrec), RenderVariable(..),
  InternalVarElim(variableBind), RenderValue(..), ValueElim(valuePrec, valueInt),
  InternalListFunc(..), RenderFunction(..), FunctionElim(functionType),
  InternalAssignStmt(..), InternalIOStmt(..), InternalControlStmt(..),
  RenderStatement(..), StatementElim(statementTerm), RenderVisibility(..),
  VisibilityElim, MethodTypeSym(..), RenderParam(..),
  ParamElim(parameterName, parameterType), RenderMethod(..), MethodElim,
  BlockCommentSym(..), BlockCommentElim, ScopeElim(..), InternalBinderElim(..))
import qualified Drasil.Shared.RendererClassesCommon as RC (import', body, block,
  uOp, bOp, variable, binderElim, value, function, statement, visibility,
  parameter, method, blockComment', stmt)
import Drasil.GOOL.RendererClassesOO (OORenderSym, RenderFile(..),
  PermElim(binding), InternalGetSet(..), OOMethodTypeSym(..),
  OORenderMethod(..), StateVarElim, RenderClass(..), ClassElim, RenderMod(..),
  ModuleElim)
import qualified Drasil.GOOL.RendererClassesOO as RC (perm, stateVar,
  class', module')
import Drasil.GOOL.Renderers (renderType)
import Drasil.Shared.LanguageRenderer (blockCmtStart, blockCmtEnd, docCmtStart,
  bodyStart, bodyEnd, commentStart, elseIfLabel, forLabel, inLabel, tryLabel,
  catchLabel, throwLabel, throwsLabel, importLabel, listSep', printLabel,
  listSep, piLabel, access, tuple, ClassDocRenderer, parameterList)
import qualified Drasil.Shared.LanguageRenderer as R (sqrt, abs, log10, log, exp,
  sin, cos, tan, asin, acos, atan, floor, ceil, pow, class', multiStmt, body,
  classVarAccess, func, castObj, classLevel, instanceLevel, break, continue,
  private, blockCmt, docCmt, addComments, commentedMod, commentedItem, switch)
import Drasil.Shared.LanguageRenderer.Constructors (mkStmtNoEnd, mkStateVal,
  mkVal, typeFromData, VSOp, unOpPrec, powerPrec, unExpr, unExpr', typeUnExpr,
  binExpr, binExpr', typeBinExpr, typeFromData)
import qualified Drasil.Shared.LanguageRenderer.LanguagePolymorphic as G (
  multiBody, block, multiBlock, obj, csc, sec, cot, negateOp, equalOp,
  notEqualOp, greaterOp, greaterEqualOp, lessOp, lessEqualOp, plusOp, minusOp,
  multOp, divideOp, moduloOp, var, classVar, instanceVarAccess, arrayElem,
  litChar, litDouble, litInt, litString, valueOf, arg, argsList, objAccess,
  objMethodCall, call, funcAppMixedArgs, newObjMixedArgs, lambda, func, get, set,
  listAccess, getFunc, setFunc, stmt, loopStmt, emptyStmt, assign, subAssign,
  objDecNew, print, returnStmt, valStmt, comment, throw, ifCond, tryCatch,
  construct, param, method, getMethod, setMethod, initStmts, function, docFunc,
  buildClass, implementingClass, docClass, commentedClass, modFromData, docMod,
  fileDoc, fileFromData, defaultOptSpace, local)
import qualified Drasil.Shared.LanguageRenderer.Common as CS
import qualified Drasil.Shared.LanguageRenderer.CommonPseudoOO as CP (
  classVarAccess, intClass, buildModule, modDoc', contains, bindingError,
  notNull, listDecDef, destructorError, stateVarDef, constVar, litArray,
  extraClass, doubleRender, double, openFileR, openFileW, self, multiAssign,
  multiReturn, listDec, listSet, funcDecDef, inOutCall, forLoopError, mainBody,
  inOutFunc, docInOutFunc', float, stringRender', string', inherit, implements,
  functionDoc, intToIndex, indexToInt, global, setMethodCall)
import qualified Drasil.Shared.LanguageRenderer.CLike as C (notOp, andOp, orOp,
  litTrue, litFalse, inlineIf, libFuncAppMixedArgs, libNewObjMixedArgs,
  listSize', varDecDef, setDecDef, extObjDecNew, while)
import qualified Drasil.Shared.LanguageRenderer.Macros as M (ifExists,
  decrement1, increment1, runStrategy, stringListVals, stringListLists,
  notifyObservers', makeSetterVal, arrayDecAsList)
import qualified Drasil.GOOL.LanguageRenderer.CommonGOOL as CG (classMethodCall,
  listAppend, innerType)
import Drasil.Shared.AST (Terminator(..), VisibilityTag(..), qualName,
  FileType(..), fileD, FuncData(..), fd, ModData(..), md, updateMod,
  MethodData(..), mthd, updateMthd, OpData(..), ParamData(..), pd, ProgData(..),
  progD, TypeData(..), ValData(..), vd, AttachmentTag(..), VarData(..), vard,
  ScopeData, BinderD(..), bindFormD, FileData, Statement)
import Drasil.Shared.Helpers (hicat, emptyIfNull, toCode, toState, onCodeValue,
  onStateValue, on2CodeValues, on2StateValues, onCodeList, onStateList)
import Drasil.Shared.State (MS, VS, lensGStoFS, lensFStoCS, lensFStoMS,
  lensCStoVS, lensMStoFS, lensMStoVS, lensVStoFS, revFiles, addLangImportVS,
  getLangImports, getLibImports, setFileType, getClassName, setModuleName,
  getModuleName, getCurrMain, getMethodExcMap, getMainDoc, setThrowUsed,
  getThrowUsed, setErrorDefined, getErrorDefined, incrementLine, incrementWord,
  getLineIndex, getWordIndex, resetIndices, useVarName, genVarNameIf,
  setVarScope, getVarScope)

import Prelude hiding (break,print,(<>),sin,cos,tan,floor)
import qualified Prelude as P ((<>))
import Control.Lens.Zoom (zoom)
import Control.Monad.State (modify)
import Data.Composition ((.:))
import Data.List (intercalate, sort)
import Data.Map (findWithDefault)
import Data.Maybe (fromMaybe, isNothing)
import Text.PrettyPrint.HughesPJ (Doc, text, (<>), (<+>), parens, empty, equals,
  vcat, lbrace, rbrace, braces, brackets, colon, space, doubleQuotes)
import qualified Text.PrettyPrint.HughesPJ as D (float)

swiftExt :: String
swiftExt :: String
swiftExt = String
"swift"

newtype SwiftCode a = SC {forall a. SwiftCode a -> a
unSC :: a} deriving SwiftCode a -> SwiftCode a -> Bool
(SwiftCode a -> SwiftCode a -> Bool)
-> (SwiftCode a -> SwiftCode a -> Bool) -> Eq (SwiftCode a)
forall a. Eq a => SwiftCode a -> SwiftCode a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => SwiftCode a -> SwiftCode a -> Bool
== :: SwiftCode a -> SwiftCode a -> Bool
$c/= :: forall a. Eq a => SwiftCode a -> SwiftCode a -> Bool
/= :: SwiftCode a -> SwiftCode a -> Bool
Eq

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

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

instance Monad SwiftCode where
  SC a
x >>= :: forall a b. SwiftCode a -> (a -> SwiftCode b) -> SwiftCode b
>>= a -> SwiftCode b
f = a -> SwiftCode b
f a
x

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

instance ProgramSym SwiftCode ProgData FileData where
  prog :: String
-> String
-> [FS (SwiftCode FileData)]
-> GSProgram SwiftCode ProgData
prog String
n String
st [FS (SwiftCode FileData)]
files = do
    fs <- (FS (SwiftCode FileData)
 -> StateT GOOLState Identity (SwiftCode FileData))
-> [FS (SwiftCode FileData)]
-> StateT GOOLState Identity [SwiftCode FileData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (LensLike'
  (Zoomed (StateT FileState Identity) (SwiftCode FileData))
  GOOLState
  FileState
-> FS (SwiftCode FileData)
-> StateT GOOLState Identity (SwiftCode FileData)
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) GOOLState FileState
-> StateT FileState Identity c -> StateT GOOLState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT FileState Identity) (SwiftCode FileData))
  GOOLState
  FileState
(FileState -> Focusing Identity (SwiftCode FileData) FileState)
-> GOOLState -> Focusing Identity (SwiftCode FileData) GOOLState
Lens' GOOLState FileState
lensGStoFS) [FS (SwiftCode FileData)]
files
    modify revFiles
    pure $ onCodeList (progD n st) fs

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

instance UnRepr SwiftCode contents where
  unRepr :: SwiftCode contents -> contents
unRepr = SwiftCode contents -> contents
forall a. SwiftCode a -> a
unSC

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

  docMod :: String
-> String
-> [String]
-> String
-> FS (SwiftCode FileData)
-> FS (SwiftCode FileData)
docMod = ModuleDocRenderer
-> String
-> String
-> String
-> [String]
-> String
-> FS (SwiftCode FileData)
-> FS (SwiftCode FileData)
forall (r :: * -> *) file mod.
(BlockCommentSym r, RenderFile r file mod) =>
ModuleDocRenderer
-> String
-> String
-> String
-> [String]
-> String
-> FS (r file)
-> FS (r file)
G.docMod ModuleDocRenderer
CP.modDoc' String
swiftExt

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

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

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

instance ImportSym SwiftCode where
  langImport :: String -> SwiftCode Block
langImport String
n = Block -> SwiftCode Block
forall (r :: * -> *) a. Monad r => a -> r a
toCode (Block -> SwiftCode Block) -> Block -> SwiftCode Block
forall a b. (a -> b) -> a -> b
$ Block
importLabel Block -> Block -> Block
<+> String -> Block
text String
n
  modImport :: String -> SwiftCode Block
modImport = String -> SwiftCode Block
forall (r :: * -> *). ImportSym r => String -> r Block
langImport

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

instance PermElim SwiftCode Doc where
  perm :: SwiftCode Block -> Block
perm = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC
  binding :: SwiftCode Block -> AttachmentTag
binding = String -> SwiftCode Block -> AttachmentTag
forall a. HasCallStack => String -> a
error (String -> SwiftCode Block -> AttachmentTag)
-> String -> SwiftCode Block -> AttachmentTag
forall a b. (a -> b) -> a -> b
$ String -> String
CP.bindingError String
swiftName

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

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

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

instance BodyElim SwiftCode Body where
  body :: SwiftCode Block -> Block
body = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC

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

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

instance BlockElim SwiftCode Block where
  block :: SwiftCode Block -> Block
block = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC

instance TypeSym SwiftCode TypeData where
  bool :: VS (SwiftCode TypeData)
bool = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CS.bool
  int :: VS (SwiftCode TypeData)
int = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
swiftIntType
  float :: VS (SwiftCode TypeData)
float = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.float
  double :: VS (SwiftCode TypeData)
double = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.double
  char :: VS (SwiftCode TypeData)
char = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
swiftCharType
  string :: VS (SwiftCode TypeData)
string = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
CP.string'
  infile :: VS (SwiftCode TypeData)
infile = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
swiftFileType
  outfile :: VS (SwiftCode TypeData)
outfile = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
swiftFileHdlType
  referenceType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
referenceType = VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall a. a -> a
id -- Ignore reference types in "high-level" langauges for now; later on think about using boxed/unboxed types
  listType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
listType = VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
swiftListType
  arrayType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
arrayType = VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType -- For now, treating arrays and lists the same, like we do for Python
  setType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
setType = VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType
  innerType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
innerType = VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
(TypeElim r typ, TypeSym r typ, OOTypeSym r typ) =>
VS (r typ) -> VS (r typ)
CG.innerType
  funcType :: [VS (SwiftCode TypeData)]
-> VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
funcType = [VS (SwiftCode TypeData)]
-> VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
swiftFuncType
  void :: VS (SwiftCode TypeData)
void = VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
swiftVoidType

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

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

instance RenderType SwiftCode TypeData where
  multiType :: [VS (SwiftCode TypeData)] -> VS (SwiftCode TypeData)
multiType [VS (SwiftCode TypeData)]
ts = do
    typs <- [VS (SwiftCode TypeData)]
-> StateT ValueState Identity [SwiftCode TypeData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [VS (SwiftCode TypeData)]
ts
    let mt = [String] -> String
tuple ([String] -> String) -> [String] -> String
forall a b. (a -> b) -> a -> b
$ SwiftCode TypeData -> String
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> String
getTypeString (SwiftCode TypeData -> String) -> [SwiftCode TypeData] -> [String]
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> [SwiftCode TypeData]
typs
    typeFromData Void mt (text mt)

instance UnaryOpSym SwiftCode where
  notOp :: VSUnOp SwiftCode
notOp = VSUnOp SwiftCode
forall (r :: * -> *). Monad r => VSOp r
C.notOp
  negateOp :: VSUnOp SwiftCode
negateOp = VSUnOp SwiftCode
forall (r :: * -> *). Monad r => VSOp r
G.negateOp
  sqrtOp :: VSUnOp SwiftCode
sqrtOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.sqrt
  absOp :: VSUnOp SwiftCode
absOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.abs
  logOp :: VSUnOp SwiftCode
logOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.log10
  lnOp :: VSUnOp SwiftCode
lnOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.log
  expOp :: VSUnOp SwiftCode
expOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.exp
  sinOp :: VSUnOp SwiftCode
sinOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.sin
  cosOp :: VSUnOp SwiftCode
cosOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.cos
  tanOp :: VSUnOp SwiftCode
tanOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.tan
  asinOp :: VSUnOp SwiftCode
asinOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.asin
  acosOp :: VSUnOp SwiftCode
acosOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.acos
  atanOp :: VSUnOp SwiftCode
atanOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.atan
  floorOp :: VSUnOp SwiftCode
floorOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.floor
  ceilOp :: VSUnOp SwiftCode
ceilOp = String -> VSUnOp SwiftCode
forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath String
R.ceil

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

instance OpElim SwiftCode where
  uOp :: SwiftCode OpData -> Block
uOp = OpData -> Block
opDoc (OpData -> Block)
-> (SwiftCode OpData -> OpData) -> SwiftCode OpData -> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode OpData -> OpData
forall a. SwiftCode a -> a
unSC
  bOp :: SwiftCode OpData -> Block
bOp = OpData -> Block
opDoc (OpData -> Block)
-> (SwiftCode OpData -> OpData) -> SwiftCode OpData -> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode OpData -> OpData
forall a. SwiftCode a -> a
unSC
  uOpPrec :: SwiftCode OpData -> Int
uOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (SwiftCode OpData -> OpData) -> SwiftCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode OpData -> OpData
forall a. SwiftCode a -> a
unSC
  bOpPrec :: SwiftCode OpData -> Int
bOpPrec = OpData -> Int
opPrec (OpData -> Int)
-> (SwiftCode OpData -> OpData) -> SwiftCode OpData -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode OpData -> OpData
forall a. SwiftCode a -> a
unSC

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

instance ScopeElim SwiftCode ScopeData where
  scopeData :: SwiftCode ScopeData -> ScopeData
scopeData = SwiftCode ScopeData -> ScopeData
forall a. SwiftCode a -> a
unSC

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

instance OOVariableSym SwiftCode Variable Value TypeData where
  classVar :: String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
classVar = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
RenderVariable r var typ =>
String -> VS (r typ) -> VS (r var)
G.classVar
  classConst :: String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
classConst = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
String -> VS (r typ) -> VS (r var)
classVar
  classVarAccess :: VS (SwiftCode TypeData)
-> VS (SwiftCode Variable) -> VS (SwiftCode Variable)
classVarAccess = (Block -> Block -> Block)
-> VS (SwiftCode TypeData)
-> VS (SwiftCode Variable)
-> VS (SwiftCode Variable)
forall (r :: * -> *) var.
(InternalVarElim r var, RenderVariable r var TypeData,
 UnRepr r TypeData, VariableElim r var TypeData) =>
(Block -> Block -> Block)
-> VS (r TypeData) -> VS (r var) -> VS (r var)
CP.classVarAccess Block -> Block -> Block
R.classVarAccess
  extClassVarAccess :: VS (SwiftCode TypeData)
-> VS (SwiftCode Variable) -> VS (SwiftCode Variable)
extClassVarAccess = VS (SwiftCode TypeData)
-> VS (SwiftCode Variable) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOVariableSym r var val typ =>
VS (r typ) -> VS (r var) -> VS (r var)
classVarAccess
  instanceVarAccess :: VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> VS (SwiftCode Variable)
instanceVarAccess = VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k) (val :: k).
(InternalVarElim r var, RenderVariable r var typ, ValueElim r val,
 VariableElim r var typ) =>
VS (r val) -> VS (r var) -> VS (r var)
G.instanceVarAccess

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

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

instance InternalVarElim SwiftCode Variable where
  variableBind :: SwiftCode Variable -> AttachmentTag
variableBind = Variable -> AttachmentTag
varBind (Variable -> AttachmentTag)
-> (SwiftCode Variable -> Variable)
-> SwiftCode Variable
-> AttachmentTag
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode Variable -> Variable
forall a. SwiftCode a -> a
unSC
  variable :: SwiftCode Variable -> Block
variable = Variable -> Block
varDoc (Variable -> Block)
-> (SwiftCode Variable -> Variable) -> SwiftCode Variable -> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode Variable -> Variable
forall a. SwiftCode a -> a
unSC

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

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

instance Argument SwiftCode Value where
  pointerArg :: VS (SwiftCode Value) -> VS (SwiftCode Value)
pointerArg = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftArgVal

instance Literal SwiftCode Value TypeData where
  litTrue :: VS (SwiftCode Value)
litTrue = VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
C.litTrue
  litFalse :: VS (SwiftCode Value)
litFalse = VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
VS (r val)
C.litFalse
  litChar :: Char -> VS (SwiftCode Value)
litChar = (Block -> Block) -> Char -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
(Block -> Block) -> Char -> VS (r val)
G.litChar Block -> Block
doubleQuotes
  litDouble :: Double -> VS (SwiftCode Value)
litDouble = Double -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Double -> VS (r val)
G.litDouble
  litFloat :: Float -> VS (SwiftCode Value)
litFloat = Float -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Float -> VS (r val)
swiftLitFloat
  litInt :: Integer -> VS (SwiftCode Value)
litInt = Integer -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Integer -> VS (r val)
G.litInt
  litString :: String -> VS (SwiftCode Value)
litString = String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
String -> VS (r val)
G.litString
  litArray :: VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)] -> VS (SwiftCode Value)
litArray = (Block -> Block)
-> VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)]
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
(Block -> Block) -> VS (r typ) -> [VS (r val)] -> VS (r val)
CP.litArray Block -> Block
brackets
  litSet :: VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)] -> VS (SwiftCode Value)
litSet = VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)] -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litArray
  litList :: VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)] -> VS (SwiftCode Value)
litList = VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)] -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litArray

instance MathConstant SwiftCode Value where
  pi :: VS (SwiftCode Value)
pi = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double Block
swiftPi

instance VariableValue SwiftCode Variable Value where
  valueOf :: VS (SwiftCode Variable) -> VS (SwiftCode Value)
valueOf = VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalVarElim r var, RenderValue r var val typ,
 VariableElim r var typ) =>
VS (r var) -> VS (r val)
G.valueOf

instance CommandLineArgs SwiftCode Value where
  arg :: Integer -> VS (SwiftCode Value)
arg Integer
n = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ, ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
G.arg (Integer -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
n) VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
argsList
  argsList :: VS (SwiftCode Value)
argsList = String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
String -> VS (r val)
G.argsList (String
swiftCommLine String -> String -> String
`access` String
swiftArgs)
  argExists :: Integer -> VS (SwiftCode Value)
argExists Integer
i = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k).
CommandLineArgs r val =>
VS (r val)
argsList VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k).
Comparison r val =>
VS (r val) -> VS (r val) -> VS (r val)
?> Integer -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt (Integer -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
i)

instance NumericExpression SwiftCode Value where
  #~ :: VS (SwiftCode Value) -> VS (SwiftCode Value)
(#~) = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr' VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
negateOp
  #/^ :: VS (SwiftCode Value) -> VS (SwiftCode Value)
(#/^) = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sqrtOp
  #| :: VS (SwiftCode Value) -> VS (SwiftCode Value)
(#|) = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
absOp
  #+ :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
(#+) = (VS (SwiftCode Value)
 -> VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
swiftNumBinExpr (VSUnOp SwiftCode
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp SwiftCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
plusOp)
  #- :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
(#-) = (VS (SwiftCode Value)
 -> VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
swiftNumBinExpr (VSUnOp SwiftCode
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp SwiftCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
minusOp)
  #* :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
(#*) = (VS (SwiftCode Value)
 -> VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
swiftNumBinExpr (VSUnOp SwiftCode
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp SwiftCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
multOp)
  #/ :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
(#/) = (VS (SwiftCode Value)
 -> VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
swiftNumBinExpr (VSUnOp SwiftCode
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp SwiftCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
divideOp)
  #% :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
(#%) = VSUnOp SwiftCode
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr VSUnOp SwiftCode
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
moduloOp
  #^ :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
(#^) VS (SwiftCode Value)
v1' VS (SwiftCode Value)
v2' = do
    v1 <- VS (SwiftCode Value)
v1'
    v2 <- v2'
    let swiftPower CodeType
Integer CodeType
Integer VS (r val)
b VS (r val)
e = VS (r typ) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int (VS (r val) -> VS (r val)) -> VS (r val) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr' VSBinOp r
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp
          (VS (r typ) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double VS (r val)
b) (VS (r typ) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double VS (r val)
e)
        swiftPower CodeType
_ CodeType
_ VS (r val)
b VS (r val)
e = VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val, ValueSym r val typ) =>
VSBinOp r -> VS (r val) -> VS (r val) -> VS (r val)
binExpr' VSBinOp r
forall (r :: * -> *). BinaryOpSym r => VSBinOp r
powerOp VS (r val)
b VS (r val)
e
    swiftPower (getCodeType $ valueType v1) (getCodeType $ valueType v2) (pure v1)
      (pure v2)

  log :: VS (SwiftCode Value) -> VS (SwiftCode Value)
log = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
logOp
  ln :: VS (SwiftCode Value) -> VS (SwiftCode Value)
ln = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
lnOp
  exp :: VS (SwiftCode Value) -> VS (SwiftCode Value)
exp = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
expOp
  sin :: VS (SwiftCode Value) -> VS (SwiftCode Value)
sin = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
sinOp
  cos :: VS (SwiftCode Value) -> VS (SwiftCode Value)
cos = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
cosOp
  tan :: VS (SwiftCode Value) -> VS (SwiftCode Value)
tan = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
tanOp
  csc :: VS (SwiftCode Value) -> VS (SwiftCode Value)
csc = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
G.csc
  sec :: VS (SwiftCode Value) -> VS (SwiftCode Value)
sec = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
G.sec
  cot :: VS (SwiftCode Value) -> VS (SwiftCode Value)
cot = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
(ValueSym r val typ, Literal r val typ, NumericExpression r val,
 TypeElim r typ) =>
VS (r val) -> VS (r val)
G.cot
  arcsin :: VS (SwiftCode Value) -> VS (SwiftCode Value)
arcsin = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
asinOp
  arccos :: VS (SwiftCode Value) -> VS (SwiftCode Value)
arccos = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
acosOp
  arctan :: VS (SwiftCode Value) -> VS (SwiftCode Value)
arctan = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
atanOp
  floor :: VS (SwiftCode Value) -> VS (SwiftCode Value)
floor = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
floorOp
  ceil :: VS (SwiftCode Value) -> VS (SwiftCode Value)
ceil = VSUnOp SwiftCode -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(OpElim r, RenderValue r var val typ, ValueElim r val,
 ValueSym r val typ) =>
VSUnOp r -> VS (r val) -> VS (r val)
unExpr VSUnOp SwiftCode
forall (r :: * -> *). UnaryOpSym r => VSUnOp r
ceilOp

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

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

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

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

  lambda :: [VS (SwiftCode BinderD)]
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
lambda = ([SwiftCode BinderD] -> SwiftCode Value -> Block)
-> [VS (SwiftCode BinderD)]
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (binder :: k) (typ :: k) (var :: k)
       (val :: k).
(BinderElim r binder typ, RenderValue r var val typ, TypeSym r typ,
 ValueSym r val typ) =>
([r binder] -> r val -> Block)
-> [VS (r binder)] -> VS (r val) -> VS (r val)
G.lambda [SwiftCode BinderD] -> SwiftCode Value -> Block
swiftLambda

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

instance OOValueExpression SwiftCode Variable Value TypeData where
  newObjMixedArgs :: MixedCtorCall SwiftCode Variable Value TypeData
newObjMixedArgs = MixedCall SwiftCode Variable Value TypeData
forall (r :: * -> *) var val.
(RenderValue r var val TypeData, UnRepr r TypeData) =>
String -> MixedCtorCall r var val TypeData
G.newObjMixedArgs String
""
  extNewObjMixedArgs :: MixedCall SwiftCode Variable Value TypeData
extNewObjMixedArgs String
m VS (SwiftCode TypeData)
tp [VS (SwiftCode Value)]
vs NamedArgs SwiftCode Variable Value
ns = do
    t <- VS (SwiftCode TypeData)
tp
    call (Just m) Nothing (getTypeString t) (pure t) vs ns
  libNewObjMixedArgs :: MixedCall SwiftCode Variable Value TypeData
libNewObjMixedArgs = MixedCall SwiftCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
String -> MixedCtorCall r var val typ
C.libNewObjMixedArgs

instance RenderValue SwiftCode Variable Value TypeData where
  inputFunc :: VS (SwiftCode Value)
inputFunc = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string Block
empty
  printFunc :: VS (SwiftCode Value)
printFunc = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Block
empty
  printLnFunc :: VS (SwiftCode Value)
printLnFunc = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Block
empty
  printFileFunc :: VS (SwiftCode Value) -> VS (SwiftCode Value)
printFileFunc VS (SwiftCode Value)
_ = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Block
empty
  printFileLnFunc :: VS (SwiftCode Value) -> VS (SwiftCode Value)
printFileLnFunc VS (SwiftCode Value)
_ = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void Block
empty

  cast :: VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
cast = VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftCast

  call :: Maybe String
-> Maybe Block -> MixedCall SwiftCode Variable Value TypeData
call Maybe String
l Maybe Block
o String
n VS (SwiftCode TypeData)
t [VS (SwiftCode Value)]
as NamedArgs SwiftCode Variable Value
ns = do
    mn <- LensLike'
  (Zoomed (StateT FileState Identity) String) ValueState FileState
-> StateT FileState Identity String
-> StateT ValueState Identity String
forall c.
LensLike'
  (Zoomed (StateT FileState Identity) c) ValueState FileState
-> StateT FileState Identity c -> StateT ValueState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT FileState Identity) String) ValueState FileState
(FileState -> Focusing Identity String FileState)
-> ValueState -> Focusing Identity String ValueState
Lens' ValueState FileState
lensVStoFS StateT FileState Identity String
getModuleName
    mem <- getMethodExcMap
        -- If function being called throws exceptions, need to wrap call in try
    let f = if [ExceptionType] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null ([ExceptionType] -> Bool) -> [ExceptionType] -> Bool
forall a b. (a -> b) -> a -> b
$ [ExceptionType]
-> QualifiedName
-> Map QualifiedName [ExceptionType]
-> [ExceptionType]
forall k a. Ord k => a -> k -> Map k a -> a
findWithDefault [] (QualifiedName
-> (String -> QualifiedName) -> Maybe String -> QualifiedName
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (String -> String -> QualifiedName
qualName String
mn String
n) (String -> String -> QualifiedName
`qualName` String
n)
          Maybe String
l) Map QualifiedName [ExceptionType]
mem then VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a. a -> a
id else VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal
    f $ G.call swiftNamedArgSep Nothing o n t as ns

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

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

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

instance OOFunctionSym SwiftCode Value TypeData where
  func :: String
-> VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)]
-> VS (SwiftCode FuncData)
func = String
-> VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)]
-> VS (SwiftCode FuncData)
forall (r :: * -> *) typ val var binder.
(RenderFunction r typ, ValueElim r val,
 ValueExpression r var val binder typ) =>
String -> VS (r typ) -> [VS (r val)] -> VS (r FuncData)
G.func
  objAccess :: VS (SwiftCode Value)
-> VS (SwiftCode FuncData) -> VS (SwiftCode Value)
objAccess = VS (SwiftCode Value)
-> VS (SwiftCode FuncData) -> VS (SwiftCode Value)
forall (r :: * -> *) typ var val.
(FunctionElim r typ, RenderValue r var val typ, ValueElim r val) =>
VS (r val) -> VS (r FuncData) -> VS (r val)
G.objAccess

instance GetSet SwiftCode Variable Value where
  get :: VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> VS (SwiftCode Value)
get = VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall (r :: * -> *) var val typ.
(InternalGetSet r var val typ, OOFunctionSym r val typ) =>
VS (r val) -> VS (r var) -> VS (r val)
G.get
  set :: VS (SwiftCode Value)
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
set = VS (SwiftCode Value)
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) val typ var.
(ValueSym r val typ, InternalGetSet r var val typ,
 OOFunctionSym r val typ) =>
VS (r val) -> VS (r var) -> VS (r val) -> VS (r val)
G.set

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

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

instance Array SwiftCode Variable Value where
  arrayElem :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Variable)
arrayElem = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 RenderVariable r var typ, ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r var)
G.arrayElem
  arrayLength :: VS (SwiftCode Value) -> VS (SwiftCode Value)
arrayLength = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val)
listSize
  arrayCopy :: VS (SwiftCode Value) -> VS (SwiftCode Value)
arrayCopy = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a. a -> a
id -- Swift uses value semantics for arrays

instance List SwiftCode Value where
  listSize :: VS (SwiftCode Value) -> VS (SwiftCode Value)
listSize = String -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k).
(TypeSym r typ, VariableSym r var typ, OOVariableSym r var val typ,
 VariableValue r var val) =>
String -> VS (r val) -> VS (r val)
C.listSize' String
swiftListSize
  listAccess :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
listAccess = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall (r :: * -> *) typ val var.
(TypeSym r typ, ValueSym r val typ, IndexTranslator r val,
 InternalListFunc r val typ, FunctionElim r typ,
 RenderFunction r typ, RenderValue r var val typ, TypeElim r typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val)
G.listAccess
  indexOf :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
indexOf = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftIndexOf

instance ListStatement SwiftCode Statement Value where
  listAdd :: VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
listAdd VS (SwiftCode Value)
list VS (SwiftCode Value)
idx VS (SwiftCode Value)
vl = let atArg :: VS (SwiftCode Variable)
atArg = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftAt VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
    in VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode TypeData)
-> VS (SwiftCode Value)
-> String
-> [VS (SwiftCode Value)]
-> NamedArgs SwiftCode Variable Value
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ)
-> VS (r val)
-> String
-> [VS (r val)]
-> NamedArgs r var val
-> VS (r val)
objMethodCallMixedArgs VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void VS (SwiftCode Value)
list String
swiftListAdd [VS (SwiftCode Value)
vl] [(VS (SwiftCode Variable)
atArg, VS (SwiftCode Value)
idx)]
  listAppend :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
listAppend = String
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (stmt :: k).
(TypeSym r typ, InternalValueExp r var val typ,
 ValueStatement r stmt val) =>
String -> VS (r val) -> VS (r val) -> MS (r stmt)
CG.listAppend String
swiftListAppend
  listSet :: VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
listSet = VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, ValueSym r val typ,
 IndexTranslator r val, RenderVariable r var typ,
 ValueElim r val) =>
VS (r val) -> VS (r val) -> VS (r val) -> MS (r stmt)
CP.listSet

instance Set SwiftCode Value where
  contains :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
contains = String
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall (r :: * -> *) typ val.
(TypeSym r typ, OOFunctionSym r val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.contains String
swiftContains
  setAdd :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
setAdd = String
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.setMethodCall String
swiftListAdd
  setRemove :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
setRemove = String
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.setMethodCall String
swiftListRemove
  setUnion :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
setUnion = String
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ,
 InternalValueExp r var val typ) =>
String -> VS (r val) -> VS (r val) -> VS (r val)
CP.setMethodCall String
swiftUnion

instance InternalList SwiftCode Block Variable Value where
  listSlice' :: Maybe (VS (SwiftCode Value))
-> Maybe (VS (SwiftCode Value))
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
listSlice' Maybe (VS (SwiftCode Value))
b Maybe (VS (SwiftCode Value))
e Maybe (VS (SwiftCode Value))
s VS (SwiftCode Variable)
vn VS (SwiftCode Value)
vo = VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> Maybe (VS (SwiftCode Value))
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
swiftListSlice VS (SwiftCode Variable)
vn VS (SwiftCode Value)
vo Maybe (VS (SwiftCode Value))
b Maybe (VS (SwiftCode Value))
e (VS (SwiftCode Value)
-> Maybe (VS (SwiftCode Value)) -> VS (SwiftCode Value)
forall a. a -> Maybe a -> a
fromMaybe (Integer -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
1) Maybe (VS (SwiftCode Value))
s)

instance InternalGetSet SwiftCode Variable Value TypeData where
  getFunc :: VS (SwiftCode Variable) -> VS (SwiftCode FuncData)
getFunc = VS (SwiftCode Variable) -> VS (SwiftCode FuncData)
forall (r :: * -> *) val typ var.
(OOFunctionSym r val typ, VariableElim r var typ) =>
VS (r var) -> VS (r FuncData)
G.getFunc
  setFunc :: VS (SwiftCode TypeData)
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> VS (SwiftCode FuncData)
setFunc = VS (SwiftCode TypeData)
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> VS (SwiftCode FuncData)
forall (r :: * -> *) val typ var.
(OOFunctionSym r val typ, VariableElim r var typ) =>
VS (r typ) -> VS (r var) -> VS (r val) -> VS (r FuncData)
G.setFunc

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

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

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

instance InternalBinderElim SwiftCode BinderD where
  binderElim :: SwiftCode BinderD -> Block
binderElim = String -> Block
text (String -> Block)
-> (SwiftCode BinderD -> String) -> SwiftCode BinderD -> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BinderD -> String
bindName (BinderD -> String)
-> (SwiftCode BinderD -> BinderD) -> SwiftCode BinderD -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode BinderD -> BinderD
forall a. SwiftCode a -> a
unSC

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

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

instance InternalAssignStmt SwiftCode Statement Variable Value where
  multiAssign :: [VS (SwiftCode Variable)]
-> [VS (SwiftCode Value)] -> MS (SwiftCode Statement)
multiAssign = (Block -> Block)
-> [VS (SwiftCode Variable)]
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, AssignStatement r stmt var val,
 InternalVarElim r var, RenderValue r var val typ,
 RenderVariable r var typ, ValueElim r val) =>
(Block -> Block) -> [VS (r var)] -> [VS (r val)] -> MS (r stmt)
CP.multiAssign Block -> Block
parens

instance InternalIOStmt SwiftCode Statement Value where
  printSt :: Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
printSt = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftPrint

instance InternalControlStmt SwiftCode Statement Value where
  multiReturn :: [VS (SwiftCode Value)] -> MS (SwiftCode Statement)
multiReturn = (Block -> Block)
-> [VS (SwiftCode Value)] -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (typ :: k) (bod :: k) (stmt :: k)
       (var :: k) (val :: k).
(TypeSym r typ, ControlStatement r bod stmt var val,
 RenderValue r var val typ, ValueElim r val) =>
(Block -> Block) -> [VS (r val)] -> MS (r stmt)
CP.multiReturn Block -> Block
parens

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

instance StatementElim SwiftCode Statement where
  statement :: SwiftCode Statement -> Block
statement = Statement -> Block
forall a b. (a, b) -> a
fst (Statement -> Block)
-> (SwiftCode Statement -> Statement)
-> SwiftCode Statement
-> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode Statement -> Statement
forall a. SwiftCode a -> a
unSC
  statementTerm :: SwiftCode Statement -> Terminator
statementTerm = Statement -> Terminator
forall a b. (a, b) -> b
snd (Statement -> Terminator)
-> (SwiftCode Statement -> Statement)
-> SwiftCode Statement
-> Terminator
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode Statement -> Statement
forall a. SwiftCode a -> a
unSC

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

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

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

instance AssignStatement SwiftCode Statement Variable Value where
  assign :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
assign = Terminator
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (var :: k) (stmt :: k) (val :: k).
(InternalVarElim r var, RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> VS (r val) -> MS (r stmt)
G.assign Terminator
Empty
  &-= :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
(&-=) = Terminator
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (var :: k) (stmt :: k) (val :: k).
(InternalVarElim r var, RenderStatement r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> VS (r val) -> MS (r stmt)
G.subAssign Terminator
Empty
  &+= :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
(&+=) = VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (var :: k) (stmt :: k) (val :: k).
(InternalVarElim r var, RenderStatement r stmt, ValueElim r val) =>
VS (r var) -> VS (r val) -> MS (r stmt)
CS.increment
  &++ :: VS (SwiftCode Variable) -> MS (SwiftCode Statement)
(&++) = VS (SwiftCode Variable) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, Literal r val typ) =>
VS (r var) -> MS (r stmt)
M.increment1
  &-- :: VS (SwiftCode Variable) -> MS (SwiftCode Statement)
(&--) = VS (SwiftCode Variable) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, Literal r val typ) =>
VS (r var) -> MS (r stmt)
M.decrement1

instance DeclStatement SwiftCode Body Statement Variable ScopeData Value where
  varDec :: VS (SwiftCode Variable)
-> SwiftCode ScopeData -> MS (SwiftCode Statement)
varDec = Block
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
swiftVarDec Block
swiftVar
  varDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
varDecDef = Terminator
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
C.varDecDef Terminator
Empty
  setDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
setDecDef = Terminator
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
(DeclStatement r bod stmt var scope val, RenderStatement r stmt,
 StatementElim r stmt, ValueElim r val) =>
Terminator -> VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
C.setDecDef Terminator
Empty
  setDec :: VS (SwiftCode Variable)
-> SwiftCode ScopeData -> MS (SwiftCode Statement)
setDec = Block
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
swiftSetDec Block
swiftConst
  listDec :: Integer
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
listDec Integer
_ = VS (SwiftCode Variable)
-> SwiftCode ScopeData -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val, TypeSym r typ,
 Literal r val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> MS (r stmt)
CP.listDec
  listDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
listDecDef = VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val, TypeSym r typ,
 Literal r val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
CP.listDecDef
  arrayDec :: Integer
-> VS (SwiftCode Value)
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
arrayDec = Integer
-> VS (SwiftCode Value)
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (scope :: k) (val :: k) (typ :: k).
(BodySym r bod block, BlockSym r block stmt, MultiStatement r stmt,
 DeclStatement r bod stmt var scope val,
 ControlStatement r bod stmt var val, TypeSym r typ,
 Literal r val typ, VariableSym r var typ, VariableValue r var val,
 ListStatement r stmt val, VariableElim r var typ) =>
Integer -> VS (r val) -> VS (r var) -> r scope -> MS (r stmt)
M.arrayDecAsList
  arrayDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
arrayDecDef = VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
listDecDef
  constDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
constDecDef VS (SwiftCode Variable)
vr SwiftCode ScopeData
scp VS (SwiftCode Value)
vl' = do
    vdec <- Block
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
swiftVarDec Block
swiftConst VS (SwiftCode Variable)
vr SwiftCode ScopeData
scp
    vl <- zoom lensMStoVS vl'
    mkStmtNoEnd $ RC.statement vdec <+> equals <+> RC.value vl
  funcDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Variable)]
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
funcDecDef = VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Variable)]
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  ScopeData
  val
  binder
  typ =>
VS (r var)
-> r ScopeData -> [VS (r var)] -> MS (r bod) -> MS (r stmt)
CP.funcDecDef

instance OODeclStatement SwiftCode Statement Variable ScopeData Value where
  objDecDef :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
objDecDef = VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k).
DeclStatement r bod stmt var scope val =>
VS (r var) -> r scope -> VS (r val) -> MS (r stmt)
varDecDef
  objDecNew :: VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
objDecNew = VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val,
 OOValueExpression r var val typ, VariableElim r var typ) =>
VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
G.objDecNew
  extObjDecNew :: String
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
extObjDecNew = String
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> [VS (SwiftCode Value)]
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (scope :: k) (val :: k) (typ :: k).
(DeclStatement r bod stmt var scope val,
 OOValueExpression r var val typ, VariableElim r var typ) =>
String -> VS (r var) -> r scope -> [VS (r val)] -> MS (r stmt)
C.extObjDecNew

instance PrintConsole SwiftCode Statement Value where
  print :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
print      = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
False Maybe (VS (SwiftCode Value))
forall a. Maybe a
Nothing VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc
  printLn :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
printLn    = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
True  Maybe (VS (SwiftCode Value))
forall a. Maybe a
Nothing VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc
  printStr :: String -> MS (SwiftCode Statement)
printStr   = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
False Maybe (VS (SwiftCode Value))
forall a. Maybe a
Nothing VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printFunc   (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> (String -> VS (SwiftCode Value))
-> String
-> MS (SwiftCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString
  printStrLn :: String -> MS (SwiftCode Statement)
printStrLn = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
True  Maybe (VS (SwiftCode Value))
forall a. Maybe a
Nothing VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val)
printLnFunc (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> (String -> VS (SwiftCode Value))
-> String
-> MS (SwiftCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString

instance ReadConsole SwiftCode Statement Variable where
  getInput :: VS (SwiftCode Variable) -> MS (SwiftCode Statement)
getInput VS (SwiftCode Variable)
v = VS (SwiftCode Variable)
v VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftInput VS (SwiftCode Variable)
v VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, RenderValue r var val typ,
 ValueElim r val, ValueExpression r var val binder typ) =>
VS (r val)
swiftReadLineFunc
  discardInput :: MS (SwiftCode Statement)
discardInput = VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, RenderValue r var val typ,
 ValueElim r val, ValueExpression r var val binder typ) =>
VS (r val)
swiftReadLineFunc

instance FileHandling SwiftCode Statement Variable Value where
  openFileR :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
openFileR VS (SwiftCode Variable)
v VS (SwiftCode Value)
pth = do
    v' <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
-> VS (SwiftCode Variable)
-> StateT MethodState Identity (SwiftCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Variable) ValueState)
-> MethodState
-> Focusing Identity (SwiftCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Variable)
v
    scpData <- getVarScope $ variableName v'
    let scp = ScopeData -> SwiftCode ScopeData
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeData -> r scope
convScope ScopeData
scpData
    multi [CP.openFileR swiftOpenFile v pth,
      varDec swiftContentsVar scp, swiftReadFile swiftContentsVar (valueOf v)]
  openFileW :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
openFileW = Bool
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOpenFileWA Bool
False
  openFileA :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
openFileA = Bool
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOpenFileWA Bool
True
  closeFile :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
closeFile = VS (SwiftCode Value) -> MS (SwiftCode Statement)
swiftCloseFile

instance PrintFile SwiftCode Statement Value where
  printFile :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
printFile VS (SwiftCode Value)
f      = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
False (VS (SwiftCode Value) -> Maybe (VS (SwiftCode Value))
forall a. a -> Maybe a
Just VS (SwiftCode Value)
f) (VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileFunc VS (SwiftCode Value)
f)
  printFileLn :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
printFileLn VS (SwiftCode Value)
f    = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
True  (VS (SwiftCode Value) -> Maybe (VS (SwiftCode Value))
forall a. a -> Maybe a
Just VS (SwiftCode Value)
f) (VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileLnFunc VS (SwiftCode Value)
f)
  printFileStr :: VS (SwiftCode Value) -> String -> MS (SwiftCode Statement)
printFileStr VS (SwiftCode Value)
f   = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
False (VS (SwiftCode Value) -> Maybe (VS (SwiftCode Value))
forall a. a -> Maybe a
Just VS (SwiftCode Value)
f) (VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileFunc VS (SwiftCode Value)
f)   (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> (String -> VS (SwiftCode Value))
-> String
-> MS (SwiftCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString
  printFileStrLn :: VS (SwiftCode Value) -> String -> MS (SwiftCode Statement)
printFileStrLn VS (SwiftCode Value)
f = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
True  (VS (SwiftCode Value) -> Maybe (VS (SwiftCode Value))
forall a. a -> Maybe a
Just VS (SwiftCode Value)
f) (VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r val) -> VS (r val)
printFileLnFunc VS (SwiftCode Value)
f) (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> (String -> VS (SwiftCode Value))
-> String
-> MS (SwiftCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString

instance ReadFile SwiftCode Statement Variable Value where
  getFileInput :: VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> MS (SwiftCode Statement)
getFileInput VS (SwiftCode Value)
_ VS (SwiftCode Variable)
v = do
    wi <- MS Integer
getWordIndex
    li <- getLineIndex
    modify incrementWord
    v &= swiftInput v
      (listAccess (listAccess swiftContentsVal (litInt li)) (litInt wi))
  discardFileInput :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
discardFileInput VS (SwiftCode Value)
_ = (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
incrementWord StateT MethodState Identity ()
-> MS (SwiftCode Statement) -> MS (SwiftCode Statement)
forall a b.
StateT MethodState Identity a
-> StateT MethodState Identity b -> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt
  getFileInputLine :: VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> MS (SwiftCode Statement)
getFileInputLine VS (SwiftCode Value)
_ VS (SwiftCode Variable)
v = do
    v' <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
-> VS (SwiftCode Variable)
-> StateT MethodState Identity (SwiftCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Variable) ValueState)
-> MethodState
-> Focusing Identity (SwiftCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Variable)
v
    scpData <- getVarScope $ variableName v'
    let scp = ScopeData -> SwiftCode ScopeData
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeData -> r scope
convScope ScopeData
scpData
    wi <- getWordIndex
    li <- getLineIndex
    modify incrementLine
    slc <- listSlice swiftLineVar (listAccess swiftContentsVal (litInt li))
      (Just $ litInt wi) Nothing Nothing
    multi [varDec swiftLineVar scp, mkStmtNoEnd $ RC.block slc,
      v &= swiftJoinedFunc ' ' swiftLineVal]
  discardFileLine :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
discardFileLine VS (SwiftCode Value)
_ = (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
incrementLine StateT MethodState Identity ()
-> MS (SwiftCode Statement) -> MS (SwiftCode Statement)
forall a b.
StateT MethodState Identity a
-> StateT MethodState Identity b -> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt
  getFileInputAll :: VS (SwiftCode Value)
-> VS (SwiftCode Variable) -> MS (SwiftCode Statement)
getFileInputAll VS (SwiftCode Value)
_ VS (SwiftCode Variable)
v = do
    li <- MS Integer
getLineIndex
    let l_binder = String -> VS (SwiftCode TypeData) -> VS (SwiftCode BinderD)
forall {k} (r :: k -> *) (binder :: k) (typ :: k).
BinderSym r binder typ =>
String -> VS (r typ) -> VS (r binder)
binder String
"l" (VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)
        l_var = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"l" (VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)
    slc <- listSlice swiftContentsVar swiftContentsVal
      (Just $ litInt (li+1)) Nothing Nothing
    multi [mkStmtNoEnd $ RC.block slc,
      v &= swiftMapFunc swiftContentsVal
        (lambda [l_binder] (swiftJoinedFunc ' ' (valueOf l_var)))]

instance StringStatement SwiftCode Statement Variable Value where
  stringSplit :: Char
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
stringSplit Char
d VS (SwiftCode Variable)
vnew VS (SwiftCode Value)
s = VS (SwiftCode Variable)
vnew VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= Char -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, TypeSym r typ, Literal r val typ,
 VariableSym r var typ) =>
Char -> VS (r val) -> VS (r val)
swiftSplitFunc Char
d VS (SwiftCode Value)
s

  stringListVals :: [VS (SwiftCode Variable)]
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
stringListVals = [VS (SwiftCode Variable)]
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(MultiStatement r stmt, AssignStatement r stmt var val, List r val,
 ValueSym r val typ, Literal r val typ, RenderValue r var val typ,
 TypeElim r typ, VariableElim r var typ) =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
M.stringListVals
  stringListLists :: [VS (SwiftCode Variable)]
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
stringListLists = [VS (SwiftCode Variable)]
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (block :: k) (stmt :: k)
       (var :: k) (val :: k) (typ :: k).
(BodySym r bod block, BlockSym r block stmt,
 ControlStatement r bod stmt var val, TypeSym r typ,
 ValueSym r val typ, Literal r val typ, NumericExpression r val,
 VariableSym r var typ, VariableValue r var val, List r val,
 ListStatement r stmt val, TypeElim r typ, VariableElim r var typ,
 RenderValue r var val typ) =>
[VS (r var)] -> VS (r val) -> MS (r stmt)
M.stringListLists

instance FuncAppStatement SwiftCode Statement Variable Value where
  inOutCall :: InOutCall SwiftCode Statement Variable Value
inOutCall = (String
 -> VS (SwiftCode TypeData)
 -> [VS (SwiftCode Value)]
 -> VS (SwiftCode Value))
-> InOutCall SwiftCode Statement Variable Value
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, InternalAssignStmt r stmt var val,
 ValueStatement r stmt val, VariableValue r var val) =>
(String -> VS (r typ) -> [VS (r val)] -> VS (r val))
-> String
-> [VS (r val)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r stmt)
CP.inOutCall String
-> VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)]
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp
  extInOutCall :: String -> InOutCall SwiftCode Statement Variable Value
extInOutCall String
m = (String
 -> VS (SwiftCode TypeData)
 -> [VS (SwiftCode Value)]
 -> VS (SwiftCode Value))
-> InOutCall SwiftCode Statement Variable Value
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, InternalAssignStmt r stmt var val,
 ValueStatement r stmt val, VariableValue r var val) =>
(String -> VS (r typ) -> [VS (r val)] -> VS (r val))
-> String
-> [VS (r val)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r stmt)
CP.inOutCall (String
-> String
-> VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)]
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> PosCall r val typ
extFuncApp String
m)

instance OOFuncAppStatement SwiftCode Statement Variable Value where
  selfInOutCall :: InOutCall SwiftCode Statement Variable Value
selfInOutCall = (String
 -> VS (SwiftCode TypeData)
 -> [VS (SwiftCode Value)]
 -> VS (SwiftCode Value))
-> InOutCall SwiftCode Statement Variable Value
forall {k} (r :: k -> *) (typ :: k) (stmt :: k) (var :: k)
       (val :: k).
(TypeSym r typ, InternalAssignStmt r stmt var val,
 ValueStatement r stmt val, VariableValue r var val) =>
(String -> VS (r typ) -> [VS (r val)] -> VS (r val))
-> String
-> [VS (r val)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r stmt)
CP.inOutCall String
-> VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)]
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, VariableValue r var val,
 SelfSym r var) =>
PosCall r val typ
selfMethodCall

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

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

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

  throw :: String -> MS (SwiftCode Statement)
throw String
msg = do
    (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
setThrowUsed
    (SwiftCode Value -> Block)
-> Terminator -> String -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (stmt :: k).
(Literal r val typ, RenderStatement r stmt) =>
(r val -> Block) -> Terminator -> String -> MS (r stmt)
G.throw SwiftCode Value -> Block
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
swiftThrowDoc Terminator
Empty String
msg

  ifCond :: [(VS (SwiftCode Value), MS (SwiftCode Block))]
-> MS (SwiftCode Block) -> MS (SwiftCode Statement)
ifCond = (Block -> Block)
-> Block
-> OptionalSpace
-> Block
-> Block
-> Block
-> [(VS (SwiftCode Value), MS (SwiftCode Block))]
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Block -> Block)
-> Block
-> OptionalSpace
-> Block
-> Block
-> Block
-> [(VS (r val), MS (r bod))]
-> MS (r bod)
-> MS (r stmt)
G.ifCond Block -> Block
forall a. a -> a
id Block
bodyStart OptionalSpace
G.defaultOptSpace Block
elseIfLabel Block
bodyEnd Block
empty
  switch :: VS (SwiftCode Value)
-> [(VS (SwiftCode Value), MS (SwiftCode Block))]
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
switch VS (SwiftCode Value)
v [(VS (SwiftCode Value), MS (SwiftCode Block))]
cs MS (SwiftCode Block)
bod = do
    st <- MS (SwiftCode Statement) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
RenderStatement r stmt =>
MS (r stmt) -> MS (r stmt)
RC.stmt MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt
    vl <- zoom lensMStoVS v
    vals <- mapM (zoom lensMStoVS . fst) cs
    bods <- mapM snd cs
    dflt <- bod
    mkStmtNoEnd $ R.switch (space <>) st vl dflt (zip vals bods)

  ifExists :: VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
ifExists = VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k) (binder :: k) (typ :: k).
(ControlStatement r bod stmt var val,
 ValueExpression r var val binder typ) =>
VS (r val) -> MS (r bod) -> MS (r bod) -> MS (r stmt)
M.ifExists

  for :: MS (SwiftCode Statement)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
for MS (SwiftCode Statement)
_ VS (SwiftCode Value)
_ MS (SwiftCode Statement)
_ MS (SwiftCode Block)
_ = String -> MS (SwiftCode Statement)
forall a. HasCallStack => String -> a
error (String -> MS (SwiftCode Statement))
-> String -> MS (SwiftCode Statement)
forall a b. (a -> b) -> a -> b
$ String -> String
CP.forLoopError String
swiftName
  forRange :: VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forRange VS (SwiftCode Variable)
i VS (SwiftCode Value)
initv VS (SwiftCode Value)
finalv VS (SwiftCode Value)
stepv = VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
VS (r var) -> VS (r val) -> MS (r bod) -> MS (r stmt)
forEach VS (SwiftCode Variable)
i (VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, VariableSym r var typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
swiftStrideFunc VS (SwiftCode Value)
initv VS (SwiftCode Value)
finalv VS (SwiftCode Value)
stepv)
  forEach :: VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forEach = (SwiftCode Variable -> SwiftCode Value -> SwiftCode Block -> Block)
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall (r :: * -> *) stmt var val.
RenderStatement r stmt =>
(r var -> r val -> r Block -> Block)
-> VS (r var) -> VS (r val) -> MS (r Block) -> MS (r stmt)
CS.forEach' SwiftCode Variable -> SwiftCode Value -> SwiftCode Block -> Block
forall {k} (r :: k -> *) (bod :: k) (var :: k) (val :: k).
(BodyElim r bod, InternalVarElim r var, ValueElim r val) =>
r var -> r val -> r bod -> Block
swiftForEach
  while :: VS (SwiftCode Value)
-> MS (SwiftCode Block) -> MS (SwiftCode Statement)
while = (Block -> Block)
-> Block
-> Block
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (val :: k).
(BodyElim r bod, RenderStatement r stmt, ValueElim r val) =>
(Block -> Block)
-> Block -> Block -> VS (r val) -> MS (r bod) -> MS (r stmt)
C.while Block -> Block
forall a. a -> a
id Block
bodyStart Block
bodyEnd

  tryCatch :: MS (SwiftCode Block)
-> MS (SwiftCode Block) -> MS (SwiftCode Statement)
tryCatch = (SwiftCode Block -> SwiftCode Block -> Block)
-> MS (SwiftCode Block)
-> MS (SwiftCode Block)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (bod :: k).
RenderStatement r stmt =>
(r bod -> r bod -> Block)
-> MS (r bod) -> MS (r bod) -> MS (r stmt)
G.tryCatch SwiftCode Block -> SwiftCode Block -> Block
forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> r bod -> Block
swiftTryCatch

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

instance ObserverPattern SwiftCode Statement TypeData where
  notifyObservers :: VS (SwiftCode FuncData)
-> VS (SwiftCode TypeData) -> MS (SwiftCode Statement)
notifyObservers = VS (SwiftCode FuncData)
-> VS (SwiftCode TypeData) -> MS (SwiftCode Statement)
forall (r :: * -> *) bod block stmt val typ var.
(BodySym r bod block, BlockSym r block stmt,
 ValueStatement r stmt val, TypeSym r typ, Literal r val typ,
 VariableSym r var typ, VariableValue r var val, List r val,
 ControlStatement r bod stmt var val, OOFunctionSym r val typ) =>
VS (r FuncData) -> VS (r typ) -> MS (r stmt)
M.notifyObservers'

instance StrategyPattern SwiftCode Body Block Variable Value where
  runStrategy :: String
-> [(String, MS (SwiftCode Block))]
-> Maybe (VS (SwiftCode Value))
-> Maybe (VS (SwiftCode Variable))
-> MS (SwiftCode Block)
runStrategy = String
-> [(String, MS (SwiftCode Block))]
-> Maybe (VS (SwiftCode Value))
-> Maybe (VS (SwiftCode Variable))
-> MS (SwiftCode Block)
forall (r :: * -> *) stmt var val bod.
(EmptyStatement r stmt, AssignStatement r stmt var val,
 BodyElim r bod, Monad r, RenderStatement r stmt,
 StatementElim r stmt) =>
String
-> [(String, MS (r bod))]
-> Maybe (VS (r val))
-> Maybe (VS (r var))
-> MS (r Block)
M.runStrategy

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

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

instance VisibilityElim SwiftCode Doc where
  visibility :: SwiftCode Block -> Block
visibility = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC

instance MethodTypeSym SwiftCode TypeData where
  mType :: VS (SwiftCode TypeData) -> MS (SwiftCode TypeData)
mType = LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode TypeData))
  MethodState
  ValueState
-> VS (SwiftCode TypeData) -> MS (SwiftCode TypeData)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode TypeData))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode TypeData) ValueState)
-> MethodState
-> Focusing Identity (SwiftCode TypeData) MethodState
Lens' MethodState ValueState
lensMStoVS

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

instance ParameterSym SwiftCode ParamData Variable where
  param :: VS (SwiftCode Variable) -> MS (SwiftCode ParamData)
param = (SwiftCode Variable -> Block)
-> VS (SwiftCode Variable) -> MS (SwiftCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k) (typ :: k).
(RenderParam r param var, VariableElim r var typ) =>
(r var -> Block) -> VS (r var) -> MS (r param)
G.param (Block -> SwiftCode Variable -> Block
swiftParam Block
empty)
  pointerParam :: VS (SwiftCode Variable) -> MS (SwiftCode ParamData)
pointerParam = (SwiftCode Variable -> Block)
-> VS (SwiftCode Variable) -> MS (SwiftCode ParamData)
forall {k} (r :: k -> *) (param :: k) (var :: k) (typ :: k).
(RenderParam r param var, VariableElim r var typ) =>
(r var -> Block) -> VS (r var) -> MS (r param)
G.param (Block -> SwiftCode Variable -> Block
swiftParam Block
swiftInOut)

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

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

instance MethodSym SwiftCode MethodData Doc ParamData Body Variable TypeData where
  docMain :: MS (SwiftCode Block) -> MS (SwiftCode MethodData)
docMain = MS (SwiftCode Block) -> MS (SwiftCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
MS (r bod) -> MS (r mthd)
mainFunction
  function :: String
-> SwiftCode Block
-> VS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
function = String
-> SwiftCode Block
-> VS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
forall {k} (r :: k -> *) (attch :: k) (typ :: k) (mthd :: k)
       (vis :: k) (param :: k) (bod :: k).
(AttachmentSym r attch, MethodTypeSym r typ,
 OORenderMethod r mthd attch vis param bod typ) =>
String
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
G.function
  mainFunction :: MS (SwiftCode Block) -> MS (SwiftCode MethodData)
mainFunction = MS (SwiftCode Block) -> MS (SwiftCode MethodData)
forall (r :: * -> *) bod mthd.
(BodyElim r bod, RenderMethod r mthd) =>
MS (r bod) -> MS (r mthd)
CP.mainBody
  docFunc :: String
-> [String]
-> Maybe String
-> MS (SwiftCode MethodData)
-> MS (SwiftCode MethodData)
docFunc = FuncDocRenderer
-> String
-> [String]
-> Maybe String
-> MS (SwiftCode MethodData)
-> MS (SwiftCode MethodData)
forall (r :: * -> *) mthd.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> String -> [String] -> Maybe String -> MS (r mthd) -> MS (r mthd)
G.docFunc FuncDocRenderer
CP.functionDoc

  inOutFunc :: String
-> SwiftCode Block -> InOutFunc SwiftCode MethodData Block Variable
inOutFunc String
n SwiftCode Block
s = (VS (SwiftCode TypeData)
 -> [MS (SwiftCode ParamData)]
 -> MS (SwiftCode Block)
 -> MS (SwiftCode MethodData))
-> InOutFunc SwiftCode MethodData Block Variable
forall {k} (r :: k -> *) (var :: k) (val :: k) (param :: k)
       (typ :: k) (scope :: k) (bod :: k) (stmt :: k) (block :: k)
       (mthd :: k).
(VariableValue r var val, ParameterSym r param var, TypeSym r typ,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 BlockSym r block stmt, BodySym r bod block, VariableElim r var typ,
 RenderBody r bod, RenderType r typ,
 InternalControlStmt r stmt val) =>
(VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd))
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
CP.inOutFunc (String
-> SwiftCode Block
-> VS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String
-> r vis
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
function String
n SwiftCode Block
s)

  docInOutFunc :: String
-> SwiftCode Block
-> DocInOutFunc SwiftCode MethodData Block Variable
docInOutFunc String
n SwiftCode Block
s = FuncDocRenderer
-> InOutFunc SwiftCode MethodData Block Variable
-> DocInOutFunc SwiftCode MethodData Block Variable
forall (r :: * -> *) mthd var bod.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> ([VS (r var)]
    -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc' FuncDocRenderer
CP.functionDoc (String
-> SwiftCode Block -> InOutFunc SwiftCode MethodData Block Variable
forall {k} (r :: k -> *) (mthd :: k) (vis :: k) (param :: k)
       (bod :: k) (var :: k) (typ :: k).
MethodSym r mthd vis param bod var typ =>
String -> r vis -> InOutFunc r mthd bod var
inOutFunc String
n SwiftCode Block
s)

instance OOMethodSym SwiftCode MethodData Doc Doc ParamData Body Variable Value TypeData where
  method :: String
-> SwiftCode Block
-> SwiftCode Block
-> VS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
method = String
-> SwiftCode Block
-> SwiftCode Block
-> VS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
forall {k} (r :: k -> *) (typ :: k) (mthd :: k) (attch :: k)
       (vis :: k) (param :: k) (bod :: k).
(MethodTypeSym r typ,
 OORenderMethod r mthd attch vis param bod typ) =>
String
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
G.method
  getMethod :: VS (SwiftCode Variable) -> MS (SwiftCode MethodData)
getMethod = VS (SwiftCode Variable) -> MS (SwiftCode MethodData)
forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
VS (r var) -> MS (r mthd)
G.getMethod
  setMethod :: VS (SwiftCode Variable) -> MS (SwiftCode MethodData)
setMethod = VS (SwiftCode Variable) -> MS (SwiftCode MethodData)
forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
OORenderSym
  r
  file
  mod
  cls
  stvr
  mthd
  attch
  vis
  param
  bod
  block
  stmt
  var
  scope
  val
  binder
  typ =>
VS (r var) -> MS (r mthd)
G.setMethod
  constructor :: [MS (SwiftCode ParamData)]
-> NamedArgs SwiftCode Variable Value
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
constructor = [MS (SwiftCode ParamData)]
-> NamedArgs SwiftCode Variable Value
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
swiftConstructor

  inOutMethod :: String
-> SwiftCode Block
-> SwiftCode Block
-> InOutFunc SwiftCode MethodData Block Variable
inOutMethod String
n SwiftCode Block
s SwiftCode Block
p = (VS (SwiftCode TypeData)
 -> [MS (SwiftCode ParamData)]
 -> MS (SwiftCode Block)
 -> MS (SwiftCode MethodData))
-> InOutFunc SwiftCode MethodData Block Variable
forall {k} (r :: k -> *) (var :: k) (val :: k) (param :: k)
       (typ :: k) (scope :: k) (bod :: k) (stmt :: k) (block :: k)
       (mthd :: k).
(VariableValue r var val, ParameterSym r param var, TypeSym r typ,
 ScopeSym r scope, DeclStatement r bod stmt var scope val,
 BlockSym r block stmt, BodySym r bod block, VariableElim r var typ,
 RenderBody r bod, RenderType r typ,
 InternalControlStmt r stmt val) =>
(VS (r typ) -> [MS (r param)] -> MS (r bod) -> MS (r mthd))
-> [VS (r var)]
-> [VS (r var)]
-> [VS (r var)]
-> MS (r bod)
-> MS (r mthd)
CP.inOutFunc (String
-> SwiftCode Block
-> SwiftCode Block
-> VS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String
-> r vis
-> r attch
-> VS (r typ)
-> [MS (r param)]
-> MS (r bod)
-> MS (r mthd)
method String
n SwiftCode Block
s SwiftCode Block
p)
  docInOutMethod :: String
-> SwiftCode Block
-> SwiftCode Block
-> DocInOutFunc SwiftCode MethodData Block Variable
docInOutMethod String
n SwiftCode Block
s SwiftCode Block
p = FuncDocRenderer
-> InOutFunc SwiftCode MethodData Block Variable
-> DocInOutFunc SwiftCode MethodData Block Variable
forall (r :: * -> *) mthd var bod.
(BlockCommentSym r, RenderMethod r mthd) =>
FuncDocRenderer
-> ([VS (r var)]
    -> [VS (r var)] -> [VS (r var)] -> MS (r bod) -> MS (r mthd))
-> String
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> [(String, VS (r var))]
-> MS (r bod)
-> MS (r mthd)
CP.docInOutFunc' FuncDocRenderer
CP.functionDoc (String
-> SwiftCode Block
-> SwiftCode Block
-> InOutFunc SwiftCode MethodData Block Variable
forall {k} (r :: k -> *) (mthd :: k) (attch :: k) (vis :: k)
       (param :: k) (bod :: k) (var :: k) (val :: k) (typ :: k).
OOMethodSym r mthd attch vis param bod var val typ =>
String -> r vis -> r attch -> InOutFunc r mthd bod var
inOutMethod String
n SwiftCode Block
s SwiftCode Block
p)

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

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

instance OORenderMethod SwiftCode MethodData Doc Doc ParamData Body TypeData where
  intMethod :: Bool
-> String
-> SwiftCode Block
-> SwiftCode Block
-> MS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
intMethod Bool
_ = String
-> SwiftCode Block
-> SwiftCode Block
-> MS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
swiftMethod
  intFunc :: Bool
-> String
-> SwiftCode Block
-> SwiftCode Block
-> MS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
intFunc Bool
_ String
n SwiftCode Block
s SwiftCode Block
_ = String
-> SwiftCode Block
-> SwiftCode Block
-> MS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
swiftMethod String
n SwiftCode Block
s SwiftCode Block
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel
  destructor :: forall stvr.
[CSStateVar SwiftCode stvr] -> MS (SwiftCode MethodData)
destructor [CSStateVar SwiftCode stvr]
_ = String -> MS (SwiftCode MethodData)
forall a. HasCallStack => String -> a
error (String -> MS (SwiftCode MethodData))
-> String -> MS (SwiftCode MethodData)
forall a b. (a -> b) -> a -> b
$ String -> String
CP.destructorError String
swiftName

instance MethodElim SwiftCode MethodData where
  method :: SwiftCode MethodData -> Block
method = MethodData -> Block
mthdDoc (MethodData -> Block)
-> (SwiftCode MethodData -> MethodData)
-> SwiftCode MethodData
-> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode MethodData -> MethodData
forall a. SwiftCode a -> a
unSC

instance StateVarSym SwiftCode Doc Doc Doc Variable Value where
  stateVar :: SwiftCode Block
-> SwiftCode Block
-> VS (SwiftCode Variable)
-> CSStateVar SwiftCode Block
stateVar SwiftCode Block
s SwiftCode Block
p VS (SwiftCode Variable)
vr = do
    v <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  ClassState
  ValueState
-> VS (SwiftCode Variable)
-> StateT ClassState Identity (SwiftCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) ClassState ValueState
-> StateT ValueState Identity c -> StateT ClassState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  ClassState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Variable) ValueState)
-> ClassState -> Focusing Identity (SwiftCode Variable) ClassState
Lens' ClassState ValueState
lensCStoVS VS (SwiftCode Variable)
vr
    stateVarDef s p vr (typeDfltVal $ getCodeType $ variableType v)
  stateVarDef :: SwiftCode Block
-> SwiftCode Block
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> CSStateVar SwiftCode Block
stateVarDef = SwiftCode Block
-> SwiftCode Block
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> CSStateVar SwiftCode Block
forall (r :: * -> *) file mod cls stvr mthd attch vis param bod
       block stmt var scope val binder typ.
(OORenderSym
   r
   file
   mod
   cls
   stvr
   mthd
   attch
   vis
   param
   bod
   block
   stmt
   var
   scope
   val
   binder
   typ,
 Monad r) =>
r vis -> r attch -> VS (r var) -> VS (r val) -> CS (r Block)
CP.stateVarDef
  constVar :: SwiftCode Block
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> CSStateVar SwiftCode Block
constVar = Block
-> SwiftCode Block
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> CSStateVar SwiftCode Block
forall (r :: * -> *) mthd vis param bod block stmt var scope val
       binder typ.
(CommonRenderSym
   r mthd vis param bod block stmt var scope val binder typ,
 Monad r) =>
Block -> r vis -> VS (r var) -> VS (r val) -> CS (r Block)
CP.constVar (SwiftCode Block -> Block
forall {k} (r :: k -> *) (attch :: k).
PermElim r attch =>
r attch -> Block
RC.perm (SwiftCode Block
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel :: SwiftCode Doc))

instance StateVarElim SwiftCode StateVar where
  stateVar :: SwiftCode Block -> Block
stateVar = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC

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

  docClass :: String -> CSStateVar SwiftCode Block -> CSStateVar SwiftCode Block
docClass = ClassDocRenderer
-> String
-> CSStateVar SwiftCode Block
-> CSStateVar SwiftCode Block
forall (r :: * -> *) cls stvr mthd vis.
(BlockCommentSym r, RenderClass r cls stvr mthd vis) =>
ClassDocRenderer -> String -> CS (r cls) -> CS (r cls)
G.docClass ClassDocRenderer
swiftClassDoc

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

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

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

instance ClassElim SwiftCode Class where
  class' :: SwiftCode Block -> Block
class' = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC

instance ModuleSym SwiftCode ModData Class MethodData where
  buildModule :: String
-> [String]
-> [MS (SwiftCode MethodData)]
-> [CSStateVar SwiftCode Block]
-> FS (SwiftCode ModData)
buildModule String
n [String]
is [MS (SwiftCode MethodData)]
fs [CSStateVar SwiftCode Block]
cs = do
    (FileState -> FileState) -> StateT FileState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify (String -> FileState -> FileState
setModuleName String
n) -- This needs to be set before the functions/
                             -- classes are evaluated. CP.buildModule will
                             -- reset it to the proper name.
    fns <- (MS (SwiftCode MethodData)
 -> StateT FileState Identity (SwiftCode MethodData))
-> [MS (SwiftCode MethodData)]
-> StateT FileState Identity [SwiftCode MethodData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM (LensLike'
  (Zoomed (StateT MethodState Identity) (SwiftCode MethodData))
  FileState
  MethodState
-> MS (SwiftCode MethodData)
-> StateT FileState Identity (SwiftCode MethodData)
forall c.
LensLike'
  (Zoomed (StateT MethodState Identity) c) FileState MethodState
-> StateT MethodState Identity c -> StateT FileState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT MethodState Identity) (SwiftCode MethodData))
  FileState
  MethodState
(MethodState
 -> Focusing Identity (SwiftCode MethodData) MethodState)
-> FileState -> Focusing Identity (SwiftCode MethodData) FileState
Lens' FileState MethodState
lensFStoMS) [MS (SwiftCode MethodData)]
fs
    cls <- mapM (zoom lensFStoCS) cs
    mn <- getCurrMain
    let modName = if Bool
mn then String
swiftMain else String
n
    CP.buildModule modName (do
      lis <- getLangImports
      libis <- getLibImports
      pure $ vcat $ RC.import' .
          (langImport :: Label -> SwiftCode Doc)
          <$> sort (lis P.<> is P.<> libis))
      (zoom lensFStoMS swiftStringError) getMainDoc
        (pure <$> fns) (pure <$> cls)

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

instance ModuleElim SwiftCode ModData where
  module' :: SwiftCode ModData -> Block
module' = ModData -> Block
modDoc (ModData -> Block)
-> (SwiftCode ModData -> ModData) -> SwiftCode ModData -> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode ModData -> ModData
forall a. SwiftCode a -> a
unSC

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

instance BlockCommentElim SwiftCode where
  blockComment' :: SwiftCode Block -> Block
blockComment' = SwiftCode Block -> Block
forall a. SwiftCode a -> a
unSC

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

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

swiftName, swiftVersion :: String
swiftName :: String
swiftName = String
"Swift"
swiftVersion :: String
swiftVersion = String
"5.2.4"

swiftUnwrapVal
  :: (RenderValue r var val typ, ValueElim r val, ValueSym r val typ)
  => VS (r val) -> VS (r val)
swiftUnwrapVal :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftUnwrapVal VS (r val)
v' = do
  v <- VS (r val)
v'
  mkVal (valueType v) (RC.value v <> swiftUnwrap')

swiftTryVal
  :: (RenderValue r var val typ, ValueElim r val, ValueSym r val typ)
  => VS (r val) -> VS (r val)
swiftTryVal :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal VS (r val)
v' = do
  v <- VS (r val)
v'
  mkVal (valueType v) (tryLabel <+> RC.value v)

swiftArgVal
  :: (RenderValue r var val typ, ValueElim r val, ValueSym r val typ)
  => VS (r val) -> VS (r val)
swiftArgVal :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftArgVal VS (r val)
v' = do
  v <- VS (r val)
v'
  mkVal (valueType v) (swiftInOutArg <> RC.value v)

-- Putting "gool" in these names to avoid name conflicts
swiftContentsVar, swiftLineVar :: VS (SwiftCode Variable)
swiftContentsVar :: VS (SwiftCode Variable)
swiftContentsVar = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"goolContents" (VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType (VS (SwiftCode TypeData) -> VS (SwiftCode TypeData))
-> VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)
swiftLineVar :: VS (SwiftCode Variable)
swiftLineVar = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"goolLine" (VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string)

swiftContentsVal, swiftLineVal :: VS (SwiftCode Value)
swiftContentsVal :: VS (SwiftCode Value)
swiftContentsVal = VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (SwiftCode Variable)
swiftContentsVar
swiftLineVal :: VS (SwiftCode Value)
swiftLineVal = VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (SwiftCode Variable)
swiftLineVar

swiftIntType :: (Monad r) => VS (r TypeData)
swiftIntType :: forall (r :: * -> *). Monad r => VS (r TypeData)
swiftIntType = CodeType -> String -> Block -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Block -> VS (r TypeData)
typeFromData CodeType
Integer String
swiftInt (String -> Block
text String
swiftInt)

swiftCharType :: (Monad r) => VS (r TypeData)
swiftCharType :: forall (r :: * -> *). Monad r => VS (r TypeData)
swiftCharType = CodeType -> String -> Block -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Block -> VS (r TypeData)
typeFromData CodeType
Char String
swiftChar (String -> Block
text String
swiftChar)

swiftFileType :: (Monad r) => VS (r TypeData)
swiftFileType :: forall (r :: * -> *). Monad r => VS (r TypeData)
swiftFileType = VS (r TypeData) -> VS (r TypeData)
forall a. VS a -> VS a
addFoundationImport (VS (r TypeData) -> VS (r TypeData))
-> VS (r TypeData) -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ CodeType -> String -> Block -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Block -> VS (r TypeData)
typeFromData CodeType
InFile String
swiftURL
  (String -> Block
text String
swiftURL)

swiftFileHdlType :: (Monad r) => VS (r TypeData)
swiftFileHdlType :: forall (r :: * -> *). Monad r => VS (r TypeData)
swiftFileHdlType = VS (r TypeData) -> VS (r TypeData)
forall a. VS a -> VS a
addFoundationImport (VS (r TypeData) -> VS (r TypeData))
-> VS (r TypeData) -> VS (r TypeData)
forall a b. (a -> b) -> a -> b
$ CodeType -> String -> Block -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Block -> VS (r TypeData)
typeFromData CodeType
OutFile String
swiftFileHdl
  (String -> Block
text String
swiftFileHdl)

swiftListType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
swiftListType :: VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
swiftListType VS (SwiftCode TypeData)
t' = do
  t <- VS (SwiftCode TypeData)
t'
  typeFromData (List $ getCodeType t) ("[" P.<> getTypeString t P.<> "]")
    (brackets $ renderType t)

swiftFuncType :: [VS (SwiftCode TypeData)] -> VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
swiftFuncType :: [VS (SwiftCode TypeData)]
-> VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
swiftFuncType [VS (SwiftCode TypeData)]
ps VS (SwiftCode TypeData)
r = do
  pts <- [VS (SwiftCode TypeData)]
-> StateT ValueState Identity [SwiftCode TypeData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [VS (SwiftCode TypeData)]
ps
  rt <- r
  typeFromData (Func (getCodeType <$> pts) (getCodeType rt))
    ("(" P.<> intercalate listSep (getTypeString <$> pts) P.<> ")" P.<> " " P.<>
      swiftRetType P.<> " " P.<> getTypeString rt)
    (parens (hicat listSep' $ renderType <$> pts) <+> swiftRetType' <+>
      renderType rt)

swiftVoidType :: (Monad r) => VS (r TypeData)
swiftVoidType :: forall (r :: * -> *). Monad r => VS (r TypeData)
swiftVoidType = CodeType -> String -> Block -> VS (r TypeData)
forall (r :: * -> *).
Monad r =>
CodeType -> String -> Block -> VS (r TypeData)
typeFromData CodeType
Void String
swiftVoid (String -> Block
text String
swiftVoid)

swiftPi, swiftFirst, swiftDesc, swiftUTF8, swiftVar, swiftConst,
  swiftDo, swiftFunc, swiftCtorName, swiftExtension, swiftInOut, swiftError,
  swiftDocDir, swiftUTF8Enc, swiftUserMask, swiftInOutArg, swiftNamedArgSep,
  swiftTypeSpec, swiftConforms, swiftNoLabel, swiftRetType', swiftUnwrap',
  swiftRetroactive :: Doc
swiftPi :: Block
swiftPi = String -> Block
text (String -> Block) -> String -> Block
forall a b. (a -> b) -> a -> b
$ String
CP.doubleRender String -> String -> String
`access` String
piLabel
swiftFirst :: Block
swiftFirst = String -> Block
text String
"first"
swiftDesc :: Block
swiftDesc = String -> Block
text String
"description"
swiftUTF8 :: Block
swiftUTF8 = String -> Block
text String
"utf8"
swiftVar :: Block
swiftVar = String -> Block
text String
"var"
swiftConst :: Block
swiftConst = String -> Block
text String
"let"
swiftDo :: Block
swiftDo = String -> Block
text String
"do"
swiftFunc :: Block
swiftFunc = String -> Block
text String
"func"
swiftCtorName :: Block
swiftCtorName = String -> Block
text String
"init"
swiftExtension :: Block
swiftExtension = String -> Block
text String
"extension"
swiftInOut :: Block
swiftInOut = String -> Block
text String
"inout"
swiftError :: Block
swiftError = String -> Block
text String
"Error"
swiftDocDir :: Block
swiftDocDir = String -> Block
text (String -> Block) -> String -> Block
forall a b. (a -> b) -> a -> b
$ String
"" String -> String -> String
`access` String
"documentDirectory"
swiftUTF8Enc :: Block
swiftUTF8Enc = String -> Block
text (String -> Block) -> String -> Block
forall a b. (a -> b) -> a -> b
$ String
"" String -> String -> String
`access` String
"utf8"
swiftUserMask :: Block
swiftUserMask = String -> Block
text (String -> Block) -> String -> Block
forall a b. (a -> b) -> a -> b
$ String
"" String -> String -> String
`access` String
"userDomainMask"
swiftNamedArgSep :: Block
swiftNamedArgSep = Block
colon Block -> Block -> Block
<> Block
space
swiftInOutArg :: Block
swiftInOutArg = String -> Block
text String
"&"
swiftTypeSpec :: Block
swiftTypeSpec = Block
colon
swiftConforms :: Block
swiftConforms = Block
colon
swiftNoLabel :: Block
swiftNoLabel = String -> Block
text String
"_"
swiftRetType' :: Block
swiftRetType' = String -> Block
text String
swiftRetType
swiftUnwrap' :: Block
swiftUnwrap' = String -> Block
text String
swiftUnwrap
swiftRetroactive :: Block
swiftRetroactive = String -> Block
text String
"@retroactive"

swiftMain, swiftFoundation, swiftMath, swiftNil, swiftInt, swiftChar,
  swiftURL, swiftFileHdl, swiftRetType, swiftVoid, swiftCommLine,
  swiftSearchDir, swiftPathMask, swiftArgs, swiftWrite, swiftIndex,
  swiftStride, swiftMap, swiftListAdd, swiftListSize, swiftListRemove,
  swiftListAppend, swiftReadLine, swiftSeekEnd, swiftClose, swiftJoined,
  swiftAppendPath, swiftUrls, swiftSplit, swiftData, swiftEncoding, swiftOf,
  swiftFrom, swiftTo, swiftBy, swiftAt, swiftTerm, swiftFor, swiftIn,
  swiftContentsOf, swiftWriteTo, swiftSep, swiftSepBy, swiftUnwrap,
  swiftContains, swiftSet, swiftUnion :: String
swiftMain :: String
swiftMain = String
"main"
swiftFoundation :: String
swiftFoundation = String
"Foundation"
swiftMath :: String
swiftMath = String
swiftFoundation
swiftNil :: String
swiftNil = String
"nil"
swiftInt :: String
swiftInt = String
"Int"
swiftChar :: String
swiftChar = String
"Character"
swiftURL :: String
swiftURL = String
"URL"
swiftFileHdl :: String
swiftFileHdl = String
"FileHandle"
swiftRetType :: String
swiftRetType = String
"->"
swiftVoid :: String
swiftVoid = String
"Void"
swiftCommLine :: String
swiftCommLine = String
"CommandLine"
swiftSearchDir :: String
swiftSearchDir = String
"SearchPathDirectory"
swiftPathMask :: String
swiftPathMask = String
"SearchPathDomainMask"
swiftArgs :: String
swiftArgs = String
"arguments"
swiftWrite :: String
swiftWrite = String
"write"
swiftIndex :: String
swiftIndex = String
"firstIndex"
swiftStride :: String
swiftStride = String
"stride"
swiftMap :: String
swiftMap = String
"map"
swiftListAdd :: String
swiftListAdd = String
"insert"
swiftListSize :: String
swiftListSize = String
"count"
swiftListRemove :: String
swiftListRemove = String
"remove"
swiftListAppend :: String
swiftListAppend = String
"append"
swiftReadLine :: String
swiftReadLine = String
"readLine"
swiftSeekEnd :: String
swiftSeekEnd = String
"seekToEnd"
swiftClose :: String
swiftClose = String
"close"
swiftJoined :: String
swiftJoined = String
"joined"
swiftAppendPath :: String
swiftAppendPath = String
"appendingPathComponent"
swiftUrls :: String
swiftUrls = String
"FileManager" String -> String -> String
`access` String
"default" String -> String -> String
`access` String
"urls"
swiftSplit :: String
swiftSplit = String
"components"
swiftData :: String
swiftData = String
"Data"
swiftEncoding :: String
swiftEncoding = String
"Encoding"
swiftOf :: String
swiftOf = String
"of"
swiftFrom :: String
swiftFrom = String
"from"
swiftTo :: String
swiftTo = String
"to"
swiftBy :: String
swiftBy = String
"by"
swiftAt :: String
swiftAt = String
"at"
swiftTerm :: String
swiftTerm = String
"terminator"
swiftFor :: String
swiftFor = String
"for"
swiftIn :: String
swiftIn = String
"in"
swiftContentsOf :: String
swiftContentsOf = String
"contentsOf"
swiftWriteTo :: String
swiftWriteTo = String
"forWritingTo"
swiftSep :: String
swiftSep = String
"separator"
swiftSepBy :: String
swiftSepBy = String
"separatedBy"
swiftUnwrap :: String
swiftUnwrap = String
"!"
swiftContains :: String
swiftContains = String
"contains"
swiftSet :: String
swiftSet = String
"Set"
swiftUnion :: String
swiftUnion = String
"union"

swiftUnaryMath :: (Monad r) => String -> VSOp r
swiftUnaryMath :: forall (r :: * -> *). Monad r => String -> VSOp r
swiftUnaryMath = VS (r OpData) -> VS (r OpData)
forall a. VS a -> VS a
addMathImport (VS (r OpData) -> VS (r OpData))
-> (String -> VS (r OpData)) -> String -> VS (r OpData)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> VS (r OpData)
forall (r :: * -> *). Monad r => String -> VSOp r
unOpPrec

swiftNumBinExpr
  :: (VS (SwiftCode Value) -> VS (SwiftCode Value) -> VS (SwiftCode Value))
  -> VS (SwiftCode Value)
  -> VS (SwiftCode Value)
  -> VS (SwiftCode Value)
swiftNumBinExpr :: (VS (SwiftCode Value)
 -> VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
swiftNumBinExpr VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f VS (SwiftCode Value)
v1' VS (SwiftCode Value)
v2' = do
  v1 <- VS (SwiftCode Value)
v1'
  v2 <- v2'
  let exprT CodeType
t1 CodeType
t2 = if CodeType
t1 CodeType -> CodeType -> Bool
forall a. Eq a => a -> a -> Bool
== CodeType
t2 then VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v1) (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v2) else CodeType -> CodeType -> VS (SwiftCode Value)
exprT' CodeType
t1 CodeType
t2
      exprT' CodeType
Double CodeType
_ = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v1) (VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v2)
      exprT' CodeType
_ CodeType
Double = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f (VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
double (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v1) (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v2)
      exprT' CodeType
Float CodeType
_  = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v1) (VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v2)
      exprT' CodeType
_ CodeType
Float  = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f (VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v1) (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v2)
      exprT' CodeType
_ CodeType
_      = VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
f (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v1) (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v2)
  exprT (getCodeType $ valueType v1) (getCodeType $ valueType v2)

swiftLitFloat
  :: (RenderValue r var val typ, TypeSym r typ)
  => Float -> VS (r val)
swiftLitFloat :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, TypeSym r typ) =>
Float -> VS (r val)
swiftLitFloat = VS (r typ) -> Block -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
float (Block -> VS (r val)) -> (Float -> Block) -> Float -> VS (r val)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Block
D.float

swiftLambda :: [SwiftCode BinderD] -> SwiftCode Value -> Doc
swiftLambda :: [SwiftCode BinderD] -> SwiftCode Value -> Block
swiftLambda [SwiftCode BinderD]
ps SwiftCode Value
ex = Block -> Block
braces (Block -> Block) -> Block -> Block
forall a b. (a -> b) -> a -> b
$ Block -> Block
parens (Block -> [Block] -> Block
hicat Block
listSep'
  ((Block -> Block -> Block) -> [Block] -> [Block] -> [Block]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith (\Block
n Block
t -> Block
n Block -> Block -> Block
<> Block
swiftTypeSpec Block -> Block -> Block
<+> Block
t)
    (SwiftCode BinderD -> Block
forall {k} (r :: k -> *) (binder :: k).
InternalBinderElim r binder =>
r binder -> Block
RC.binderElim (SwiftCode BinderD -> Block) -> [SwiftCode BinderD] -> [Block]
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> [SwiftCode BinderD]
ps)
    (SwiftCode TypeData -> Block
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Block
renderType (SwiftCode TypeData -> Block)
-> (SwiftCode BinderD -> SwiftCode TypeData)
-> SwiftCode BinderD
-> Block
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode BinderD -> SwiftCode TypeData
forall {k} (r :: k -> *) (binder :: k) (typ :: k).
BinderElim r binder typ =>
r binder -> r typ
binderType (SwiftCode BinderD -> Block) -> [SwiftCode BinderD] -> [Block]
forall (r :: * -> *) a b. Functor r => (a -> b) -> r a -> r b
<$> [SwiftCode BinderD]
ps)))
  Block -> Block -> Block
<+> Block
swiftRetType' Block -> Block -> Block
<+> SwiftCode TypeData -> Block
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Block
renderType (SwiftCode Value -> SwiftCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType SwiftCode Value
ex) Block -> Block -> Block
<+> Block
inLabel Block -> Block -> Block
<+> SwiftCode Value -> Block
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
RC.value SwiftCode Value
ex

swiftReadableTypes :: [CodeType]
swiftReadableTypes :: [CodeType]
swiftReadableTypes = [CodeType
Integer, CodeType
Double, CodeType
Float, CodeType
Boolean, CodeType
Char]

swiftCast
  :: VS (SwiftCode TypeData) -> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftCast :: VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftCast VS (SwiftCode TypeData)
t' VS (SwiftCode Value)
v' = do
  t <- VS (SwiftCode TypeData)
t'
  v <- v'
  let unwrap = if SwiftCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType SwiftCode TypeData
t CodeType -> [CodeType] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [CodeType]
swiftReadableTypes Bool -> Bool -> Bool
&&
        SwiftCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (SwiftCode Value -> SwiftCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType SwiftCode Value
v) CodeType -> CodeType -> Bool
forall a. Eq a => a -> a -> Bool
== CodeType
String then VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftUnwrapVal else VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a. a -> a
id
  unwrap $ mkStateVal (pure t) (R.castObj (renderType t) (RC.value v))

swiftIndexFunc
  ::
    ( TypeSym r typ
    , ValueSym r val typ
    , InternalValueExp r var val typ
    , VariableSym r var typ
    )
  => VS (r val) -> VS (r val) -> VS (r val)
swiftIndexFunc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ, InternalValueExp r var val typ,
 VariableSym r var typ) =>
VS (r val) -> VS (r val) -> VS (r val)
swiftIndexFunc VS (r val)
l VS (r val)
v' = do
  v <- VS (r val)
v'
  let t = r typ -> StateT ValueState Identity (r typ)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (r typ -> StateT ValueState Identity (r typ))
-> r typ -> StateT ValueState Identity (r typ)
forall a b. (a -> b) -> a -> b
$ r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType r val
v
      ofArg = String -> StateT ValueState Identity (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftOf StateT ValueState Identity (r typ)
t
  objMethodCallNamedArgs int l swiftIndex [(ofArg, pure v)]

swiftStrideFunc
  ::
    ( TypeSym r typ
    , VariableSym r var typ
    , RenderValue r var val typ
    , ValueExpression r var val binder typ
    )
  => VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
swiftStrideFunc :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, VariableSym r var typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
swiftStrideFunc VS (r val)
beg VS (r val)
end VS (r val)
step = let t :: VS (r typ)
t = VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
                                   fromArg :: VS (r var)
fromArg = String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftFrom VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
                                   toArg :: VS (r var)
toArg = String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftTo VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
                                   byArg :: VS (r var)
byArg = String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftBy VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
  in VS (r typ) -> VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (r typ)
t (String -> VS (r typ) -> NamedArgs r var val -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> VS (r typ) -> NamedArgs r var val -> VS (r val)
funcAppNamedArgs String
swiftStride VS (r typ)
t
    [(VS (r var)
fromArg, VS (r val)
beg), (VS (r var)
toArg, VS (r val)
end), (VS (r var)
byArg, VS (r val)
step)])

swiftMapFunc
  :: (ValueSym r val typ, InternalValueExp r var val typ)
  => VS (r val) -> VS (r val) -> VS (r val)
swiftMapFunc :: forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k).
(ValueSym r val typ, InternalValueExp r var val typ) =>
VS (r val) -> VS (r val) -> VS (r val)
swiftMapFunc VS (r val)
lst VS (r val)
f = VS (r typ) -> VS (r val) -> String -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> [VS (r val)] -> VS (r val)
objMethodCall ((r val -> r typ) -> VS (r val) -> VS (r typ)
forall a b s. (a -> b) -> State s a -> State s b
onStateValue r val -> r typ
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType VS (r val)
lst) VS (r val)
lst String
swiftMap [VS (r val)
f]

swiftWriteFunc
  :: VS (SwiftCode Value) -> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftWriteFunc :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftWriteFunc VS (SwiftCode Value)
v VS (SwiftCode Value)
f = let contentsArg :: VS (SwiftCode Variable)
contentsArg = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftContentsOf (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftData)
  in VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode TypeData)
-> VS (SwiftCode Value)
-> String
-> NamedArgs SwiftCode Variable Value
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ)
-> VS (r val) -> String -> NamedArgs r var val -> VS (r val)
objMethodCallNamedArgs VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void VS (SwiftCode Value)
f String
swiftWrite
    [(VS (SwiftCode Variable)
contentsArg, VS (SwiftCode TypeData)
-> [VS (SwiftCode Value)] -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
OOValueExpression r var val typ =>
PosCtorCall r val typ
newObj (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftData) [VS (SwiftCode Value)
v VS (SwiftCode Value)
-> VS (SwiftCode FuncData) -> VS (SwiftCode Value)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. Block -> VS (SwiftCode TypeData) -> VS (SwiftCode FuncData)
forall (r :: * -> *) typ.
RenderFunction r typ =>
Block -> VS (r typ) -> VS (r FuncData)
funcFromData (Block -> Block
R.func Block
swiftUTF8)
    (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftEncoding)])]

swiftReadLineFunc
  ::
    ( TypeSym r typ
    , ValueSym r val typ
    , RenderValue r var val typ
    , ValueElim r val
    , ValueExpression r var val binder typ
    )
  => VS (r val)
swiftReadLineFunc :: forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k)
       (binder :: k).
(TypeSym r typ, ValueSym r val typ, RenderValue r var val typ,
 ValueElim r val, ValueExpression r var val binder typ) =>
VS (r val)
swiftReadLineFunc = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftUnwrapVal (VS (r val) -> VS (r val)) -> VS (r val) -> VS (r val)
forall a b. (a -> b) -> a -> b
$ PosCall r val typ
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
PosCall r val typ
funcApp String
swiftReadLine VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string []

swiftReadFileFunc
  ::
    ( TypeSym r typ
    , VariableSym r var typ
    , ValueSym r val typ
    , RenderValue r var val typ
    , ValueElim r val
    , ValueExpression r var val binder typ
    )
  => VS (r val) -> VS (r val)
swiftReadFileFunc :: forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, VariableSym r var typ, ValueSym r val typ,
 RenderValue r var val typ, ValueElim r val,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
swiftReadFileFunc VS (r val)
v = VS (r val) -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal (VS (r val) -> VS (r val)) -> VS (r val) -> VS (r val)
forall a b. (a -> b) -> a -> b
$
  String -> VS (r typ) -> NamedArgs r var val -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> VS (r typ) -> NamedArgs r var val -> VS (r val)
funcAppNamedArgs String
CP.stringRender' VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string [(VS (r var), VS (r val))
contentsArg, (VS (r var), VS (r val))
encodingArg]
  where
    encVal :: VS (r val)
encVal = VS (r typ) -> Block -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string Block
swiftUTF8Enc
    contentsArg :: (VS (r var), VS (r val))
contentsArg = (String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftContentsOf VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
infile, VS (r val)
v)
    encodingArg :: (VS (r var), VS (r val))
encodingArg = (String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"encoding" VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string, VS (r val)
encVal)

swiftSplitFunc
  ::
    ( InternalValueExp r var val typ
    , TypeSym r typ
    , Literal r val typ
    , VariableSym r var typ
    )
  => Char -> VS (r val) -> VS (r val)
swiftSplitFunc :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, TypeSym r typ, Literal r val typ,
 VariableSym r var typ) =>
Char -> VS (r val) -> VS (r val)
swiftSplitFunc Char
d VS (r val)
s = let sepArg :: VS (r var)
sepArg = String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftSepBy VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
char
  in VS (r typ)
-> VS (r val) -> String -> NamedArgs r var val -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ)
-> VS (r val) -> String -> NamedArgs r var val -> VS (r val)
objMethodCallNamedArgs (VS (r typ) -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string) VS (r val)
s String
swiftSplit [(VS (r var)
sepArg, Char -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Char -> VS (r val)
litChar Char
d)]

swiftJoinedFunc
  ::
    ( InternalValueExp r var val typ
    , TypeSym r typ
    , Literal r val typ
    , VariableSym r var typ
    )
  => Char -> VS (r val) -> VS (r val)
swiftJoinedFunc :: forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, TypeSym r typ, Literal r val typ,
 VariableSym r var typ) =>
Char -> VS (r val) -> VS (r val)
swiftJoinedFunc Char
d VS (r val)
s = let sepArg :: VS (r var)
sepArg = String -> VS (r typ) -> VS (r var)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftSep VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
char
  in VS (r typ)
-> VS (r val) -> String -> NamedArgs r var val -> VS (r val)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ)
-> VS (r val) -> String -> NamedArgs r var val -> VS (r val)
objMethodCallNamedArgs VS (r typ)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string VS (r val)
s String
swiftJoined [(VS (r var)
sepArg, Char -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Char -> VS (r val)
litChar Char
d)]

swiftIndexOf
  :: VS (SwiftCode Value) -> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftIndexOf :: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftIndexOf = VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftUnwrapVal (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> (VS (SwiftCode Value)
    -> VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall c d a b. (c -> d) -> (a -> b -> c) -> a -> b -> d
.: VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (val :: k) (var :: k).
(TypeSym r typ, ValueSym r val typ, InternalValueExp r var val typ,
 VariableSym r var typ) =>
VS (r val) -> VS (r val) -> VS (r val)
swiftIndexFunc

-- | Swift's syntactic sugar for list slicing.
swiftListSlice
  :: VS (SwiftCode Variable)
  -> VS (SwiftCode Value)
  -> Maybe (VS (SwiftCode Value))
  -> Maybe (VS (SwiftCode Value))
  -> VS (SwiftCode Value)
  -> MS (SwiftCode Block)
swiftListSlice :: VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> Maybe (VS (SwiftCode Value))
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> MS (SwiftCode Block)
swiftListSlice VS (SwiftCode Variable)
vn VS (SwiftCode Value)
vo Maybe (VS (SwiftCode Value))
beg Maybe (VS (SwiftCode Value))
end VS (SwiftCode Value)
step = do

  vnew <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
-> VS (SwiftCode Variable)
-> StateT MethodState Identity (SwiftCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Variable) ValueState)
-> MethodState
-> Focusing Identity (SwiftCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Variable)
vn
  scpData <- getVarScope $ variableName vnew
  let scp = ScopeData -> SwiftCode ScopeData
forall {k} (r :: k -> *) (scope :: k).
ScopeSym r scope =>
ScopeData -> r scope
convScope ScopeData
scpData

  stepV <- zoom lensMStoVS step
  let mbStepV = SwiftCode Value -> Maybe Integer
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Maybe Integer
valueInt SwiftCode Value
stepV

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

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

      i_binder = String -> VS (SwiftCode TypeData) -> VS (SwiftCode BinderD)
forall {k} (r :: k -> *) (binder :: k) (typ :: k).
BinderSym r binder typ =>
String -> VS (r typ) -> VS (r binder)
binder String
"i" VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
      i_var = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"i" VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
int
      setToSlice = VS (SwiftCode Variable)
vn VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k).
(ValueSym r val typ, InternalValueExp r var val typ) =>
VS (r val) -> VS (r val) -> VS (r val)
swiftMapFunc (VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, VariableSym r var typ, RenderValue r var val typ,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val) -> VS (r val) -> VS (r val)
swiftStrideFunc VS (SwiftCode Value)
begVal VS (SwiftCode Value)
endVal VS (SwiftCode Value)
step) ([VS (SwiftCode BinderD)]
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
[VS (r binder)] -> VS (r val) -> VS (r val)
lambda [VS (SwiftCode BinderD)
i_binder] (VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k).
List r val =>
VS (r val) -> VS (r val) -> VS (r val)
listAccess VS (SwiftCode Value)
vo (VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (SwiftCode Variable)
i_var)))
  block [
      setBeg,
      setEnd,
      setToSlice
    ]

swiftPrint
  :: Bool
  -> Maybe (VS (SwiftCode Value))
  -> VS (SwiftCode Value)
  -> VS (SwiftCode Value)
  -> MS (SwiftCode Statement)
swiftPrint :: Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftPrint Bool
newLn Maybe (VS (SwiftCode Value))
Nothing VS (SwiftCode Value)
_ VS (SwiftCode Value)
v = do
  let s :: VS (SwiftCode Value)
s = String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString String
"" :: VS (SwiftCode Value)
      nl :: NamedArgs SwiftCode Variable Value
nl = [(String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftTerm VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string, VS (SwiftCode Value)
s) | Bool -> Bool
not Bool
newLn]
  VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall a b. (a -> b) -> a -> b
$ MixedCall SwiftCode Variable Value TypeData
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
MixedCall r var val typ
funcAppMixedArgs String
printLabel VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void [VS (SwiftCode Value)
v] NamedArgs SwiftCode Variable Value
nl
swiftPrint Bool
newLn (Just VS (SwiftCode Value)
f) VS (SwiftCode Value)
_ VS (SwiftCode Value)
v' = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Value))
  MethodState
  ValueState
-> VS (SwiftCode Value)
-> StateT MethodState Identity (SwiftCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Value) ValueState)
-> MethodState -> Focusing Identity (SwiftCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Value)
v'
  let valToPrint (List CodeType
_) = SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v VS (SwiftCode Value)
-> VS (SwiftCode FuncData) -> VS (SwiftCode Value)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. Block -> VS (SwiftCode TypeData) -> VS (SwiftCode FuncData)
forall (r :: * -> *) typ.
RenderFunction r typ =>
Block -> VS (r typ) -> VS (r FuncData)
funcFromData (Block -> Block
R.func Block
swiftDesc) VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string
      valToPrint CodeType
String = SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v
      valToPrint CodeType
_ = VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
v)
      prNewLn = if Bool
newLn then VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftWriteFunc (String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString String
"\\n") VS (SwiftCode Value)
f)
        else MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt
  tryCatch (bodyStatements
    [valStmt $ swiftWriteFunc (valToPrint $ getCodeType $ valueType v) f, prNewLn])
    (oneLiner $ throw "Error printing to file.")

-- swiftPrint can handle lists, so don't use G.print for lists.
swiftOut
  :: Bool
  -> Maybe (VS (SwiftCode Value))
  -> VS (SwiftCode Value)
  -> VS (SwiftCode Value)
  -> MS (SwiftCode Statement)
swiftOut :: Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOut Bool
newLn Maybe (VS (SwiftCode Value))
f VS (SwiftCode Value)
printFn VS (SwiftCode Value)
v = LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Value))
  MethodState
  ValueState
-> VS (SwiftCode Value)
-> StateT MethodState Identity (SwiftCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Value) ValueState)
-> MethodState -> Focusing Identity (SwiftCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Value)
v StateT MethodState Identity (SwiftCode Value)
-> (SwiftCode Value -> MS (SwiftCode Statement))
-> MS (SwiftCode Statement)
forall a b.
StateT MethodState Identity a
-> (a -> StateT MethodState Identity b)
-> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= CodeType -> MS (SwiftCode Statement)
swOut (CodeType -> MS (SwiftCode Statement))
-> (SwiftCode Value -> CodeType)
-> SwiftCode Value
-> MS (SwiftCode Statement)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode TypeData -> CodeType
forall {k} (r :: k -> *) (typ :: k).
TypeElim r typ =>
r typ -> CodeType
getCodeType (SwiftCode TypeData -> CodeType)
-> (SwiftCode Value -> SwiftCode TypeData)
-> SwiftCode Value
-> CodeType
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SwiftCode Value -> SwiftCode TypeData
forall {k} (r :: k -> *) (val :: k) (typ :: k).
ValueSym r val typ =>
r val -> r typ
valueType
  where swOut :: CodeType -> MS (SwiftCode Statement)
swOut (List CodeType
_) = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
InternalIOStmt r stmt val =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
printSt Bool
newLn Maybe (VS (SwiftCode Value))
f VS (SwiftCode Value)
printFn VS (SwiftCode Value)
v
        swOut CodeType
_ = Bool
-> Maybe (VS (SwiftCode Value))
-> VS (SwiftCode Value)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k)
       (val :: k) (scope :: k) (var :: k) (typ :: k).
(BlockSym r block stmt, BodySym r bod block, MultiStatement r stmt,
 PrintConsole r stmt val, PrintFile r stmt val, ScopeSym r scope,
 DeclStatement r bod stmt var scope val,
 AssignStatement r stmt var val,
 ControlStatement r bod stmt var val, ValueSym r val typ,
 Literal r val typ, NumericExpression r val, Comparison r val,
 VariableSym r var typ, VariableValue r var val, List r val,
 TypeSym r typ, TypeElim r typ, InternalIOStmt r stmt val) =>
Bool
-> Maybe (VS (r val)) -> VS (r val) -> VS (r val) -> MS (r stmt)
G.print Bool
newLn Maybe (VS (SwiftCode Value))
f VS (SwiftCode Value)
printFn VS (SwiftCode Value)
v

swiftInput
  :: VS (SwiftCode Variable) -> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftInput :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
swiftInput VS (SwiftCode Variable)
vr VS (SwiftCode Value)
vl = do
  vr' <- VS (SwiftCode Variable)
vr
  let swiftInput' CodeType
String = VS (SwiftCode Value)
vl
      swiftInput' CodeType
ct
        | CodeType
ct CodeType -> [CodeType] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [CodeType]
swiftReadableTypes = VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> VS (r val) -> VS (r val)
cast (SwiftCode TypeData -> VS (SwiftCode TypeData)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (SwiftCode TypeData -> VS (SwiftCode TypeData))
-> SwiftCode TypeData -> VS (SwiftCode TypeData)
forall a b. (a -> b) -> a -> b
$ SwiftCode Variable -> SwiftCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType SwiftCode Variable
vr') VS (SwiftCode Value)
vl
        | Bool
otherwise = String -> VS (SwiftCode Value)
forall a. HasCallStack => String -> a
error String
"Attempt to read value of unreadable type"
  swiftInput' (getCodeType $ variableType vr')

swiftOpenFile
  :: VS (SwiftCode Value) -> VS (SwiftCode TypeData) -> VS (SwiftCode Value)
swiftOpenFile :: VS (SwiftCode Value)
-> VS (SwiftCode TypeData) -> VS (SwiftCode Value)
swiftOpenFile VS (SwiftCode Value)
n VS (SwiftCode TypeData)
t = let forArg :: VS (SwiftCode Variable)
forArg = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftFor (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftSearchDir)
                        dirVal :: VS (SwiftCode Value)
dirVal = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftSearchDir) Block
swiftDocDir
                        inArg :: VS (SwiftCode Variable)
inArg = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftIn (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftPathMask)
                        maskVal :: VS (SwiftCode Value)
maskVal = VS (SwiftCode TypeData) -> Block -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
RenderValue r var val typ =>
VS (r typ) -> Block -> VS (r val)
mkStateVal (String -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
OOTypeSym r typ =>
String -> VS (r typ)
obj String
swiftPathMask) Block
swiftUserMask
  in VS (SwiftCode TypeData)
-> VS (SwiftCode Value)
-> String
-> [VS (SwiftCode Value)]
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> [VS (r val)] -> VS (r val)
objMethodCall VS (SwiftCode TypeData)
t (VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftUnwrapVal (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$
    String
-> VS (SwiftCode TypeData)
-> NamedArgs SwiftCode Variable Value
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> VS (r typ) -> NamedArgs r var val -> VS (r val)
funcAppNamedArgs String
swiftUrls (VS (SwiftCode TypeData) -> VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k).
TypeSym r typ =>
VS (r typ) -> VS (r typ)
listType VS (SwiftCode TypeData)
t) [(VS (SwiftCode Variable)
forArg, VS (SwiftCode Value)
dirVal), (VS (SwiftCode Variable)
inArg, VS (SwiftCode Value)
maskVal)]
    VS (SwiftCode Value)
-> VS (SwiftCode FuncData) -> VS (SwiftCode Value)
forall (r :: * -> *) val typ.
OOFunctionSym r val typ =>
VS (r val) -> VS (r FuncData) -> VS (r val)
$. Block -> VS (SwiftCode TypeData) -> VS (SwiftCode FuncData)
forall (r :: * -> *) typ.
RenderFunction r typ =>
Block -> VS (r typ) -> VS (r FuncData)
funcFromData (Block -> Block
R.func Block
swiftFirst) VS (SwiftCode TypeData)
t) String
swiftAppendPath [VS (SwiftCode Value)
n]

swiftOpenFileHdl
  :: VS (SwiftCode Value) -> VS (SwiftCode TypeData) -> VS (SwiftCode Value)
swiftOpenFileHdl :: VS (SwiftCode Value)
-> VS (SwiftCode TypeData) -> VS (SwiftCode Value)
swiftOpenFileHdl VS (SwiftCode Value)
n VS (SwiftCode TypeData)
t = let forWritingArg :: VS (SwiftCode Variable)
forWritingArg = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
swiftWriteTo VS (SwiftCode TypeData)
forall (r :: * -> *). Monad r => VS (r TypeData)
swiftFileType
  in VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ String
-> VS (SwiftCode TypeData)
-> NamedArgs SwiftCode Variable Value
-> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
String -> VS (r typ) -> NamedArgs r var val -> VS (r val)
funcAppNamedArgs String
swiftFileHdl VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
outfile
    [(VS (SwiftCode Variable)
forWritingArg, VS (SwiftCode Value)
-> VS (SwiftCode TypeData) -> VS (SwiftCode Value)
swiftOpenFile VS (SwiftCode Value)
n VS (SwiftCode TypeData)
t)]

swiftOpenFileWA
  :: Bool
  -> VS (SwiftCode Variable)
  -> VS (SwiftCode Value)
  -> MS (SwiftCode Statement)
swiftOpenFileWA :: Bool
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
swiftOpenFileWA Bool
app VS (SwiftCode Variable)
f' VS (SwiftCode Value)
n' = MS (SwiftCode Block)
-> MS (SwiftCode Block) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r bod) -> MS (r bod) -> MS (r stmt)
tryCatch
    ([MS (SwiftCode Statement)] -> MS (SwiftCode Block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
[MS (r stmt)] -> MS (r bod)
bodyStatements [(VS (SwiftCode Value)
 -> VS (SwiftCode TypeData)
 -> VS (SwiftCode Value)
 -> VS (SwiftCode Value))
-> VS (SwiftCode Variable)
-> VS (SwiftCode Value)
-> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k)
       (typ :: k).
(AssignStatement r stmt var val, TypeSym r typ,
 Literal r val typ) =>
(VS (r val) -> VS (r typ) -> VS (r val) -> VS (r val))
-> VS (r var) -> VS (r val) -> MS (r stmt)
CP.openFileW (\VS (SwiftCode Value)
f VS (SwiftCode TypeData)
n VS (SwiftCode Value)
_ -> VS (SwiftCode Value)
-> VS (SwiftCode TypeData) -> VS (SwiftCode Value)
swiftOpenFileHdl VS (SwiftCode Value)
f VS (SwiftCode TypeData)
n) VS (SwiftCode Variable)
f' VS (SwiftCode Value)
n',
      if Bool
app
        then VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> VS (r val)
objMethodCallNoParams VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void (VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (SwiftCode Variable)
f')
          String
swiftSeekEnd
        else MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt])
    -- It's important for the catch case to throw, or else the swift compiler
    -- will have no guarantees that the file variable has been initialized.
    (MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (SwiftCode Statement) -> MS (SwiftCode Block))
-> MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall a b. (a -> b) -> a -> b
$ String -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
String -> MS (r stmt)
throw String
"Error opening file.")

swiftCloseFile :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
swiftCloseFile :: VS (SwiftCode Value) -> MS (SwiftCode Statement)
swiftCloseFile VS (SwiftCode Value)
f' = do
  f <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Value))
  MethodState
  ValueState
-> VS (SwiftCode Value)
-> StateT MethodState Identity (SwiftCode Value)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Value))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Value) ValueState)
-> MethodState -> Focusing Identity (SwiftCode Value) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Value)
f'
  -- How I've currently implemented file-reading, files don't need to be
  -- "closed", so InFile case is (correctly) just an empty stmt
  let swClose CodeType
InFile = (MethodState -> MethodState) -> StateT MethodState Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify MethodState -> MethodState
resetIndices StateT MethodState Identity ()
-> MS (SwiftCode Statement) -> MS (SwiftCode Statement)
forall a b.
StateT MethodState Identity a
-> StateT MethodState Identity b -> StateT MethodState Identity b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k).
EmptyStatement r stmt =>
MS (r stmt)
emptyStmt
      swClose CodeType
OutFile = MS (SwiftCode Block)
-> MS (SwiftCode Block) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r bod) -> MS (r bod) -> MS (r stmt)
tryCatch (MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (SwiftCode Statement) -> MS (SwiftCode Block))
-> MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (val :: k).
ValueStatement r stmt val =>
VS (r val) -> MS (r stmt)
valStmt (VS (SwiftCode Value) -> MS (SwiftCode Statement))
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(RenderValue r var val typ, ValueElim r val, ValueSym r val typ) =>
VS (r val) -> VS (r val)
swiftTryVal (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$
          VS (SwiftCode TypeData)
-> VS (SwiftCode Value) -> String -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
InternalValueExp r var val typ =>
VS (r typ) -> VS (r val) -> String -> VS (r val)
objMethodCallNoParams VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
void (SwiftCode Value -> VS (SwiftCode Value)
forall a. a -> StateT ValueState Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SwiftCode Value
f) String
swiftClose)
        (MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (SwiftCode Statement) -> MS (SwiftCode Block))
-> MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall a b. (a -> b) -> a -> b
$ String -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
String -> MS (r stmt)
throw String
"Error closing file.")
      swClose CodeType
_ = String -> MS (SwiftCode Statement)
forall a. HasCallStack => String -> a
error String
"closeFile called on non-file-typed value"
  swClose (getCodeType $ valueType f)

swiftReadFile
  :: VS (SwiftCode Variable)
  -> VS (SwiftCode Value)
  -> MS (SwiftCode Statement)
swiftReadFile :: VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
swiftReadFile VS (SwiftCode Variable)
v VS (SwiftCode Value)
f =
  let l_binder :: VS (SwiftCode BinderD)
l_binder = String -> VS (SwiftCode TypeData) -> VS (SwiftCode BinderD)
forall {k} (r :: k -> *) (binder :: k) (typ :: k).
BinderSym r binder typ =>
String -> VS (r typ) -> VS (r binder)
binder String
"l" VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string
      l_var :: VS (SwiftCode Variable)
l_var = String -> VS (SwiftCode TypeData) -> VS (SwiftCode Variable)
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableSym r var typ =>
String -> VS (r typ) -> VS (r var)
var String
"l" VS (SwiftCode TypeData)
forall {k} (r :: k -> *) (typ :: k). TypeSym r typ => VS (r typ)
string
  in MS (SwiftCode Block)
-> MS (SwiftCode Block) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
MS (r bod) -> MS (r bod) -> MS (r stmt)
tryCatch
  (MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (SwiftCode Statement) -> MS (SwiftCode Block))
-> MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode Variable)
v VS (SwiftCode Variable)
-> VS (SwiftCode Value) -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (stmt :: k) (var :: k) (val :: k).
AssignStatement r stmt var val =>
VS (r var) -> VS (r val) -> MS (r stmt)
&= VS (SwiftCode Value)
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (val :: k) (typ :: k) (var :: k).
(ValueSym r val typ, InternalValueExp r var val typ) =>
VS (r val) -> VS (r val) -> VS (r val)
swiftMapFunc (Char -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, TypeSym r typ, Literal r val typ,
 VariableSym r var typ) =>
Char -> VS (r val) -> VS (r val)
swiftSplitFunc Char
'\n' (VS (SwiftCode Value) -> VS (SwiftCode Value))
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall a b. (a -> b) -> a -> b
$ VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (typ :: k) (var :: k) (val :: k)
       (binder :: k).
(TypeSym r typ, VariableSym r var typ, ValueSym r val typ,
 RenderValue r var val typ, ValueElim r val,
 ValueExpression r var val binder typ) =>
VS (r val) -> VS (r val)
swiftReadFileFunc VS (SwiftCode Value)
f)
    ([VS (SwiftCode BinderD)]
-> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (binder :: k)
       (typ :: k).
ValueExpression r var val binder typ =>
[VS (r binder)] -> VS (r val) -> VS (r val)
lambda [VS (SwiftCode BinderD)
l_binder] (Char -> VS (SwiftCode Value) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k) (typ :: k).
(InternalValueExp r var val typ, TypeSym r typ, Literal r val typ,
 VariableSym r var typ) =>
Char -> VS (r val) -> VS (r val)
swiftSplitFunc Char
' ' (VS (SwiftCode Variable) -> VS (SwiftCode Value)
forall {k} (r :: k -> *) (var :: k) (val :: k).
VariableValue r var val =>
VS (r var) -> VS (r val)
valueOf VS (SwiftCode Variable)
l_var))))
  (MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall {k} (r :: k -> *) (block :: k) (stmt :: k) (bod :: k).
(BlockSym r block stmt, BodySym r bod block) =>
MS (r stmt) -> MS (r bod)
oneLiner (MS (SwiftCode Statement) -> MS (SwiftCode Block))
-> MS (SwiftCode Statement) -> MS (SwiftCode Block)
forall a b. (a -> b) -> a -> b
$ String -> MS (SwiftCode Statement)
forall {k} (r :: k -> *) (bod :: k) (stmt :: k) (var :: k)
       (val :: k).
ControlStatement r bod stmt var val =>
String -> MS (r stmt)
throw String
"Error reading from file.")

swiftVarDec
  :: Doc
  -> VS (SwiftCode Variable)
  -> SwiftCode ScopeData
  -> MS (SwiftCode Statement)
swiftVarDec :: Block
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
swiftVarDec Block
dec VS (SwiftCode Variable)
v' SwiftCode ScopeData
scp = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
-> VS (SwiftCode Variable)
-> StateT MethodState Identity (SwiftCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Variable) ValueState)
-> MethodState
-> Focusing Identity (SwiftCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Variable)
v'
  modify $ useVarName (variableName v)
  modify $ setVarScope (variableName v) (scopeData scp)
  let bind AttachmentTag
ClassLevel = SwiftCode Block
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel :: SwiftCode Doc
      bind AttachmentTag
InstanceLevel = SwiftCode Block
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel :: SwiftCode Doc
      p = AttachmentTag -> SwiftCode Block
bind (AttachmentTag -> SwiftCode Block)
-> AttachmentTag -> SwiftCode Block
forall a b. (a -> b) -> a -> b
$ SwiftCode Variable -> AttachmentTag
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> AttachmentTag
variableBind SwiftCode Variable
v
  mkStmtNoEnd (RC.perm p <+> dec <+> RC.variable v <> swiftTypeSpec
    <+> renderType (variableType v))

swiftSetDec
  :: Doc
  -> VS (SwiftCode Variable)
  -> SwiftCode ScopeData
  -> MS (SwiftCode Statement)
swiftSetDec :: Block
-> VS (SwiftCode Variable)
-> SwiftCode ScopeData
-> MS (SwiftCode Statement)
swiftSetDec Block
dec VS (SwiftCode Variable)
v' SwiftCode ScopeData
scp = do
  v <- LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
-> VS (SwiftCode Variable)
-> StateT MethodState Identity (SwiftCode Variable)
forall c.
LensLike'
  (Zoomed (StateT ValueState Identity) c) MethodState ValueState
-> StateT ValueState Identity c -> StateT MethodState Identity c
forall (m :: * -> *) (n :: * -> *) s t c.
Zoom m n s t =>
LensLike' (Zoomed m c) t s -> m c -> n c
zoom LensLike'
  (Zoomed (StateT ValueState Identity) (SwiftCode Variable))
  MethodState
  ValueState
(ValueState -> Focusing Identity (SwiftCode Variable) ValueState)
-> MethodState
-> Focusing Identity (SwiftCode Variable) MethodState
Lens' MethodState ValueState
lensMStoVS VS (SwiftCode Variable)
v'
  innerTp <- zoom lensMStoVS (innerType $ pure $ variableType v)
  modify $ useVarName (variableName v)
  modify $ setVarScope (variableName v) (scopeData scp)
  let bind AttachmentTag
ClassLevel = SwiftCode Block
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
classLevel :: SwiftCode Doc
      bind AttachmentTag
InstanceLevel = SwiftCode Block
forall {k} (r :: k -> *) (attch :: k).
AttachmentSym r attch =>
r attch
instanceLevel :: SwiftCode Doc
      p = AttachmentTag -> SwiftCode Block
bind (AttachmentTag -> SwiftCode Block)
-> AttachmentTag -> SwiftCode Block
forall a b. (a -> b) -> a -> b
$ SwiftCode Variable -> AttachmentTag
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> AttachmentTag
variableBind SwiftCode Variable
v
  mkStmtNoEnd (RC.perm p <+> dec <+> RC.variable v <> swiftTypeSpec
    <+> text (swiftSet P.<> "<" P.<> getTypeString innerTp P.<> ">"))

swiftThrowDoc :: (ValueElim r val) => r val -> Doc
swiftThrowDoc :: forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
swiftThrowDoc r val
errMsg = Block
throwLabel Block -> Block -> Block
<+> r val -> Block
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
RC.value r val
errMsg

swiftForEach
  :: (BodyElim r bod, InternalVarElim r var, ValueElim r val)
  => r var -> r val -> r bod -> Doc
swiftForEach :: forall {k} (r :: k -> *) (bod :: k) (var :: k) (val :: k).
(BodyElim r bod, InternalVarElim r var, ValueElim r val) =>
r var -> r val -> r bod -> Block
swiftForEach r var
i r val
lstVar r bod
b = [Block] -> Block
vcat [
  Block
forLabel Block -> Block -> Block
<+> r var -> Block
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> Block
RC.variable r var
i Block -> Block -> Block
<+> Block
inLabel Block -> Block -> Block
<+> r val -> Block
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
RC.value r val
lstVar Block -> Block -> Block
<+> Block
bodyStart,
  Block -> Block
indent (Block -> Block) -> Block -> Block
forall a b. (a -> b) -> a -> b
$ r bod -> Block
forall {k} (r :: k -> *) (bod :: k).
BodyElim r bod =>
r bod -> Block
RC.body r bod
b,
  Block
bodyEnd]

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

swiftAssert :: (ValueElim r val) => r val -> r val -> Doc
swiftAssert :: forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> r val -> Block
swiftAssert r val
condition r val
errorMessage = [Block] -> Block
vcat [
  String -> Block
text String
"assert(" Block -> Block -> Block
<+> r val -> Block
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
RC.value r val
condition Block -> Block -> Block
<+> String -> Block
text String
"," Block -> Block -> Block
<+> r val -> Block
forall {k} (r :: k -> *) (val :: k).
ValueElim r val =>
r val -> Block
RC.value r val
errorMessage Block -> Block -> Block
<> String -> Block
text String
")"
  ]

swiftParam :: Doc -> SwiftCode Variable -> Doc
swiftParam :: Block -> SwiftCode Variable -> Block
swiftParam Block
io SwiftCode Variable
v = Block
swiftNoLabel Block -> Block -> Block
<+> SwiftCode Variable -> Block
forall {k} (r :: k -> *) (var :: k).
InternalVarElim r var =>
r var -> Block
RC.variable SwiftCode Variable
v Block -> Block -> Block
<> Block
swiftTypeSpec Block -> Block -> Block
<+> Block
io
  Block -> Block -> Block
<+> SwiftCode TypeData -> Block
forall (r :: * -> *). UnRepr r TypeData => r TypeData -> Block
renderType (SwiftCode Variable -> SwiftCode TypeData
forall {k} (r :: k -> *) (var :: k) (typ :: k).
VariableElim r var typ =>
r var -> r typ
variableType SwiftCode Variable
v)

swiftMethod
  :: Label
  -> SwiftCode Doc
  -> SwiftCode Doc
  -> MS (SwiftCode TypeData)
  -> [MS (SwiftCode ParamData)]
  -> MS (SwiftCode Body)
  -> MS (SwiftCode MethodData)
swiftMethod :: String
-> SwiftCode Block
-> SwiftCode Block
-> MS (SwiftCode TypeData)
-> [MS (SwiftCode ParamData)]
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
swiftMethod String
n SwiftCode Block
s SwiftCode Block
p MS (SwiftCode TypeData)
t [MS (SwiftCode ParamData)]
ps MS (SwiftCode Block)
b = do
  tp <- MS (SwiftCode TypeData)
t
  pms <- sequence ps
  bod <- b
  mem <- zoom lensMStoVS getMethodExcMap
  mn <- zoom lensMStoFS getModuleName
  let excs = [ExceptionType]
-> QualifiedName
-> Map QualifiedName [ExceptionType]
-> [ExceptionType]
forall k a. Ord k => a -> k -> Map k a -> a
findWithDefault [] (String -> String -> QualifiedName
qualName String
mn String
n) Map QualifiedName [ExceptionType]
mem
  mthdFromData Pub (vcat [
    RC.visibility s <+> RC.perm p <+> swiftFunc <+> text n <>
      parens (parameterList pms) <+> emptyIfNull excs throwsLabel <+>
      swiftRetType' <+> renderType tp <+> bodyStart,
    indent $ RC.body bod,
    bodyEnd])

swiftConstructor
  :: [MS (SwiftCode ParamData)]
  -> Initializers SwiftCode Variable Value
  -> MS (SwiftCode Body)
  -> MS (SwiftCode MethodData)
swiftConstructor :: [MS (SwiftCode ParamData)]
-> NamedArgs SwiftCode Variable Value
-> MS (SwiftCode Block)
-> MS (SwiftCode MethodData)
swiftConstructor [MS (SwiftCode ParamData)]
ps NamedArgs SwiftCode Variable Value
is MS (SwiftCode Block)
b = do
  pms <- [MS (SwiftCode ParamData)]
-> StateT MethodState Identity [SwiftCode ParamData]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [MS (SwiftCode ParamData)]
ps
  bod <- multiBody [G.initStmts is, b]
  mem <- zoom lensMStoVS getMethodExcMap
  mn <- zoom lensMStoFS getModuleName
  cn <- getClassName
  let excs = [ExceptionType]
-> QualifiedName
-> Map QualifiedName [ExceptionType]
-> [ExceptionType]
forall k a. Ord k => a -> k -> Map k a -> a
findWithDefault [] (String -> String -> QualifiedName
qualName String
mn String
cn) Map QualifiedName [ExceptionType]
mem
  mthdFromData Pub (vcat [
    swiftCtorName <> parens (parameterList pms) <+>
      emptyIfNull excs throwsLabel <+> bodyStart,
    indent $ RC.body bod,
    bodyEnd])

-- If the program uses throw, then generate code that extends Strings with the
-- Error protocol. This line only needs to be generated once for the entire
-- program
swiftStringError :: MS Doc
swiftStringError :: StateT MethodState Identity Block
swiftStringError = do
  tu <- MS Bool
getThrowUsed
  errdef <- getErrorDefined
  str <- zoom lensMStoVS (string :: VS (SwiftCode TypeData))
  if tu && not errdef then do
    modify setErrorDefined
    pure (swiftExtension <+> renderType str <> swiftConforms <+> swiftRetroactive
      <+> swiftError <+> bodyStart <> bodyEnd)
  else pure empty

swiftClassDoc :: ClassDocRenderer
swiftClassDoc :: ClassDocRenderer
swiftClassDoc String
desc = [String
desc | Bool -> Bool
not (String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
desc)]

typeDfltVal
  :: (Literal r val typ, TypeSym r typ, OOTypeSym r typ)
  => CodeType -> VS (r val)
typeDfltVal :: forall {k} (r :: k -> *) (val :: k) (typ :: k).
(Literal r val typ, TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r val)
typeDfltVal CodeType
Boolean = VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r val)
litFalse
typeDfltVal CodeType
Integer = Integer -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Integer -> VS (r val)
litInt Integer
0
typeDfltVal CodeType
Float = Float -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Float -> VS (r val)
litFloat Float
0.0
typeDfltVal CodeType
Double = Double -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Double -> VS (r val)
litDouble Double
0.0
typeDfltVal CodeType
Char = Char -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
Char -> VS (r val)
litChar Char
' '
typeDfltVal CodeType
String = String -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
String -> VS (r val)
litString String
""
typeDfltVal (List CodeType
t) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litList (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t) []
typeDfltVal (Array CodeType
t) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litArray (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t) []
typeDfltVal (Set CodeType
t) = VS (r typ) -> [VS (r val)] -> VS (r val)
forall {k} (r :: k -> *) (val :: k) (typ :: k).
Literal r val typ =>
VS (r typ) -> [VS (r val)] -> VS (r val)
litSet (CodeType -> VS (r typ)
forall {k} (r :: k -> *) (typ :: k).
(TypeSym r typ, OOTypeSym r typ) =>
CodeType -> VS (r typ)
convTypeOO CodeType
t) []
typeDfltVal CodeType
_ = String -> VS (r val)
forall a. HasCallStack => String -> a
error String
"Attempt to get default value for type with none."