| Safe Haskell | None |
|---|---|
| Language | GHC2024 |
Language.Drasil
Description
The Drasil language, including expressions, chunks, sentences, references, classes, datatypes, and generally useful functions. Re-exports modules to simplify external use.
Synopsis
- data Expr
- class ExprC r where
- lit :: Literal -> r
- ($=) :: r -> r -> r
- ($!=) :: r -> r -> r
- ($<) :: r -> r -> r
- ($>) :: r -> r -> r
- ($<=) :: r -> r -> r
- ($>=) :: r -> r -> r
- ($.) :: r -> r -> r
- ($+) :: r -> r -> r
- ($*) :: r -> r -> r
- ($-) :: r -> r -> r
- ($/) :: r -> r -> r
- ($^) :: r -> r -> r
- ($&&) :: r -> r -> r
- ($||) :: r -> r -> r
- in' :: r -> r -> r
- abs_ :: r -> r
- neg :: r -> r
- log :: r -> r
- ln :: r -> r
- sqrt :: r -> r
- sin :: r -> r
- cos :: r -> r
- tan :: r -> r
- sec :: r -> r
- csc :: r -> r
- cot :: r -> r
- arcsin :: r -> r
- arccos :: r -> r
- arctan :: r -> r
- exp :: r -> r
- dim :: r -> r
- norm :: r -> r
- negVec :: r -> r
- not_ :: r -> r
- idx :: r -> r -> r
- idxOf :: r -> r -> r
- defint :: Symbol -> r -> r -> r -> r
- defsum :: Symbol -> r -> r -> r -> r
- defprod :: Symbol -> r -> r -> r -> r
- realInterval :: IsChunk c => c -> RealInterval r r -> r
- euclidean :: [r] -> r
- cross :: r -> r -> r
- vScale :: r -> r -> r
- vAdd :: r -> r -> r
- vSub :: r -> r -> r
- completeCase :: [(r, r)] -> r
- incompleteCase :: [(r, r)] -> r
- matrix :: [[r]] -> r
- set' :: Space -> [r] -> r
- apply :: (IsChunk f, HasSymbol f) => f -> [r] -> r
- sy :: (IsChunk c, HasSymbol c) => c -> r
- frac :: (ExprC r, LiteralC r) => Integer -> Integer -> r
- recip_ :: (ExprC r, LiteralC r) => r -> r
- square :: (ExprC r, LiteralC r) => r -> r
- half :: (ExprC r, LiteralC r) => r -> r
- oneHalf :: (ExprC r, LiteralC r) => r
- oneThird :: (ExprC r, LiteralC r) => r
- apply1 :: (ExprC r, IsChunk f, HasSymbol f, IsChunk a, HasSymbol a) => f -> a -> r
- apply2 :: (ExprC r, IsChunk f, HasSymbol f, IsChunk a, HasSymbol a, IsChunk b, HasSymbol b) => f -> a -> b -> r
- m2x2 :: ExprC r => r -> r -> r -> r -> r
- vec2D :: ExprC r => r -> r -> r
- dgnl2x2 :: (ExprC r, LiteralC r) => r -> r -> r
- rowVec :: ExprC r => [r] -> r
- columnVec :: ExprC r => [r] -> r
- mkSet :: ExprC r => Space -> [r] -> r
- data Completeness
- type Relation = Expr
- data Literal
- class LiteralC r where
- data ModelExpr where
- data DerivType
- class ModelExprC r where
- deriv :: (IsChunk c, HasSymbol c) => r -> c -> r
- pderiv :: (IsChunk c, HasSymbol c) => r -> c -> r
- nthderiv :: (IsChunk c, HasSymbol c) => Integer -> r -> c -> r
- nthpderiv :: (IsChunk c, HasSymbol c) => Integer -> r -> c -> r
- defines :: r -> r -> r
- space :: Space -> r
- isIn :: r -> Space -> r
- equiv :: [r] -> r
- intAll :: Symbol -> r -> r
- sumAll :: Symbol -> r -> r
- prodAll :: Symbol -> r -> r
- data Special = Circle
- class RenderSpecial r where
- class HasSymbol c where
- class IsChunk c => NamedIdea c where
- class NamedIdea c => Idea c where
- class NamedIdea c => CommonIdea c where
- class Definition c where
- class ConceptDomain c where
- type Concept c = (Idea c, Definition c)
- class HasSpace c where
- class HasUnitSymbol u where
- type Quantity c = (Idea c, HasSpace c, HasSymbol c)
- class HasReasVal c where
- reasVal :: Lens' c (Maybe ReasonableValue)
- class Constrained c where
- constraints :: Lens' c [ConstraintE]
- class HasAdditionalNotes c where
- class (Idea u, Definition u, HasUnitSymbol u) => IsUnit u where
- class DefiningExpr (c :: Type -> Type) where
- defnExpr :: Lens' (c e) e
- class Express c where
- data IdeaDict
- idea :: UID -> NP -> String -> IdeaDict
- idea' :: UID -> NP -> IdeaDict
- data CI
- commonIdea :: UID -> NP -> String -> [IdeaDict] -> CI
- prependAbrv :: CommonIdea c => c -> String -> String
- data ConceptChunk
- sDom :: [UID] -> UID
- cncpt :: Concept dom => UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
- cncpt' :: Concept dom => UID -> NP -> Sentence -> [dom] -> ConceptChunk
- cncpt'' :: UID -> NP -> Sentence -> String -> ConceptChunk
- cncpt''' :: UID -> NP -> Sentence -> ConceptChunk
- cw :: Concept c => c -> ConceptChunk
- data QDefinition e
- fromEqn :: String -> NP -> Sentence -> Symbol -> Space -> UnitDefn -> e -> QDefinition e
- fromEqn' :: String -> NP -> Sentence -> Symbol -> Space -> e -> QDefinition e
- fromEqnSt :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> UnitDefn -> e -> QDefinition e
- fromEqnSt' :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> e -> QDefinition e
- fromEqnSt'' :: String -> NP -> Sentence -> (Stage -> Symbol) -> Space -> e -> QDefinition e
- mkQDefSt :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> Maybe UnitDefn -> e -> QDefinition e
- mkQuantDef :: (Quantity c, MayHaveUnit c, Concept c) => c -> e -> QDefinition e
- mkQuantDef' :: (Quantity c, MayHaveUnit c) => c -> NP -> e -> QDefinition e
- ec :: (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e
- mkFuncDef :: (IsChunk f, HasSymbol f, HasSpace f, IsChunk i, HasSymbol i, HasSpace i) => f -> NP -> Sentence -> UnitDefn -> [i] -> e -> QDefinition e
- mkFuncDef' :: (IsChunk f, HasSymbol f, HasSpace f, IsChunk i, HasSymbol i, HasSpace i) => f -> NP -> Sentence -> [i] -> e -> QDefinition e
- mkFuncDefByQ :: (Quantity c, MayHaveUnit c, HasSpace c, Quantity i, HasSpace i) => c -> [i] -> e -> QDefinition e
- data DefinedQuantityDict
- quant :: UID -> NP -> Sentence -> Symbol -> Space -> UnitDefn -> DefinedQuantityDict
- quant' :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> UnitDefn -> DefinedQuantityDict
- quantAU :: UID -> NP -> Sentence -> Maybe String -> (Stage -> Symbol) -> Space -> Maybe UnitDefn -> DefinedQuantityDict
- quantNoUnit :: UID -> NP -> Sentence -> Symbol -> Space -> DefinedQuantityDict
- quantNoUnit' :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> DefinedQuantityDict
- dqd :: ConceptChunk -> Symbol -> Space -> UnitDefn -> DefinedQuantityDict
- dqd' :: ConceptChunk -> (Stage -> Symbol) -> Space -> Maybe UnitDefn -> DefinedQuantityDict
- dqdNoUnit :: ConceptChunk -> Symbol -> Space -> DefinedQuantityDict
- dqdNoUnit' :: ConceptChunk -> (Stage -> Symbol) -> Space -> DefinedQuantityDict
- dqdWr :: (Quantity c, Concept c, MayHaveUnit c) => c -> DefinedQuantityDict
- class DefinesQuantity d where
- defLhs :: Getter d DefinedQuantityDict
- implVar :: UID -> NP -> String -> Space -> Symbol -> DefinedQuantityDict
- implVar' :: UID -> NP -> Sentence -> Space -> Symbol -> DefinedQuantityDict
- implVarAU' :: UID -> NP -> Sentence -> Maybe String -> Space -> Symbol -> Maybe UnitDefn -> DefinedQuantityDict
- data UnitDefn = UD {
- _vc :: ConceptChunk
- _cas :: UnitSymbol
- _cu :: [UID]
- fromUDefn :: UDefn -> USymb
- unitCon :: String -> ConceptChunk
- makeDerU :: ConceptChunk -> UnitEquation -> UnitDefn
- (^:) :: UnitDefn -> Integer -> UnitEquation
- (/:) :: UnitDefn -> UnitDefn -> UnitEquation
- (*:) :: UnitDefn -> UnitDefn -> UnitEquation
- (*$) :: UnitDefn -> UnitEquation -> UnitEquation
- (/$) :: UnitDefn -> UnitEquation -> UnitEquation
- (^$) :: UnitEquation -> UnitEquation -> UnitEquation
- newUnit :: String -> UnitEquation -> UnitDefn
- scale :: IsUnit s => Double -> s -> UDefn
- shift :: IsUnit s => Double -> s -> UDefn
- derUC :: String -> String -> String -> Symbol -> UDefn -> UnitDefn
- derUC' :: String -> String -> String -> Symbol -> UDefn -> UnitDefn
- derUC'' :: String -> NP -> String -> Symbol -> UDefn -> UnitDefn
- fund :: String -> String -> String -> UnitDefn
- fund' :: String -> String -> Symbol -> UnitDefn
- compUnitDefn :: UnitDefn -> UnitDefn -> Ordering
- derCUC :: String -> String -> String -> Symbol -> UnitEquation -> UnitDefn
- derCUC' :: String -> String -> String -> Symbol -> UnitEquation -> UnitDefn
- derCUC'' :: String -> NP -> String -> Symbol -> UnitEquation -> UnitDefn
- getCu :: UnitEquation -> [UID]
- class MayHaveUnit u where
- data ConstraintReason
- data Constraint a where
- Range :: forall a. ConstraintReason -> RealInterval a a -> Constraint a
- Elem :: forall a. ConstraintReason -> a -> Constraint a
- type ConstraintE = Constraint Expr
- physRange :: RealInterval Expr Expr -> ConstraintE
- sfwrRange :: RealInterval Expr Expr -> ConstraintE
- physElem :: Expr -> ConstraintE
- sfwrElem :: Expr -> ConstraintE
- isPhysC :: Constraint e -> Bool
- isSfwrC :: Constraint e -> Bool
- data ConstrConcept = ConstrConcept {
- _uu :: UID
- _defq :: DefinedQuantityDict
- _constr' :: [ConstraintE]
- _reasV' :: Maybe ReasonableValue
- constrained' :: (Concept c, MayHaveUnit c, Quantity c) => c -> [ConstraintE] -> Expr -> ConstrConcept
- constrainedWithRationale :: (Concept c, MayHaveUnit c, Quantity c) => c -> [ConstraintE] -> Expr -> Sentence -> ConstrConcept
- cuc' :: String -> NP -> String -> Symbol -> UnitDefn -> Space -> [ConstraintE] -> Expr -> ConstrConcept
- cuc'' :: String -> NP -> String -> (Stage -> Symbol) -> UnitDefn -> Space -> [ConstraintE] -> Expr -> ConstrConcept
- cucNoUnit' :: String -> NP -> String -> Symbol -> Space -> [ConstraintE] -> Expr -> ConstrConcept
- constrainedNRV' :: (Concept c, MayHaveUnit c, Quantity c) => c -> [ConstraintE] -> ConstrConcept
- cnstrw' :: (Quantity c, Concept c, Constrained c, HasReasVal c, MayHaveUnit c) => c -> ConstrConcept
- data ReasonableValue
- reasonableValue :: Expr -> Maybe Sentence -> ReasonableValue
- reasV :: Lens' ReasonableValue Expr
- rationale :: Lens' ReasonableValue (Maybe Sentence)
- data UncertQ
- uq :: (Quantity c, Constrained c, Concept c, HasReasVal c, MayHaveUnit c) => c -> Uncertainty -> UncertQ
- uqc :: String -> NP -> String -> Symbol -> UnitDefn -> Space -> [ConstraintE] -> Expr -> Uncertainty -> UncertQ
- uqcND :: String -> NP -> Symbol -> UnitDefn -> Space -> [ConstraintE] -> Expr -> Uncertainty -> UncertQ
- uqDirect :: ConstrConcept -> Uncertainty -> UncertQ
- data Uncertainty
- uncty :: Double -> Maybe Int -> Uncertainty
- class HasUncertainty c where
- unc :: Lens' c Uncertainty
- defaultUncrt :: Uncertainty
- uncVal :: HasUncertainty x => x -> Double
- uncPrec :: HasUncertainty x => x -> Maybe Int
- exact :: Uncertainty
- data Month
- type People = [Person]
- data Person
- person :: String -> String -> Person
- class HasName p
- fullName :: HasName n => n -> String
- person' :: String -> String -> Person
- personWM :: String -> [String] -> String -> Person
- personWM' :: String -> [String] -> String -> Person
- mononym :: String -> Person
- nameStr :: HasName p => p -> String
- rendPersLFM :: Person -> String
- rendPersLFM' :: Person -> String
- rendPersLFM'' :: Person -> String
- comparePeople :: [Person] -> [Person] -> Ordering
- data Sentence where
- Ch :: SentenceStyle -> TermCapitalization -> UID -> Sentence
- SyCh :: forall t. (IsChunk t, Idea t, HasSpace t, HasSymbol t) => UIDRef t -> Sentence
- Sy :: USymb -> Sentence
- NP :: NP -> Sentence
- S :: String -> Sentence
- P :: Symbol -> Sentence
- E :: ModelExpr -> Sentence
- Ref :: UID -> Sentence -> RefInfo -> Sentence
- Quote :: Sentence -> Sentence
- Percent :: Sentence
- (:+:) :: Sentence -> Sentence -> Sentence
- EmptyS :: Sentence
- data SentenceStyle
- data TermCapitalization
- data RefInfo
- (+:+) :: Sentence -> Sentence -> Sentence
- (+:+.) :: Sentence -> Sentence -> Sentence
- (+:) :: Sentence -> Sentence -> Sentence
- (!.) :: Sentence -> Sentence
- capSent :: Sentence -> Sentence
- ch :: (IsChunk t, Idea t, HasSpace t, HasSymbol t) => t -> Sentence
- eS :: ModelExpr -> Sentence
- eS' :: Express t => t -> Sentence
- sC :: Sentence -> Sentence -> Sentence
- sDash :: Sentence -> Sentence -> Sentence
- sParen :: Sentence -> Sentence
- fterms :: (NamedIdea c, NamedIdea d) => (NP -> NP -> t) -> c -> d -> t
- getTandS :: Quantity a => a -> Sentence
- checkValidStr :: String -> String -> Either String String
- class NounPhrase n where
- data NP
- pn :: String -> NP
- pn' :: String -> NP
- pn'' :: String -> NP
- pn''' :: String -> NP
- pnIrr :: String -> PluralRule -> NP
- cn :: String -> NP
- cn' :: String -> NP
- cn'' :: String -> NP
- cn''' :: String -> NP
- cnIP :: String -> PluralRule -> NP
- cnIrr :: String -> PluralRule -> CapitalizationRule -> NP
- cnIES :: String -> NP
- cnICES :: String -> NP
- cnIS :: String -> NP
- cnUM :: String -> NP
- nounPhrase :: String -> PluralString -> NP
- nounPhrase' :: String -> PluralString -> CapitalizationRule -> NP
- data CapitalizationRule
- atStartNP :: NounPhrase n => n -> Capitalization
- atStartNP' :: NounPhrase n => n -> Capitalization
- data PluralRule
- compoundPhrase :: (NounPhrase a, NounPhrase b) => a -> b -> NP
- compoundPhrase' :: NP -> NP -> NP
- compoundPhrase'' :: (NP -> NPStruct) -> (NP -> NPStruct) -> NP -> NP -> NP
- compoundPhrase''' :: (NP -> NPStruct) -> NP -> NP -> NP
- compoundPhraseP1 :: NP -> NP -> NP
- titleizeNP :: NounPhrase n => n -> Capitalization
- titleizeNP' :: NounPhrase n => n -> Capitalization
- nounPhrase'' :: NPStruct -> PluralForm -> CapitalizationRule -> CapitalizationRule -> NP
- nounPhraseSP :: String -> NP
- nounPhraseSent :: NPStruct -> NP
- introduceAbb :: Idea n => n -> Sentence
- introduceAbbPlrl :: Idea n => n -> Sentence
- phrase :: NamedIdea n => n -> Sentence
- plural :: NamedIdea n => n -> Sentence
- phrasePoss :: NamedIdea n => n -> Sentence
- pluralPoss :: NamedIdea n => n -> Sentence
- atStart :: NamedIdea n => n -> Sentence
- atStart' :: NamedIdea n => n -> Sentence
- titleize :: NamedIdea n => n -> Sentence
- titleize' :: NamedIdea n => n -> Sentence
- short :: Idea c => c -> Sentence
- data EnumType
- data WrapType
- data SepType
- data FoldType
- foldlEnumList :: EnumType -> WrapType -> SepType -> FoldType -> [Sentence] -> Sentence
- foldlList :: SepType -> FoldType -> [Sentence] -> Sentence
- foldlSent :: [Sentence] -> Sentence
- foldlSent_ :: [Sentence] -> Sentence
- foldlSentCol :: [Sentence] -> Sentence
- foldOpts :: [Sentence] -> Sentence
- foldNums :: String -> [Int] -> Sentence
- numList :: String -> [Int] -> [String]
- data Space
- data RealInterval a b where
- Bounded :: forall a b. (Inclusive, a) -> (Inclusive, b) -> RealInterval a b
- UpTo :: forall a b. (Inclusive, a) -> RealInterval a b
- UpFrom :: forall b a. (Inclusive, b) -> RealInterval a b
- data Inclusive
- data DomainDesc (tplgy :: RTopology) a b where
- BoundedDD :: forall a b. Symbol -> RTopology -> a -> b -> DomainDesc 'Discrete a b
- AllDD :: forall a b. Symbol -> RTopology -> DomainDesc 'Continuous a b
- data RTopology
- type ContinuousDomainDesc a b = DomainDesc 'Continuous a b
- type DiscreteDomainDesc a b = DomainDesc 'Discrete a b
- getActorName :: Space -> String
- getInnerSpace :: Space -> Space
- mkFunction :: [Primitive] -> Primitive -> Space
- type Primitive = Space
- data Decoration
- data Symbol
- newtype USymb = US [(Symbol, Integer)]
- data Stage
- eqSymb :: HasSymbol q => q -> Symbol
- codeSymb :: HasSymbol q => q -> Symbol
- hasStageSymbol :: HasSymbol q => q -> Stage -> Bool
- sortBySymbol :: HasSymbol a => [a] -> [a]
- sortBySymbolTuple :: HasSymbol a => [(a, b)] -> [(a, b)]
- autoStage :: Symbol -> Stage -> Symbol
- hat :: Symbol -> Symbol
- prime :: Symbol -> Symbol
- staged :: Symbol -> Symbol -> Stage -> Symbol
- sub :: Symbol -> Symbol -> Symbol
- subStr :: Symbol -> String -> Symbol
- sup :: Symbol -> Symbol -> Symbol
- unicodeConv :: Symbol -> Symbol
- upperLeft :: Symbol -> Symbol -> Symbol
- vec :: Symbol -> Symbol
- label :: String -> Symbol
- variable :: String -> Symbol
- type ConstQDef = QDefinition Literal
- type SimpleQDef = QDefinition Expr
- type ModelQDef = QDefinition ModelExpr
- type PExpr = forall r. (ExprC r, LiteralC r) => r
- type TypingContext t = Map UID t
- type TypeError = String
- inferFromContext :: TypingContext t -> UID -> Either TypeError t
- class (Eq t, Show t) => Typed e t where
- infer :: TypingContext t -> e -> Either TypeError t
- check :: TypingContext t -> e -> t -> Either TypeError t
- class Typed e t => RequiresChecking c e t where
- requiredChecks :: c -> [(e, t)]
- temporaryIndent :: String -> String -> String
The Drasil Expression Language
Encodes mathematical and display related expressions.
Base Expression Language
Defines the expression types and common operators.
Expression language where all terms are supposed to be 'well understood' (i.e., have a definite meaning). Right now, this coincides with "having a definite value", but should not be restricted to that.
Instances
Methods
($=) :: r -> r -> r infixr 4 Source #
Smart constructor for ordering two equations.
Smart constructor for ordering two equations.
Smart constructor for ordering two equations.
Smart constructor for ordering two equations.
Smart constructor for the dot product of two equations.
Add two expressions.
Multiply two expressions.
($/) :: r -> r -> r infixl 7 Source #
($^) :: r -> r -> r infixr 8 Source #
($&&) :: r -> r -> r infixr 9 Source #
($||) :: r -> r -> r infixr 9 Source #
Smart constructor for set-theoretic membership relation. Added ' to avoid conflict.
Smart constructor for taking the absolute value of an expression.
Smart constructor for negating an expression.
Smart constructor to take the log of an expression.
Smart constructor to take the ln of an expression.
Smart constructor to take the square root of an expression.
Smart constructor to apply sin to an expression.
Smart constructor to apply cos to an expression.
Smart constructor to apply tan to an expression.
Smart constructor to apply sec to an expression.
Smart constructor to apply csc to an expression.
Smart constructor to apply cot to an expression.
Smart constructor to apply arcsin to an expression.
Smart constructor to apply arccos to an expression.
Smart constructor to apply arctan to an expression.
Smart constructor for the exponential (base e) function.
Smart constructor for calculating the dimension of a vector.
Smart constructor for calculating the normal form of a vector.
Smart constructor for negating vectors.
Smart constructor for applying logical negation to an expression.
Smart constructor for indexing.
Smart constructor for indexOf. Finds the index of the first occurrence of a value in a list.
defint :: Symbol -> r -> r -> r -> r Source #
Smart constructor for the summation, product, and integral functions over an interval.
defsum :: Symbol -> r -> r -> r -> r Source #
Smart constructor for the summation, product, and integral functions over an interval.
defprod :: Symbol -> r -> r -> r -> r Source #
Smart constructor for the summation, product, and integral functions over an interval.
realInterval :: IsChunk c => c -> RealInterval r r -> r Source #
Smart constructor for 'real interval' membership.
euclidean :: [r] -> r Source #
Euclidean function : takes a vector and returns the sqrt of the sum-of-squares.
Smart constructor to cross product two expressions.
vScale :: r -> r -> r Source #
Smart constructor for vector scaling
Vector Addition
Vector Subtraction
completeCase :: [(r, r)] -> r Source #
Smart constructor for case statements with a complete set of cases.
incompleteCase :: [(r, r)] -> r Source #
Smart constructor for case statements with an incomplete set of cases.
Create a matrix.
set' :: Space -> [r] -> r Source #
Create a Set.
apply :: (IsChunk f, HasSymbol f) => f -> [r] -> r Source #
Applies a given function with a list of parameters.
Instances
recip_ :: (ExprC r, LiteralC r) => r -> r Source #
Smart constructor for rational expressions (only in 1/x form).
apply2 :: (ExprC r, IsChunk f, HasSymbol f, IsChunk a, HasSymbol a, IsChunk b, HasSymbol b) => f -> a -> b -> r Source #
m2x2 :: ExprC r => r -> r -> r -> r -> r Source #
Create a two-by-two matrix from four given values. For example:
>>>m2x2 1 2 3 4[ [1,2], [3,4] ]
vec2D :: ExprC r => r -> r -> r Source #
Create a 2D vector (a matrix with two rows, one column). First argument is placed above the second.
dgnl2x2 :: (ExprC r, LiteralC r) => r -> r -> r Source #
Creates a diagonal two-by-two matrix. For example:
>>>dgnl2x2 1 2[ [1, 0], [0, 2] ]
data Completeness Source #
For case expressions (either complete or incomplete).
Instances
| Eq Completeness Source # | |
Defined in Language.Drasil.Expr.Lang | |
Literals Language
Expression Modelling Language
Defines display-related expression functions. Used in models.
Expression language where all terms are supposed to have a meaning, but that meaning may not be that of a definite value. For example, specification expressions, especially with quantifiers, belong here.
Instances
Determines the type of the derivative (either a partial derivative or a total derivative).
class ModelExprC r where Source #
Methods
deriv :: (IsChunk c, HasSymbol c) => r -> c -> r Source #
pderiv :: (IsChunk c, HasSymbol c) => r -> c -> r Source #
nthderiv :: (IsChunk c, HasSymbol c) => Integer -> r -> c -> r Source #
nthpderiv :: (IsChunk c, HasSymbol c) => Integer -> r -> c -> r Source #
defines :: r -> r -> r Source #
One expression is "defined" by another.
Space literals.
isIn :: r -> Space -> r Source #
Check if a value belongs to a Space.
Binary associative Equivalence.
intAll :: Symbol -> r -> r Source #
Smart constructor for the summation, product, and integral functions over all Real numbers.
sumAll :: Symbol -> r -> r Source #
Smart constructor for the summation, product, and integral functions over all Real numbers.
prodAll :: Symbol -> r -> r Source #
Smart constructor for the summation, product, and integral functions over all Real numbers.
Instances
| ModelExprC ModelExpr Source # | |
Defined in Language.Drasil.ModelExpr.Class Methods deriv :: (IsChunk c, HasSymbol c) => ModelExpr -> c -> ModelExpr Source # pderiv :: (IsChunk c, HasSymbol c) => ModelExpr -> c -> ModelExpr Source # nthderiv :: (IsChunk c, HasSymbol c) => Integer -> ModelExpr -> c -> ModelExpr Source # nthpderiv :: (IsChunk c, HasSymbol c) => Integer -> ModelExpr -> c -> ModelExpr Source # defines :: ModelExpr -> ModelExpr -> ModelExpr Source # space :: Space -> ModelExpr Source # isIn :: ModelExpr -> Space -> ModelExpr Source # equiv :: [ModelExpr] -> ModelExpr Source # intAll :: Symbol -> ModelExpr -> ModelExpr Source # | |
Unicode symbols
Some expressions need special unicode characters.
Special characters include partial derivatives and the degree circle.
Constructors
| Circle |
class RenderSpecial r where Source #
Class for rendering special characters.
The Drasil Language (Information Encoding)
This is the basis of the Drasil language for encoding information. Every chunk used in Drasil is defined here, along with some classes that help us to use these chunks.
Classes
Contains many of the classes used in Drasil, along with their methods.
Chunk-related
class HasSymbol c where Source #
A HasSymbol is anything which has a Symbol.
Methods
symbol :: c -> Stage -> Symbol Source #
Provides the Symbol for a particular stage of generation.
Instances
| HasSymbol CodeChunk Source # | Finds the |
| HasSymbol CodeFuncChunk Source # | Finds the |
Defined in Drasil.Code.CodeVar | |
| HasSymbol CodeVarChunk Source # | Finds the |
Defined in Drasil.Code.CodeVar | |
| HasSymbol ConstrConcept Source # | Finds the |
Defined in Language.Drasil.Chunk.Constrained | |
| HasSymbol DefinedQuantityDict Source # | Finds the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| HasSymbol UncertQ Source # | Finds the |
| HasSymbol (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
class IsChunk c => NamedIdea c where Source #
Instances
class NamedIdea c => Idea c where Source #
An Idea is the combination of a NamedIdea and a CommonIdea. In other
words, it may have an acronym/abbreviation.
Instances
class NamedIdea c => CommonIdea c where Source #
CommonIdea is a NamedIdea with the additional
constraint that it must have an abbreviation. This is the main
distinction between getA and abrv, where getA may return Nothing,
while abrv will always return the abbreviation.
class Definition c where Source #
Defines a chunk.
Instances
class ConceptDomain c where Source #
Some concepts have a domain (related information encoded in UIDs to other chunks).
Methods
Provides Getter for the concept domain tags for a chunk
cdom should be exported for use by the Drasil framework, but should not be exported beyond that.
Instances
| ConceptDomain ConceptChunk Source # | Finds the domain of |
Defined in Language.Drasil.Chunk.Concept.Core Methods cdom :: ConceptChunk -> [UID] Source # | |
| ConceptDomain ConceptInstance Source # | Finds the domain contained in the |
Defined in Language.Drasil.Document.ConceptInstance Methods cdom :: ConceptInstance -> [UID] Source # | |
class HasSpace c where Source #
HasSpace is anything which has a Space.
Instances
class HasUnitSymbol u where Source #
Some chunks store a unit symbol.
Instances
| HasUnitSymbol UnitDefn Source # | Finds unit symbol of the |
type Quantity c = (Idea c, HasSpace c, HasSymbol c) Source #
A Quantity is an Idea with a Space and a Symbol.
In theory, it should also restrict to being a part of MayHaveUnit, but that causes
all sorts of import cycles (or lots of orphans).
class HasReasVal c where Source #
A Quantity that could have a reasonable value.
Methods
reasVal :: Lens' c (Maybe ReasonableValue) Source #
Provides a Lens to the possible reasonable value.
Instances
| HasReasVal ConstrConcept Source # | Finds a reasonable value for the |
Defined in Language.Drasil.Chunk.Constrained Methods reasVal :: Lens' ConstrConcept (Maybe ReasonableValue) Source # | |
| HasReasVal UncertQ Source # | Finds a reasonable value for the |
Defined in Language.Drasil.Chunk.UncertainQuantity | |
class Constrained c where Source #
The Constrained class is a Quantity that has value constraints.
It does not enforce Quantity at this point.
Instances
| Constrained ConstrConcept Source # | Finds the |
Defined in Language.Drasil.Chunk.Constrained Methods constraints :: Lens' ConstrConcept [ConstraintE] Source # | |
| Constrained UncertQ Source # | Finds the |
Defined in Language.Drasil.Chunk.UncertainQuantity Methods constraints :: Lens' UncertQ [ConstraintE] Source # | |
class HasAdditionalNotes c where Source #
Records any additional notes needed to avoid losing information
class (Idea u, Definition u, HasUnitSymbol u) => IsUnit u where Source #
Units are Ideas with a Definition which store a unit symbol.
They must also be explicitly declared to be instances of IsUnit.
Minimal complete definition
udefn, getUnits
class DefiningExpr (c :: Type -> Type) where Source #
Methods
defnExpr :: Lens' (c e) e Source #
Provides a Lens to the expression.
TODO: Well, technically, e doesn't need to be an "expression" of any sorts.
It just needs to be _something_, and it would have approximately have same meaning.
Instances
| DefiningExpr QDefinition Source # | |
Defined in Language.Drasil.Chunk.Eq Methods defnExpr :: Lens' (QDefinition e) e Source # | |
class Express c where Source #
Express something axiomatically.
Methods
express :: c -> ModelExpr Source #
Express something as a single fact.
mexpress :: c -> NonEmpty ModelExpr Source #
Express something as a series of facts.
Instances
| Express ConstrConcept Source # | Convert the symbol of the |
Defined in Language.Drasil.Chunk.Constrained | |
| Express DefinedQuantityDict Source # | Convert the symbol of the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| Express UncertQ Source # | Convert the symbol of the |
| Express Expr Source # | |
| Express Literal Source # | |
| Express ModelExpr Source # | No change, it's already a |
| Express e => Express (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
| Express t => Express (NonEmpty t) Source # | |
| Express t => Express [t] Source # | |
Types
Contains helper functions and smart constructors for each type. Similar types are grouped together.
Basic types
IdeaDict is the canonical dictionary associated to an Idea.
Contains a UID and a term that could have an abbreviation (Maybe String).
Ex. The project name "Double Pendulum" may have the abbreviation DblPend.
Instances
Arguments
| :: UID | The |
| -> NP | The |
| -> String | The |
| -> IdeaDict |
Construct an IdeaDict (with an acronym/abbreviation).
Construct an IdeaDict (without an acronym/abbreviation).
The common idea (with NounPhrase) data type. It must have a UID,
NounPhrase for its term, an abbreviation (String), and a domain ([UID]).
It is similar to IdeaDict and IdeaDict in the sense that these are for things worth naming,
but this type also carries an abbreviation and related domains of knowledge.
Ex. The term "Operating System" has the abbreviation OS and comes from the domain of computer science.
Instances
| HasChunkRefs CI Source # | |||||
| HasUID CI Source # | |||||
Defined in Language.Drasil.Chunk.CommonIdea | |||||
| Idea CI Source # | Finds the idea of a | ||||
| NamedIdea CI Source # | |||||
| CommonIdea CI Source # | Finds the idea of a | ||||
| Generic CI Source # | |||||
Defined in Language.Drasil.Chunk.CommonIdea Associated Types
| |||||
| type Rep CI Source # | |||||
Defined in Language.Drasil.Chunk.CommonIdea type Rep CI = D1 ('MetaData "CI" "Language.Drasil.Chunk.CommonIdea" "drasil-lang-0.1.60.0-1HMwkmtaiHpDlCGzFv9lso" 'False) (C1 ('MetaCons "CI" 'PrefixI 'True) (S1 ('MetaSel ('Just "_nc'") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 IdeaDict) :*: (S1 ('MetaSel ('Just "_ab") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 String) :*: S1 ('MetaSel ('Just "cdom'") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [UID])))) | |||||
prependAbrv :: CommonIdea c => c -> String -> String Source #
Prepends the abbreviation from a CommonIdea to a String.
Concepts
data ConceptChunk Source #
The ConceptChunk datatype records a concept that contains a unique id (UID),
a term (NP), a definition (Sentence), an optional abbreviation ('Maybe String'),
and an associated domain of knowledge ([UID]).
Ex. The concept of Accuracy may be defined as the quality or state of being correct or precise.
Instances
| HasChunkRefs ConceptChunk Source # | |||||
Defined in Language.Drasil.Chunk.Concept.Core Methods chunkRefs :: ConceptChunk -> Set UID # | |||||
| HasUID ConceptChunk Source # | Finds | ||||
Defined in Language.Drasil.Chunk.Concept.Core Methods uid :: Getter ConceptChunk UID # | |||||
| Idea ConceptChunk Source # | Finds the abbreviation of the | ||||
Defined in Language.Drasil.Chunk.Concept.Core | |||||
| NamedIdea ConceptChunk Source # | Finds term ( | ||||
Defined in Language.Drasil.Chunk.Concept.Core Methods term :: Lens' ConceptChunk NP Source # | |||||
| ConceptDomain ConceptChunk Source # | Finds the domain of | ||||
Defined in Language.Drasil.Chunk.Concept.Core Methods cdom :: ConceptChunk -> [UID] Source # | |||||
| Definition ConceptChunk Source # | Finds definition of a | ||||
Defined in Language.Drasil.Chunk.Concept.Core Methods defn :: Lens' ConceptChunk Sentence Source # | |||||
| Generic ConceptChunk Source # | |||||
Defined in Language.Drasil.Chunk.Concept.Core Associated Types
| |||||
| Eq ConceptChunk Source # | Equal if | ||||
Defined in Language.Drasil.Chunk.Concept.Core | |||||
| type Rep ConceptChunk Source # | |||||
Defined in Language.Drasil.Chunk.Concept.Core type Rep ConceptChunk = D1 ('MetaData "ConceptChunk" "Language.Drasil.Chunk.Concept.Core" "drasil-lang-0.1.60.0-1HMwkmtaiHpDlCGzFv9lso" 'False) (C1 ('MetaCons "ConDict" 'PrefixI 'True) ((S1 ('MetaSel ('Just "_uu") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 UID) :*: S1 ('MetaSel ('Just "_np") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 NP)) :*: (S1 ('MetaSel ('Just "mabbr") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe String)) :*: (S1 ('MetaSel ('Just "_defn'") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 Sentence) :*: S1 ('MetaSel ('Just "cdom'") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [UID]))))) | |||||
Check if something has one domain. Throws an error if there is more than one.
Arguments
| :: Concept dom | |
| => UID | The |
| -> NP | |
| -> Sentence | The definition of the |
| -> String | The term's abbreviation. |
| -> [dom] | The domain the |
| -> ConceptChunk |
Construct a ConceptChunk.
Arguments
| :: Concept dom | |
| => UID | The |
| -> NP | The |
| -> Sentence | The definition of the |
| -> [dom] | The domain the |
| -> ConceptChunk |
Construct a ConceptChunk.
Arguments
| :: UID | The |
| -> NP | The |
| -> Sentence | The definition of the |
| -> String | The term's abbreviation. |
| -> ConceptChunk |
Construct a ConceptChunk.
Arguments
| :: UID | The |
| -> NP | The |
| -> Sentence | The definition of the |
| -> ConceptChunk |
Construct a ConceptChunk.
cw :: Concept c => c -> ConceptChunk Source #
Deprecated: Chunk down-casting is strongly discouraged. If you want to construct a ConceptChunk, use one of its normal constructors.
For projecting out to the ConceptChunk data-type.
Quantities and Units
data QDefinition e Source #
A QDefinition is a representation of a formula relating a DefinedQuantityDict
with an arbitrary expression e given a (possibly empty) list of input variables.
Ex:
F = ma(with symbol F, space Real and unit Newtons)f(t) = t^2(with symbol f [displayed as f(t)], space Real and unit seconds^2)
A QDefinition can be thought of as a MultiDefn with only a single formula.
Instances
| DefiningExpr QDefinition Source # | |
Defined in Language.Drasil.Chunk.Eq Methods defnExpr :: Lens' (QDefinition e) e Source # | |
| HasChunkRefs (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods chunkRefs :: QDefinition e -> Set UID # | |
| HasUID (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods uid :: Getter (QDefinition e) UID # | |
| DefinesQuantity (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods defLhs :: Getter (QDefinition e) DefinedQuantityDict Source # | |
| Idea (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
| NamedIdea (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods term :: Lens' (QDefinition e) NP Source # | |
| MayHaveUnit (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
| Definition (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods defn :: Lens' (QDefinition e) Sentence Source # | |
| Express e => Express (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
| HasSpace (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods typ :: Getter (QDefinition e) Space Source # | |
| HasSymbol (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
| Eq (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods (==) :: QDefinition e -> QDefinition e -> Bool # (/=) :: QDefinition e -> QDefinition e -> Bool # | |
| RequiresChecking (QDefinition Expr) Expr Space Source # | |
Defined in Language.Drasil.Chunk.Eq Methods requiredChecks :: QDefinition Expr -> [(Expr, Space)] Source # | |
fromEqn' :: String -> NP -> Sentence -> Symbol -> Space -> e -> QDefinition e Source #
Same as fromEqn, but has no units.
fromEqnSt :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> UnitDefn -> e -> QDefinition e Source #
Same as fromEqn, but symbol depends on stage.
fromEqnSt' :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> e -> QDefinition e Source #
Same as fromEqn, but symbol depends on stage and has no units.
fromEqnSt'' :: String -> NP -> Sentence -> (Stage -> Symbol) -> Space -> e -> QDefinition e Source #
Same as fromEqnSt', but takes a String instead of a UID.
mkQDefSt :: UID -> NP -> Sentence -> (Stage -> Symbol) -> Space -> Maybe UnitDefn -> e -> QDefinition e Source #
Wrapper for fromEqnSt and fromEqnSt'
mkQuantDef :: (Quantity c, MayHaveUnit c, Concept c) => c -> e -> QDefinition e Source #
Used to help make QDefinitions when UID, term, and Symbol come from the same source.
mkQuantDef' :: (Quantity c, MayHaveUnit c) => c -> NP -> e -> QDefinition e Source #
Used to help make QDefinitions when UID and Symbol come from the same source, with the term separate.
ec :: (Quantity c, MayHaveUnit c) => c -> e -> QDefinition e Source #
mkFuncDef :: (IsChunk f, HasSymbol f, HasSpace f, IsChunk i, HasSymbol i, HasSpace i) => f -> NP -> Sentence -> UnitDefn -> [i] -> e -> QDefinition e Source #
Create a QDefinition function with a symbol, name, term, list of inputs,
resultant units, and a defining Expr
mkFuncDef' :: (IsChunk f, HasSymbol f, HasSpace f, IsChunk i, HasSymbol i, HasSpace i) => f -> NP -> Sentence -> [i] -> e -> QDefinition e Source #
Create a QDefinition function with a symbol, name, term, list of inputs,
and a defining Expr
mkFuncDefByQ :: (Quantity c, MayHaveUnit c, HasSpace c, Quantity i, HasSpace i) => c -> [i] -> e -> QDefinition e Source #
Create a QDefinition functions using a symbol, list of inputs, and a
defining Expr
data DefinedQuantityDict Source #
DefinedQuantityDict is a representation of a future value with information about its type (Space),
unit (when applicable, UnitDefn), and symbol (in different Stage contexts, Symbol).
Additionally, it contains a reference to the general concept the value is an instance of (ConceptChunk).
Ex. A pendulum arm can be defined as a concept with a symbol (l), space (Real numbers), and units (cm, m, etc.).
Instances
| HasChunkRefs DefinedQuantityDict Source # | |
Defined in Language.Drasil.Chunk.DefinedQuantity Methods chunkRefs :: DefinedQuantityDict -> Set UID # | |
| HasUID DefinedQuantityDict Source # | Finds the |
Defined in Language.Drasil.Chunk.DefinedQuantity Methods uid :: Getter DefinedQuantityDict UID # | |
| Idea DefinedQuantityDict Source # | Finds the idea contained in the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| NamedIdea DefinedQuantityDict Source # | Finds the term ( |
Defined in Language.Drasil.Chunk.DefinedQuantity Methods term :: Lens' DefinedQuantityDict NP Source # | |
| MayHaveUnit DefinedQuantityDict Source # | Finds the units of the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| Definition DefinedQuantityDict Source # | Finds the definition contained in the |
Defined in Language.Drasil.Chunk.DefinedQuantity Methods defn :: Lens' DefinedQuantityDict Sentence Source # | |
| Express DefinedQuantityDict Source # | Convert the symbol of the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| HasSpace DefinedQuantityDict Source # | Finds the |
Defined in Language.Drasil.Chunk.DefinedQuantity Methods typ :: Getter DefinedQuantityDict Space Source # | |
| HasSymbol DefinedQuantityDict Source # | Finds the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| Eq DefinedQuantityDict Source # | Equal if |
Defined in Language.Drasil.Chunk.DefinedQuantity Methods (==) :: DefinedQuantityDict -> DefinedQuantityDict -> Bool # (/=) :: DefinedQuantityDict -> DefinedQuantityDict -> Bool # | |
Arguments
| :: UID | The |
| -> NP | The quantity being defined. |
| -> Sentence | The definition of the quantity. |
| -> Symbol | The |
| -> Space | The |
| -> UnitDefn | The unit of the quantity. |
| -> DefinedQuantityDict |
Construct a DefinedQuantityDict (with a unit)
Arguments
| :: UID | The |
| -> NP | The quantity being defined. |
| -> Sentence | The definition of the quantity. |
| -> (Stage -> Symbol) | |
| -> Space | The |
| -> UnitDefn | The unit of the quantity. |
| -> DefinedQuantityDict |
Construct a DefinedQuantityDict (with a unit and a symbol dependent on stage)
Arguments
| :: UID | The |
| -> NP | The quantity being defined. |
| -> Sentence | The definition of the quantity. |
| -> Maybe String | The (optional) abbreviation for the quantity. |
| -> (Stage -> Symbol) | |
| -> Space | The |
| -> Maybe UnitDefn | The (optional) unit of the quantity. |
| -> DefinedQuantityDict |
Construct a DefinedQuantityDict (with an optional unit, optional
abbreviation and a symbol dependent on stage)
Arguments
| :: UID | The |
| -> NP | The quantity being defined. |
| -> Sentence | The definition of the quantity. |
| -> Symbol | The |
| -> Space | The |
| -> DefinedQuantityDict |
Construct a DefinedQuantityDict (without a unit)
Arguments
| :: UID | The |
| -> NP | The quantity being defined. |
| -> Sentence | The definition of the quantity. |
| -> (Stage -> Symbol) | |
| -> Space | The |
| -> DefinedQuantityDict |
Construct a DefinedQuantityDict (wihout a unit and with a symbol dependent on stage)
dqd :: ConceptChunk -> Symbol -> Space -> UnitDefn -> DefinedQuantityDict Source #
Deprecated: Smart constructors allow externally-known chunk nesting; use one of `quant, quant', quantNoUnit, quantNoUnit'` instead.
Smart constructor that creates a DefinedQuantityDict with a ConceptChunk, a Symbol independent of Stage, a Space, and a unit.
dqd' :: ConceptChunk -> (Stage -> Symbol) -> Space -> Maybe UnitDefn -> DefinedQuantityDict Source #
dqdNoUnit :: ConceptChunk -> Symbol -> Space -> DefinedQuantityDict Source #
Deprecated: Smart constructors allow externally-known chunk nesting; use one of `quant, quant', quantNoUnit, quantNoUnit'` instead.
Similar to dqd, but without any units.
dqdNoUnit' :: ConceptChunk -> (Stage -> Symbol) -> Space -> DefinedQuantityDict Source #
Deprecated: Smart constructors allow externally-known chunk nesting; use one of `quant, quant', quantNoUnit, quantNoUnit'` instead.
dqdWr :: (Quantity c, Concept c, MayHaveUnit c) => c -> DefinedQuantityDict Source #
When the input already has all the necessary information. A projection operator from some a type with instances of listed classes to a DefinedQuantityDict.
class DefinesQuantity d where Source #
Methods
defLhs :: Getter d DefinedQuantityDict Source #
Instances
| DefinesQuantity (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq Methods defLhs :: Getter (QDefinition e) DefinedQuantityDict Source # | |
implVar :: UID -> NP -> String -> Space -> Symbol -> DefinedQuantityDict Source #
Makes a variable that is implementation-only.
implVarAU' :: UID -> NP -> Sentence -> Maybe String -> Space -> Symbol -> Maybe UnitDefn -> DefinedQuantityDict Source #
Similar to implVarAU but takes a Sentence for the description rather than a String.
For defining units.
It has a ConceptChunk (that defines what kind of unit it is),
a unit symbol, maybe another (when it is a synonym),
perhaps a definition, and a list of UID of the units that make up
the definition.
Ex. Meter is a unit of length defined by the symbol (m).
Instances
| HasChunkRefs UnitDefn Source # | |
| HasUID UnitDefn Source # | Finds |
Defined in Language.Drasil.Chunk.UnitDefn | |
| Idea UnitDefn Source # | Finds the idea contained in the |
| NamedIdea UnitDefn Source # | Finds term ( |
| Definition UnitDefn Source # | Finds definition of the |
| HasUnitSymbol UnitDefn Source # | Finds unit symbol of the |
| IsUnit UnitDefn Source # | Gets the UnitDefn and contributing units. |
| Eq UnitDefn Source # | Equal if |
unitCon :: String -> ConceptChunk Source #
Helper for fundamental unit concept chunk creation. Uses the same String
for the identifier, term, and definition.
makeDerU :: ConceptChunk -> UnitEquation -> UnitDefn Source #
Create a derived unit chunk from a concept and a unit equation.
(*$) :: UnitDefn -> UnitEquation -> UnitEquation Source #
Combinator for multiplying a unit and a symbol.
(/$) :: UnitDefn -> UnitEquation -> UnitEquation Source #
Combinator for dividing a unit and a symbol.
(^$) :: UnitEquation -> UnitEquation -> UnitEquation Source #
Combinator for mulitiplying two unit equations.
newUnit :: String -> UnitEquation -> UnitDefn Source #
Smart constructor for new derived units from existing units.
compUnitDefn :: UnitDefn -> UnitDefn -> Ordering Source #
We don't want an Ord on units, but this still allows us to compare them.
getCu :: UnitEquation -> [UID] Source #
Get a list of UID of the units that make up the UnitEquation.
class MayHaveUnit u where Source #
Types may contain a unit (UnitDefn).
Instances
| MayHaveUnit CodeChunk Source # | Finds the units of the |
| MayHaveUnit CodeFuncChunk Source # | Finds the units of the |
Defined in Drasil.Code.CodeVar | |
| MayHaveUnit CodeVarChunk Source # | Finds the units of the |
Defined in Drasil.Code.CodeVar | |
| MayHaveUnit ConstrConcept Source # | Finds the units of the |
Defined in Language.Drasil.Chunk.Constrained | |
| MayHaveUnit DefinedQuantityDict Source # | Finds the units of the |
Defined in Language.Drasil.Chunk.DefinedQuantity | |
| MayHaveUnit UncertQ Source # | Finds the units of the |
| MayHaveUnit (QDefinition e) Source # | |
Defined in Language.Drasil.Chunk.Eq | |
Constrained and Uncertain Values
data ConstraintReason Source #
The reason behind the constraint's existence.
data Constraint a where Source #
Constructors
| Range :: forall a. ConstraintReason -> RealInterval a a -> Constraint a | By default, physical and software constraints are ranges. |
| Elem :: forall a. ConstraintReason -> a -> Constraint a |
type ConstraintE = Constraint Expr Source #
Type synonym for ConstraintE
physRange :: RealInterval Expr Expr -> ConstraintE Source #
Smart constructor for range of Physical constraints between two given expressions.
sfwrRange :: RealInterval Expr Expr -> ConstraintE Source #
Smart constructor for range of Software constraints between two given expressions.
physElem :: Expr -> ConstraintE Source #
sfwrElem :: Expr -> ConstraintE Source #
isPhysC :: Constraint e -> Bool Source #
Helpful for filtering for Physical constraints. True if constraint is Physical.
isSfwrC :: Constraint e -> Bool Source #
Helpful for filtering for Software constraints. True if constraint is Software.
data ConstrConcept Source #
ConstrConcepts are conceptual symbolic quantities (DefinedQuantityDict)
with Constraints and maybe a reasonable value.
Ex. Measuring the length of a pendulum arm could be a concept that has some reasonable value (between 1 cm and 2 m) and the constraint that the length cannot be a negative value.
Constructors
| ConstrConcept | |
Fields
| |
Instances
| HasChunkRefs ConstrConcept Source # | |
Defined in Language.Drasil.Chunk.Constrained Methods chunkRefs :: ConstrConcept -> Set UID # | |
| HasUID ConstrConcept Source # | Finds |
Defined in Language.Drasil.Chunk.Constrained Methods uid :: Getter ConstrConcept UID # | |
| Idea ConstrConcept Source # | Finds the idea contained in the |
Defined in Language.Drasil.Chunk.Constrained | |
| NamedIdea ConstrConcept Source # | Finds term ( |
Defined in Language.Drasil.Chunk.Constrained Methods term :: Lens' ConstrConcept NP Source # | |
| MayHaveUnit ConstrConcept Source # | Finds the units of the |
Defined in Language.Drasil.Chunk.Constrained | |
| Constrained ConstrConcept Source # | Finds the |
Defined in Language.Drasil.Chunk.Constrained Methods constraints :: Lens' ConstrConcept [ConstraintE] Source # | |
| Definition ConstrConcept Source # | Finds definition of the |
Defined in Language.Drasil.Chunk.Constrained Methods defn :: Lens' ConstrConcept Sentence Source # | |
| HasReasVal ConstrConcept Source # | Finds a reasonable value for the |
Defined in Language.Drasil.Chunk.Constrained Methods reasVal :: Lens' ConstrConcept (Maybe ReasonableValue) Source # | |
| Express ConstrConcept Source # | Convert the symbol of the |
Defined in Language.Drasil.Chunk.Constrained | |
| HasSpace ConstrConcept Source # | Finds the |
Defined in Language.Drasil.Chunk.Constrained Methods typ :: Getter ConstrConcept Space Source # | |
| HasSymbol ConstrConcept Source # | Finds the |
Defined in Language.Drasil.Chunk.Constrained | |
| Eq ConstrConcept Source # | Equal if |
Defined in Language.Drasil.Chunk.Constrained Methods (==) :: ConstrConcept -> ConstrConcept -> Bool # (/=) :: ConstrConcept -> ConstrConcept -> Bool # | |
constrained' :: (Concept c, MayHaveUnit c, Quantity c) => c -> [ConstraintE] -> Expr -> ConstrConcept Source #
Creates a ConstrConcept with a quantitative concept, a list of Constraints and an Expr.
constrainedWithRationale :: (Concept c, MayHaveUnit c, Quantity c) => c -> [ConstraintE] -> Expr -> Sentence -> ConstrConcept Source #
Similar to constrained', but with a rationale Sentence explaining the reasonable value.
cuc' :: String -> NP -> String -> Symbol -> UnitDefn -> Space -> [ConstraintE] -> Expr -> ConstrConcept Source #
cuc'' :: String -> NP -> String -> (Stage -> Symbol) -> UnitDefn -> Space -> [ConstraintE] -> Expr -> ConstrConcept Source #
cucNoUnit' :: String -> NP -> String -> Symbol -> Space -> [ConstraintE] -> Expr -> ConstrConcept Source #
Similar to cuc', but does not include a unit.
constrainedNRV' :: (Concept c, MayHaveUnit c, Quantity c) => c -> [ConstraintE] -> ConstrConcept Source #
Similar to constrained', but defaults Maybe Expr to Nothing.
cnstrw' :: (Quantity c, Concept c, Constrained c, HasReasVal c, MayHaveUnit c) => c -> ConstrConcept Source #
Similar to cnstrw, but types must also have a Concept.
data ReasonableValue Source #
Represents a reasonable value (Expr) with an optional
rationale ('Maybe Sentence').
A reasonable value is an example of a value that is physically admissible.
reasonableValue :: Expr -> Maybe Sentence -> ReasonableValue Source #
reasV :: Lens' ReasonableValue Expr Source #
UncertQs are conceptual symbolic quantities with constraints and an Uncertainty.
Contains the same information as a ConstrConcept with an added Uncertainty.
Ex. Measuring the length of a pendulum arm may be recorded with an uncertainty value.
Instances
| HasChunkRefs UncertQ Source # | |
| HasUID UncertQ Source # | Finds |
Defined in Language.Drasil.Chunk.UncertainQuantity | |
| Idea UncertQ Source # | Finds the idea contained in the |
| NamedIdea UncertQ Source # | Finds term ( |
| MayHaveUnit UncertQ Source # | Finds the units of the |
| Constrained UncertQ Source # | Finds the |
Defined in Language.Drasil.Chunk.UncertainQuantity Methods constraints :: Lens' UncertQ [ConstraintE] Source # | |
| Definition UncertQ Source # | Finds definition of the |
| HasReasVal UncertQ Source # | Finds a reasonable value for the |
Defined in Language.Drasil.Chunk.UncertainQuantity | |
| Express UncertQ Source # | Convert the symbol of the |
| HasSpace UncertQ Source # | Finds the |
| HasSymbol UncertQ Source # | Finds the |
| HasUncertainty UncertQ Source # | Finds the uncertainty of an |
Defined in Language.Drasil.Chunk.UncertainQuantity Methods unc :: Lens' UncertQ Uncertainty Source # | |
| Eq UncertQ Source # | Equal if |
uq :: (Quantity c, Constrained c, Concept c, HasReasVal c, MayHaveUnit c) => c -> Uncertainty -> UncertQ Source #
Smart constructor that requires a Quantity, a percentage, and a reasonable value with an Uncertainty.
uqc :: String -> NP -> String -> Symbol -> UnitDefn -> Space -> [ConstraintE] -> Expr -> Uncertainty -> UncertQ Source #
Uncertainty quantity (uq) but with a constraint.
uqcND :: String -> NP -> Symbol -> UnitDefn -> Space -> [ConstraintE] -> Expr -> Uncertainty -> UncertQ Source #
Uncertainty quantity constraint (uqc) without a description.
uqDirect :: ConstrConcept -> Uncertainty -> UncertQ Source #
Directly wraps a ConstrConcept with an Uncertainty, preserving all fields (including rationale).
data Uncertainty Source #
Something that may contain an uncertainty value and a precision value.
Instances
| HasChunkRefs Uncertainty Source # | |||||
Defined in Language.Drasil.Uncertainty Methods chunkRefs :: Uncertainty -> Set UID # | |||||
| Generic Uncertainty Source # | |||||
Defined in Language.Drasil.Uncertainty Associated Types
| |||||
| type Rep Uncertainty Source # | |||||
Defined in Language.Drasil.Uncertainty type Rep Uncertainty = D1 ('MetaData "Uncertainty" "Language.Drasil.Uncertainty" "drasil-lang-0.1.60.0-1HMwkmtaiHpDlCGzFv9lso" 'False) (C1 ('MetaCons "Uncert" 'PrefixI 'True) (S1 ('MetaSel ('Just "_uncert") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Double)) :*: S1 ('MetaSel ('Just "_prec") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 (Maybe Int)))) | |||||
class HasUncertainty c where Source #
HasUncertainty is just a chunk with some uncertainty associated to it. This uncertainty is represented as a decimal value between 0 and 1 (percentage).
Instances
| HasUncertainty UncertQ Source # | Finds the uncertainty of an |
Defined in Language.Drasil.Chunk.UncertainQuantity Methods unc :: Lens' UncertQ Uncertainty Source # | |
defaultUncrt :: Uncertainty Source #
The default uncertainty is set to 0.1.
uncVal :: HasUncertainty x => x -> Double Source #
Accessor for uncertainty value from something that has an uncertainty.
uncPrec :: HasUncertainty x => x -> Maybe Int Source #
Accessor for precision value from something that has an uncertainty.
exact :: Uncertainty Source #
Smart constructor for exact values (no uncertainty).
Custom type for months (abbreviated).
Instances
| HasChunkRefs Month Source # | |||||
| Generic Month Source # | |||||
Defined in Language.Drasil.Data.Date Associated Types
| |||||
| Show Month Source # | |||||
| Eq Month Source # | |||||
| Ord Month Source # | |||||
| type Rep Month Source # | |||||
Defined in Language.Drasil.Data.Date type Rep Month = D1 ('MetaData "Month" "Language.Drasil.Data.Date" "drasil-lang-0.1.60.0-1HMwkmtaiHpDlCGzFv9lso" 'False) (((C1 ('MetaCons "Jan" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Feb" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Mar" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "Apr" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "May" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Jun" 'PrefixI 'False) (U1 :: Type -> Type)))) :+: ((C1 ('MetaCons "Jul" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Aug" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Sep" 'PrefixI 'False) (U1 :: Type -> Type))) :+: (C1 ('MetaCons "Oct" 'PrefixI 'False) (U1 :: Type -> Type) :+: (C1 ('MetaCons "Nov" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Dec" 'PrefixI 'False) (U1 :: Type -> Type))))) | |||||
A person can have a given name, middle name(s), and surname, as well as the naming convention they use.
person :: String -> String -> Person Source #
Constructor for a person using Western naming conventions. Used for a person with only a given name and surname. Arguments are in the order: given name, surname.
Members of this class must have a name.
Minimal complete definition
fullName :: HasName n => n -> String Source #
Gets the name of a Person. Adds a dot after any initials.
person' :: String -> String -> Person Source #
Constructor for a person using Eastern naming conventions. Used for a person with only a given name and surname. Arguments are in the order: surname, given name.
personWM :: String -> [String] -> String -> Person Source #
Constructor for a person using Western naming conventions.
Similar to the person constructor,
except the middle argument is a list of middle names.
personWM' :: String -> [String] -> String -> Person Source #
Constructor for a person using Eastern naming conventions.
Similar to the person' constructor,
except the middle argument is a list of middle names.
Sentences
Things like expressions and terms are displayed by using Sentences.
We also use NounPhrases to record the proper pluralization and capitalization of terms.
For writing Sentences via combining smaller elements.
Sentences are made up of some known vocabulary of things:
- units (their visual representation)
- words (via
Strings) - special characters
- accented letters
- references to specific layout objects
Constructors
| Ch :: SentenceStyle -> TermCapitalization -> UID -> Sentence | Ch looks up the term for a given |
| SyCh :: forall t. (IsChunk t, Idea t, HasSpace t, HasSymbol t) => UIDRef t -> Sentence | A branch of Ch dedicated to SymbolStyle only. |
| Sy :: USymb -> Sentence | Converts a unit symbol into a usable Sentence form. |
| NP :: NP -> Sentence | Directly embeds a |
| S :: String -> Sentence | Constructor for |
| P :: Symbol -> Sentence | Converts the graphical representation of a symbol into a usable Sentence form. |
| E :: ModelExpr -> Sentence | Lifts an expression into a Sentence. |
| Ref :: UID -> Sentence -> RefInfo -> Sentence | Takes a FIXME: Attempting to convert this |
| Quote :: Sentence -> Sentence | Adds quotation marks around a Sentence. |
| Percent :: Sentence | Used for a % symbol. |
| (:+:) :: Sentence -> Sentence -> Sentence infixr 5 | Direct concatenation of two Sentences (no implicit spaces!). |
| EmptyS :: Sentence | Empty Sentence. |
data SentenceStyle Source #
Used in Ch constructor to determine the state of a term
(can record whether something is in plural form, a singular term, or in short form).
Constructors
| PluralTerm | |
| TermStyle | |
| ShortStyle |
data TermCapitalization Source #
Holds any extra information needed for a Reference, be it an equation, pages, a note, or nothing.
Instances
| HasChunkRefs RefInfo Source # | |||||
| Generic RefInfo Source # | |||||
Defined in Language.Drasil.Sentence Associated Types
| |||||
| type Rep RefInfo Source # | |||||
Defined in Language.Drasil.Sentence type Rep RefInfo = D1 ('MetaData "RefInfo" "Language.Drasil.Sentence" "drasil-lang-0.1.60.0-1HMwkmtaiHpDlCGzFv9lso" 'False) ((C1 ('MetaCons "None" 'PrefixI 'False) (U1 :: Type -> Type) :+: C1 ('MetaCons "Equation" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [Int]))) :+: (C1 ('MetaCons "Page" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 [Int])) :+: C1 ('MetaCons "RefNote" 'PrefixI 'False) (S1 ('MetaSel ('Nothing :: Maybe Symbol) 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedStrict) (Rec0 String)))) | |||||
(+:+) :: Sentence -> Sentence -> Sentence Source #
Helper for concatenating two Sentences with a space between them.
(+:) :: Sentence -> Sentence -> Sentence Source #
Helper which concatenates two sentences using +:+ and appends a colon.
(!.) :: Sentence -> Sentence Source #
Helper which appends a period to the end of a Sentence (used often as a post-fix operator).
ch :: (IsChunk t, Idea t, HasSpace t, HasSymbol t) => t -> Sentence Source #
Gets a symbol and places it in a Sentence.
sC :: Sentence -> Sentence -> Sentence Source #
Helper for concatenating two Sentences with a comma and space between them.
sDash :: Sentence -> Sentence -> Sentence Source #
Helper for concatenating two Sentences with a space-surrounded dash between them.
fterms :: (NamedIdea c, NamedIdea d) => (NP -> NP -> t) -> c -> d -> t Source #
Apply a binary function to the terms of two named ideas, instead of to the named
ideas themselves. Ex. fterms compoundPhrase t1 t2 instead of
compoundPhrase (t1 ^. term) (t2 ^. term).
getTandS :: Quantity a => a -> Sentence Source #
Used when you want to say a term followed by its symbol. ex. "...using the Force F in...".
class NounPhrase n where Source #
Methods
phraseNP :: n -> NPStruct Source #
Retrieves singular form of term. Ex. "the quick brown fox".
pluralNP :: n -> PluralForm Source #
Retrieves plural form of term. Ex. "the quick brown foxes".
sentenceCase :: n -> (NP -> NPStruct) -> Capitalization Source #
Retrieves the singular form and applies a captalization rule (usually capitalizes the first word) to produce a 'NPStruct. Ex. "The quick brown fox".
titleCase :: n -> (NP -> NPStruct) -> Capitalization Source #
Retrieves the singular form and applies a captalization rule (usually capitalizes all words) to produce a 'NPStruct. Ex. "The Quick Brown Fox".
For nouns and NounPhrases. May be constructed from a
proper noun, common noun, or phrase (Sentence) and their
respective pluralization and capitalization rules.
Instances
| HasChunkRefs NP Source # | Gather the chunk references mentioned within an |
| NounPhrase NP Source # | Defines NP as a NounPhrase.
Default capitalization rules for proper and common nouns
are |
Constructs a Proper Noun, it is always capitalized as written.
Self plural.
Constructs a Proper Noun, it is always capitalized as written.
Plural form simply adds "s" (ex. Henderson -> Hendersons).
Constructs a Proper Noun, it is always capitalized as written.
Plural form adds "e".
pn''' :: String -> NP Source #
Constructs a Proper Noun, it is always capitalized as written.
Plural form adds "es" (ex. Bush -> Bushes).
pnIrr :: String -> PluralRule -> NP Source #
Constructs a ProperNoun with a custom plural rule (using IrregPlur from PluralRule).
First argument is the String representing the noun, second is the rule.
Constructs a common noun which capitalizes the first letter of the first word at the beginning of a sentence.
Self plural.
Constructs a common noun which capitalizes the first letter of the first word at the beginning of a sentence.
Plural form simply adds "s" (ex. dog -> dogs).
Constructs a common noun which capitalizes the first letter of the first word at the beginning of a sentence.
Plural form adds "e" (ex. formula -> formulae).
cn''' :: String -> NP Source #
Constructs a common noun which capitalizes the first letter of the first word at the beginning of a sentence.
Plural form adds "es" (ex. bush -> bushes).
cnIP :: String -> PluralRule -> NP Source #
Constructs a common noun that allows you to specify the pluralization rule
(as in pnIrr).
cnIrr :: String -> PluralRule -> CapitalizationRule -> NP Source #
Common noun that allows you to specify both the pluralization rule and the capitalization rule for sentence case (if the noun is used at the beginning of a sentence).
cnIES :: String -> NP Source #
Constructs a common noun that pluralizes by dropping the last letter and adding an "ies" ending (ex. body -> bodies).
cnICES :: String -> NP Source #
Construct a common noun that pluralizes by dropping the last two letters and adding an "ices" ending (ex. matrix -> matrices).
Constructs a common noun that pluralizes by dropping the last two letters and adding "es" (ex. analysis -> analyses).
Constructs a common noun that pluralizes by dropping the last two letters and adding "a" (ex. datum -> data).
nounPhrase :: String -> PluralString -> NP Source #
nounPhrase' :: String -> PluralString -> CapitalizationRule -> NP Source #
Similar to nounPhrase, but takes a specified capitalization rule for the sentence case.
data CapitalizationRule Source #
Capitalization rules.
atStartNP :: NounPhrase n => n -> Capitalization Source #
Helper function for getting the sentence case of a noun phrase.
Singular sentence case.
atStartNP' :: NounPhrase n => n -> Capitalization Source #
Helper function for getting the sentence case of a noun phrase.
Plural sentence case.
data PluralRule Source #
Pluralization rules.
compoundPhrase :: (NounPhrase a, NounPhrase b) => a -> b -> NP Source #
Combine two noun phrases. The singular form becomes phrase from t1 followed
by phrase of t2. The plural becomes phrase of t1 followed by plural of t2.
Uses standard CapFirst sentence case and CapWords title case.
For example: compoundPhrase system constraint will have singular form
"system constraint" and plural "system constraints".
compoundPhrase' :: NP -> NP -> NP Source #
Similar to compoundPhrase, but the sentence case is the same
as the title case (CapWords).
compoundPhrase'' :: (NP -> NPStruct) -> (NP -> NPStruct) -> NP -> NP -> NP Source #
Similar to compoundPhrase', but accepts two functions that will be used to
construct the plural form. For example,
compoundPhrase'' plural phrase system constraint would have the plural
form "systems constraint".
compoundPhrase''' :: (NP -> NPStruct) -> NP -> NP -> NP Source #
Similar to compoundPhrase, but used when you need a special function applied
to the first term of both singular and pluralcases (eg. short or plural).
compoundPhraseP1 :: NP -> NP -> NP Source #
Similar to compoundPhrase, but pluralizes the first NP for both singular and plural cases.
titleizeNP :: NounPhrase n => n -> Capitalization Source #
Helper function for getting the title case of a noun phrase.
Singular title case.
titleizeNP' :: NounPhrase n => n -> Capitalization Source #
Helper function for getting the title case of a noun phrase.
Plural title case.
nounPhrase'' :: NPStruct -> PluralForm -> CapitalizationRule -> CapitalizationRule -> NP Source #
Custom noun phrase constructor that takes a singular form ('NPStruct), plural form ('NPStruct), sentence case capitalization rule, and title case capitalization rule.
nounPhraseSP :: String -> NP Source #
For things that should not be pluralized (or are self-plural). Works like nounPhrase, but with
only the first argument.
nounPhraseSent :: NPStruct -> NP Source #
Similar to nounPhrase, except it only accepts one 'NPStruct.
Plural case is just AddS.
introduceAbb :: Idea n => n -> Sentence Source #
Introduce a noun phrase and its (parenthesized) abbreviation.
introduceAbbPlrl :: Idea n => n -> Sentence Source #
Introduce a plural noun phrase and its (parenthesized) abbreviation.
phrase :: NamedIdea n => n -> Sentence Source #
Helper for getting the phrase from a NamedIdea using it's UID.
plural :: NamedIdea n => n -> Sentence Source #
Helper for getting the plural of a phrase from a NamedIdea.
phrasePoss :: NamedIdea n => n -> Sentence Source #
Helper for getting the possesive cases from the term of a NamedIdea.
Singular possesive function
pluralPoss :: NamedIdea n => n -> Sentence Source #
Helper for getting the possesive cases from the term of a NamedIdea.
Plural possesive function
atStart :: NamedIdea n => n -> Sentence Source #
Helper function for getting the sentence case of a noun phrase from a
NamedIdea.
Singular sentence case.
atStart' :: NamedIdea n => n -> Sentence Source #
Helper function for getting the sentence case of a noun phrase from a
NamedIdea.
Plural sentence case.
titleize :: NamedIdea n => n -> Sentence Source #
Helper function for getting the title case of a noun phrase from a
NamedIdea.
Singular title case.
titleize' :: NamedIdea n => n -> Sentence Source #
Helper function for getting the title case of a noun phrase from a
NamedIdea.
Plural title case.
Sentence Fold-type utilities.
From Utils.Drasil.Fold. Defines many general fold functions for use with Drasil-related types.
Folding Options as Types
Type that helps determine enumeration method. Can use either numbers, uppercase letters, or lowercase letters.
Type to help wrap a sentence with parenthesis or to add a period at the end.
Type to help separate words with commas or semicolons.
Type to help fold differently between listed items, or if there are options (ex. using "and" or "or" at the end of a list of words).
Folding functions
Sentence-related
foldlEnumList :: EnumType -> WrapType -> SepType -> FoldType -> [Sentence] -> Sentence Source #
Creates a list of elements with "enumerators" in "wrappers" using foldlList.
foldlList :: SepType -> FoldType -> [Sentence] -> Sentence Source #
Creates a list of elements separated by a "separator", ending with "and" or "or".
foldlSent :: [Sentence] -> Sentence Source #
Partial function application of foldle for sentences specifically.
Folds with spaces and adds a period (".") at the end.
foldOpts :: [Sentence] -> Sentence Source #
Folds a list of elements separated forward slashes ("/").
foldNums :: String -> [Int] -> Sentence Source #
Parses a list of integers into a nice sentence (ie. S "1, 4-7, and 13").
numList :: String -> [Int] -> [String] Source #
Parses a list of integers into a list of strings (ie. ["1", "4-7", "13"]).
Symbols, Stages, Spaces
Used for rendering mathematical symbols in Drasil.
The difference kinds of spaces that may exist. This type holds numerical spaces (such as the set of integers, rationals, etc.), a space for booleans, a space for characters, dimensional spaces (vectors, arrays, etc.), a space for Actors, discrete sets (both for numbers and strings), and a void space.
Constructors
| Integer | |
| Rational | |
| Real | |
| Natural | |
| Boolean | |
| Char | |
| String | |
| Vect Space | |
| Set Space | |
| Matrix Int Int Space | |
| Array Space | |
| Actor String | |
| Function (NonEmpty Primitive) Primitive | |
| Reference Space | |
| Void |
data RealInterval a b where Source #
A RealInterval is a subset of Real (as a Space).
These come in different flavours.
For now, we embed Expr for the bounds, but that will change as well.
Constructors
| Bounded | |
Fields
| |
| UpTo | |
Fields
| |
| UpFrom | |
Fields
| |
data DomainDesc (tplgy :: RTopology) a b where Source #
Describes the domain of a Symbol given a topology. Can be bounded or encase all of the domain.
Constructors
| BoundedDD :: forall a b. Symbol -> RTopology -> a -> b -> DomainDesc 'Discrete a b | |
| AllDD :: forall a b. Symbol -> RTopology -> DomainDesc 'Continuous a b |
type ContinuousDomainDesc a b = DomainDesc 'Continuous a b Source #
type DiscreteDomainDesc a b = DomainDesc 'Discrete a b Source #
data Decoration Source #
Decorations on symbols/characters such as hats or Vector representations (determines bolding, italics, etc).
Instances
| Eq Decoration Source # | |
Defined in Language.Drasil.Symbol | |
| Ord Decoration Source # | |
Defined in Language.Drasil.Symbol Methods compare :: Decoration -> Decoration -> Ordering # (<) :: Decoration -> Decoration -> Bool # (<=) :: Decoration -> Decoration -> Bool # (>) :: Decoration -> Decoration -> Bool # (>=) :: Decoration -> Decoration -> Bool # max :: Decoration -> Decoration -> Decoration # min :: Decoration -> Decoration -> Decoration # | |
A Symbol is actually going to be a graphical description of what gets
rendered as a (unique) symbol. This is actually NOT based on semantics at
all, but just a description of how things look.
Symbols can be:
VariableLabelSpecialDecoratedsymbols usingAtopConcatenationsof symbols, including subscripts and superscriptsEmpty
Stages are what part of the development process we are in. There are currently two: 1) The Equational stage (should be called Specification) 2) The Implemenation stage
The point is that information may be rendered differently depending at what stage we're at. Being able to talk about stages lets us also attach different display information.
Constructors
| Equational | |
| Implementation |
eqSymb :: HasSymbol q => q -> Symbol Source #
Helper function for getting a symbol in the Equational Stage.
codeSymb :: HasSymbol q => q -> Symbol Source #
Helper function for getting a symbol in the Implementation Stage.
hasStageSymbol :: HasSymbol q => q -> Stage -> Bool Source #
Finds if a Stage symbol is real or Empty. True if real.
sortBySymbol :: HasSymbol a => [a] -> [a] Source #
Sorts a list of HasSymbols by Symbol.
sortBySymbolTuple :: HasSymbol a => [(a, b)] -> [(a, b)] Source #
Sorts a tuple list of HasSymbols by first Symbol in the tuple.
staged :: Symbol -> Symbol -> Stage -> Symbol Source #
Helper for creating a symbol that depends on the stage.
sub :: Symbol -> Symbol -> Symbol Source #
Helper for creating a symbol with a subscript to the right. Arguments: Base symbol, then subscripted symbol.
subStr :: Symbol -> String -> Symbol Source #
Helper for a common case of subscript, with a string
Arguments: Base symbol, then subscript String.
sup :: Symbol -> Symbol -> Symbol Source #
Helper for creating a symbol with a superscript to the right. Arguments: Base symbol, then superscripted symbol.
unicodeConv :: Symbol -> Symbol Source #
upperLeft :: Symbol -> Symbol -> Symbol Source #
Helper for creating a symbol with a superscript on the left side of the symbol. Arguments: Base symbol, then superscripted symbol.
Type Synonyms
type ConstQDef = QDefinition Literal Source #
Commonly used type for QDefinitions containing Literals.
type SimpleQDef = QDefinition Expr Source #
Commonly used type for QDefinitions containing Exprs.
type ModelQDef = QDefinition ModelExpr Source #
Commonly used type for QDefinitions containing ModelExprs.
Type systems
type TypingContext t = Map UID t Source #
inferFromContext :: TypingContext t -> UID -> Either TypeError t Source #
Look for a known type of a specific UID.
class (Eq t, Show t) => Typed e t where Source #
Build a bidirectional type checker for your expression language, e, with respect to a specific type universe, t.
Methods
infer :: TypingContext t -> e -> Either TypeError t Source #
Given a typing context and an expression, infer a unique type or explain what went awry.
check :: TypingContext t -> e -> t -> Either TypeError t Source #
Given a typing context, an expression, and an expected type, check if the expression can satisfy the expectation.
class Typed e t => RequiresChecking c e t where Source #
For all containers, c, which contain typed expressions, e, against a specific type universe, t, expose all expressions and relations that need to be type-checked.
Instances
| RequiresChecking (QDefinition Expr) Expr Space Source # | |
Defined in Language.Drasil.Chunk.Eq Methods requiredChecks :: QDefinition Expr -> [(Expr, Space)] Source # | |