-- | Defines concepts used to create documentation.

-- Changes to documentation-related named chunks and common ideas should be reflected in the 
-- 'Creating Your Project in Drasil' tutorial found on the wiki:
-- https://github.com/JacquesCarette/Drasil/wiki/Creating-Your-Project-in-Drasil


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

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

-- * Common Ideas

------------------------------------------------------------------------------------------------------------------------------
-- | CI       |                  |    uid      |         term                                   | abbreviation | ConceptDomain
------------------------------------------------------------------------------------------------------------------------------
assumption :: CI
assumption  = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"assumption"  (String -> NP
cn' String
"assumption")                                    String
"A"       [IdeaDict
softEng]
desSpec :: CI
desSpec     = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"desSpec"     (IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
combineNINI IdeaDict
design IdeaDict
specification)                    String
"DS"      [IdeaDict
softEng]
goalStmt :: CI
goalStmt    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"goalStmt"    (IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
combineNINI IdeaDict
goal IdeaDict
statement)                          String
"GS"      [IdeaDict
softEng]
dataConst :: CI
dataConst   = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"dataConst"   (String -> NP
cn' String
"data constraint")                               String
"DC"      [IdeaDict
softEng]
likelyChg :: CI
likelyChg   = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"likelyChg"   (String -> NP
cn' String
"likely change")                                 String
"LC"      [IdeaDict
softEng]
learnObj :: CI
learnObj    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"learnObj"    (String -> NP
cn' String
"learning objective")                            String
"LO"      [IdeaDict
documentc]
unlikelyChg :: CI
unlikelyChg = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"unlikelyChg" (String -> NP
cn' String
"unlikely change")                               String
"UC"      [IdeaDict
softEng]
physSyst :: CI
physSyst    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"physSyst"    (IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
combineNINI IdeaDict
physicalSystem IdeaDict
description)              String
"PS"      [IdeaDict
softEng]
requirement :: CI
requirement = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"requirement" (String -> NP
cn' String
"requirement")                                   String
"R"       [IdeaDict
softEng]
mis :: CI
mis         = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"mis"         ((NP -> NP -> NP) -> IdeaDict -> IdeaDict -> 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 IdeaDict
moduleInterface IdeaDict
specification) String
"MIS"     [IdeaDict
softEng]
mg :: CI
mg          = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"mg"          ((NP -> NP -> NP) -> IdeaDict -> IdeaDict -> 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 IdeaDict
module_ IdeaDict
guide)                 String
"MG"      [IdeaDict
softEng]
notApp :: CI
notApp      = String -> NP -> String -> [UID] -> CI
commonIdea         String
"notApp"      (String -> NP
nounPhraseSP String
"not applicable")                       String
"N/A"     []
typUnc :: CI
typUnc      = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"typUnc"      (String -> NP
cn' String
"typical uncertainty")                           String
"Uncert." [IdeaDict
softEng]
sec :: CI
sec         = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"section"     (String -> NP
cn' String
"section")                                       String
"Sec"     [IdeaDict
documentc]
srs :: CI
srs         = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"srs"         NP
softReqSpec                                           String
"SRS"     [IdeaDict
softEng]
notebook :: CI
notebook    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"notebook"    (String -> NP
cn' String
"notebook")                                      String
"NB"      [IdeaDict
softEng]
refBy :: CI
refBy       = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"refBy"       (String -> NP
cn  String
"referenced by")                                 String
"RefBy"   [IdeaDict
documentc]
refName :: CI
refName     = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"refName"     (String -> NP
cn' String
"reference name")                                String
"Refname" [IdeaDict
documentc]

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

-- 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 :: IdeaDict

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


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

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

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

-- ** Compound Chunks

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

-- * Domains

-- | Root SRS Domain.
srsDom :: ConceptChunk
srsDom :: ConceptChunk
srsDom = String -> NP -> String -> ConceptChunk
dcc String
"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
Lens' CI NP
term) String
"srs"

goalStmtDom, assumpDom, reqDom, funcReqDom, nonFuncReqDom, chgProbDom, 
  likeChgDom, unlikeChgDom, refByDom, refNameDom :: 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 String
"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
Lens' CI NP
term)                 (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"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 String
"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
Lens' CI NP
term)               (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"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 String
"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
Lens' CI NP
term)              (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"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 String
"funcReqDom"    (IdeaDict
functionalRequirement IdeaDict -> Getting NP IdeaDict NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP IdeaDict NP
forall c. NamedIdea c => Lens' c NP
Lens' IdeaDict NP
term)    (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"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 String
"nonFuncReqDom" (IdeaDict
nonfunctionalRequirement IdeaDict -> Getting NP IdeaDict NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP IdeaDict NP
forall c. NamedIdea c => Lens' c NP
Lens' IdeaDict NP
term) (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"NFR")      Sentence
EmptyS [ConceptChunk
reqDom]
chgProbDom :: ConceptChunk
chgProbDom    = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> IdeaDict
nc String
"chgProbDom" (NP -> IdeaDict) -> NP -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> NP
cn' String
"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 String
"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
Lens' CI NP
term)                (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"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 String
"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
Lens' CI NP
term)              (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"UC")       Sentence
EmptyS [ConceptChunk
chgProbDom]
refByDom :: ConceptChunk
refByDom      = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea String
"refByDom"      (CI
refBy 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
Lens' CI NP
term)                    (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"RefBy")    Sentence
EmptyS [ConceptChunk
srsDom]
refNameDom :: ConceptChunk
refNameDom    = IdeaDict -> Sentence -> [ConceptChunk] -> ConceptChunk
forall c d.
(Idea c, Concept d) =>
c -> Sentence -> [d] -> ConceptChunk
ccs (String -> NP -> Maybe String -> IdeaDict
mkIdea String
"refNameDom"    (CI
refName 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
Lens' CI NP
term)                  (Maybe String -> IdeaDict) -> Maybe String -> IdeaDict
forall a b. (a -> b) -> a -> b
$ String -> Maybe String
forall a. a -> Maybe a
Just String
"RefName")  Sentence
EmptyS [ConceptChunk
srsDom]

-- | 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, ConceptChunk
refByDom, ConceptChunk
refNameDom]