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 Drasil.Database (mkUid)
import Language.Drasil (CI, NP, IdeaDict, cn, cn', cnIES, cnICES, cnUM,
  commonIdea, fterms, compoundPhrase, compoundPhraseP1, titleizeNP',
  term, ConceptChunk, cncpt, cncpt', Sentence(EmptyS), idea', cncpt''', Sentence(..))
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          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"TAbbAcc")        (IdeaDict
abbreviation IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_PP` IdeaDict
acronym)
abbreviation :: IdeaDict
abbreviation    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"abbreviation")   (String -> NP
cn'    String
"abbreviation"       )
acronym :: IdeaDict
acronym         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"acronym")        (String -> NP
cn'    String
"acronym"            )
appendix :: IdeaDict
appendix        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"appendix")       (String -> NP
cnICES String
"appendix"           )
caseProb :: IdeaDict
caseProb        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"caseProb")       (String -> NP
cn' String
"case problem")
characteristic :: IdeaDict
characteristic  = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"characteristic") (String -> NP
cn'    String
"characteristic"     )
charOfIR :: IdeaDict
charOfIR        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"charOfIR")       (IdeaDict
characteristic IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_PS` IdeaDict
intReader)
client :: IdeaDict
client          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"client")         (String -> NP
cn'    String
"client"             )
code :: IdeaDict
code            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"code")           (String -> NP
cn     String
"code"               )
column :: IdeaDict
column          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"column")         (String -> NP
cn'    String
"column"             ) --general enough to be in Documentation?
component :: IdeaDict
component       = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"component")      (String -> NP
cn'    String
"component"          )
constraint :: IdeaDict
constraint      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"constraint")     (String -> NP
cn'    String
"constraint"         )
consVals :: IdeaDict
consVals        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"consVals")       (String -> NP
cn String
"values of auxiliary constants")
content :: IdeaDict
content         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"content")        (String -> NP
cn'    String
"content"            )
context :: IdeaDict
context         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"context")        (String -> NP
cn'    String
"context"            )
corSol :: IdeaDict
corSol          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"corSol")         (String -> NP
cn' String
"correct solution")
customer :: IdeaDict
customer        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"customer")       (String -> NP
cn'    String
"customer"           )
datum :: IdeaDict
datum           = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"datum")          (String -> NP
cnUM   String
"datum"              )
decision :: IdeaDict
decision        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"decision")       (String -> NP
cn'    String
"decision"           )
definition :: IdeaDict
definition      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"definition")     (String -> NP
cn'    String
"definition"         )
dependency :: IdeaDict
dependency      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"dependency")     (String -> NP
cnIES  String
"dependency"         )
description :: IdeaDict
description     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"description")    (String -> NP
cn'    String
"description"        )
design :: IdeaDict
design          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"design")         (String -> NP
cn'    String
"design"             )
document :: IdeaDict
document        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"document")       (String -> NP
cn'    String
"document"           )
documentation :: IdeaDict
documentation   = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"documentation")  (String -> NP
cn'    String
"documentation"      )
endUser :: IdeaDict
endUser         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"end user")       (String -> NP
cn'    String
"end user"           )
element :: IdeaDict
element         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"element")        (String -> NP
cn'    String
"element"            )
environment :: IdeaDict
environment     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"environment")    (String -> NP
cn'    String
"environment"        ) -- Is this term in the right spot?
example :: IdeaDict
example         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"example")        (String -> NP
cn'    String
"example"            )
form :: IdeaDict
form            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"form")           (String -> NP
cn'    String
"form"               )
full :: IdeaDict
full            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"full")           (String -> NP
cn'    String
"full"               ) --FIXME: Adjective
functional :: IdeaDict
functional      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"functional")     (String -> NP
cn'    String
"functional"         ) --FIXME: Adjective
general :: IdeaDict
general         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"general")        (String -> NP
cn'    String
"general"            ) --FIXME: Adjective
goal :: IdeaDict
goal            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"goal")           (String -> NP
cn'    String
"goal"               )
guide :: IdeaDict
guide           = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"guide")          (String -> NP
cn'    String
"guide"              )
implementation :: IdeaDict
implementation  = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"implementation") (String -> NP
cn'    String
"implementation"     )
inDatumConstraint :: IdeaDict
inDatumConstraint   = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"InDataConstraints")  (String -> NP
cn' String
"input data constraint")
individual :: IdeaDict
individual      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"individual")     (String -> NP
cn'    String
"individual"         )
information :: IdeaDict
information     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"information")    (String -> NP
cn     String
"information"        )
input_ :: IdeaDict
input_          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"input")          (String -> NP
cn'    String
"input"              )
interest :: IdeaDict
interest        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"interest")       (String -> NP
cn'    String
"interest"           )
interface :: IdeaDict
interface       = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"interface")      (String -> NP
cn'    String
"interface"          )
intReader :: IdeaDict
intReader       = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"intReader")      (String -> NP
cn'    String
"intended reader"    )
introduction :: IdeaDict
introduction    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"introduction")   (String -> NP
cn'    String
"introduction"       )
item :: IdeaDict
item            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"item")           (String -> NP
cn'    String
"item"               )
limitation :: IdeaDict
limitation      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"limitation")     (String -> NP
cn'    String
"limitation"         )
model :: IdeaDict
model           = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"model")          (String -> NP
cn'    String
"model"              )
module_ :: IdeaDict
module_         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"module")         (String -> NP
cn'    String
"module"             )
nonfunctional :: IdeaDict
nonfunctional   = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"non-functional") (String -> NP
cn'    String
"non-functional"     ) --FIXME: Adjective
offShelf :: IdeaDict
offShelf        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"Off-the-Shelf")  (String -> NP
cn'    String
"Off-the-Shelf"      )
organization :: IdeaDict
organization    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"organization")   (String -> NP
cn'    String
"organization"       )
orgOfDoc :: IdeaDict
orgOfDoc        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"orgOfDoc")       (IdeaDict
organization IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` IdeaDict
document)
output_ :: IdeaDict
output_         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"output")         (String -> NP
cn'    String
"output"             )
outDatumConstraint :: IdeaDict
outDatumConstraint  = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"OutDataConstraints") (String -> NP
cn' String
"output data constraint")
physical :: IdeaDict
physical        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"physical")       (String -> NP
cn'    String
"physical"           ) --FIXME: Adjective
plan :: IdeaDict
plan            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"plan")           (String -> NP
cn'    String
"plan"               )
product_ :: IdeaDict
product_        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"product")        (String -> NP
cn'    String
"product"            )
problem :: IdeaDict
problem         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"problem")        (String -> NP
cn'    String
"problem"            )
project :: IdeaDict
project         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"project")        (String -> NP
cn'    String
"project"            )
property :: IdeaDict
property        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"property")       (String -> NP
cnIES  String
"property"           )
propOfCorSol :: IdeaDict
propOfCorSol    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"propOfCorSol")   (IdeaDict
property IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`ofAPS` IdeaDict
corSol     )
prpsOfDoc :: IdeaDict
prpsOfDoc       = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"prpsOfDoc")      (IdeaDict
purpose IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` IdeaDict
document      )
purpose :: IdeaDict
purpose         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"purpose")        (String -> NP
cn'    String
"purpose"            )
quantity :: IdeaDict
quantity        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"quantity")       (String -> NP
cnIES  String
"quantity"           ) --general enough to be in documentaion.hs?
reference :: IdeaDict
reference       = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"reference")      (String -> NP
cn'    String
"reference"          )
refMat :: IdeaDict
refMat          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"refMat")         (String -> NP
cn' String
"reference material"    )
reqInput :: IdeaDict
reqInput        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"ReqInputs")      (String -> NP
cn' String
"required input"        )
review :: IdeaDict
review          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"review")         (String -> NP
cn'    String
"review"             )
scope :: IdeaDict
scope           = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"scope")          (String -> NP
cn'    String
"scope"              )
scpOfReq :: IdeaDict
scpOfReq        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"scpOfReq")       (IdeaDict
scope IdeaDict -> CI -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` CI
requirement     )
section_ :: IdeaDict
section_        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"section")        (String -> NP
cn'    String
"section"            )
software :: IdeaDict
software        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"software")       (String -> NP
cn     String
"software"           )
solution :: IdeaDict
solution        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"solution")       (String -> NP
cn'    String
"solution"           )
specific :: IdeaDict
specific        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"specific")       (String -> NP
cn'    String
"specific"           ) --FIXME: Adjective
specification :: IdeaDict
specification   = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"specification")  (String -> NP
cn'    String
"specification"      )
stakeholder :: IdeaDict
stakeholder     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"stakeholder")    (String -> NP
cn'    String
"stakeholder"        )
statement :: IdeaDict
statement       = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"statement")      (String -> NP
cn'    String
"statement"          )
summary :: IdeaDict
summary         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"summary")        (String -> NP
cnIES  String
"summary"            )
symbol_ :: IdeaDict
symbol_         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"symbol")         (String -> NP
cn'    String
"symbol"             )
system :: IdeaDict
system          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"system")         (String -> NP
cn'    String
"system"             )
table_ :: IdeaDict
table_          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"table")          (String -> NP
cn'    String
"table"              )
tAuxConsts :: IdeaDict
tAuxConsts      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"TAuxConsts")     (String -> NP
cn' String
"auxiliary constant")
template :: IdeaDict
template        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"template")       (String -> NP
cn'    String
"template"           )
term_ :: IdeaDict
term_           = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"term")           (String -> NP
cn'    String
"term"               )
terminology :: IdeaDict
terminology     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"terminology")    (String -> NP
cnIES  String
"terminology"        )
termAndDef :: IdeaDict
termAndDef      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"termAndDef")     (IdeaDict
terminology IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_` IdeaDict
definition)
theory :: IdeaDict
theory          = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"theory")         (String -> NP
cnIES  String
"theory"             )
tOfCont :: IdeaDict
tOfCont         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"tOfCont")        (IdeaDict
table_ IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` IdeaDict
content)
tOfSymb :: IdeaDict
tOfSymb         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"tOfSymb")        (IdeaDict
table_ IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` IdeaDict
symbol_)
tOfUnit :: IdeaDict
tOfUnit         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"tOfUnit")        (IdeaDict
table_ IdeaDict -> ConceptChunk -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`of_` ConceptChunk
unit_)
traceyGraph :: IdeaDict
traceyGraph     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"traceyGraph")    (String -> NP
cn'    String
"traceability graph" )
traceyMatrix :: IdeaDict
traceyMatrix    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"traceyMatrix")   (String -> NP
cnICES String
"traceability matrix")
uncertainty :: IdeaDict
uncertainty     = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"uncertainty")    (String -> NP
cnIES  String
"uncertainty"        )
useCase :: IdeaDict
useCase         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"useCase")        (String -> NP
cn'    String
"use case"           )
user :: IdeaDict
user            = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"user")           (String -> NP
cn'    String
"user"               )
validation :: IdeaDict
validation      = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"validation")     (String -> NP
cn'    String
"validation"         )
value :: IdeaDict
value           = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"value")          (String -> NP
cn'    String
"value"              )
variable :: IdeaDict
variable        = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"variable")       (String -> NP
cn'    String
"variable"           )
vav :: IdeaDict
vav             = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid String
"vav")            (IdeaDict
verification IdeaDict -> IdeaDict -> NP
forall c d. (NamedIdea c, NamedIdea d) => c -> d -> NP
`and_` IdeaDict
validation)
verification :: IdeaDict
verification    = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid 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         = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid 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 = UID -> NP -> Sentence -> ConceptChunk
cncpt''' (String -> UID
mkUid 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 -> Sentence
S String
"srs")

assumpDom, chgProbDom, funcReqDom, goalStmtDom, likeChgDom,
  nonFuncReqDom, reqDom, unlikeChgDom :: ConceptChunk
assumpDom :: ConceptChunk
assumpDom     = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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)               Sentence
EmptyS String
"A"   [ConceptChunk
srsDom]
chgProbDom :: ConceptChunk
chgProbDom    = UID -> NP -> Sentence -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> [dom] -> ConceptChunk
cncpt' (String -> UID
mkUid String
"chgProbDom")    (String -> NP
cn' String
"change")                     Sentence
EmptyS       [ConceptChunk
srsDom]
funcReqDom :: ConceptChunk
funcReqDom    = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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)    Sentence
EmptyS String
"FR"  [ConceptChunk
reqDom]
goalStmtDom :: ConceptChunk
goalStmtDom   = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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)                 Sentence
EmptyS String
"GS"  [ConceptChunk
srsDom]
likeChgDom :: ConceptChunk
likeChgDom    = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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)                Sentence
EmptyS String
"LC"  [ConceptChunk
chgProbDom]
nonFuncReqDom :: ConceptChunk
nonFuncReqDom = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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) Sentence
EmptyS String
"NFR" [ConceptChunk
reqDom]
reqDom :: ConceptChunk
reqDom        = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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)              Sentence
EmptyS String
"R"   [ConceptChunk
srsDom]
unlikeChgDom :: ConceptChunk
unlikeChgDom  = UID -> NP -> Sentence -> String -> [ConceptChunk] -> ConceptChunk
forall dom.
Concept dom =>
UID -> NP -> Sentence -> String -> [dom] -> ConceptChunk
cncpt  (String -> UID
mkUid 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)              Sentence
EmptyS String
"UC"  [ConceptChunk
chgProbDom]

-- FIXME: Some of the below are duplicated knowledge of the above (above preferred). None should be CIs, too.

assumption, desSpec, goalStmt, learnObj, likelyChg, mg, mis, notebook, physSyst,
  refBy, refName, requirement, sec, srs, typUnc, unlikelyChg :: CI
assumption :: CI
assumption  = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"assumption")  (String -> NP
cn' String
"assumption")                                    String
"A"       [IdeaDict
softEng]
desSpec :: CI
desSpec     = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid 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    = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid 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    = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"learnObj")    (String -> NP
cn' String
"learning objective")                            String
"LO"      [IdeaDict
documentc]
likelyChg :: CI
likelyChg   = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"likelyChg")   (String -> NP
cn' String
"likely change")                                 String
"LC"      [IdeaDict
softEng]
physSyst :: CI
physSyst    = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid 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          = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid 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         = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid 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    = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"notebook")    (String -> NP
cn' String
"notebook")                                      String
"NB"      [IdeaDict
softEng]
refBy :: CI
refBy       = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"refBy")       (String -> NP
cn  String
"referenced by")                                 String
"RefBy"   [IdeaDict
documentc]
refName :: CI
refName     = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"refName")     (String -> NP
cn' String
"reference name")                                String
"Refname" [IdeaDict
documentc]
requirement :: CI
requirement = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"requirement") (String -> NP
cn' String
"requirement")                                   String
"R"       [IdeaDict
softEng]
sec :: CI
sec         = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"section")     (String -> NP
cn' String
"section")                                       String
"Sec"     [IdeaDict
documentc]
srs :: CI
srs         = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"srs")         NP
softReqSpec                                           String
"SRS"     [IdeaDict
softEng]
typUnc :: CI
typUnc      = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"typUnc")      (String -> NP
cn' String
"typical uncertainty")                           String
"Uncert." [IdeaDict
softEng]
unlikelyChg :: CI
unlikelyChg = UID -> NP -> String -> [IdeaDict] -> CI
commonIdea (String -> UID
mkUid String
"unlikelyChg") (String -> NP
cn' String
"unlikely change")                               String
"UC"      [IdeaDict
softEng]

scpOfTheProj :: (IdeaDict -> NPStruct) -> IdeaDict
scpOfTheProj :: (IdeaDict -> NPStruct) -> IdeaDict
scpOfTheProj IdeaDict -> NPStruct
oper = UID -> NP -> IdeaDict
idea' (String -> UID
mkUid 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?