-- | Defines concepts used to create documentation.
module Data.Drasil.Concepts.Documentation where

import Language.Drasil hiding (organization, year, label, variable)
import Language.Drasil.Chunk.Concept.NamedCombinators

import Data.Drasil.Concepts.Math (graph, unit_)
import Data.Drasil.Domains (documentc, softEng)
import Data.Drasil.TheoryConcepts (dataDefn, genDefn, inModel, thModel)

import Control.Lens ((^.))

-- | Collects all documentation-related named chunks (not concept-level yet).
doccon :: [NamedChunk]
doccon :: [NamedChunk]
doccon = [NamedChunk
abbAcc, NamedChunk
abbreviation, NamedChunk
acronym, NamedChunk
analysis, NamedChunk
appendix, NamedChunk
aspect, NamedChunk
body, NamedChunk
charOfIR, NamedChunk
characteristic,
  NamedChunk
class_, NamedChunk
client, NamedChunk
code, NamedChunk
column, NamedChunk
company, NamedChunk
component, NamedChunk
concept, NamedChunk
condition, NamedChunk
connection,
  NamedChunk
consVals, NamedChunk
constant, NamedChunk
constraint, NamedChunk
consumer, NamedChunk
content, NamedChunk
context, NamedChunk
coordinate, NamedChunk
coordinateSystem, 
  NamedChunk
corSol, NamedChunk
customer, NamedChunk
datum, NamedChunk
datumConstraint, NamedChunk
decision, NamedChunk
definition, NamedChunk
dependency, NamedChunk
description,
  NamedChunk
design, NamedChunk
designDoc, NamedChunk
document, NamedChunk
documentation, NamedChunk
effect, NamedChunk
element, NamedChunk
emphasis, NamedChunk
endUser,
  NamedChunk
environment, NamedChunk
example, NamedChunk
failure, NamedChunk
figure, NamedChunk
first, NamedChunk
form, NamedChunk
full, NamedChunk
fullForm, NamedChunk
functional,
  NamedChunk
functionalRequirement, NamedChunk
game, NamedChunk
general, NamedChunk
generalSystemDescription, NamedChunk
goal, NamedChunk
guide, 
  NamedChunk
implementation, NamedChunk
indPRCase, NamedChunk
individual, NamedChunk
information, NamedChunk
input_, NamedChunk
instance_, NamedChunk
intReader,
  NamedChunk
interest, NamedChunk
interface, NamedChunk
introduction, NamedChunk
issue, NamedChunk
item, NamedChunk
label, NamedChunk
library, NamedChunk
limitation,
  NamedChunk
literacy, NamedChunk
loss, NamedChunk
material_, NamedChunk
mainIdea, NamedChunk
message, NamedChunk
method_, NamedChunk
methAndAnls, NamedChunk
model, NamedChunk
module_, NamedChunk
name_, 
  NamedChunk
nonfunctional, NamedChunk
nonfunctionalRequirement, NamedChunk
object, NamedChunk
offShelf, NamedChunk
offShelfSolution, NamedChunk
open, NamedChunk
orgOfDoc,
  NamedChunk
organization, NamedChunk
output_, NamedChunk
physical, NamedChunk
physicalConstraint, NamedChunk
physicalProperty, NamedChunk
physicalSim,
  NamedChunk
physicalSystem, NamedChunk
physics, NamedChunk
plan, NamedChunk
practice, NamedChunk
priority, NamedChunk
problem, NamedChunk
problemDescription, NamedChunk
procedure,
  NamedChunk
prodUCTable, NamedChunk
productUC, NamedChunk
product_, NamedChunk
project, NamedChunk
procForAnls, NamedChunk
propOfCorSol, NamedChunk
property, NamedChunk
prpsOfDoc,
  NamedChunk
purpose, NamedChunk
quantity, NamedChunk
realtime, NamedChunk
review, NamedChunk
reference, NamedChunk
refMat, NamedChunk
reqInput, NamedChunk
requirement_, NamedChunk
response, NamedChunk
result,
  NamedChunk
reviewer, NamedChunk
safety, NamedChunk
safetyReq, NamedChunk
scenario, NamedChunk
scope, NamedChunk
scpOfReq, NamedChunk
scpOfTheProjS, NamedChunk
second_,
  NamedChunk
section_, NamedChunk
simulation, NamedChunk
software, NamedChunk
softwareConstraint, NamedChunk
softwareDoc, NamedChunk
softwareReq,
  NamedChunk
softwareSys, NamedChunk
softwareVAV, NamedChunk
softwareVerif, NamedChunk
solution, NamedChunk
solutionCharSpec,
  NamedChunk
solutionCharacteristic, NamedChunk
summary, NamedChunk
source, NamedChunk
specific, NamedChunk
specification, NamedChunk
specificsystemdescription,
  NamedChunk
stakeholder, NamedChunk
standard, NamedChunk
statement, NamedChunk
symbol_, NamedChunk
sysCont, NamedChunk
system, NamedChunk
systemConstraint,
  NamedChunk
systemdescription, NamedChunk
tAuxConsts, NamedChunk
tOfCont, NamedChunk
tOfSymb, NamedChunk
tOfUnit, NamedChunk
inDatumConstraint, NamedChunk
outDatumConstraint,
  NamedChunk
table_, NamedChunk
task, NamedChunk
template, NamedChunk
termAndDef, NamedChunk
term_,
  NamedChunk
terminology, NamedChunk
theory, NamedChunk
traceyGraph, NamedChunk
traceyMandG, NamedChunk
traceyMatrix, NamedChunk
type_, NamedChunk
uncertCol,
  NamedChunk
uncertainty, NamedChunk
useCase, NamedChunk
useCaseTable, NamedChunk
user, NamedChunk
userCharacteristic, NamedChunk
userInput,
  NamedChunk
validation, NamedChunk
value, NamedChunk
variable, NamedChunk
vav, NamedChunk
vavPlan, NamedChunk
verification, NamedChunk
video, NamedChunk
year]

-- | Collects all documentation-related common ideas (like a concept, but with no definition).
doccon' :: [CI]
doccon' :: [CI]
doccon' = [CI
assumption, CI
dataConst, CI
dataDefn, CI
desSpec, CI
genDefn, CI
goalStmt, CI
inModel,
  CI
likelyChg, CI
mg, CI
mis, CI
notApp, CI
physSyst, CI
requirement, CI
srs, CI
thModel, CI
typUnc, CI
unlikelyChg, CI
notebook]

assumption, desSpec, goalStmt, dataConst, likelyChg, unlikelyChg, physSyst, requirement,
  mg, mis, notApp, srs, typUnc, sec, notebook :: CI

softReqSpec :: NP
softReqSpec :: NP
softReqSpec = (NP -> NP -> NP) -> NamedChunk -> NamedChunk -> NP
forall c d t.
(NamedIdea c, NamedIdea d) =>
(NP -> NP -> t) -> c -> d -> t
fterms NP -> NP -> NP
compoundPhraseP1 NamedChunk
softwareReq NamedChunk
specification

-- * Common Ideas

------------------------------------------------------------------------------------------------------------------------------
-- | CI       |                  |    uid      |         term                                   | abbreviation | ConceptDomain
------------------------------------------------------------------------------------------------------------------------------
assumption :: CI
assumption  = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "assumption"  (String -> NP
cn' "assumption")                                    "A"       [IdeaDict
softEng]
desSpec :: CI
desSpec     = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "desSpec"     (NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
combineNINI NamedChunk
design NamedChunk
specification)                    "DS"      [IdeaDict
softEng]
goalStmt :: CI
goalStmt    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "goalStmt"    (NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
combineNINI NamedChunk
goal NamedChunk
statement)                          "GS"      [IdeaDict
softEng]
dataConst :: CI
dataConst   = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "dataConst"   (String -> NP
cn' "data constraint")                               "DC"      [IdeaDict
softEng]
likelyChg :: CI
likelyChg   = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "likelyChg"   (String -> NP
cn' "likely change")                                 "LC"      [IdeaDict
softEng]
unlikelyChg :: CI
unlikelyChg = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "unlikelyChg" (String -> NP
cn' "unlikely change")                               "UC"      [IdeaDict
softEng]
physSyst :: CI
physSyst    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "physSyst"    (NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
combineNINI NamedChunk
physicalSystem NamedChunk
description)              "PS"      [IdeaDict
softEng]
requirement :: CI
requirement = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "requirement" (String -> NP
cn' "requirement")                                   "R"       [IdeaDict
softEng]
mis :: CI
mis         = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "mis"         ((NP -> NP -> NP) -> NamedChunk -> NamedChunk -> NP
forall c d t.
(NamedIdea c, NamedIdea d) =>
(NP -> NP -> t) -> c -> d -> t
fterms NP -> NP -> NP
forall a b. (NounPhrase a, NounPhrase b) => a -> b -> NP
compoundPhrase NamedChunk
moduleInterface NamedChunk
specification) "MIS"     [IdeaDict
softEng]
mg :: CI
mg          = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "mg"          ((NP -> NP -> NP) -> NamedChunk -> NamedChunk -> NP
forall c d t.
(NamedIdea c, NamedIdea d) =>
(NP -> NP -> t) -> c -> d -> t
fterms NP -> NP -> NP
forall a b. (NounPhrase a, NounPhrase b) => a -> b -> NP
compoundPhrase NamedChunk
module_ NamedChunk
guide)                 "MG"      [IdeaDict
softEng]
notApp :: CI
notApp      = String -> NP -> String -> [UID] -> CI
commonIdea         "notApp"      (String -> NP
nounPhraseSP "not applicable")                       "N/A"     []
typUnc :: CI
typUnc      = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "typUnc"      (String -> NP
cn' "typical uncertainty")                           "Uncert." [IdeaDict
softEng]
sec :: CI
sec         = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "section"     (String -> NP
cn' "section")                                       "Sec"     [IdeaDict
documentc]
srs :: CI
srs         = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "srs"         NP
softReqSpec                                           "SRS"     [IdeaDict
softEng]
notebook :: CI
notebook    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict "notebook"    (String -> NP
cn' "notebook")                                      "NB"      [IdeaDict
softEng]

---------------------------------------------------------------------

-- concepts relating to the templates and their contents
-- * Named Chunks
-- ** Basic Chunks

abbreviation, acronym, analysis, appendix, aspect, body, characteristic, class_, client, 
  code, column, company, component, concept, condition, connection, constant,
  constraint, consumer, content, context, coordinate, customer, datum, decision, 
  definition, dependency, description, design, document, documentation, effect, 
  element, emphasis, endUser, environment, example, failure, figure, first, form, full, 
  functional, game, general, goal, guide, implementation, individual, information, 
  interest, interface, input_, instance_, intReader, introduction, issue, item, 
  loss, label, library, limitation, literacy, material_, mainIdea, message, method_, module_,
  model, name_, nonfunctional, object, offShelf, open, organization, output_,
  physics, physical, plan, practice, priority, problem, procedure, product_, project,
  property, purpose, quantity, realtime, review, reference, requirement_, response, 
  result, reviewer, safety, scope, scpOfTheProjS, second_, section_, scenario,
  source, simulation, software, solution, summary, specific, specification, stakeholder,
  standard, statement, symbol_, system, table_, task, template, term_, terminology,
  theory, traceyGraph, traceyMatrix, type_, uncertainty, user, useCase, validation,
  value, variable, video, verification, year :: NamedChunk

abbreviation :: NamedChunk
abbreviation    = String -> NP -> NamedChunk
nc "abbreviation"   (String -> NP
cn'    "abbreviation"       )
acronym :: NamedChunk
acronym         = String -> NP -> NamedChunk
nc "acronym"        (String -> NP
cn'    "acronym"            )
analysis :: NamedChunk
analysis        = String -> NP -> NamedChunk
nc "analysis"       (String -> NP
cnIS   "analysis"           )
appendix :: NamedChunk
appendix        = String -> NP -> NamedChunk
nc "appendix"       (String -> NP
cnICES "appendix"           )
aspect :: NamedChunk
aspect          = String -> NP -> NamedChunk
nc "aspect"         (String -> NP
cn'    "aspect"             )
body :: NamedChunk
body            = String -> NP -> NamedChunk
nc "body"           (String -> NP
cnIES  "body"               )
characteristic :: NamedChunk
characteristic  = String -> NP -> NamedChunk
nc "characteristic" (String -> NP
cn'    "characteristic"     )
class_ :: NamedChunk
class_          = String -> NP -> NamedChunk
nc "class"          (String -> NP
cn'''  "class"              )
client :: NamedChunk
client          = String -> NP -> NamedChunk
nc "client"         (String -> NP
cn'    "client"             )
code :: NamedChunk
code            = String -> NP -> NamedChunk
nc "code"           (String -> NP
cn     "code"               )
column :: NamedChunk
column          = String -> NP -> NamedChunk
nc "column"         (String -> NP
cn'    "column"             ) --general enough to be in Documentation?
company :: NamedChunk
company         = String -> NP -> NamedChunk
nc "company"        (String -> NP
cnIES  "company"            )
component :: NamedChunk
component       = String -> NP -> NamedChunk
nc "component"      (String -> NP
cn'    "component"          )
concept :: NamedChunk
concept         = String -> NP -> NamedChunk
nc "concept"        (String -> NP
cn'    "concept"            )
condition :: NamedChunk
condition       = String -> NP -> NamedChunk
nc "condition"      (String -> NP
cn'    "condition"          )
connection :: NamedChunk
connection      = String -> NP -> NamedChunk
nc "connection"     (String -> NP
cn'    "connection"         )
constant :: NamedChunk
constant        = String -> NP -> NamedChunk
nc "constant"       (String -> NP
cn'    "constant"           )
constraint :: NamedChunk
constraint      = String -> NP -> NamedChunk
nc "constraint"     (String -> NP
cn'    "constraint"         )
consumer :: NamedChunk
consumer        = String -> NP -> NamedChunk
nc "consumer"       (String -> NP
cn'    "consumer"           )
content :: NamedChunk
content         = String -> NP -> NamedChunk
nc "content"        (String -> NP
cn'    "content"            )
context :: NamedChunk
context         = String -> NP -> NamedChunk
nc "context"        (String -> NP
cn'    "context"            )
coordinate :: NamedChunk
coordinate      = String -> NP -> NamedChunk
nc "coordinate"     (String -> NP
cn'    "coordinate"         )
customer :: NamedChunk
customer        = String -> NP -> NamedChunk
nc "customer"       (String -> NP
cn'    "customer"           )
datum :: NamedChunk
datum           = String -> NP -> NamedChunk
nc "datum"          (String -> NP
cnUM   "datum"              )
decision :: NamedChunk
decision        = String -> NP -> NamedChunk
nc "decision"       (String -> NP
cn'    "decision"           )
definition :: NamedChunk
definition      = String -> NP -> NamedChunk
nc "definition"     (String -> NP
cn'    "definition"         )
dependency :: NamedChunk
dependency      = String -> NP -> NamedChunk
nc "dependency"     (String -> NP
cnIES  "dependency"         )
description :: NamedChunk
description     = String -> NP -> NamedChunk
nc "description"    (String -> NP
cn'    "description"        )
design :: NamedChunk
design          = String -> NP -> NamedChunk
nc "design"         (String -> NP
cn'    "design"             )
document :: NamedChunk
document        = String -> NP -> NamedChunk
nc "document"       (String -> NP
cn'    "document"           )
documentation :: NamedChunk
documentation   = String -> NP -> NamedChunk
nc "documentation"  (String -> NP
cn'    "documentation"      )
effect :: NamedChunk
effect          = String -> NP -> NamedChunk
nc "effect"         (String -> NP
cn'    "effect"             )
element :: NamedChunk
element         = String -> NP -> NamedChunk
nc "element"        (String -> NP
cn'    "element"            )
emphasis :: NamedChunk
emphasis        = String -> NP -> NamedChunk
nc "emphasis"       (String -> NP
cnIS   "emphasis"           )
endUser :: NamedChunk
endUser         = String -> NP -> NamedChunk
nc "end user"       (String -> NP
cn'    "end user"           )
environment :: NamedChunk
environment     = String -> NP -> NamedChunk
nc "environment"    (String -> NP
cn'    "environment"        ) -- Is this term in the right spot?
example :: NamedChunk
example         = String -> NP -> NamedChunk
nc "example"        (String -> NP
cn'    "example"            )
failure :: NamedChunk
failure         = String -> NP -> NamedChunk
nc "failure"        (String -> NP
cn'    "failure"            )
figure :: NamedChunk
figure          = String -> NP -> NamedChunk
nc "figure"         (String -> NP
cn'    "figure"             )
first :: NamedChunk
first           = String -> NP -> NamedChunk
nc "first"          (String -> NP
cn'    "first"              ) --Does it make sense for this to be here?
form :: NamedChunk
form            = String -> NP -> NamedChunk
nc "form"           (String -> NP
cn'    "form"               ) 
full :: NamedChunk
full            = String -> NP -> NamedChunk
nc "full"           (String -> NP
cn'    "full"               ) --FIXME: Adjective
functional :: NamedChunk
functional      = String -> NP -> NamedChunk
nc "functional"     (String -> NP
cn'    "functional"         ) --FIXME: Adjective
game :: NamedChunk
game            = String -> NP -> NamedChunk
nc "game"           (String -> NP
cn'    "game"               )
general :: NamedChunk
general         = String -> NP -> NamedChunk
nc "general"        (String -> NP
cn'    "general"            ) --FIXME: Adjective
goal :: NamedChunk
goal            = String -> NP -> NamedChunk
nc "goal"           (String -> NP
cn'    "goal"               )
guide :: NamedChunk
guide           = String -> NP -> NamedChunk
nc "guide"          (String -> NP
cn'    "guide"              )
implementation :: NamedChunk
implementation  = String -> NP -> NamedChunk
nc "implementation" (String -> NP
cn'    "implementation"     )
individual :: NamedChunk
individual      = String -> NP -> NamedChunk
nc "individual"     (String -> NP
cn'    "individual"         )
information :: NamedChunk
information     = String -> NP -> NamedChunk
nc "information"    (String -> NP
cn     "information"        )
interest :: NamedChunk
interest        = String -> NP -> NamedChunk
nc "interest"       (String -> NP
cn'    "interest"           )
interface :: NamedChunk
interface       = String -> NP -> NamedChunk
nc "interface"      (String -> NP
cn'    "interface"          )
input_ :: NamedChunk
input_          = String -> NP -> NamedChunk
nc "input"          (String -> NP
cn'    "input"              )
instance_ :: NamedChunk
instance_       = String -> NP -> NamedChunk
nc "instance"       (String -> NP
cn'    "instance"           )
intReader :: NamedChunk
intReader       = String -> NP -> NamedChunk
nc "intReader"      (String -> NP
cn'    "intended reader"    )
introduction :: NamedChunk
introduction    = String -> NP -> NamedChunk
nc "introduction"   (String -> NP
cn'    "introduction"       )
issue :: NamedChunk
issue           = String -> NP -> NamedChunk
nc "issue"          (String -> NP
cn'    "issue"              )
item :: NamedChunk
item            = String -> NP -> NamedChunk
nc "item"           (String -> NP
cn'    "item"               )
label :: NamedChunk
label           = String -> NP -> NamedChunk
nc "label"          (String -> NP
cn'    "label"              )
library :: NamedChunk
library         = String -> NP -> NamedChunk
nc "library"        (String -> NP
cnIES  "library"            )
limitation :: NamedChunk
limitation      = String -> NP -> NamedChunk
nc "limitation"     (String -> NP
cn'    "limitation"         )
literacy :: NamedChunk
literacy        = String -> NP -> NamedChunk
nc "literacy"       (String -> NP
cnIES  "literacy"           )
loss :: NamedChunk
loss            = String -> NP -> NamedChunk
nc "loss"           (String -> NP
cn'''  "loss"               )
material_ :: NamedChunk
material_       = String -> NP -> NamedChunk
nc "material"       (String -> NP
cn'    "material"           )
mainIdea :: NamedChunk
mainIdea        = String -> NP -> NamedChunk
nc "mainIdea"       (String -> NP
cn'    "main idea"          )
message :: NamedChunk
message         = String -> NP -> NamedChunk
nc "message"        (String -> NP
cn'    "message"            )
method_ :: NamedChunk
method_         = String -> NP -> NamedChunk
nc "method"         (String -> NP
cn'    "method"             )
module_ :: NamedChunk
module_         = String -> NP -> NamedChunk
nc "module"         (String -> NP
cn'    "module"             )
model :: NamedChunk
model           = String -> NP -> NamedChunk
nc "model"          (String -> NP
cn'    "model"              )
name_ :: NamedChunk
name_           = String -> NP -> NamedChunk
nc "name"           (String -> NP
cn'    "name"               )
nonfunctional :: NamedChunk
nonfunctional   = String -> NP -> NamedChunk
nc "non-functional" (String -> NP
cn'    "non-functional"     ) --FIXME: Adjective
object :: NamedChunk
object          = String -> NP -> NamedChunk
nc "object"         (String -> NP
cn'    "object"             )
offShelf :: NamedChunk
offShelf        = String -> NP -> NamedChunk
nc "Off-the-Shelf"  (String -> NP
cn'    "Off-the-Shelf"      )
open :: NamedChunk
open            = String -> NP -> NamedChunk
nc "open"           (String -> NP
cn'    "open"               )
organization :: NamedChunk
organization    = String -> NP -> NamedChunk
nc "organization"   (String -> NP
cn'    "organization"       )
output_ :: NamedChunk
output_         = String -> NP -> NamedChunk
nc "output"         (String -> NP
cn'    "output"             )
physics :: NamedChunk
physics         = String -> NP -> NamedChunk
nc "physics"        (String -> NP
cn'    "physics"            )
physical :: NamedChunk
physical        = String -> NP -> NamedChunk
nc "physical"       (String -> NP
cn'    "physical"           ) --FIXME: Adjective
plan :: NamedChunk
plan            = String -> NP -> NamedChunk
nc "plan"           (String -> NP
cn'    "plan"               )
practice :: NamedChunk
practice        = String -> NP -> NamedChunk
nc "practice"       (String -> NP
cn'    "practice"           )
priority :: NamedChunk
priority        = String -> NP -> NamedChunk
nc "priority"       (String -> NP
cnIES  "priority"           )
problem :: NamedChunk
problem         = String -> NP -> NamedChunk
nc "problem"        (String -> NP
cn'    "problem"            )
procedure :: NamedChunk
procedure       = String -> NP -> NamedChunk
nc "procedure"      (String -> NP
cn'    "procedure"          )
product_ :: NamedChunk
product_        = String -> NP -> NamedChunk
nc "product"        (String -> NP
cn'    "product"            )
project :: NamedChunk
project         = String -> NP -> NamedChunk
nc "project"        (String -> NP
cn'    "project"            )
property :: NamedChunk
property        = String -> NP -> NamedChunk
nc "property"       (String -> NP
cnIES  "property"           )
purpose :: NamedChunk
purpose         = String -> NP -> NamedChunk
nc "purpose"        (String -> NP
cn'    "purpose"            )
quantity :: NamedChunk
quantity        = String -> NP -> NamedChunk
nc "quantity"       (String -> NP
cnIES  "quantity"           ) --general enough to be in documentaion.hs?
realtime :: NamedChunk
realtime        = String -> NP -> NamedChunk
nc "real-time"      (String -> NP
cn'    "real-time"          )
review :: NamedChunk
review          = String -> NP -> NamedChunk
nc "review"         (String -> NP
cn'    "review"             )
reference :: NamedChunk
reference       = String -> NP -> NamedChunk
nc "reference"      (String -> NP
cn'    "reference"          )
requirement_ :: NamedChunk
requirement_    = String -> NP -> NamedChunk
nc "requirement"    (String -> NP
cn'    "requirement"        ) --FIXME: Eventually only have one requirement
response :: NamedChunk
response        = String -> NP -> NamedChunk
nc "response"       (String -> NP
cn'    "response"           )
result :: NamedChunk
result          = String -> NP -> NamedChunk
nc "result"         (String -> NP
cn'    "result"             )
reviewer :: NamedChunk
reviewer        = String -> NP -> NamedChunk
nc "reviewer"       (String -> NP
cn'    "reviewer"           )
safety :: NamedChunk
safety          = String -> NP -> NamedChunk
nc "safety"         (String -> NP
cnIES  "safety"             )
scope :: NamedChunk
scope           = String -> NP -> NamedChunk
nc "scope"          (String -> NP
cn'    "scope"              )
second_ :: NamedChunk
second_         = String -> NP -> NamedChunk
nc "second"         (String -> NP
cn'    "second"             ) --Does it make sense for this to be here?
section_ :: NamedChunk
section_        = String -> NP -> NamedChunk
nc "section"        (String -> NP
cn'    "section"            )
scenario :: NamedChunk
scenario        = String -> NP -> NamedChunk
nc "scenario"       (String -> NP
cn'    "scenario"           )
source :: NamedChunk
source          = String -> NP -> NamedChunk
nc "source"         (String -> NP
cn'    "source"             )
simulation :: NamedChunk
simulation      = String -> NP -> NamedChunk
nc "simulation"     (String -> NP
cn'    "simulation"         )
solution :: NamedChunk
solution        = String -> NP -> NamedChunk
nc "solution"       (String -> NP
cn'    "solution"           )
software :: NamedChunk
software        = String -> NP -> NamedChunk
nc "software"       (String -> NP
cn     "software"           )
summary :: NamedChunk
summary         = String -> NP -> NamedChunk
nc "summary"        (String -> NP
cnIES  "summary"            )
specific :: NamedChunk
specific        = String -> NP -> NamedChunk
nc "specific"       (String -> NP
cn'    "specific"           ) --FIXME: Adjective
specification :: NamedChunk
specification   = String -> NP -> NamedChunk
nc "specification"  (String -> NP
cn'    "specification"      )
stakeholder :: NamedChunk
stakeholder     = String -> NP -> NamedChunk
nc "stakeholder"    (String -> NP
cn'    "stakeholder"        )
standard :: NamedChunk
standard        = String -> NP -> NamedChunk
nc "standard"       (String -> NP
cn'    "standard"           )
statement :: NamedChunk
statement       = String -> NP -> NamedChunk
nc "statement"      (String -> NP
cn'    "statement"          )
symbol_ :: NamedChunk
symbol_         = String -> NP -> NamedChunk
nc "symbol"         (String -> NP
cn'    "symbol"             )
system :: NamedChunk
system          = String -> NP -> NamedChunk
nc "system"         (String -> NP
cn'    "system"             )
table_ :: NamedChunk
table_          = String -> NP -> NamedChunk
nc "table"          (String -> NP
cn'    "table"              )
task :: NamedChunk
task            = String -> NP -> NamedChunk
nc "task"           (String -> NP
cn'    "task"               )
template :: NamedChunk
template        = String -> NP -> NamedChunk
nc "template"       (String -> NP
cn'    "template"           )
term_ :: NamedChunk
term_           = String -> NP -> NamedChunk
nc "term"           (String -> NP
cn'    "term"               )
terminology :: NamedChunk
terminology     = String -> NP -> NamedChunk
nc "terminology"    (String -> NP
cnIES  "terminology"        )
theory :: NamedChunk
theory          = String -> NP -> NamedChunk
nc "theory"         (String -> NP
cnIES  "theory"             )
traceyGraph :: NamedChunk
traceyGraph     = String -> NP -> NamedChunk
nc "traceyGraph"    (String -> NP
cn'    "traceability graph" )
traceyMatrix :: NamedChunk
traceyMatrix    = String -> NP -> NamedChunk
nc "traceyMatrix"   (String -> NP
cnICES "traceability matrix")
type_ :: NamedChunk
type_           = String -> NP -> NamedChunk
nc "type"           (String -> NP
cn'    "type"               )
uncertainty :: NamedChunk
uncertainty     = String -> NP -> NamedChunk
nc "uncertainty"    (String -> NP
cnIES  "uncertainty"        )
user :: NamedChunk
user            = String -> NP -> NamedChunk
nc "user"           (String -> NP
cn'    "user"               )
useCase :: NamedChunk
useCase         = String -> NP -> NamedChunk
nc "useCase"        (String -> NP
cn'    "use case"           )
validation :: NamedChunk
validation      = String -> NP -> NamedChunk
nc "validation"     (String -> NP
cn'    "validation"         )
value :: NamedChunk
value           = String -> NP -> NamedChunk
nc "value"          (String -> NP
cn'    "value"              )
variable :: NamedChunk
variable        = String -> NP -> NamedChunk
nc "variable"       (String -> NP
cn'    "variable"           )
verification :: NamedChunk
verification    = String -> NP -> NamedChunk
nc "verification"   (String -> NP
cn'    "verification"       )
video :: NamedChunk
video           = String -> NP -> NamedChunk
nc "video"          (String -> NP
cn'    "video"              )
year :: NamedChunk
year            = String -> NP -> NamedChunk
nc "year"           (String -> NP
cn'    "year"               )
scpOfTheProjS :: NamedChunk
scpOfTheProjS   = String -> NP -> NamedChunk
nc "scpOfTheProj"   (String -> NP
cn'    "scope of the project") -- temporary generated for test


abbAcc, charOfIR, consVals, corSol, methAndAnls, orgOfDoc, procForAnls, propOfCorSol, prpsOfDoc, 
  refMat, reqInput, scpOfReq, tAuxConsts, tOfSymb, tOfUnit,
  termAndDef, traceyMandG, vav, tOfCont :: NamedChunk

abbAcc :: NamedChunk
abbAcc              = String -> NP -> NamedChunk
nc "TAbbAcc"            (NamedChunk
abbreviation NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_PP` NamedChunk
acronym)
consVals :: NamedChunk
consVals            = String -> NP -> NamedChunk
nc "consVals"           (String -> NP
cn "values of auxiliary constants")
corSol :: NamedChunk
corSol              = String -> NP -> NamedChunk
nc "corSol"             (String -> NP
cn' "correct solution")
charOfIR :: NamedChunk
charOfIR            = String -> NP -> NamedChunk
nc "charOfIR"           (NamedChunk
characteristic NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_PS` NamedChunk
intReader)
methAndAnls :: NamedChunk
methAndAnls         = String -> NP -> NamedChunk
nc "methAndAnls"        (NamedChunk
method_ NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_` NamedChunk
analysis)
orgOfDoc :: NamedChunk
orgOfDoc            = String -> NP -> NamedChunk
nc "orgOfDoc"           (NamedChunk
organization NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` NamedChunk
document)
procForAnls :: NamedChunk
procForAnls         = String -> NP -> NamedChunk
nc "procForAnls"        (NamedChunk
procedure NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`for` NamedChunk
analysis)
propOfCorSol :: NamedChunk
propOfCorSol        = String -> NP -> NamedChunk
nc "propOfCorSol"       (NamedChunk
property NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`ofAPS` NamedChunk
corSol)
prpsOfDoc :: NamedChunk
prpsOfDoc           = String -> NP -> NamedChunk
nc "prpsOfDoc"          (NamedChunk
purpose NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` NamedChunk
document)
refMat :: NamedChunk
refMat              = String -> NP -> NamedChunk
nc "refMat"             (String -> NP
cn' "reference material")
reqInput :: NamedChunk
reqInput            = String -> NP -> NamedChunk
nc "ReqInputs"          (String -> NP
cn' "required input")
scpOfReq :: NamedChunk
scpOfReq            = String -> NP -> NamedChunk
nc "scpOfReq"           (NamedChunk
scope NamedChunk -> CI -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` CI
requirement)
tAuxConsts :: NamedChunk
tAuxConsts          = String -> NP -> NamedChunk
nc "TAuxConsts"         (String -> NP
cn' "auxiliary constant")
termAndDef :: NamedChunk
termAndDef          = String -> NP -> NamedChunk
nc "termAndDef"         (NamedChunk
terminology NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_` NamedChunk
definition)
tOfCont :: NamedChunk
tOfCont             = String -> NP -> NamedChunk
nc "tOfCont"            (NamedChunk
table_ NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` NamedChunk
content)
tOfSymb :: NamedChunk
tOfSymb             = String -> NP -> NamedChunk
nc "tOfSymb"            (NamedChunk
table_ NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` NamedChunk
symbol_)
tOfUnit :: NamedChunk
tOfUnit             = String -> NP -> NamedChunk
nc "tOfUnit"            (NamedChunk
table_ NamedChunk -> ConceptChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` ConceptChunk
unit_)
inDatumConstraint :: NamedChunk
inDatumConstraint   = String -> NP -> NamedChunk
nc "InDataConstraints"  (String -> NP
cn' "input data constraint") -- should be moved below
outDatumConstraint :: NamedChunk
outDatumConstraint  = String -> NP -> NamedChunk
nc "OutDataConstraints" (String -> NP
cn' "output data constraint")
traceyMandG :: NamedChunk
traceyMandG         = String -> NP -> NamedChunk
nc "traceyMandG"        ((NamedChunk -> Sentence)
-> (ConceptChunk -> Sentence) -> NamedChunk -> ConceptChunk -> NP
forall c d.
(NamedIdea c, NamedIdea d) =>
(c -> Sentence) -> (d -> Sentence) -> c -> d -> NP
and_TGen NamedChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
titleize' ConceptChunk -> Sentence
forall n. NamedIdea n => n -> Sentence
titleize' NamedChunk
traceyMatrix ConceptChunk
graph)
vav :: NamedChunk
vav                 = String -> NP -> NamedChunk
nc "vav"                (NamedChunk
verification NamedChunk -> NamedChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_` NamedChunk
validation)

scpOfTheProj :: (NamedChunk -> Sentence) -> NamedChunk
scpOfTheProj :: (NamedChunk -> Sentence) -> NamedChunk
scpOfTheProj oper :: NamedChunk -> Sentence
oper = String -> NP -> NamedChunk
nc "scpOfTheProj" (NamedChunk
scope NamedChunk -> NP -> NP
forall c d. (NamedIdea c, NounPhrase d) => c -> d -> NP
`of_NINP` (NamedChunk -> Sentence) -> NamedChunk -> NP
forall t. (t -> Sentence) -> t -> NP
theGen NamedChunk -> Sentence
oper NamedChunk
project) -- reasonable hack?

-- ** Compound Chunks

designDoc, fullForm, generalSystemDescription, moduleInterface, indPRCase,
  physicalConstraint, physicalSystem, problemDescription, prodUCTable,
  specificsystemdescription, systemdescription, systemConstraint, sysCont,
  userCharacteristic, coordinateSystem, datumConstraint, inDatumConstraint, 
  outDatumConstraint, functionalRequirement, nonfunctionalRequirement, safetyReq, 
  softwareConstraint, softwareDoc, softwareReq, softwareSys, softwareVerif, 
  softwareVAV, solutionCharSpec, solutionCharacteristic, offShelfSolution, 
  physicalSim, productUC, useCaseTable, physicalProperty, vavPlan, uncertCol, userInput :: NamedChunk
 
coordinateSystem :: NamedChunk
coordinateSystem             = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
coordinate NamedChunk
system
datumConstraint :: NamedChunk
datumConstraint              = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNCPP NamedChunk
datum NamedChunk
constraint
designDoc :: NamedChunk
designDoc                    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
design NamedChunk
document
fullForm :: NamedChunk
fullForm                     = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
full NamedChunk
form
functionalRequirement :: NamedChunk
functionalRequirement        = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
functional NamedChunk
requirement_
generalSystemDescription :: NamedChunk
generalSystemDescription     = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
general NamedChunk
systemdescription
moduleInterface :: NamedChunk
moduleInterface              = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
module_ NamedChunk
interface
indPRCase :: NamedChunk
indPRCase                    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
individual NamedChunk
productUC
--inDatumConstraint            = compoundNC input_ datumConstraint -- may be used later, but they break stable for now
--outDatumConstraint           = compoundNC output_ datumConstraint 
nonfunctionalRequirement :: NamedChunk
nonfunctionalRequirement     = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
nonfunctional NamedChunk
requirement_
offShelfSolution :: NamedChunk
offShelfSolution             = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
offShelf NamedChunk
solution
physicalConstraint :: NamedChunk
physicalConstraint           = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
physical NamedChunk
constraint
physicalProperty :: NamedChunk
physicalProperty             = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
physical NamedChunk
property
physicalSim :: NamedChunk
physicalSim                  = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
physical NamedChunk
simulation
physicalSystem :: NamedChunk
physicalSystem               = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
physical NamedChunk
system
problemDescription :: NamedChunk
problemDescription           = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
problem NamedChunk
description
prodUCTable :: NamedChunk
prodUCTable                  = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
productUC NamedChunk
table_
productUC :: NamedChunk
productUC                    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
product_ NamedChunk
useCase
safetyReq :: NamedChunk
safetyReq                    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
safety NamedChunk
requirement_
softwareConstraint :: NamedChunk
softwareConstraint           = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
software NamedChunk
constraint
softwareDoc :: NamedChunk
softwareDoc                  = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
software NamedChunk
documentation
softwareReq :: NamedChunk
softwareReq                  = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNCPP NamedChunk
software NamedChunk
requirement_
softwareSys :: NamedChunk
softwareSys                  = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
software NamedChunk
system
softwareVAV :: NamedChunk
softwareVAV                  = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
software NamedChunk
vav
softwareVerif :: NamedChunk
softwareVerif                = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
software NamedChunk
verification
solutionCharSpec :: NamedChunk
solutionCharSpec             = NamedChunk -> NamedChunk -> NamedChunk
compoundNCPSPP NamedChunk
solutionCharacteristic NamedChunk
specification
solutionCharacteristic :: NamedChunk
solutionCharacteristic       = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
solution NamedChunk
characteristic
specificsystemdescription :: NamedChunk
specificsystemdescription    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
specific NamedChunk
systemdescription
sysCont :: NamedChunk
sysCont                      = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
system NamedChunk
context
systemConstraint :: NamedChunk
systemConstraint             = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
system NamedChunk
constraint
systemdescription :: NamedChunk
systemdescription            = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
system NamedChunk
description
uncertCol :: NamedChunk
uncertCol                    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
uncertainty NamedChunk
column
useCaseTable :: NamedChunk
useCaseTable                 = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
useCase NamedChunk
table_
userCharacteristic :: NamedChunk
userCharacteristic           = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
user NamedChunk
characteristic
userInput :: NamedChunk
userInput                    = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
user NamedChunk
input_
vavPlan :: NamedChunk
vavPlan                      = NamedChunk -> NamedChunk -> NamedChunk
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> NamedChunk
compoundNC NamedChunk
vav NamedChunk
plan

-- * Domains

-- | Root SRS Domain.
srsDom :: ConceptChunk
srsDom :: ConceptChunk
srsDom = String -> NP -> String -> ConceptChunk
dcc "srsDom" (CI
srs CI -> Getting NP CI NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP CI NP
forall c. NamedIdea c => Lens' c NP
term) "srs"

goalStmtDom, assumpDom, reqDom, funcReqDom, nonFuncReqDom, chgProbDom, likeChgDom, unlikeChgDom :: ConceptChunk
goalStmtDom :: ConceptChunk
goalStmtDom   = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "goalStmtDom"   (CI
goalStmt CI -> Getting NP CI NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP CI NP
forall c. NamedIdea c => Lens' c NP
term)                 (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "GS")  Sentence
EmptyS [ConceptChunk
srsDom]
assumpDom :: ConceptChunk
assumpDom     = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "assumpDom"     (CI
assumption CI -> Getting NP CI NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP CI NP
forall c. NamedIdea c => Lens' c NP
term)               (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "A")   Sentence
EmptyS [ConceptChunk
srsDom]
reqDom :: ConceptChunk
reqDom        = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "reqDom"        (CI
requirement CI -> Getting NP CI NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP CI NP
forall c. NamedIdea c => Lens' c NP
term)              (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "R")   Sentence
EmptyS [ConceptChunk
srsDom]
funcReqDom :: ConceptChunk
funcReqDom    = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "funcReqDom"    (NamedChunk
functionalRequirement NamedChunk -> Getting NP NamedChunk NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP NamedChunk NP
forall c. NamedIdea c => Lens' c NP
term)    (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "FR")  Sentence
EmptyS [ConceptChunk
reqDom]
nonFuncReqDom :: ConceptChunk
nonFuncReqDom = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "nonFuncReqDom" (NamedChunk
nonfunctionalRequirement NamedChunk -> Getting NP NamedChunk NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP NamedChunk NP
forall c. NamedIdea c => Lens' c NP
term) (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "NFR") Sentence
EmptyS [ConceptChunk
reqDom]
chgProbDom :: ConceptChunk
chgProbDom    = NamedChunk -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> NamedChunk
nc "chgProbDom" (NP -> NamedChunk) -> NP -> NamedChunk
forall a b. (a -> b) -> a -> b
$ String -> NP
cn' "change")                                         Sentence
EmptyS [ConceptChunk
srsDom]
likeChgDom :: ConceptChunk
likeChgDom    = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "likeChgDom"    (CI
likelyChg CI -> Getting NP CI NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP CI NP
forall c. NamedIdea c => Lens' c NP
term)                (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "LC")  Sentence
EmptyS [ConceptChunk
chgProbDom]
unlikeChgDom :: ConceptChunk
unlikeChgDom  = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea "unlikeChgDom"  (CI
unlikelyChg CI -> Getting NP CI NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP CI NP
forall c. NamedIdea c => Lens' c NP
term)              (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just "UC")  Sentence
EmptyS [ConceptChunk
chgProbDom]

-- | List of SRS-related concepts, including SRS.
srsDomains :: [ConceptChunk]
srsDomains :: [ConceptChunk]
srsDomains = [ConceptChunk -> ConceptChunk
forall c. Concept c => c -> ConceptChunk
cw ConceptChunk
srsDom, ConceptChunk
goalStmtDom, ConceptChunk
reqDom, ConceptChunk
funcReqDom, ConceptChunk
nonFuncReqDom, ConceptChunk
assumpDom, ConceptChunk
chgProbDom, ConceptChunk
likeChgDom, ConceptChunk
unlikeChgDom]