Safe Haskell	Safe-Inferred
Language	Haskell2010

Language.Drasil.Code

Description

Re-export code-related smart constructors for external code writing and generation.

Synopsis

makeCode :: [FileData] -> [AuxData] -> Code
createCodeFiles :: Code -> IO ()
generator :: Lang -> String -> [Expr] -> Choices -> CodeSpec -> DrasilState
generateCode :: (OOProg progRepr, PackageSym packRepr) => Lang -> (progRepr (Program progRepr) -> ProgData) -> (packRepr (Package packRepr) -> PackData) -> DrasilState -> IO ()
readWithDataDesc :: FilePath -> DataDesc' -> IO [Expr]
sampleInputDD :: [CodeVarChunk] -> DataDesc'
data Choices = Choices {
- lang :: [Lang]
- architecture :: Architecture
- dataInfo :: DataInfo
- maps :: Maps
- optFeats :: OptionalFeatures
- srsConstraints :: Constraints
- extLibs :: [ExtLib]
- folderVal :: Int
}
data Comments
- = CommentFunc
- | CommentClass
- | CommentMod
data Verbosity
- = Verbose
- | Quiet
data ConstraintBehaviour
- = Warning
- | Exception
makeArchit :: Modularity -> ImplementationType -> Architecture
data Architecture = Archt {
- modularity :: Modularity
- impType :: ImplementationType
}
data DataInfo = DataInfo {
- inputStructure :: Structure
- constStructure :: ConstantStructure
- constRepr :: ConstantRepr
}
makeData :: Structure -> ConstantStructure -> ConstantRepr -> DataInfo
data Maps = Maps {
- conceptMatch :: ConceptMatchMap
- spaceMatch :: SpaceMatch
}
makeMaps :: ConceptMatchMap -> SpaceMatch -> Maps
spaceToCodeType :: Space -> [CodeType]
makeConstraints :: ConstraintBehaviour -> ConstraintBehaviour -> Constraints
makeODE :: [ODEInfo] -> [ODELibPckg] -> ODE
makeDocConfig :: [Comments] -> Verbosity -> Visibility -> DocConfig
makeLogConfig :: [Logging] -> FilePath -> LogConfig
data LogConfig = LogConfig {
- logging :: [Logging]
- logFile :: FilePath
}
data OptionalFeatures = OptFeats {
- docConfig :: DocConfig
- logConfig :: LogConfig
- auxFiles :: [AuxFile]
}
makeOptFeats :: DocConfig -> LogConfig -> [AuxFile] -> OptionalFeatures
newtype ExtLib = Math ODE
data ImplementationType
- = Library
- | Program
data Logging
- = LogFunc
- | LogVar
data Modularity
- = Modular InputModule
- | Unmodular
data Structure
- = Unbundled
- | Bundled
data ConstantStructure
- = Inline
- | WithInputs
- | Store Structure
data ConstantRepr
- = Var
- | Const
data InputModule
- = Combined
- | Separated
data CodeConcept = Pi
matchConcepts :: HasUID c => [(c, [CodeConcept])] -> ConceptMatchMap
type SpaceMatch = Space -> [CodeType]
matchSpaces :: [(Space, [CodeType])] -> SpaceMatch
data AuxFile
- = SampleInput FilePath
- | ReadME
getSampleData :: Choices -> Maybe FilePath
data Visibility
- = Show
- | Hide
defaultChoices :: Choices
data CodeSpec where
- CodeSpec :: HasName a => {..} -> CodeSpec
funcUID :: Func -> UID
asVC :: Func -> QuantityDict
codeSpec :: SystemInformation -> Choices -> [Mod] -> CodeSpec
($:=) :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> FuncStmt
data Mod = Mod Name Description [Import] [Class] [Func]
data StateVariable
data Func
data FuncStmt where
- FAsg :: CodeVarChunk -> CodeExpr -> FuncStmt
- FAsgIndex :: CodeVarChunk -> Integer -> CodeExpr -> FuncStmt
- FFor :: CodeVarChunk -> CodeExpr -> CodeExpr -> CodeExpr -> [FuncStmt] -> FuncStmt
- FForEach :: CodeVarChunk -> CodeExpr -> [FuncStmt] -> FuncStmt
- FWhile :: CodeExpr -> [FuncStmt] -> FuncStmt
- FCond :: CodeExpr -> [FuncStmt] -> [FuncStmt] -> FuncStmt
- FRet :: CodeExpr -> FuncStmt
- FThrow :: String -> FuncStmt
- FTry :: [FuncStmt] -> [FuncStmt] -> FuncStmt
- FContinue :: FuncStmt
- FDecDef :: CodeVarChunk -> CodeExpr -> FuncStmt
- FFuncDef :: CodeFuncChunk -> [ParameterChunk] -> [FuncStmt] -> FuncStmt
- FVal :: CodeExpr -> FuncStmt
- FMulti :: [FuncStmt] -> FuncStmt
- FAppend :: CodeExpr -> CodeExpr -> FuncStmt
pubStateVar :: CodeVarChunk -> StateVariable
privStateVar :: CodeVarChunk -> StateVariable
fDecDef :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> FuncStmt
ffor :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> [FuncStmt] -> FuncStmt
fforRange :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> CodeExpr -> CodeExpr -> [FuncStmt] -> FuncStmt
funcData :: Name -> Description -> DataDesc -> Func
funcDef :: (Quantity c, MayHaveUnit c) => Name -> Description -> [c] -> Space -> Maybe Description -> [FuncStmt] -> Func
packmod :: Name -> Description -> [Class] -> [Func] -> Mod
junkLine :: Data
multiLine :: LinePattern -> Delim -> Data
repeated :: [DataItem] -> LinePattern
singleLine :: LinePattern -> Delim -> Data
singleton :: DataItem -> Data
type ExternalLibrary = [StepGroup]
data Step
data FunctionInterface
data Argument
externalLib :: [StepGroup] -> ExternalLibrary
choiceSteps :: [[Step]] -> StepGroup
choiceStep :: [Step] -> StepGroup
mandatoryStep :: Step -> StepGroup
mandatorySteps :: [Step] -> StepGroup
callStep :: FunctionInterface -> Step
libFunction :: Requires -> CodeFuncChunk -> [Argument] -> FunctionInterface
libMethod :: Requires -> CodeVarChunk -> CodeFuncChunk -> [Argument] -> FunctionInterface
libFunctionWithResult :: Requires -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface
libMethodWithResult :: Requires -> CodeVarChunk -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface
libConstructor :: Requires -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface
libConstructorMultiReqs :: [Requires] -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface
constructAndReturn :: Requires -> CodeFuncChunk -> [Argument] -> FunctionInterface
lockedArg :: CodeExpr -> Argument
lockedNamedArg :: NamedArgument -> CodeExpr -> Argument
inlineArg :: Space -> Argument
inlineNamedArg :: NamedArgument -> Space -> Argument
preDefinedArg :: CodeVarChunk -> Argument
preDefinedNamedArg :: NamedArgument -> CodeVarChunk -> Argument
functionArg :: CodeFuncChunk -> [Parameter] -> Step -> Argument
customObjArg :: [Requires] -> Description -> CodeVarChunk -> CodeFuncChunk -> ClassInfo -> Argument
recordArg :: Requires -> CodeFuncChunk -> CodeVarChunk -> [CodeVarChunk] -> Argument
lockedParam :: CodeVarChunk -> Parameter
unnamedParam :: Space -> Parameter
customClass :: [MethodInfo] -> ClassInfo
implementation :: String -> [MethodInfo] -> ClassInfo
constructorInfo :: CodeFuncChunk -> [Parameter] -> [Step] -> MethodInfo
methodInfo :: CodeFuncChunk -> Description -> [Parameter] -> Description -> [Step] -> MethodInfo
methodInfoNoReturn :: CodeFuncChunk -> Description -> [Parameter] -> [Step] -> MethodInfo
appendCurrSol :: CodeExpr -> Step
populateSolList :: CodeVarChunk -> CodeVarChunk -> CodeVarChunk -> [Step]
assignArrayIndex :: Step
assignSolFromObj :: CodeVarChunk -> Step
initSolListFromArray :: CodeVarChunk -> Step
initSolListWithVal :: Step
solveAndPopulateWhile :: FunctionInterface -> CodeVarChunk -> CodeVarChunk -> FunctionInterface -> CodeVarChunk -> Step
returnExprList :: Step
fixedReturn :: CodeExpr -> Step
fixedReturn' :: Step
initSolWithVal :: Step
type ExternalLibraryCall = [StepGroupFill]
data StepGroupFill = SGF Int [StepFill]
data StepFill
- = CallF FunctionIntFill
- | LoopF (NonEmpty FunctionIntFill) [CodeExpr] (NonEmpty StepFill)
- | StatementF [CodeVarChunk] [CodeExpr]
newtype FunctionIntFill = FIF [ArgumentFill]
data ArgumentFill
- = UserDefinedArgF (Maybe NamedArgument) CodeExpr
- | BasicF CodeExpr
- | FnF [ParameterFill] StepFill
- | ClassF [StateVariable] ClassInfoFill
- | RecordF [CodeExpr]
data ParameterFill
- = NameableParamF ParameterChunk
- | UserDefined ParameterChunk
data ClassInfoFill
- = RegularF [MethodInfoFill]
- | ImplementsF [MethodInfoFill]
data MethodInfoFill
- = CIF [ParameterFill] [Initializer] [StepFill]
- | MIF [ParameterFill] (NonEmpty StepFill)
externalLibCall :: [StepGroupFill] -> ExternalLibraryCall
choiceStepsFill :: Int -> [StepFill] -> StepGroupFill
choiceStepFill :: Int -> StepFill -> StepGroupFill
mandatoryStepFill :: StepFill -> StepGroupFill
mandatoryStepsFill :: [StepFill] -> StepGroupFill
callStepFill :: FunctionIntFill -> StepFill
libCallFill :: [ArgumentFill] -> FunctionIntFill
userDefinedArgFill :: CodeExpr -> ArgumentFill
basicArgFill :: CodeExpr -> ArgumentFill
functionArgFill :: [ParameterFill] -> StepFill -> ArgumentFill
customObjArgFill :: [StateVariable] -> ClassInfoFill -> ArgumentFill
recordArgFill :: [CodeExpr] -> ArgumentFill
unnamedParamFill :: CodeVarChunk -> ParameterFill
unnamedParamPBVFill :: CodeVarChunk -> ParameterFill
userDefinedParamFill :: CodeVarChunk -> ParameterFill
customClassFill :: [MethodInfoFill] -> ClassInfoFill
implementationFill :: [MethodInfoFill] -> ClassInfoFill
constructorInfoFill :: [ParameterFill] -> [Initializer] -> [StepFill] -> MethodInfoFill
methodInfoFill :: [ParameterFill] -> [StepFill] -> MethodInfoFill
appendCurrSolFill :: CodeVarChunk -> StepFill
populateSolListFill :: CodeVarChunk -> [StepFill]
assignArrayIndexFill :: CodeVarChunk -> [CodeExpr] -> StepFill
assignSolFromObjFill :: CodeVarChunk -> StepFill
initSolListFromArrayFill :: CodeVarChunk -> StepFill
initSolListWithValFill :: CodeVarChunk -> CodeExpr -> StepFill
solveAndPopulateWhileFill :: FunctionIntFill -> CodeExpr -> FunctionIntFill -> CodeVarChunk -> StepFill
returnExprListFill :: [CodeExpr] -> StepFill
fixedStatementFill :: StepFill
fixedStatementFill' :: CodeExpr -> StepFill
initSolWithValFill :: CodeVarChunk -> CodeExpr -> StepFill
data Lang
- = Cpp
- | CSharp
- | Java
- | Python
- | Swift
class AuxiliarySym r => PackageSym r where
- type Package r
- package :: ProgData -> [r (Auxiliary r)] -> r (Package r)
class AuxiliarySym r where
- type Auxiliary r
- type AuxHelper r
- doxConfig :: String -> GOOLState -> Verbosity -> r (Auxiliary r)
- readMe :: ReadMeInfo -> r (Auxiliary r)
- sampleInput :: ChunkDB -> DataDesc -> [Expr] -> r (Auxiliary r)
- optimizeDox :: r (AuxHelper r)
- makefile :: [FilePath] -> ImplementationType -> [Comments] -> GOOLState -> ProgData -> r (Auxiliary r)
- auxHelperDoc :: r (AuxHelper r) -> Doc
- auxFromData :: FilePath -> Doc -> r (Auxiliary r)
data AuxData
data PackData
data CodeChunk
data CodeVarChunk
data CodeFuncChunk
quantvar :: (Quantity c, MayHaveUnit c) => c -> CodeVarChunk
quantfunc :: (Quantity c, MayHaveUnit c) => c -> CodeFuncChunk
ccObjVar :: CodeVarChunk -> CodeVarChunk -> CodeVarChunk
listToArray :: CodeVarChunk -> CodeVarChunk
field :: CodeExprC r => CodeVarChunk -> CodeVarChunk -> r
data ODEInfo = ODEInfo {
- indepVar :: CodeVarChunk
- depVar :: CodeVarChunk
- otherVars :: [CodeVarChunk]
- tInit :: CodeExpr
- tFinal :: CodeExpr
- initVal :: [CodeExpr]
- odeSyst :: [CodeExpr]
- odeOpts :: ODEOptions
}
odeInfo :: CodeVarChunk -> CodeVarChunk -> [CodeVarChunk] -> CodeExpr -> CodeExpr -> [CodeExpr] -> [CodeExpr] -> ODEOptions -> ODEInfo
odeInfo' :: [CodeVarChunk] -> ODEOptions -> DifferentialModel -> InitialValueProblem -> ODEInfo
data ODEOptions = ODEOpts {
- solveMethod :: ODEMethod
- absTol :: CodeExpr
- relTol :: CodeExpr
- stepSize :: CodeExpr
}
odeOptions :: ODEMethod -> CodeExpr -> CodeExpr -> CodeExpr -> ODEOptions
data ODEMethod
- = RK45
- | BDF
- | Adams
data ODELibPckg = ODELib {
- libName :: Name
- libVers :: Version
- libSpec :: ExternalLibrary
- libCall :: ODEInfo -> ExternalLibraryCall
- libPath :: Maybe FilePath
- compatibleLangs :: [Lang]
}
mkODELib :: Name -> Version -> ExternalLibrary -> (ODEInfo -> ExternalLibraryCall) -> FilePath -> [Lang] -> ODELibPckg
mkODELibNoPath :: Name -> Version -> ExternalLibrary -> (ODEInfo -> ExternalLibraryCall) -> [Lang] -> ODELibPckg
unPP :: PythonProject a -> a
unJP :: JavaProject a -> a
unCSP :: CSharpProject a -> a
unCPPP :: CppProject a -> a
unSP :: SwiftProject a -> a
data NamedArgument
narg :: (Quantity q, MayHaveUnit q) => q -> NamedArgument

Documentation

makeCode :: [FileData] -> [AuxData] -> Code Source #

Makes code from FileData (FilePaths with module data) and AuxData (FilePaths with auxiliary document information).

createCodeFiles :: Code -> IO () Source #

Creates the requested Code by producing files.

generator :: Lang -> String -> [Expr] -> Choices -> CodeSpec -> DrasilState Source #

Initializes the generator's DrasilState. Space parameter is a string representing the date. \['Expr'\] parameter is the sample input values provided by the user.

generateCode :: (OOProg progRepr, PackageSym packRepr) => Lang -> (progRepr (Program progRepr) -> ProgData) -> (packRepr (Package packRepr) -> PackData) -> DrasilState -> IO () Source #

Generates a package with the given DrasilState. The passed un-representation functions determine which target language the package will be generated in.

readWithDataDesc :: FilePath -> DataDesc' -> IO [Expr] Source #

Reads data from a file and converts the values to Exprs. The file must be formatted according to the DataDesc' passed as a parameter.

sampleInputDD :: [CodeVarChunk] -> DataDesc' Source #

Defines the DataDesc for the file containing a sample data set, which a user must supply if they want to generate a sample input file.

data Choices Source #

The instruction indicates how the generated program should be written down. Full details of Choices documentation https://github.com/JacquesCarette/Drasil/wiki/The-Code-Generator

Constructors

Choices

Fields

lang :: [Lang]
Target languages. Choosing multiple means program will be generated in multiple languages.
architecture :: Architecture
Architecture of the program, include modularity and implementation type
dataInfo :: DataInfo
Data structure and represent
maps :: Maps
Maps for 'Drasil concepts' to 'code concepts' or Space to a 'CodeType
optFeats :: OptionalFeatures
Setting for Softifacts that can be added to the program or left it out
srsConstraints :: Constraints
Constraint violation behaviour. Exception or Warning.
extLibs :: [ExtLib]
List of external libraries what to utilize
folderVal :: Int
Number of folders to go up in order to obtain the image

data Comments Source #

Comment implementation options.

Constructors

CommentFunc	Function/method-level comments.
CommentClass	Class-level comments.
CommentMod	File/Module-level comments.

Instances

Instances details

Eq Comments Source #
Instance details Defined in Language.Drasil.Choices Methods (==) :: Comments -> Comments -> Bool # (/=) :: Comments -> Comments -> Bool #

data Verbosity Source #

Doxygen file verbosity options.

Constructors

Verbose
Quiet

data ConstraintBehaviour Source #

Constraint behaviour options within program.

Constructors

Warning	Print warning when constraint violated.
Exception	Throw exception when constraint violated.

makeArchit :: Modularity -> ImplementationType -> Architecture Source #

Constructor to create a Architecture

data Architecture Source #

Architecture of a program

Constructors

Archt
Fields modularity :: Modularity How the program should be modularized. impType :: ImplementationType Implementation type, program or library.

data DataInfo Source #

Data of a program - how information should be encoded.

Constructors

DataInfo
Fields inputStructure :: Structure Structure of inputs (bundled or not). constStructure :: ConstantStructure Structure of constants (inlined or bundled or not, or stored with inputs). constRepr :: ConstantRepr Representation of constants (as variables or as constants).

makeData :: Structure -> ConstantStructure -> ConstantRepr -> DataInfo Source #

Constructor to create a DataInfo

data Maps Source #

Maps for Concepts and Space

Constructors

Maps
Fields conceptMatch :: ConceptMatchMap Map of `UID`s for Drasil concepts to code concepts. Matching a `UID` to a code concept means the code concept should be used instead of the chunk associated with the `UID`. spaceMatch :: SpaceMatch Map of `Space`s to `CodeType`s Matching a `Space` to a `CodeType` means values of the `Space` should have that `CodeType` in the generated code.

makeMaps :: ConceptMatchMap -> SpaceMatch -> Maps Source #

Constructor to create a Maps

spaceToCodeType :: Space -> [CodeType] Source #

Default mapping between Space and CodeType.

makeConstraints :: ConstraintBehaviour -> ConstraintBehaviour -> Constraints Source #

Constructor to create a Constraints

makeODE :: [ODEInfo] -> [ODELibPckg] -> ODE Source #

Constructor to create an ODE

makeDocConfig :: [Comments] -> Verbosity -> Visibility -> DocConfig Source #

Constructor to create a DocConfig

makeLogConfig :: [Logging] -> FilePath -> LogConfig Source #

Constructor to create a LogConfig

data LogConfig Source #

Log Configuration

Constructors

LogConfig
Fields logging :: [Logging] Turns different forms of logging on or off. logFile :: FilePath Name of log file.

data OptionalFeatures Source #

Constructors

OptFeats
Fields docConfig :: DocConfig logConfig :: LogConfig auxFiles :: [AuxFile] Turns generation of different auxiliary (non-source-code) files on or off.

makeOptFeats :: DocConfig -> LogConfig -> [AuxFile] -> OptionalFeatures Source #

Constructor to create a OptionalFeatures

newtype ExtLib Source #

External Library Options

Constructors

Math ODE

data ImplementationType Source #

Program implementation options.

Constructors

Library	Generated code does not include Controller.
Program	Generated code includes Controller.

data Logging Source #

Logging options for function calls and variable assignments. Eq instances required for Logging and Comments because generator needs to check membership of these elements in lists

Constructors

LogFunc	Log messages generated for function calls.
LogVar	Log messages generated for variable assignments.

Instances

Instances details

Eq Logging Source #
Instance details Defined in Language.Drasil.Choices Methods (==) :: Logging -> Logging -> Bool # (/=) :: Logging -> Logging -> Bool #

data Modularity Source #

Modularity of a program.

Constructors

Modular InputModule	Different modules. For controller, input, calculations, output.
Unmodular	All generated code is in one module/file.

data Structure Source #

Variable structure options.

Constructors

Unbundled	Individual variables
Bundled	Variables bundled in a class

data ConstantStructure Source #

Constants options.

Constructors

Inline	Inline values for constants.
WithInputs	Store constants with inputs.
Store Structure	Store constants separately from inputs, whether bundled or unbundled.

data ConstantRepr Source #

Options for representing constants in a program.

Constructors

Var	Constants represented as regular variables.
Const	Use target language's mechanism for defining constants.

data InputModule Source #

Options for input modules.

Constructors

Combined	Input-related functions combined in one module.
Separated	Input-related functions each in own module.

data CodeConcept Source #

Code concepts. For now, just pi.

Constructors

Pi

Instances

Instances details

Eq CodeConcept Source #
Instance details Defined in Language.Drasil.Choices Methods (==) :: CodeConcept -> CodeConcept -> Bool # (/=) :: CodeConcept -> CodeConcept -> Bool #

matchConcepts :: HasUID c => [(c, [CodeConcept])] -> ConceptMatchMap Source #

Builds a ConceptMatchMap from an association list of chunks and CodeConcepts.

type SpaceMatch = Space -> [CodeType] Source #

Specifies which CodeType should be used to represent each mathematical Space. [CodeType] is preferentially-ordered, first CodeType that does not conflict with other choices will be selected.

matchSpaces :: [(Space, [CodeType])] -> SpaceMatch Source #

Builds a SpaceMatch from an association list of Spaces and CodeTypes.

data AuxFile Source #

Currently we only support two kind of auxiliary files: sample input file, readme. To generate a sample input file compatible with the generated program, FilePath is the path to the user-provided file containing a sample set of input data.

Constructors

SampleInput FilePath
ReadME

Instances

Instances details

Eq AuxFile Source #
Instance details Defined in Language.Drasil.Choices Methods (==) :: AuxFile -> AuxFile -> Bool # (/=) :: AuxFile -> AuxFile -> Bool #

getSampleData :: Choices -> Maybe FilePath Source #

Gets the file path to a sample input data set from a Choices structure, if the user chose to generate a sample input file.

data Visibility Source #

Doxygen date-field visibility options.

Constructors

Show
Hide

defaultChoices :: Choices Source #

Default choices to be used as the base from which design specifications can be built.

data CodeSpec where Source #

Code specifications. Holds information needed to generate code.

Constructors

CodeSpec

Fields

:: HasName a
=> { pName :: Name
Program name.
, authors :: [a]
Authors.
, purpose :: Purpose
Purpose.
, background :: Background
Example Background.
, inputs :: [Input]
All inputs.
, extInputs :: [Input]
Explicit inputs (values to be supplied by a file).
, derivedInputs :: [Derived]
Derived inputs (each calculated from explicit inputs in a single step).
, outputs :: [Output]
All outputs.
, configFiles :: [FilePath]
List of files that must be in same directory for running the executable.
, execOrder :: [Def]
Mathematical definitions, ordered so that they form a path from inputs to outputs.
, cMap :: ConstraintCEMap
Map from UIDs to constraints for all constrained chunks used in the problem.
, constants :: [Const]
List of all constants used in the problem.
, constMap :: ConstantMap
Map containing all constants used in the problem.
, mods :: [Mod]
Additional modules required in the generated code, which Drasil cannot yet automatically define.
, sysinfodb :: ChunkDB
The database of all chunks used in the problem.
} -> CodeSpec

funcUID :: Func -> UID Source #

Get a UID of a chunk corresponding to a Func.

asVC :: Func -> QuantityDict Source #

Convert a Func to an implementation-stage QuantityDict representing the function.

codeSpec :: SystemInformation -> Choices -> [Mod] -> CodeSpec Source #

Defines a CodeSpec based on the SystemInformation, Choices, and Mods defined by the user.

($:=) :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> FuncStmt Source #

Define an assignment statement.

data Mod Source #

Holds module information.

Constructors

Mod Name Description [Import] [Class] [Func]

data StateVariable Source #

State variables hold attach a ScopeTag to a CodeVarChunk.

data Func Source #

Holds a function definition or function data.

data FuncStmt where Source #

Constructors

FAsg :: CodeVarChunk -> CodeExpr -> FuncStmt
FAsgIndex :: CodeVarChunk -> Integer -> CodeExpr -> FuncStmt
FFor :: CodeVarChunk -> CodeExpr -> CodeExpr -> CodeExpr -> [FuncStmt] -> FuncStmt	For-loop; Variable, Start, Stop, Step, Body.
FForEach :: CodeVarChunk -> CodeExpr -> [FuncStmt] -> FuncStmt
FWhile :: CodeExpr -> [FuncStmt] -> FuncStmt
FCond :: CodeExpr -> [FuncStmt] -> [FuncStmt] -> FuncStmt
FRet :: CodeExpr -> FuncStmt
FThrow :: String -> FuncStmt
FTry :: [FuncStmt] -> [FuncStmt] -> FuncStmt
FContinue :: FuncStmt
FDecDef :: CodeVarChunk -> CodeExpr -> FuncStmt
FFuncDef :: CodeFuncChunk -> [ParameterChunk] -> [FuncStmt] -> FuncStmt
FVal :: CodeExpr -> FuncStmt
FMulti :: [FuncStmt] -> FuncStmt
FAppend :: CodeExpr -> CodeExpr -> FuncStmt

pubStateVar :: CodeVarChunk -> StateVariable Source #

Define a public state variable based on the given CodeVarChunk.

privStateVar :: CodeVarChunk -> StateVariable Source #

Define a private state variable based on the given CodeVarChunk.

fDecDef :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> FuncStmt Source #

Define a declare-define statement.

ffor :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> [FuncStmt] -> FuncStmt Source #

Define a for-loop. Quantity is for the iteration variable, CodeExpr is the upper bound at that variable (the variable will start with a value of 0). [FuncStmt] is for the loop body.

fforRange :: (Quantity c, MayHaveUnit c) => c -> CodeExpr -> CodeExpr -> CodeExpr -> [FuncStmt] -> FuncStmt Source #

Define a for-loop. Quantity is for the iteration variable, and 3 CodeExprs for the start, stop, step numbers. [FuncStmt] is for the loop body.

funcData :: Name -> Description -> DataDesc -> Func Source #

Define a function that reads data from a file, according to the given DataDesc.

funcDef :: (Quantity c, MayHaveUnit c) => Name -> Description -> [c] -> Space -> Maybe Description -> [FuncStmt] -> Func Source #

Define a function by providing the FuncStmts for its body. Other parameters are function name, description, list of parameters, space of the returned value, and description of the returned value.

packmod :: Name -> Description -> [Class] -> [Func] -> Mod Source #

Define a Mod with the given Name, Description, Classes, and Functions.

junkLine :: Data Source #

Constructor for junk data.

multiLine :: LinePattern -> Delim -> Data Source #

Constructor for an unknown amount of lines of data.

repeated :: [DataItem] -> LinePattern Source #

Constructor for data with a repeated pattern.

singleLine :: LinePattern -> Delim -> Data Source #

Constructor for a single line of data.

singleton :: DataItem -> Data Source #

Constructor for a single datum.

type ExternalLibrary = [StepGroup] Source #

External library is a group of Steps

data Step Source #

A step can be a call to an external library function or method.

data FunctionInterface Source #

The first item in the Requires list should be where the function being called is defined.

data Argument Source #

An argument may contain a named argument and argument information.

externalLib :: [StepGroup] -> ExternalLibrary Source #

Specifies an external library.

choiceSteps :: [[Step]] -> StepGroup Source #

To be used when there are multiple options for a group of consecutive steps, where a single use-case-specific factor decides which step group to use.

choiceStep :: [Step] -> StepGroup Source #

To be used when there are multiple options for a single step, where a use-case-specific factor decides which step to use.

mandatoryStep :: Step -> StepGroup Source #

Specifies a step which must exist in some form in every use case.

mandatorySteps :: [Step] -> StepGroup Source #

Specifies multiple consecutive steps that all must exist in some form in every use case.

callStep :: FunctionInterface -> Step Source #

libFunction :: Requires -> CodeFuncChunk -> [Argument] -> FunctionInterface Source #

Specifies a call to an external library function.

libMethod :: Requires -> CodeVarChunk -> CodeFuncChunk -> [Argument] -> FunctionInterface Source #

Specifies a call to an external library method.

libFunctionWithResult :: Requires -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface Source #

Specifies a call to an external library function, where the result is assigned to a variable.

libMethodWithResult :: Requires -> CodeVarChunk -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface Source #

Specifies a call to an external library method, where the result is assigned to a variable.

libConstructor :: Requires -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface Source #

Specifies a call to an external library constructor, where the result is assigned to a variable.

libConstructorMultiReqs :: [Requires] -> CodeFuncChunk -> [Argument] -> CodeVarChunk -> FunctionInterface Source #

Specifies a call to an external library function, where multiple modules from the external library are required, and the result is assigned to a variable.

constructAndReturn :: Requires -> CodeFuncChunk -> [Argument] -> FunctionInterface Source #

Specifies a call to an external library constructor, where the result is returned.

lockedArg :: CodeExpr -> Argument Source #

Specifies an argument that is not use-case-dependent.

lockedNamedArg :: NamedArgument -> CodeExpr -> Argument Source #

Specifies a named argument that is not use-case-dependent.

inlineArg :: Space -> Argument Source #

Specifies a use-case-dependent argument whose value can be inlined in the call.

inlineNamedArg :: NamedArgument -> Space -> Argument Source #

Specifies a use-case-dependent named argument whose value can be inlined in the call.

preDefinedArg :: CodeVarChunk -> Argument Source #

Specifies use-case-dependent argument whose value must be assigned to a variable before being passed in the call.

preDefinedNamedArg :: NamedArgument -> CodeVarChunk -> Argument Source #

Specifies use-case-dependent named argument whose value must be assigned to a variable before being passed in the call.

functionArg :: CodeFuncChunk -> [Parameter] -> Step -> Argument Source #

Specifies a function type argument, where the body consists of a single step.

customObjArg :: [Requires] -> Description -> CodeVarChunk -> CodeFuncChunk -> ClassInfo -> Argument Source #

Specifies an argument that is an object of a class that must be defined in the calling program.

recordArg :: Requires -> CodeFuncChunk -> CodeVarChunk -> [CodeVarChunk] -> Argument Source #

Specifies an argument that is an object of a class from the external library. The list of [CodeVarChunk] represents fields of the object that must be set in the calling program.

lockedParam :: CodeVarChunk -> Parameter Source #

Specifies a use-case-independent parameter.

unnamedParam :: Space -> Parameter Source #

Specifies a parameter whose name depends on the use case.

customClass :: [MethodInfo] -> ClassInfo Source #

Specifies a class that must be implemented in the calling program.

implementation :: String -> [MethodInfo] -> ClassInfo Source #

Specifies an implementation of an interface from the external library.

constructorInfo :: CodeFuncChunk -> [Parameter] -> [Step] -> MethodInfo Source #

Specifies a constructor.

methodInfo :: CodeFuncChunk -> Description -> [Parameter] -> Description -> [Step] -> MethodInfo Source #

Specifies a method.

methodInfoNoReturn :: CodeFuncChunk -> Description -> [Parameter] -> [Step] -> MethodInfo Source #

Specifies a method that does not return anything.

appendCurrSol :: CodeExpr -> Step Source #

Specifies a statement where a current solution is appended to a solution list.

populateSolList :: CodeVarChunk -> CodeVarChunk -> CodeVarChunk -> [Step] Source #

Specifies a statement where a solution list is populated by iterating through a solution array.

assignArrayIndex :: Step Source #

Specifies statements where every index of an array is assigned a value.

assignSolFromObj :: CodeVarChunk -> Step Source #

Specifies a statement where a solution is assigned from the field of an object.

initSolListFromArray :: CodeVarChunk -> Step Source #

Specifies a statement where a solution list is initialized with the first element of an array.

initSolListWithVal :: Step Source #

Specifies a statement where a solution list is initialized with the first value.

solveAndPopulateWhile :: FunctionInterface -> CodeVarChunk -> CodeVarChunk -> FunctionInterface -> CodeVarChunk -> Step Source #

A solve and populate loop. FunctionInterface for loop condition, CodeChunk for solution object, CodeChunk for independent var, FunctionInterface for solving, CodeChunk for soln array to populate with.

returnExprList :: Step Source #

Specifies a statement where a list is returned, where each value of the list is explicitly defined.

fixedReturn :: CodeExpr -> Step Source #

Specifies a use-case-independent statement that returns a fixed value.

fixedReturn' :: Step Source #

Specifies a use-case-dependent statement that returns a non-fixed value.

initSolWithVal :: Step Source #

Specifies a statement where a single solution is initialized with a value.

type ExternalLibraryCall = [StepGroupFill] Source #

External library call holds a group of step groups.

data StepGroupFill Source #

Holds a group of steps (StepFills). The Int is to "choose" from the options in ExternalLibrary.

Constructors

SGF Int [StepFill]

data StepFill Source #

Mirrors ExternalLibrary's Step. A StepFill can be a call to an external library function or method.

Constructors

CallF FunctionIntFill
LoopF (NonEmpty FunctionIntFill) [CodeExpr] (NonEmpty StepFill)
StatementF [CodeVarChunk] [CodeExpr]

newtype FunctionIntFill Source #

Mirrors ExternalLibrary's FunctionInterface.

Constructors

FIF [ArgumentFill]

data ArgumentFill Source #

Mirrors ExternalLibrary's ArgumentInfo. Determines the context needed for an argument to work.

Constructors

UserDefinedArgF (Maybe NamedArgument) CodeExpr	For arguments that are completely dependent on use case.
BasicF CodeExpr	A basic function.
FnF [ParameterFill] StepFill	Fills in the names for the unnamed parameters.
ClassF [StateVariable] ClassInfoFill	List of CodeChunk for state variables.
RecordF [CodeExpr]	Fills in the field values.

data ParameterFill Source #

Mirrors ExternalLibrary's Parameter.

Constructors

NameableParamF ParameterChunk
UserDefined ParameterChunk

data ClassInfoFill Source #

Mirrors ExternalLibrary's ClassInfo.

Constructors

RegularF [MethodInfoFill]
ImplementsF [MethodInfoFill]

data MethodInfoFill Source #

Mirrors ExternalLibrary's MethodInfo.

Constructors

CIF [ParameterFill] [Initializer] [StepFill]
MIF [ParameterFill] (NonEmpty StepFill)

externalLibCall :: [StepGroupFill] -> ExternalLibraryCall Source #

Constructs an ExternalLibraryCall specification.

choiceStepsFill :: Int -> [StepFill] -> StepGroupFill Source #

Corresponds to ExternalLibrary's choiceSteps. Provides the index of the steps that should be used for the current use case.

choiceStepFill :: Int -> StepFill -> StepGroupFill Source #

Corresponds to ExternalLibrary's choiceStep. Provides the index of the step that should be used for the current use case.

mandatoryStepFill :: StepFill -> StepGroupFill Source #

Corresponds to ExternalLibrary's mandatorySteps.

mandatoryStepsFill :: [StepFill] -> StepGroupFill Source #

Corresponds to ExternalLibrary's mandatoryStep.

callStepFill :: FunctionIntFill -> StepFill Source #

Corresponds to ExternalLibrary's callStep.

libCallFill :: [ArgumentFill] -> FunctionIntFill Source #

Corresponds to any of ExternalLibrary's FunctionInterface constructors.

userDefinedArgFill :: CodeExpr -> ArgumentFill Source #

Does not correspond to anything in ExternalLibrary. To be used when the presence of an argument is only a consequence of the use case.

basicArgFill :: CodeExpr -> ArgumentFill Source #

Corresponds to ExternalLibrary's inlineArg, inlineNamedArg, preDefinedArg, and preDefinedNamedArg. Provides the CodeExpr for the argument's value.

functionArgFill :: [ParameterFill] -> StepFill -> ArgumentFill Source #

Corresponds to ExternalLibrary's functionArg.

customObjArgFill :: [StateVariable] -> ClassInfoFill -> ArgumentFill Source #

Corresponds to ExternalLibrary's customObjArg. Provides the list of state variables for the class that must be written in the calling program.

recordArgFill :: [CodeExpr] -> ArgumentFill Source #

Corresponds to ExternalLibrary's recordArg. Provides the list of CodeExprs for the values of the fields that must be set by the calling program.

unnamedParamFill :: CodeVarChunk -> ParameterFill Source #

Corresponds to ExternalLibrary's unnamedParam. Provides the CodeVarChunk representing the parameter.

unnamedParamPBVFill :: CodeVarChunk -> ParameterFill Source #

Corresponds to ExternalLibrary's unnamedParam. Provides the CodeVarChunk representing the parameter. Specifies that the parameter is passed by value.

userDefinedParamFill :: CodeVarChunk -> ParameterFill Source #

Does not correspond to anything in ExternalLibrary. To be used when the presence of a parameter is only a consequence of the use case.

customClassFill :: [MethodInfoFill] -> ClassInfoFill Source #

Corresponds to ExternalLibrary's customClass.

implementationFill :: [MethodInfoFill] -> ClassInfoFill Source #

Corresponds to ExternalLibrary's implementation.

constructorInfoFill :: [ParameterFill] -> [Initializer] -> [StepFill] -> MethodInfoFill Source #

Corresponds to ExternalLibrary's constructorInfo. Provides Variable-Value pairs for variables initialized by the constructor.

methodInfoFill :: [ParameterFill] -> [StepFill] -> MethodInfoFill Source #

Corresponds to ExternalLibrary's methodInfo.

appendCurrSolFill :: CodeVarChunk -> StepFill Source #

Corresponds to ExternalLibrary's appendCurrSol. Provides the CodeVarChunk for the solution list.

populateSolListFill :: CodeVarChunk -> [StepFill] Source #

Corresponds to ExternalLibrary's populateSolList. Provides the CodeVarChunk for the solution list.

assignArrayIndexFill :: CodeVarChunk -> [CodeExpr] -> StepFill Source #

Corresponds to ExternalLibrary's assignArrayIndex. Provides the CodeVarChunk for the array variable. Provides the CodeExprs for the values to assign to each array index.

assignSolFromObjFill :: CodeVarChunk -> StepFill Source #

Corresponds to ExternalLibrary's assignSolFromObj. Provides the CodeVarChunk for the variable that the solution should be assigned to.

initSolListFromArrayFill :: CodeVarChunk -> StepFill Source #

Corresponds to ExternalLibrary's initSolListFromArray. Provides the CodeVarChunk for the solution list.

initSolListWithValFill :: CodeVarChunk -> CodeExpr -> StepFill Source #

Corresponds to ExternalLibrary's initSolListWithVal. Provides the CodeVarChunk for the solution list and the CodeExpr for the initial element of the solution list

solveAndPopulateWhileFill :: FunctionIntFill -> CodeExpr -> FunctionIntFill -> CodeVarChunk -> StepFill Source #

Corresponds to ExternalLibrary's solveAndPopulateWhile. Provides the CodeExpr for the upper bound in the while loop condition and the CodeVarChunk for the solution list.

returnExprListFill :: [CodeExpr] -> StepFill Source #

Corresponds to ExternalLibrary's returnExprList. Provides the list of CodeExprs to return.

fixedStatementFill :: StepFill Source #

Corresponds to ExternalLibrary's fixedReturn. No parameters because the statement is not use-case-dependent.

fixedStatementFill' :: CodeExpr -> StepFill Source #

Corresponds to ExternalLibrary's fixedReturn'. use-case-specific a CodeExpr that parameterize the statement.

initSolWithValFill :: CodeVarChunk -> CodeExpr -> StepFill Source #

Corresponds to ExternalLibrary's initSolWithVal. Provides the CodeVarChunk for one solution and one CodeExpr for the initial element of the solution list

data Lang Source #

Various OO languages where code may be generated.

Constructors

Cpp
CSharp
Java
Python
Swift

Instances

Instances details

Show Lang Source #
Instance details Defined in Language.Drasil.Code.Lang Methods showsPrec :: Int -> Lang -> ShowS # show :: Lang -> String # showList :: [Lang] -> ShowS #
Eq Lang Source #
Instance details Defined in Language.Drasil.Code.Lang Methods (==) :: Lang -> Lang -> Bool # (/=) :: Lang -> Lang -> Bool #

class AuxiliarySym r => PackageSym r where Source #

Members of this class must have all the information necessary for the AuxiliarySym in addition to information necessary to create a package.

Associated Types

type Package r Source #

Methods

package :: ProgData -> [r (Auxiliary r)] -> r (Package r) Source #

class AuxiliarySym r where Source #

Members of this class must have a doxygen configuration, ReadMe file, sample input, omptimize doxygen document, information necessary for a makefile, auxiliary helper documents, and auxiliary from data documents.

Associated Types

type Auxiliary r Source #

type AuxHelper r Source #

Methods

doxConfig :: String -> GOOLState -> Verbosity -> r (Auxiliary r) Source #

readMe :: ReadMeInfo -> r (Auxiliary r) Source #

sampleInput :: ChunkDB -> DataDesc -> [Expr] -> r (Auxiliary r) Source #

optimizeDox :: r (AuxHelper r) Source #

makefile :: [FilePath] -> ImplementationType -> [Comments] -> GOOLState -> ProgData -> r (Auxiliary r) Source #

auxHelperDoc :: r (AuxHelper r) -> Doc Source #

auxFromData :: FilePath -> Doc -> r (Auxiliary r) Source #

data AuxData Source #

The underlying data type for auxiliary files in all renderers.

data PackData Source #

The underlying data type for packages in all renderers.

data CodeChunk #

Basic chunk representation in the code generation context. Contains a QuantityDict and the kind of code (variable or function).

Instances

Instances details

CodeIdea CodeChunk Source #	Finds the code name of a `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.Code Methods codeName :: CodeChunk -> String # codeChunk :: CodeChunk -> CodeChunk #
Idea CodeChunk	Finds the idea contained in the `QuantityDict` used to make the `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods getA :: CodeChunk -> Maybe String #
NamedIdea CodeChunk	Finds the term (`NP`) of the `QuantityDict` used to make the `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods term :: Lens' CodeChunk NP #
MayHaveUnit CodeChunk	Finds the units of the `QuantityDict` used to make the `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods getUnit :: CodeChunk -> Maybe UnitDefn #
Quantity CodeChunk	`CodeChunk`s have a `Quantity`.
Instance details Defined in Language.Drasil.Chunk.CodeVar
HasSpace CodeChunk	Finds the `Space` of the `QuantityDict` used to make the `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods typ :: Getter CodeChunk Space #
HasSymbol CodeChunk	Finds the `Stage` dependent `Symbol` of the `QuantityDict` used to make the `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods symbol :: CodeChunk -> Stage -> Symbol #
HasUID CodeChunk	Finds the `UID` of the `QuantityDict` used to make the `CodeChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods uid :: Lens' CodeChunk UID #
Eq CodeChunk	Equal if `UID`s are equal.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods (==) :: CodeChunk -> CodeChunk -> Bool # (/=) :: CodeChunk -> CodeChunk -> Bool #

data CodeVarChunk #

Chunk representing a variable. The obv field represents the object containing this variable, if it is an object field.

Instances

Instances details

CodeIdea CodeVarChunk Source #	Finds the code name and `CodeChunk` within a `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.Code Methods codeName :: CodeVarChunk -> String # codeChunk :: CodeVarChunk -> CodeChunk #
Idea CodeVarChunk	Finds the idea contained in the `CodeChunk` used to make the `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods getA :: CodeVarChunk -> Maybe String #
NamedIdea CodeVarChunk	Finds the term (`NP`) of the `CodeChunk` used to make the `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods term :: Lens' CodeVarChunk NP #
MayHaveUnit CodeVarChunk	Finds the units of the `CodeChunk` used to make the `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods getUnit :: CodeVarChunk -> Maybe UnitDefn #
Quantity CodeVarChunk	`CodeVarChunk`s have a `Quantity`.
Instance details Defined in Language.Drasil.Chunk.CodeVar
HasSpace CodeVarChunk	Finds the `Space` of the `CodeChunk` used to make the `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods typ :: Getter CodeVarChunk Space #
HasSymbol CodeVarChunk	Finds the `Stage` dependent `Symbol` of the `CodeChunk` used to make the `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods symbol :: CodeVarChunk -> Stage -> Symbol #
HasUID CodeVarChunk	Finds the `UID` of the `CodeChunk` used to make the `CodeVarChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods uid :: Lens' CodeVarChunk UID #
Eq CodeVarChunk	Equal if `UID`s are equal.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods (==) :: CodeVarChunk -> CodeVarChunk -> Bool # (/=) :: CodeVarChunk -> CodeVarChunk -> Bool #

data CodeFuncChunk #

Chunk representing a function.

Instances

Instances details

CodeIdea CodeFuncChunk Source #	Finds the code name and `CodeChunk` within a `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.Code Methods codeName :: CodeFuncChunk -> String # codeChunk :: CodeFuncChunk -> CodeChunk #
Idea CodeFuncChunk	Finds the idea contained in the `CodeChunk` used to make the `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods getA :: CodeFuncChunk -> Maybe String #
NamedIdea CodeFuncChunk	Finds the term (`NP`) of the `CodeChunk` used to make the `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods term :: Lens' CodeFuncChunk NP #
MayHaveUnit CodeFuncChunk	Finds the units of the `CodeChunk` used to make the `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods getUnit :: CodeFuncChunk -> Maybe UnitDefn #
Callable CodeFuncChunk	Functions are Callable.
Instance details Defined in Language.Drasil.Chunk.CodeVar
Quantity CodeFuncChunk	`CodeFuncChunk`s have a `Quantity`.
Instance details Defined in Language.Drasil.Chunk.CodeVar
HasSpace CodeFuncChunk	Finds the `Space` of the `CodeChunk` used to make the `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods typ :: Getter CodeFuncChunk Space #
HasSymbol CodeFuncChunk	Finds the `Stage` dependent `Symbol` of the `CodeChunk` used to make the `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods symbol :: CodeFuncChunk -> Stage -> Symbol #
HasUID CodeFuncChunk	Finds the `UID` of the `CodeChunk` used to make the `CodeFuncChunk`.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods uid :: Lens' CodeFuncChunk UID #
Eq CodeFuncChunk	Equal if `UID`s are equal.
Instance details Defined in Language.Drasil.Chunk.CodeVar Methods (==) :: CodeFuncChunk -> CodeFuncChunk -> Bool # (/=) :: CodeFuncChunk -> CodeFuncChunk -> Bool #

quantvar :: (Quantity c, MayHaveUnit c) => c -> CodeVarChunk Source #

Construct a CodeVarChunk from a Quantity.

quantfunc :: (Quantity c, MayHaveUnit c) => c -> CodeFuncChunk Source #

Construct a CodeFuncChunk from a Quantity.

ccObjVar :: CodeVarChunk -> CodeVarChunk -> CodeVarChunk Source #

Combine an Object-type CodeChunk with another CodeChunk to create a new CodeChunk which represents a field of the first. ex. ccObjVar obj f = obj.f.

listToArray :: CodeVarChunk -> CodeVarChunk #

field :: CodeExprC r => CodeVarChunk -> CodeVarChunk -> r #

Constructs a CodeExpr representing the field of an actor

data ODEInfo Source #

Structure to hold ODE information.

Constructors

ODEInfo

Fields

indepVar :: CodeVarChunk
Independent variable.
depVar :: CodeVarChunk
Dependent variable.
otherVars :: [CodeVarChunk]
Other variables in the ODE.
tInit :: CodeExpr
tFinal :: CodeExpr
initVal :: [CodeExpr]
Initial value of an ODE.
odeSyst :: [CodeExpr]
ODE equations.
odeOpts :: ODEOptions
Various options related to the ODE, including solution method, step size, initial value of a second order ODE, etc.

odeInfo :: CodeVarChunk -> CodeVarChunk -> [CodeVarChunk] -> CodeExpr -> CodeExpr -> [CodeExpr] -> [CodeExpr] -> ODEOptions -> ODEInfo Source #

Basic ODEInfo constructor.

odeInfo' :: [CodeVarChunk] -> ODEOptions -> DifferentialModel -> InitialValueProblem -> ODEInfo Source #

Create ODEInfo with Other variables, ODEOptions, DifferentialModel, and InitialValueProblem

data ODEOptions Source #

Other parameters for solving the ODE numerically

Constructors

ODEOpts
Fields solveMethod :: ODEMethod Solution method. absTol :: CodeExpr Absolute tolerance. relTol :: CodeExpr Relative tolerance. stepSize :: CodeExpr Step size.

odeOptions :: ODEMethod -> CodeExpr -> CodeExpr -> CodeExpr -> ODEOptions Source #

Basic ODEOptions constructor

data ODEMethod Source #

Methods for solving ODEs. Includes Runge-Kutta 4-5, Backwards Differentiation Formula, or Adams' method.

Constructors

RK45
BDF
Adams

data ODELibPckg Source #

Holds an ODE library package.

Constructors

ODELib
Fields libName :: Name Library name. libVers :: Version Version. libSpec :: ExternalLibrary Library specifications. libCall :: ODEInfo -> ExternalLibraryCall Library call. libPath :: Maybe FilePath Library path. compatibleLangs :: [Lang] Compatible OO languages.

mkODELib :: Name -> Version -> ExternalLibrary -> (ODEInfo -> ExternalLibraryCall) -> FilePath -> [Lang] -> ODELibPckg Source #

Makes an ODELibPckg with the given name, ExternalLibrary specification, ExternalLibraryCall specification parameterized by an ODEInfo, local file path to the library, and list of compatible languages.

mkODELibNoPath :: Name -> Version -> ExternalLibrary -> (ODEInfo -> ExternalLibraryCall) -> [Lang] -> ODELibPckg Source #

Makes an ODELibPckg with the given name, ExternalLibrary specification, ExternalLibraryCall specification parameterized by an ODEInfo, and list of compatible languages.

unPP :: PythonProject a -> a Source #

unJP :: JavaProject a -> a Source #

unCSP :: CSharpProject a -> a Source #

unCPPP :: CppProject a -> a Source #

unSP :: SwiftProject a -> a Source #

data NamedArgument Source #

Any quantity can be a named argument (wrapper for QuantityDict), but with more of a focus on generating code arguments.

Instances

Instances details

Idea NamedArgument Source #	Finds the idea contained in the `QuantityDict` used to make the `NamedArgument`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods getA :: NamedArgument -> Maybe String #
NamedIdea NamedArgument Source #	Finds the term (`NP`) of the `QuantityDict` used to make the `NamedArgument`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods term :: Lens' NamedArgument NP #
MayHaveUnit NamedArgument Source #	Finds the units of the `QuantityDict` used to make the `NamedArgument`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods getUnit :: NamedArgument -> Maybe UnitDefn #
IsArgumentName NamedArgument Source #	`NamedArgument`s have an argument name.
Instance details Defined in Language.Drasil.Chunk.NamedArgument
Quantity NamedArgument Source #	`NamedArgument`s have a `Quantity`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument
HasSpace NamedArgument Source #	Finds the `Space` of the `QuantityDict` used to make the `NamedArgument`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods typ :: Getter NamedArgument Space #
HasSymbol NamedArgument Source #	Finds the `Symbol` of the `QuantityDict` used to make the `NamedArgument`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods symbol :: NamedArgument -> Stage -> Symbol #
HasUID NamedArgument Source #	Finds the `UID` of the `QuantityDict` used to make the `NamedArgument`.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods uid :: Lens' NamedArgument UID #
Eq NamedArgument Source #	Equal if `UID`s are equal.
Instance details Defined in Language.Drasil.Chunk.NamedArgument Methods (==) :: NamedArgument -> NamedArgument -> Bool # (/=) :: NamedArgument -> NamedArgument -> Bool #

narg :: (Quantity q, MayHaveUnit q) => q -> NamedArgument Source #

Smart constructor for NamedArgument .