module Drasil.Metadata.Documentation
  ( abbAcc, abbreviation, acronym, appendix, assumption, assumpDom, caseProb
  , charOfIR, characteristic, chgProbDom
  , client, code, column, component, consVals
  , constraint, content, context, corSol, customer, datum, datumConstraint
  , decision , definition, dependency, description, desSpec, design, designDoc
  , document, documentation, endUser
  , element, environment, example, form, full, fullForm
  , functional, functionalRequirement, funcReqDom, general, generalSystemDescription
  , goal, goalStmt, goalStmtDom, guide
  , implementation, inDatumConstraint, individual, indPRCase
  , information, input_, interface, interest, introduction, intReader, item
  , learnObj, likelyChg, likeChgDom, limitation, mg, mis, model, module_, moduleInterface
  , nonfunctional, nonfunctionalRequirement, nonFuncReqDom
  , notebook, offShelf, offShelfSolution, organization, orgOfDoc, output_
  , outDatumConstraint
  , physical, physSyst, physicalConstraint, physicalSystem, plan, product_
  , productUC, prodUCTable
  , problem, problemDescription, problemIntro, project, property, propOfCorSol
  , prpsOfDoc, purpose, quantity, reference, refBy, refName, refMat
  , requirement, reqDom, reqInput, review, scope, scpOfTheProj, scpOfReq, section_, sec
  , software, softwareConstraint, softwareDoc, softwareReq, softwareVAV
  , solution, solutionCharSpec
  , solutionCharacteristic
  , specific, specification, specificsystemdescription, srs, srsDom, stakeholder
  , statement, summary, symbol_, system, systemConstraint, sysCont, systemdescription
  , table_, tAuxConsts, template, term_
  , terminology, termAndDef, theory, tOfCont, tOfSymb, tOfUnit, traceyGraph, traceyMandG
  , traceyMatrix, typUnc, uncertainty
  , unlikelyChg, unlikeChgDom, useCase, user, userCharacteristic
  , value, variable, vav, vavPlan, validation, verification
  )
  where

-- General Haskell
import Control.Lens ((^.))

-- General Drasil
import Language.Drasil (CI, NP, IdeaDict, nc, cn, cn', cnIES, cnICES, cnUM,
  commonIdeaWithDict, fterms, compoundPhrase, compoundPhraseP1, titleizeNP',
  term, ConceptChunk,
  ccs, mkIdea, Sentence(EmptyS), dcc)
import Language.Drasil.Chunk.Concept.NamedCombinators
  (combineNINI, compoundNC, compoundNCPP, of_, of_PS, ofAPS, of_NINP, theGen
  , compoundNCPSPP, and_, and_TGen, and_PP)
import Language.Drasil.Development (NPStruct)
--
-- Vocabulary
import Drasil.Metadata.Concepts.Math (graph, unit_)
import Drasil.Metadata.Domains (documentc, softEng)

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

abbAcc, abbreviation, acronym, appendix, caseProb,
  characteristic, charOfIR, client, code, column, component,
  consVals, constraint, content, context, corSol, customer, datum, decision,
  definition, dependency, description, design, document, documentation,
  endUser, element, environment, example, form, full,
  functional, general, goal, guide, implementation,
  inDatumConstraint, individual, information, input_, interface, interest,
  introduction, intReader, item, limitation, model, module_,
  nonfunctional, outDatumConstraint,
  offShelf, organization, orgOfDoc, output_,
  physical, plan, project, product_, problem, property, propOfCorSol, prpsOfDoc, purpose,
  quantity, reference, refMat, reqInput, review,
  scope, scpOfReq, section_, software, solution, specific,
  specification, stakeholder, statement, summary, symbol_, system, table_, tAuxConsts,
  template, term_, terminology, termAndDef, theory,
  tOfCont, tOfSymb, tOfUnit, traceyGraph, traceyMatrix,
  uncertainty, useCase, user, validation, value, variable, vav, verification :: 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)
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"            )
appendix :: IdeaDict
appendix        = String -> NP -> IdeaDict
nc String
"appendix"       (String -> NP
cnICES String
"appendix"           )
caseProb :: IdeaDict
caseProb        = String -> NP -> IdeaDict
nc String
"caseProb"       (String -> NP
cn' String
"case problem")
characteristic :: IdeaDict
characteristic  = String -> NP -> IdeaDict
nc String
"characteristic" (String -> NP
cn'    String
"characteristic"     )
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)
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?
component :: IdeaDict
component       = String -> NP -> IdeaDict
nc String
"component"      (String -> NP
cn'    String
"component"          )
constraint :: IdeaDict
constraint      = String -> NP -> IdeaDict
nc String
"constraint"     (String -> NP
cn'    String
"constraint"         )
consVals :: IdeaDict
consVals        = String -> NP -> IdeaDict
nc String
"consVals"       (String -> NP
cn String
"values of auxiliary constants")
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"            )
corSol :: IdeaDict
corSol          = String -> NP -> IdeaDict
nc String
"corSol"         (String -> NP
cn' String
"correct solution")
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"      )
endUser :: IdeaDict
endUser         = String -> NP -> IdeaDict
nc String
"end user"       (String -> NP
cn'    String
"end user"           )
element :: IdeaDict
element         = String -> NP -> IdeaDict
nc String
"element"        (String -> NP
cn'    String
"element"            )
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"            )
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
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"     )
inDatumConstraint :: IdeaDict
inDatumConstraint   = String -> NP -> IdeaDict
nc String
"InDataConstraints"  (String -> NP
cn' String
"input data constraint")
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"        )
input_ :: IdeaDict
input_          = String -> NP -> IdeaDict
nc String
"input"          (String -> NP
cn'    String
"input"              )
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"          )
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"       )
item :: IdeaDict
item            = String -> NP -> IdeaDict
nc String
"item"           (String -> NP
cn'    String
"item"               )
limitation :: IdeaDict
limitation      = String -> NP -> IdeaDict
nc String
"limitation"     (String -> NP
cn'    String
"limitation"         )
model :: IdeaDict
model           = String -> NP -> IdeaDict
nc String
"model"          (String -> NP
cn'    String
"model"              )
module_ :: IdeaDict
module_         = String -> NP -> IdeaDict
nc String
"module"         (String -> NP
cn'    String
"module"             )
nonfunctional :: IdeaDict
nonfunctional   = String -> NP -> IdeaDict
nc String
"non-functional" (String -> NP
cn'    String
"non-functional"     ) --FIXME: Adjective
offShelf :: IdeaDict
offShelf        = String -> NP -> IdeaDict
nc String
"Off-the-Shelf"  (String -> NP
cn'    String
"Off-the-Shelf"      )
organization :: IdeaDict
organization    = String -> NP -> IdeaDict
nc String
"organization"   (String -> NP
cn'    String
"organization"       )
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)
output_ :: IdeaDict
output_         = String -> NP -> IdeaDict
nc String
"output"         (String -> NP
cn'    String
"output"             )
outDatumConstraint :: IdeaDict
outDatumConstraint  = String -> NP -> IdeaDict
nc String
"OutDataConstraints" (String -> NP
cn' String
"output data constraint")
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"               )
product_ :: IdeaDict
product_        = String -> NP -> IdeaDict
nc String
"product"        (String -> NP
cn'    String
"product"            )
problem :: IdeaDict
problem         = String -> NP -> IdeaDict
nc String
"problem"        (String -> NP
cn'    String
"problem"            )
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"           )
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      )
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?
reference :: IdeaDict
reference       = String -> NP -> IdeaDict
nc String
"reference"      (String -> NP
cn'    String
"reference"          )
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"        )
review :: IdeaDict
review          = String -> NP -> IdeaDict
nc String
"review"         (String -> NP
cn'    String
"review"             )
scope :: IdeaDict
scope           = String -> NP -> IdeaDict
nc String
"scope"          (String -> NP
cn'    String
"scope"              )
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     )
section_ :: IdeaDict
section_        = String -> NP -> IdeaDict
nc String
"section"        (String -> NP
cn'    String
"section"            )
software :: IdeaDict
software        = String -> NP -> IdeaDict
nc String
"software"       (String -> NP
cn     String
"software"           )
solution :: IdeaDict
solution        = String -> NP -> IdeaDict
nc String
"solution"       (String -> NP
cn'    String
"solution"           )
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"        )
statement :: IdeaDict
statement       = String -> NP -> IdeaDict
nc String
"statement"      (String -> NP
cn'    String
"statement"          )
summary :: IdeaDict
summary         = String -> NP -> IdeaDict
nc String
"summary"        (String -> NP
cnIES  String
"summary"            )
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"              )
tAuxConsts :: IdeaDict
tAuxConsts      = String -> NP -> IdeaDict
nc String
"TAuxConsts"     (String -> NP
cn' String
"auxiliary constant")
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"        )
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)
theory :: IdeaDict
theory          = String -> NP -> IdeaDict
nc String
"theory"         (String -> NP
cnIES  String
"theory"             )
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_)
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")
uncertainty :: IdeaDict
uncertainty     = String -> NP -> IdeaDict
nc String
"uncertainty"    (String -> NP
cnIES  String
"uncertainty"        )
useCase :: IdeaDict
useCase         = String -> NP -> IdeaDict
nc String
"useCase"        (String -> NP
cn'    String
"use case"           )
user :: IdeaDict
user            = String -> NP -> IdeaDict
nc String
"user"           (String -> NP
cn'    String
"user"               )
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"           )
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)
verification :: IdeaDict
verification    = String -> NP -> IdeaDict
nc String
"verification"   (String -> NP
cn'    String
"verification"       )

datumConstraint, designDoc, fullForm, functionalRequirement,
  generalSystemDescription, indPRCase, moduleInterface,
  nonfunctionalRequirement, offShelfSolution, physicalConstraint,
  physicalSystem, problemDescription, problemIntro,
  productUC, prodUCTable, softwareReq, solutionCharacteristic, solutionCharSpec,
  softwareConstraint, softwareDoc, softwareVAV,
  specificsystemdescription, sysCont, systemConstraint, systemdescription,
  userCharacteristic, vavPlan :: IdeaDict
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 -> CI -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
functional CI
requirement
generalSystemDescription :: IdeaDict
generalSystemDescription     = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
general IdeaDict
systemdescription
indPRCase :: IdeaDict
indPRCase                    = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
individual IdeaDict
productUC
moduleInterface :: IdeaDict
moduleInterface              = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
module_ IdeaDict
interface
nonfunctionalRequirement :: IdeaDict
nonfunctionalRequirement     = IdeaDict -> CI -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
nonfunctional CI
requirement
offShelfSolution :: IdeaDict
offShelfSolution             = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
offShelf IdeaDict
solution
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
physicalConstraint :: IdeaDict
physicalConstraint           = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
physical IdeaDict
constraint
physicalSystem :: IdeaDict
physicalSystem               = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
physical IdeaDict
system
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 -> CI -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNCPP IdeaDict
software CI
requirement
softwareVAV :: IdeaDict
softwareVAV                  = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
software IdeaDict
vav
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
userCharacteristic :: IdeaDict
userCharacteristic           = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
user IdeaDict
characteristic
vavPlan :: IdeaDict
vavPlan                      = IdeaDict -> IdeaDict -> IdeaDict
forall a b. (NamedIdea a, NamedIdea b) => a -> b -> IdeaDict
compoundNC IdeaDict
vav IdeaDict
plan

traceyMandG :: IdeaDict
traceyMandG :: IdeaDict
traceyMandG         = String -> NP -> IdeaDict
nc String
"traceyMandG"        ((IdeaDict -> NPStruct)
-> (ConceptChunk -> NPStruct) -> IdeaDict -> ConceptChunk -> NP
forall c d.
(NamedIdea c, NamedIdea d) =>
(c -> NPStruct) -> (d -> NPStruct) -> c -> d -> NP
and_TGen (\IdeaDict
t -> NP -> NPStruct
forall n. NounPhrase n => n -> NPStruct
titleizeNP' (IdeaDict
t 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)) (\ConceptChunk
t -> NP -> NPStruct
forall n. NounPhrase n => n -> NPStruct
titleizeNP' (ConceptChunk
t ConceptChunk -> Getting NP ConceptChunk NP -> NP
forall s a. s -> Getting a s a -> a
^. Getting NP ConceptChunk NP
forall c. NamedIdea c => Lens' c NP
Lens' ConceptChunk NP
term)) IdeaDict
traceyMatrix ConceptChunk
graph)

-- * 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"

assumpDom, chgProbDom, funcReqDom, goalStmtDom, likeChgDom,
  nonFuncReqDom, reqDom, unlikeChgDom :: ConceptChunk
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]
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]
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]
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]
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]
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]
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]
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]

assumption, desSpec, goalStmt, learnObj, likelyChg, mg, mis, notebook, physSyst,
  refBy, refName, requirement, sec, srs, typUnc, unlikelyChg :: CI
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]
learnObj :: CI
learnObj    = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"learnObj"    (String -> NP
cn' String
"learning objective")                            String
"LO"      [IdeaDict
documentc]
likelyChg :: CI
likelyChg   = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"likelyChg"   (String -> NP
cn' String
"likely change")                                 String
"LC"      [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]
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]
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]
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]
requirement :: CI
requirement = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"requirement" (String -> NP
cn' String
"requirement")                                   String
"R"       [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]
typUnc :: CI
typUnc      = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"typUnc"      (String -> NP
cn' String
"typical uncertainty")                           String
"Uncert." [IdeaDict
softEng]
unlikelyChg :: CI
unlikelyChg = String -> NP -> String -> [IdeaDict] -> CI
commonIdeaWithDict String
"unlikelyChg" (String -> NP
cn' String
"unlikely change")                               String
"UC"      [IdeaDict
softEng]

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