{-# Language TupleSections #-}
---------------------------------------------------------------------------
-- | Start the process of moving away from Document as the main internal
-- representation of information, to something more informative.
-- Over time, we'll want to have a cleaner separation, but doing that
-- all at once would break too much for too long.  So we start here
-- instead.
module Drasil.DocumentLanguage where

import Drasil.DocDecl (SRSDecl, mkDocDesc)
import Drasil.DocumentLanguage.Core (AppndxSec(..), AuxConstntSec(..),
  DerivationDisplay(..), DocDesc, DocSection(..), OffShelfSolnsSec(..), GSDSec(..),
  GSDSub(..), IntroSec(..), IntroSub(..), LCsSec(..), LFunc(..),
  PDSub(..), ProblemDescription(..), RefSec(..), RefTab(..), ReqrmntSec(..),
  ReqsSub(..), SCSSub(..), StkhldrSec(..), StkhldrSub(..), SolChSpec(..),
  SSDSec(..), SSDSub(..), TraceabilitySec(..), TraceConfig(..),
  TSIntro(..), UCsSec(..), getTraceConfigUID)
import Drasil.DocumentLanguage.Definitions (ddefn, derivation, instanceModel,
  gdefn, tmodel)
import Drasil.ExtractDocDesc (getDocDesc, egetDocDesc)
import Drasil.TraceTable (generateTraceMap)

import Language.Drasil hiding (kind)
import Language.Drasil.Display (compsy)

import Database.Drasil hiding (cdb)
import SysInfo.Drasil

import Drasil.Sections.TableOfAbbAndAcronyms (tableAbbAccGen)
import Drasil.Sections.TableOfContents (toToC, findToC)
import Drasil.Sections.TableOfSymbols (table, tsIntro)
import Drasil.Sections.TableOfUnits (tOfUnitSIName, tuIntro, defaultTUI)
import qualified Drasil.DocLang.SRS as SRS (appendix,
  genSysDes, likeChg, unlikeChg, reference, solCharSpec,
  stakeholder, tOfCont, tOfSymb, tOfUnit, userChar, offShelfSol, refMat,
  tOfAbbAcc)
import Drasil.DocLang.References (secRefs)
import qualified Drasil.Sections.AuxiliaryConstants as AC (valsOfAuxConstantsF)
import qualified Drasil.Sections.GeneralSystDesc as GSD (genSysIntro,
  systCon, usrCharsF, sysContxt)
import qualified Drasil.Sections.Introduction as Intro (charIntRdrF,
  introductionSection, orgSec, purposeOfDoc, scopeOfRequirements)
import qualified Drasil.Sections.Requirements as R (reqF, fReqF, nfReqF)
import qualified Drasil.Sections.SpecificSystemDescription as SSD (assumpF,
  datConF, dataDefnF, genDefnF, goalStmtF, inModelF, physSystDesc, probDescF,
  propCorSolF, solutionCharSpecIntro, specSysDescr, termDefnF, thModF, helperCI,
  tmStub, ddStub, gdStub, imStub, pdStub)
import qualified Drasil.Sections.Stakeholders as Stk (stakeholderIntro,
  tClientF, tCustomerF)
import qualified Drasil.DocumentLanguage.TraceabilityMatrix as TM (
  generateTraceTableView, traceMHeader, layoutUIDs)
import qualified Drasil.DocumentLanguage.TraceabilityGraph as TG (traceMGF)
import Drasil.DocumentLanguage.TraceabilityGraph (traceyGraphGetRefs)
import Drasil.Sections.TraceabilityMandGs (traceMatStandard)

import qualified Data.Drasil.Concepts.Documentation as Doc (likelyChg, section_,
  software, unlikelyChg)

import Control.Lens ((^.), set)
import Data.Function (on)
import Data.List (nub, sortBy, sortOn)
import qualified Data.Map as Map (elems, toList, assocs, keys)
import Data.Maybe (maybeToList)
import Drasil.Sections.ReferenceMaterial (emptySectSentPlu)

-- * Main Function
-- | Creates a document from a document description, a title combinator function, and system information.
mkDoc :: SRSDecl -> (IdeaDict -> IdeaDict -> Sentence) -> SystemInformation -> Document
mkDoc :: SRSDecl
-> (IdeaDict -> IdeaDict -> Sentence)
-> SystemInformation
-> Document
mkDoc SRSDecl
dd IdeaDict -> IdeaDict -> Sentence
comb si :: SystemInformation
si@SI {_sys :: ()
_sys = a
sys, _kind :: ()
_kind = b
kind, _authors :: SystemInformation -> People
_authors = People
docauthors} =
  Sentence
-> Sentence -> ShowTableOfContents -> [Section] -> Document
Document (b -> IdeaDict
forall c. Idea c => c -> IdeaDict
nw b
kind IdeaDict -> IdeaDict -> Sentence
`comb` a -> IdeaDict
forall c. Idea c => c -> IdeaDict
nw a
sys) (SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List ([Sentence] -> Sentence) -> [Sentence] -> Sentence
forall a b. (a -> b) -> a -> b
$ (Person -> Sentence) -> People -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Sentence
S (String -> Sentence) -> (Person -> String) -> Person -> Sentence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Person -> String
forall n. HasName n => n -> String
name) People
docauthors) ([DocSection] -> ShowTableOfContents
findToC [DocSection]
l) ([Section] -> Document) -> [Section] -> Document
forall a b. (a -> b) -> a -> b
$
  SystemInformation -> [DocSection] -> [Section]
mkSections SystemInformation
fullSI [DocSection]
l where
    fullSI :: SystemInformation
fullSI = SRSDecl -> SystemInformation -> SystemInformation
fillcdbSRS SRSDecl
dd SystemInformation
si
    l :: [DocSection]
l = SystemInformation -> SRSDecl -> [DocSection]
mkDocDesc SystemInformation
fullSI SRSDecl
dd

-- * Functions to Fill 'ChunkDB'

-- TODO: Move all of these "filler" functions to a new file?
-- TODO: Add in 'fillTermMap' once #2775 is complete.
-- | Assuming a given 'ChunkDB' with no traces and minimal/no references, fill in for rest of system information.
-- Currently fills in references, traceability matrix information and 'IdeaDict's.
fillcdbSRS :: SRSDecl -> SystemInformation -> SystemInformation
fillcdbSRS :: SRSDecl -> SystemInformation -> SystemInformation
fillcdbSRS SRSDecl
srsDec SystemInformation
si = SRSDecl -> SystemInformation -> SystemInformation
fillSecAndLC SRSDecl
srsDec (SystemInformation -> SystemInformation)
-> SystemInformation -> SystemInformation
forall a b. (a -> b) -> a -> b
$ SRSDecl -> SystemInformation -> SystemInformation
fillReferences SRSDecl
srsDec (SystemInformation -> SystemInformation)
-> SystemInformation -> SystemInformation
forall a b. (a -> b) -> a -> b
$ SRSDecl -> SystemInformation -> SystemInformation
fillTraceSI SRSDecl
srsDec SystemInformation
si

{-Don't want to manually add concepts here, Drasil should do it automatically. Perhaps through traversal?
fillConcepts :: SystemInformation -> SystemInformation
fillConcepts si = si2
  where
    si2 = set sysinfodb chkdb2 si
    chkdb = si ^. sysinfodb
    tmtbl = termTable chkdb
    chkdb2 = chkdb{termTable = termMap $ nub (map nw doccon ++ map nw doccon' ++ map nw softwarecon ++ map nw physicCon ++ map nw physicCon' ++ map nw physicalcon ++ map nw educon ++ map nw mathcon ++ map nw mathcon' ++ map nw compcon ++ map nw compcon' ++ map nw solidcon ++ map nw thermocon ++ (map (fst.snd) $ Map.assocs tmtbl))}
-}

{- FIXME: See #2775
-- Fill in term map from all concepts and quantities.
fillTermMap :: SystemInformation -> SystemInformation
fillTermMap si = si2
  where
    -- Get current contents of si
    chkdb = si ^. sysinfodb
    -- extract everything that could possibly lead to an 'IdeaDict'
    symbs    = map (fst.snd) $ Map.assocs $ symbolTable chkdb
    trms     = map (fst.snd) $ Map.assocs $ termTable chkdb
    concepts = map (fst.snd) $ Map.assocs $ defTable chkdb

    -- TODO: Uncomment these when the second part of #2775 is resolved.
    -- Some Definitions and models overwrite the term for a given UID.
    -- We don't really want this behaviour, so it should be resolved by
    -- changing some of the constructors for ModelKind found in drasil-theory

    ddefs   = map (fst.snd) $ Map.assocs $ chkdb ^. dataDefnTable
    gdefs   = map (fst.snd) $ Map.assocs $ chkdb ^. gendefTable
    imods   = map (fst.snd) $ Map.assocs $ chkdb ^. insmodelTable
    tmods   = map (fst.snd) $ Map.assocs $ chkdb ^. theoryModelTable
    concIns = map (fst.snd) $ Map.assocs $ chkdb ^. conceptinsTable
    -- fill in the appropriate chunkdb field
    chkdb2 = chkdb {termTable = termMap $ nub $ map nw symbs ++ map nw trms
      ++ map nw concepts ++ map nw concIns
      ++ map nw ddefs ++ map nw gdefs ++ map nw imods ++ map nw tmods}
    -- return the filled in system information
    si2 = set sysinfodb chkdb2 si
    -}

-- | Fill in the 'Section's and 'LabelledContent' maps of the 'ChunkDB' from the 'SRSDecl'.
fillSecAndLC :: SRSDecl -> SystemInformation -> SystemInformation
fillSecAndLC :: SRSDecl -> SystemInformation -> SystemInformation
fillSecAndLC SRSDecl
dd SystemInformation
si = SystemInformation
si2
  where
    -- Get current contents of si
    chkdb :: ChunkDB
chkdb = SystemInformation
si SystemInformation
-> Getting ChunkDB SystemInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB SystemInformation ChunkDB
forall c. HasSystemInformation c => Lens' c ChunkDB
Lens' SystemInformation ChunkDB
sysinfodb
    -- extract sections and labelledcontent
    allSections :: [Section]
allSections = (Section -> [Section]) -> [Section] -> [Section]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Section -> [Section]
findAllSec ([Section] -> [Section]) -> [Section] -> [Section]
forall a b. (a -> b) -> a -> b
$ SystemInformation -> [DocSection] -> [Section]
mkSections SystemInformation
si ([DocSection] -> [Section]) -> [DocSection] -> [Section]
forall a b. (a -> b) -> a -> b
$ SystemInformation -> SRSDecl -> [DocSection]
mkDocDesc SystemInformation
si SRSDecl
dd
    allLC :: [LabelledContent]
allLC = (Section -> [LabelledContent]) -> [Section] -> [LabelledContent]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Section -> [LabelledContent]
findAllLC [Section]
allSections
    existingSections :: [Section]
existingSections = ((UID, (Section, Int)) -> Section)
-> [(UID, (Section, Int))] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map ((Section, Int) -> Section
forall a b. (a, b) -> a
fst((Section, Int) -> Section)
-> ((UID, (Section, Int)) -> (Section, Int))
-> (UID, (Section, Int))
-> Section
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (Section, Int)) -> (Section, Int)
forall a b. (a, b) -> b
snd) ([(UID, (Section, Int))] -> [Section])
-> [(UID, (Section, Int))] -> [Section]
forall a b. (a -> b) -> a -> b
$ Map UID (Section, Int) -> [(UID, (Section, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (Section, Int) -> [(UID, (Section, Int))])
-> Map UID (Section, Int) -> [(UID, (Section, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (Section, Int)) ChunkDB (Map UID (Section, Int))
-> Map UID (Section, Int)
forall s a. s -> Getting a s a -> a
^. Getting (Map UID (Section, Int)) ChunkDB (Map UID (Section, Int))
Lens' ChunkDB (Map UID (Section, Int))
sectionTable
    existingLC :: [LabelledContent]
existingLC = ((UID, (LabelledContent, Int)) -> LabelledContent)
-> [(UID, (LabelledContent, Int))] -> [LabelledContent]
forall a b. (a -> b) -> [a] -> [b]
map ((LabelledContent, Int) -> LabelledContent
forall a b. (a, b) -> a
fst((LabelledContent, Int) -> LabelledContent)
-> ((UID, (LabelledContent, Int)) -> (LabelledContent, Int))
-> (UID, (LabelledContent, Int))
-> LabelledContent
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (LabelledContent, Int)) -> (LabelledContent, Int)
forall a b. (a, b) -> b
snd) ([(UID, (LabelledContent, Int))] -> [LabelledContent])
-> [(UID, (LabelledContent, Int))] -> [LabelledContent]
forall a b. (a -> b) -> a -> b
$ Map UID (LabelledContent, Int) -> [(UID, (LabelledContent, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (LabelledContent, Int) -> [(UID, (LabelledContent, Int))])
-> Map UID (LabelledContent, Int)
-> [(UID, (LabelledContent, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (LabelledContent, Int))
     ChunkDB
     (Map UID (LabelledContent, Int))
-> Map UID (LabelledContent, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (LabelledContent, Int))
  ChunkDB
  (Map UID (LabelledContent, Int))
Lens' ChunkDB (Map UID (LabelledContent, Int))
labelledcontentTable
    -- fill in the appropriate chunkdb fields
    chkdb2 :: ChunkDB
chkdb2 = ASetter
  ChunkDB
  ChunkDB
  (Map UID (LabelledContent, Int))
  (Map UID (LabelledContent, Int))
-> Map UID (LabelledContent, Int) -> ChunkDB -> ChunkDB
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  ChunkDB
  ChunkDB
  (Map UID (LabelledContent, Int))
  (Map UID (LabelledContent, Int))
Lens' ChunkDB (Map UID (LabelledContent, Int))
labelledcontentTable ([LabelledContent] -> Map UID (LabelledContent, Int)
forall a. HasUID a => [a] -> Map UID (a, Int)
idMap ([LabelledContent] -> Map UID (LabelledContent, Int))
-> [LabelledContent] -> Map UID (LabelledContent, Int)
forall a b. (a -> b) -> a -> b
$ [LabelledContent] -> [LabelledContent]
forall a. Eq a => [a] -> [a]
nub ([LabelledContent] -> [LabelledContent])
-> [LabelledContent] -> [LabelledContent]
forall a b. (a -> b) -> a -> b
$ [LabelledContent]
existingLC [LabelledContent] -> [LabelledContent] -> [LabelledContent]
forall a. [a] -> [a] -> [a]
++ [LabelledContent]
allLC)
      (ChunkDB -> ChunkDB) -> ChunkDB -> ChunkDB
forall a b. (a -> b) -> a -> b
$ ASetter
  ChunkDB ChunkDB (Map UID (Section, Int)) (Map UID (Section, Int))
-> Map UID (Section, Int) -> ChunkDB -> ChunkDB
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  ChunkDB ChunkDB (Map UID (Section, Int)) (Map UID (Section, Int))
Lens' ChunkDB (Map UID (Section, Int))
sectionTable ([Section] -> Map UID (Section, Int)
forall a. HasUID a => [a] -> Map UID (a, Int)
idMap ([Section] -> Map UID (Section, Int))
-> [Section] -> Map UID (Section, Int)
forall a b. (a -> b) -> a -> b
$ [Section] -> [Section]
forall a. Eq a => [a] -> [a]
nub ([Section] -> [Section]) -> [Section] -> [Section]
forall a b. (a -> b) -> a -> b
$ [Section]
existingSections [Section] -> [Section] -> [Section]
forall a. [a] -> [a] -> [a]
++ [Section]
allSections) ChunkDB
chkdb
    -- return the filled in system information
    si2 :: SystemInformation
si2 = ASetter SystemInformation SystemInformation ChunkDB ChunkDB
-> ChunkDB -> SystemInformation -> SystemInformation
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter SystemInformation SystemInformation ChunkDB ChunkDB
forall c. HasSystemInformation c => Lens' c ChunkDB
Lens' SystemInformation ChunkDB
sysinfodb ChunkDB
chkdb2 SystemInformation
si
    -- Helper and finder functions
    findAllSec :: Section -> [Section]
    findAllSec :: Section -> [Section]
findAllSec s :: Section
s@(Section Sentence
_ [SecCons]
cs Reference
_) = Section
s Section -> [Section] -> [Section]
forall a. a -> [a] -> [a]
: (SecCons -> [Section]) -> [SecCons] -> [Section]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SecCons -> [Section]
findAllSubSec [SecCons]
cs
    findAllSubSec :: SecCons -> [Section]
    findAllSubSec :: SecCons -> [Section]
findAllSubSec (Sub Section
s) = Section -> [Section]
findAllSec Section
s
    findAllSubSec SecCons
_ = []
    findAllLC :: Section -> [LabelledContent]
    findAllLC :: Section -> [LabelledContent]
findAllLC (Section Sentence
_ [SecCons]
cs Reference
_) = (SecCons -> [LabelledContent]) -> [SecCons] -> [LabelledContent]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SecCons -> [LabelledContent]
findLCSecCons [SecCons]
cs
    findLCSecCons :: SecCons -> [LabelledContent]
    findLCSecCons :: SecCons -> [LabelledContent]
findLCSecCons (Sub Section
s) = Section -> [LabelledContent]
findAllLC Section
s
    findLCSecCons (Con (LlC LabelledContent
lblcons)) = [LabelledContent
lblcons]
    findLCSecCons SecCons
_ = []

-- | Takes in existing information from the Chunk database to construct a database of references.
fillReferences :: SRSDecl -> SystemInformation -> SystemInformation
fillReferences :: SRSDecl -> SystemInformation -> SystemInformation
fillReferences SRSDecl
dd si :: SystemInformation
si@SI{_sys :: ()
_sys = a
sys} = SystemInformation
si2
  where
    -- get old chunk database + ref database
    chkdb :: ChunkDB
chkdb = SystemInformation
si SystemInformation
-> Getting ChunkDB SystemInformation ChunkDB -> ChunkDB
forall s a. s -> Getting a s a -> a
^. Getting ChunkDB SystemInformation ChunkDB
forall c. HasSystemInformation c => Lens' c ChunkDB
Lens' SystemInformation ChunkDB
sysinfodb
    rfdb :: ReferenceDB
rfdb = SystemInformation -> ReferenceDB
refdb SystemInformation
si
    -- convert SRSDecl into a list of sections (to easily get at all the references used in the SRS)
    allSections :: [Section]
allSections = SystemInformation -> [DocSection] -> [Section]
mkSections SystemInformation
si ([DocSection] -> [Section]) -> [DocSection] -> [Section]
forall a b. (a -> b) -> a -> b
$ SystemInformation -> SRSDecl -> [DocSection]
mkDocDesc SystemInformation
si SRSDecl
dd
    -- get refs from SRSDecl. Should include all section labels and labelled content.
    refsFromSRS :: [Reference]
refsFromSRS = (Section -> [Reference]) -> [Section] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Section -> [Reference]
findAllRefs [Section]
allSections
    -- get refs from the stuff already inside the chunk database
    inRefs :: [Reference]
inRefs  = (DataDefinition -> [Reference]) -> [DataDefinition] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap DataDefinition -> [Reference]
forall a. HasDecRef a => a -> [Reference]
dRefToRef [DataDefinition]
ddefs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> [Reference]) -> [GenDefn] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap GenDefn -> [Reference]
forall a. HasDecRef a => a -> [Reference]
dRefToRef [GenDefn]
gdefs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++
                (InstanceModel -> [Reference]) -> [InstanceModel] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap InstanceModel -> [Reference]
forall a. HasDecRef a => a -> [Reference]
dRefToRef [InstanceModel]
imods [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (TheoryModel -> [Reference]) -> [TheoryModel] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap TheoryModel -> [Reference]
forall a. HasDecRef a => a -> [Reference]
dRefToRef [TheoryModel]
tmods
    ddefs :: [DataDefinition]
ddefs   = ((UID, (DataDefinition, Int)) -> DataDefinition)
-> [(UID, (DataDefinition, Int))] -> [DataDefinition]
forall a b. (a -> b) -> [a] -> [b]
map ((DataDefinition, Int) -> DataDefinition
forall a b. (a, b) -> a
fst((DataDefinition, Int) -> DataDefinition)
-> ((UID, (DataDefinition, Int)) -> (DataDefinition, Int))
-> (UID, (DataDefinition, Int))
-> DataDefinition
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (DataDefinition, Int)) -> (DataDefinition, Int)
forall a b. (a, b) -> b
snd) ([(UID, (DataDefinition, Int))] -> [DataDefinition])
-> [(UID, (DataDefinition, Int))] -> [DataDefinition]
forall a b. (a -> b) -> a -> b
$ Map UID (DataDefinition, Int) -> [(UID, (DataDefinition, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (DataDefinition, Int) -> [(UID, (DataDefinition, Int))])
-> Map UID (DataDefinition, Int) -> [(UID, (DataDefinition, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (DataDefinition, Int))
     ChunkDB
     (Map UID (DataDefinition, Int))
-> Map UID (DataDefinition, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (DataDefinition, Int))
  ChunkDB
  (Map UID (DataDefinition, Int))
Lens' ChunkDB (Map UID (DataDefinition, Int))
dataDefnTable
    gdefs :: [GenDefn]
gdefs   = ((UID, (GenDefn, Int)) -> GenDefn)
-> [(UID, (GenDefn, Int))] -> [GenDefn]
forall a b. (a -> b) -> [a] -> [b]
map ((GenDefn, Int) -> GenDefn
forall a b. (a, b) -> a
fst((GenDefn, Int) -> GenDefn)
-> ((UID, (GenDefn, Int)) -> (GenDefn, Int))
-> (UID, (GenDefn, Int))
-> GenDefn
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (GenDefn, Int)) -> (GenDefn, Int)
forall a b. (a, b) -> b
snd) ([(UID, (GenDefn, Int))] -> [GenDefn])
-> [(UID, (GenDefn, Int))] -> [GenDefn]
forall a b. (a -> b) -> a -> b
$ Map UID (GenDefn, Int) -> [(UID, (GenDefn, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (GenDefn, Int) -> [(UID, (GenDefn, Int))])
-> Map UID (GenDefn, Int) -> [(UID, (GenDefn, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (GenDefn, Int)) ChunkDB (Map UID (GenDefn, Int))
-> Map UID (GenDefn, Int)
forall s a. s -> Getting a s a -> a
^. Getting (Map UID (GenDefn, Int)) ChunkDB (Map UID (GenDefn, Int))
Lens' ChunkDB (Map UID (GenDefn, Int))
gendefTable
    imods :: [InstanceModel]
imods   = ((UID, (InstanceModel, Int)) -> InstanceModel)
-> [(UID, (InstanceModel, Int))] -> [InstanceModel]
forall a b. (a -> b) -> [a] -> [b]
map ((InstanceModel, Int) -> InstanceModel
forall a b. (a, b) -> a
fst((InstanceModel, Int) -> InstanceModel)
-> ((UID, (InstanceModel, Int)) -> (InstanceModel, Int))
-> (UID, (InstanceModel, Int))
-> InstanceModel
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (InstanceModel, Int)) -> (InstanceModel, Int)
forall a b. (a, b) -> b
snd) ([(UID, (InstanceModel, Int))] -> [InstanceModel])
-> [(UID, (InstanceModel, Int))] -> [InstanceModel]
forall a b. (a -> b) -> a -> b
$ Map UID (InstanceModel, Int) -> [(UID, (InstanceModel, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (InstanceModel, Int) -> [(UID, (InstanceModel, Int))])
-> Map UID (InstanceModel, Int) -> [(UID, (InstanceModel, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (InstanceModel, Int))
     ChunkDB
     (Map UID (InstanceModel, Int))
-> Map UID (InstanceModel, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (InstanceModel, Int))
  ChunkDB
  (Map UID (InstanceModel, Int))
Lens' ChunkDB (Map UID (InstanceModel, Int))
insmodelTable
    tmods :: [TheoryModel]
tmods   = ((UID, (TheoryModel, Int)) -> TheoryModel)
-> [(UID, (TheoryModel, Int))] -> [TheoryModel]
forall a b. (a -> b) -> [a] -> [b]
map ((TheoryModel, Int) -> TheoryModel
forall a b. (a, b) -> a
fst((TheoryModel, Int) -> TheoryModel)
-> ((UID, (TheoryModel, Int)) -> (TheoryModel, Int))
-> (UID, (TheoryModel, Int))
-> TheoryModel
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (TheoryModel, Int)) -> (TheoryModel, Int)
forall a b. (a, b) -> b
snd) ([(UID, (TheoryModel, Int))] -> [TheoryModel])
-> [(UID, (TheoryModel, Int))] -> [TheoryModel]
forall a b. (a -> b) -> a -> b
$ Map UID (TheoryModel, Int) -> [(UID, (TheoryModel, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (TheoryModel, Int) -> [(UID, (TheoryModel, Int))])
-> Map UID (TheoryModel, Int) -> [(UID, (TheoryModel, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (TheoryModel, Int)) ChunkDB (Map UID (TheoryModel, Int))
-> Map UID (TheoryModel, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (TheoryModel, Int)) ChunkDB (Map UID (TheoryModel, Int))
Lens' ChunkDB (Map UID (TheoryModel, Int))
theoryModelTable
    concIns :: [ConceptInstance]
concIns = ((UID, (ConceptInstance, Int)) -> ConceptInstance)
-> [(UID, (ConceptInstance, Int))] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map ((ConceptInstance, Int) -> ConceptInstance
forall a b. (a, b) -> a
fst((ConceptInstance, Int) -> ConceptInstance)
-> ((UID, (ConceptInstance, Int)) -> (ConceptInstance, Int))
-> (UID, (ConceptInstance, Int))
-> ConceptInstance
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (ConceptInstance, Int)) -> (ConceptInstance, Int)
forall a b. (a, b) -> b
snd) ([(UID, (ConceptInstance, Int))] -> [ConceptInstance])
-> [(UID, (ConceptInstance, Int))] -> [ConceptInstance]
forall a b. (a -> b) -> a -> b
$ Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))])
-> Map UID (ConceptInstance, Int)
-> [(UID, (ConceptInstance, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (ConceptInstance, Int))
     ChunkDB
     (Map UID (ConceptInstance, Int))
-> Map UID (ConceptInstance, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (ConceptInstance, Int))
  ChunkDB
  (Map UID (ConceptInstance, Int))
Lens' ChunkDB (Map UID (ConceptInstance, Int))
conceptinsTable
    secs :: [Section]
secs    = ((UID, (Section, Int)) -> Section)
-> [(UID, (Section, Int))] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map ((Section, Int) -> Section
forall a b. (a, b) -> a
fst((Section, Int) -> Section)
-> ((UID, (Section, Int)) -> (Section, Int))
-> (UID, (Section, Int))
-> Section
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (Section, Int)) -> (Section, Int)
forall a b. (a, b) -> b
snd) ([(UID, (Section, Int))] -> [Section])
-> [(UID, (Section, Int))] -> [Section]
forall a b. (a -> b) -> a -> b
$ Map UID (Section, Int) -> [(UID, (Section, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (Section, Int) -> [(UID, (Section, Int))])
-> Map UID (Section, Int) -> [(UID, (Section, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (Section, Int)) ChunkDB (Map UID (Section, Int))
-> Map UID (Section, Int)
forall s a. s -> Getting a s a -> a
^. Getting (Map UID (Section, Int)) ChunkDB (Map UID (Section, Int))
Lens' ChunkDB (Map UID (Section, Int))
sectionTable
    lblCon :: [LabelledContent]
lblCon  = ((UID, (LabelledContent, Int)) -> LabelledContent)
-> [(UID, (LabelledContent, Int))] -> [LabelledContent]
forall a b. (a -> b) -> [a] -> [b]
map ((LabelledContent, Int) -> LabelledContent
forall a b. (a, b) -> a
fst((LabelledContent, Int) -> LabelledContent)
-> ((UID, (LabelledContent, Int)) -> (LabelledContent, Int))
-> (UID, (LabelledContent, Int))
-> LabelledContent
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (LabelledContent, Int)) -> (LabelledContent, Int)
forall a b. (a, b) -> b
snd) ([(UID, (LabelledContent, Int))] -> [LabelledContent])
-> [(UID, (LabelledContent, Int))] -> [LabelledContent]
forall a b. (a -> b) -> a -> b
$ Map UID (LabelledContent, Int) -> [(UID, (LabelledContent, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (LabelledContent, Int) -> [(UID, (LabelledContent, Int))])
-> Map UID (LabelledContent, Int)
-> [(UID, (LabelledContent, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (LabelledContent, Int))
     ChunkDB
     (Map UID (LabelledContent, Int))
-> Map UID (LabelledContent, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (LabelledContent, Int))
  ChunkDB
  (Map UID (LabelledContent, Int))
Lens' ChunkDB (Map UID (LabelledContent, Int))
labelledcontentTable
    cites :: BibRef
cites   = SystemInformation -> BibRef
citeDB SystemInformation
si -- map (fst.snd) $ Map.assocs $ rfdb  ^. citationDB
    conins :: [ConceptInstance]
conins  = ((UID, (ConceptInstance, Int)) -> ConceptInstance)
-> [(UID, (ConceptInstance, Int))] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map ((ConceptInstance, Int) -> ConceptInstance
forall a b. (a, b) -> a
fst((ConceptInstance, Int) -> ConceptInstance)
-> ((UID, (ConceptInstance, Int)) -> (ConceptInstance, Int))
-> (UID, (ConceptInstance, Int))
-> ConceptInstance
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (ConceptInstance, Int)) -> (ConceptInstance, Int)
forall a b. (a, b) -> b
snd) ([(UID, (ConceptInstance, Int))] -> [ConceptInstance])
-> [(UID, (ConceptInstance, Int))] -> [ConceptInstance]
forall a b. (a -> b) -> a -> b
$ Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))])
-> Map UID (ConceptInstance, Int)
-> [(UID, (ConceptInstance, Int))]
forall a b. (a -> b) -> a -> b
$ ReferenceDB
rfdb  ReferenceDB
-> Getting
     (Map UID (ConceptInstance, Int))
     ReferenceDB
     (Map UID (ConceptInstance, Int))
-> Map UID (ConceptInstance, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (ConceptInstance, Int))
  ReferenceDB
  (Map UID (ConceptInstance, Int))
Lens' ReferenceDB (Map UID (ConceptInstance, Int))
conceptDB
    -- search the old reference table just in case the user wants to manually add in some references
    refs :: [Reference]
refs    = ((UID, (Reference, Int)) -> Reference)
-> [(UID, (Reference, Int))] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map ((Reference, Int) -> Reference
forall a b. (a, b) -> a
fst((Reference, Int) -> Reference)
-> ((UID, (Reference, Int)) -> (Reference, Int))
-> (UID, (Reference, Int))
-> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(UID, (Reference, Int)) -> (Reference, Int)
forall a b. (a, b) -> b
snd) ([(UID, (Reference, Int))] -> [Reference])
-> [(UID, (Reference, Int))] -> [Reference]
forall a b. (a -> b) -> a -> b
$ Map UID (Reference, Int) -> [(UID, (Reference, Int))]
forall k a. Map k a -> [(k, a)]
Map.assocs (Map UID (Reference, Int) -> [(UID, (Reference, Int))])
-> Map UID (Reference, Int) -> [(UID, (Reference, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
chkdb ChunkDB
-> Getting
     (Map UID (Reference, Int)) ChunkDB (Map UID (Reference, Int))
-> Map UID (Reference, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (Reference, Int)) ChunkDB (Map UID (Reference, Int))
Lens' ChunkDB (Map UID (Reference, Int))
refTable
    -- set new reference table in the chunk database
    chkdb2 :: ChunkDB
chkdb2 = ASetter
  ChunkDB
  ChunkDB
  (Map UID (Reference, Int))
  (Map UID (Reference, Int))
-> Map UID (Reference, Int) -> ChunkDB -> ChunkDB
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter
  ChunkDB
  ChunkDB
  (Map UID (Reference, Int))
  (Map UID (Reference, Int))
Lens' ChunkDB (Map UID (Reference, Int))
refTable ([Reference] -> Map UID (Reference, Int)
forall a. HasUID a => [a] -> Map UID (a, Int)
idMap ([Reference] -> Map UID (Reference, Int))
-> [Reference] -> Map UID (Reference, Int)
forall a b. (a -> b) -> a -> b
$ [Reference] -> [Reference]
forall a. Eq a => [a] -> [a]
nub ([Reference] -> [Reference]) -> [Reference] -> [Reference]
forall a b. (a -> b) -> a -> b
$ [Reference]
refsFromSRS [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ [Reference]
inRefs
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (TraceConfig -> Reference) -> [TraceConfig] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map (Reference -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref(Reference -> Reference)
-> (TraceConfig -> Reference) -> TraceConfig -> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
.UID -> Reference
makeTabRef'(UID -> Reference)
-> (TraceConfig -> UID) -> TraceConfig -> Reference
forall b c a. (b -> c) -> (a -> b) -> a -> c
.TraceConfig -> UID
getTraceConfigUID) (SystemInformation -> [TraceConfig]
traceMatStandard SystemInformation
si) [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ [Reference]
secRefs -- secRefs can be removed once #946 is complete
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ String -> [Reference]
traceyGraphGetRefs (a -> String
forall c. CommonIdea c => c -> String
programName a
sys) [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (Citation -> Reference) -> BibRef -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map Citation -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref BibRef
cites
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (ConceptInstance -> Reference) -> [ConceptInstance] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map ConceptInstance -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [ConceptInstance]
conins [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (DataDefinition -> Reference) -> [DataDefinition] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map DataDefinition -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [DataDefinition]
ddefs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> Reference) -> [GenDefn] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map GenDefn -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [GenDefn]
gdefs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (InstanceModel -> Reference) -> [InstanceModel] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map InstanceModel -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [InstanceModel]
imods
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (TheoryModel -> Reference) -> [TheoryModel] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map TheoryModel -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [TheoryModel]
tmods [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (ConceptInstance -> Reference) -> [ConceptInstance] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map ConceptInstance -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [ConceptInstance]
concIns [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (Section -> Reference) -> [Section] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map Section -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [Section]
secs [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ (LabelledContent -> Reference) -> [LabelledContent] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref [LabelledContent]
lblCon
      [Reference] -> [Reference] -> [Reference]
forall a. [a] -> [a] -> [a]
++ [Reference]
refs) ChunkDB
chkdb
    -- set new chunk database into system information
    si2 :: SystemInformation
si2 = ASetter SystemInformation SystemInformation ChunkDB ChunkDB
-> ChunkDB -> SystemInformation -> SystemInformation
forall s t a b. ASetter s t a b -> b -> s -> t
set ASetter SystemInformation SystemInformation ChunkDB ChunkDB
forall c. HasSystemInformation c => Lens' c ChunkDB
Lens' SystemInformation ChunkDB
sysinfodb ChunkDB
chkdb2 SystemInformation
si

-- | Helper that gets references from definitions and models.
dRefToRef :: HasDecRef a => a -> [Reference]
dRefToRef :: forall a. HasDecRef a => a -> [Reference]
dRefToRef a
r = (DecRef -> Reference) -> [DecRef] -> [Reference]
forall a b. (a -> b) -> [a] -> [b]
map DecRef -> Reference
forall r.
(HasUID r, HasRefAddress r, HasShortName r) =>
r -> Reference
ref ([DecRef] -> [Reference]) -> [DecRef] -> [Reference]
forall a b. (a -> b) -> a -> b
$ a
r a -> Getting [DecRef] a [DecRef] -> [DecRef]
forall s a. s -> Getting a s a -> a
^. Getting [DecRef] a [DecRef]
forall c. HasDecRef c => Lens' c [DecRef]
Lens' a [DecRef]
getDecRefs

-- | Recursively find all references in a section (meant for getting at 'LabelledContent').
findAllRefs :: Section -> [Reference]
findAllRefs :: Section -> [Reference]
findAllRefs (Section Sentence
_ [SecCons]
cs Reference
r) = Reference
rReference -> [Reference] -> [Reference]
forall a. a -> [a] -> [a]
: (SecCons -> [Reference]) -> [SecCons] -> [Reference]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap SecCons -> [Reference]
findRefSecCons [SecCons]
cs
  where
    findRefSecCons :: SecCons -> [Reference]
    findRefSecCons :: SecCons -> [Reference]
findRefSecCons (Sub Section
s) = Section -> [Reference]
findAllRefs Section
s
    findRefSecCons (Con (LlC (LblC Reference
rf RawContent
_))) = [Reference
rf]
    findRefSecCons SecCons
_ = []

-- | Helper for filling in the traceability matrix and graph information into the system.
fillTraceSI :: SRSDecl -> SystemInformation -> SystemInformation
fillTraceSI :: SRSDecl -> SystemInformation -> SystemInformation
fillTraceSI SRSDecl
dd SystemInformation
si = [DocSection] -> SystemInformation -> SystemInformation
fillTraceMaps [DocSection]
l (SystemInformation -> SystemInformation)
-> SystemInformation -> SystemInformation
forall a b. (a -> b) -> a -> b
$ [DocSection] -> SystemInformation -> SystemInformation
fillReqs [DocSection]
l SystemInformation
si
  where
    l :: [DocSection]
l = SystemInformation -> SRSDecl -> [DocSection]
mkDocDesc SystemInformation
si SRSDecl
dd

-- | Fills in the traceabiliy matrix and graphs section of the system information using the document description.
fillTraceMaps :: DocDesc -> SystemInformation -> SystemInformation
fillTraceMaps :: [DocSection] -> SystemInformation -> SystemInformation
fillTraceMaps [DocSection]
dd si :: SystemInformation
si@SI{_sysinfodb :: SystemInformation -> ChunkDB
_sysinfodb = ChunkDB
db} = SystemInformation
si {_sysinfodb =
  set refbyTable (generateRefbyMap tdb) $ set traceTable tdb db} where
  tdb :: Map UID [UID]
tdb = [DocSection] -> Map UID [UID]
generateTraceMap [DocSection]
dd

-- | Fills in the requirements section of the system information using the document description.
fillReqs :: DocDesc -> SystemInformation -> SystemInformation
fillReqs :: [DocSection] -> SystemInformation -> SystemInformation
fillReqs [] SystemInformation
si = SystemInformation
si
fillReqs (ReqrmntSec (ReqsProg [ReqsSub]
x):[DocSection]
_) si :: SystemInformation
si@SI{_sysinfodb :: SystemInformation -> ChunkDB
_sysinfodb = ChunkDB
db} = [ReqsSub] -> SystemInformation
genReqs [ReqsSub]
x
  where
    genReqs :: [ReqsSub] -> SystemInformation
genReqs [] = SystemInformation
si
    genReqs (FReqsSub [ConceptInstance]
c [LabelledContent]
_:[ReqsSub]
_) = SystemInformation
si {_sysinfodb = set conceptinsTable newCI db} where
        newCI :: Map UID (ConceptInstance, Int)
newCI = [ConceptInstance] -> Map UID (ConceptInstance, Int)
forall a. HasUID a => [a] -> Map UID (a, Int)
idMap ([ConceptInstance] -> Map UID (ConceptInstance, Int))
-> [ConceptInstance] -> Map UID (ConceptInstance, Int)
forall a b. (a -> b) -> a -> b
$ [ConceptInstance] -> [ConceptInstance]
forall a. Eq a => [a] -> [a]
nub ([ConceptInstance] -> [ConceptInstance])
-> [ConceptInstance] -> [ConceptInstance]
forall a b. (a -> b) -> a -> b
$ [ConceptInstance]
c [ConceptInstance] -> [ConceptInstance] -> [ConceptInstance]
forall a. [a] -> [a] -> [a]
++ ((ConceptInstance, Int) -> ConceptInstance)
-> [(ConceptInstance, Int)] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map (ConceptInstance, Int) -> ConceptInstance
forall a b. (a, b) -> a
fst (((ConceptInstance, Int) -> Int)
-> [(ConceptInstance, Int)] -> [(ConceptInstance, Int)]
forall b a. Ord b => (a -> b) -> [a] -> [a]
sortOn (ConceptInstance, Int) -> Int
forall a b. (a, b) -> b
snd ([(ConceptInstance, Int)] -> [(ConceptInstance, Int)])
-> [(ConceptInstance, Int)] -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> a -> b
$ ((UID, (ConceptInstance, Int)) -> (ConceptInstance, Int))
-> [(UID, (ConceptInstance, Int))] -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> [a] -> [b]
map (UID, (ConceptInstance, Int)) -> (ConceptInstance, Int)
forall a b. (a, b) -> b
snd ([(UID, (ConceptInstance, Int))] -> [(ConceptInstance, Int)])
-> [(UID, (ConceptInstance, Int))] -> [(ConceptInstance, Int)]
forall a b. (a -> b) -> a -> b
$ Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))]
forall k a. Map k a -> [(k, a)]
Map.toList (Map UID (ConceptInstance, Int) -> [(UID, (ConceptInstance, Int))])
-> Map UID (ConceptInstance, Int)
-> [(UID, (ConceptInstance, Int))]
forall a b. (a -> b) -> a -> b
$ ChunkDB
db ChunkDB
-> Getting
     (Map UID (ConceptInstance, Int))
     ChunkDB
     (Map UID (ConceptInstance, Int))
-> Map UID (ConceptInstance, Int)
forall s a. s -> Getting a s a -> a
^. Getting
  (Map UID (ConceptInstance, Int))
  ChunkDB
  (Map UID (ConceptInstance, Int))
Lens' ChunkDB (Map UID (ConceptInstance, Int))
conceptinsTable)
    genReqs (ReqsSub
_:[ReqsSub]
xs) = [ReqsSub] -> SystemInformation
genReqs [ReqsSub]
xs
fillReqs (DocSection
_:[DocSection]
xs) SystemInformation
si = [DocSection] -> SystemInformation -> SystemInformation
fillReqs [DocSection]
xs SystemInformation
si

-- | Constructs the unit definitions ('UnitDefn's) found in the document description ('DocDesc') from a database ('ChunkDB').
extractUnits :: DocDesc -> ChunkDB -> [UnitDefn]
extractUnits :: [DocSection] -> ChunkDB -> [UnitDefn]
extractUnits [DocSection]
dd ChunkDB
cdb = ChunkDB -> [QuantityDict] -> [UnitDefn]
forall c. Quantity c => ChunkDB -> [c] -> [UnitDefn]
collectUnits ChunkDB
cdb ([QuantityDict] -> [UnitDefn]) -> [QuantityDict] -> [UnitDefn]
forall a b. (a -> b) -> a -> b
$ [Sentence] -> [ModelExpr] -> ChunkDB -> [QuantityDict]
ccss' ([DocSection] -> [Sentence]
getDocDesc [DocSection]
dd) ([DocSection] -> [ModelExpr]
egetDocDesc [DocSection]
dd) ChunkDB
cdb

-- * Section Creator Functions

-- | Helper for creating the different document sections.
mkSections :: SystemInformation -> DocDesc -> [Section]
mkSections :: SystemInformation -> [DocSection] -> [Section]
mkSections SystemInformation
si [DocSection]
dd = (DocSection -> Section) -> [DocSection] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map DocSection -> Section
doit [DocSection]
dd
  where
    doit :: DocSection -> Section
    doit :: DocSection -> Section
doit DocSection
TableOfContents      = [DocSection] -> Section
mkToC [DocSection]
dd
    doit (RefSec RefSec
rs)          = SystemInformation -> [DocSection] -> RefSec -> Section
mkRefSec SystemInformation
si [DocSection]
dd RefSec
rs
    doit (IntroSec IntroSec
is)        = SystemInformation -> IntroSec -> Section
mkIntroSec SystemInformation
si IntroSec
is
    doit (StkhldrSec StkhldrSec
sts)     = StkhldrSec -> Section
mkStkhldrSec StkhldrSec
sts
    doit (SSDSec SSDSec
ss)          = SystemInformation -> SSDSec -> Section
mkSSDSec SystemInformation
si SSDSec
ss
    doit (AuxConstntSec AuxConstntSec
acs)  = AuxConstntSec -> Section
mkAuxConsSec AuxConstntSec
acs 
    doit DocSection
Bibliography         = BibRef -> Section
mkBib (SystemInformation -> BibRef
citeDB SystemInformation
si)
    doit (GSDSec GSDSec
gs')         = GSDSec -> Section
mkGSDSec GSDSec
gs'
    doit (ReqrmntSec ReqrmntSec
r)       = ReqrmntSec -> Section
mkReqrmntSec ReqrmntSec
r
    doit (LCsSec LCsSec
lc)          = LCsSec -> Section
mkLCsSec LCsSec
lc
    doit (UCsSec UCsSec
ulcs)        = UCsSec -> Section
mkUCsSec UCsSec
ulcs
    doit (TraceabilitySec TraceabilitySec
t)  = TraceabilitySec -> SystemInformation -> Section
mkTraceabilitySec TraceabilitySec
t SystemInformation
si
    doit (AppndxSec AppndxSec
a)        = AppndxSec -> Section
mkAppndxSec AppndxSec
a
    doit (OffShelfSolnsSec OffShelfSolnsSec
o) = OffShelfSolnsSec -> Section
mkOffShelfSolnSec OffShelfSolnsSec
o

-- ** Table of Contents

-- | Helper for making the Table of Contents section.
mkToC :: DocDesc -> Section
mkToC :: [DocSection] -> Section
mkToC [DocSection]
dd = [Contents] -> [Section] -> Section
SRS.tOfCont [Contents
intro, UnlabelledContent -> Contents
UlC (UnlabelledContent -> Contents) -> UnlabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ RawContent -> UnlabelledContent
ulcc (RawContent -> UnlabelledContent)
-> RawContent -> UnlabelledContent
forall a b. (a -> b) -> a -> b
$ ListType -> RawContent
Enumeration (ListType -> RawContent) -> ListType -> RawContent
forall a b. (a -> b) -> a -> b
$ [(ItemType, Maybe String)] -> ListType
Bullet ([(ItemType, Maybe String)] -> ListType)
-> [(ItemType, Maybe String)] -> ListType
forall a b. (a -> b) -> a -> b
$ (DocSection -> (ItemType, Maybe String))
-> [DocSection] -> [(ItemType, Maybe String)]
forall a b. (a -> b) -> [a] -> [b]
map ((, Maybe String
forall a. Maybe a
Nothing) (ItemType -> (ItemType, Maybe String))
-> (DocSection -> ItemType)
-> DocSection
-> (ItemType, Maybe String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DocSection -> ItemType
toToC) [DocSection]
dd] []
  where
    intro :: Contents
intro = Sentence -> Contents
mkParagraph (Sentence -> Contents) -> Sentence -> Contents
forall a b. (a -> b) -> a -> b
$ String -> Sentence
S String
"An outline of all sections included in this SRS is recorded here for easy reference."

-- ** Reference Materials

-- | Helper for creating the reference section and subsections.
-- Includes Table of Symbols, Units and Abbreviations and Acronyms.
mkRefSec :: SystemInformation -> DocDesc -> RefSec -> Section
mkRefSec :: SystemInformation -> [DocSection] -> RefSec -> Section
mkRefSec SystemInformation
si [DocSection]
dd (RefProg Contents
c [RefTab]
l) = [Contents] -> [Section] -> Section
SRS.refMat [Contents
c] ((RefTab -> Section) -> [RefTab] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (SystemInformation -> RefTab -> Section
mkSubRef SystemInformation
si) [RefTab]
l)
  where
    mkSubRef :: SystemInformation -> RefTab -> Section
    mkSubRef :: SystemInformation -> RefTab -> Section
mkSubRef SystemInformation
si' RefTab
TUnits = SystemInformation -> RefTab -> Section
mkSubRef SystemInformation
si' (RefTab -> Section) -> RefTab -> Section
forall a b. (a -> b) -> a -> b
$ [TUIntro] -> ([UnitDefn] -> LabelledContent) -> RefTab
TUnits' [TUIntro]
defaultTUI [UnitDefn] -> LabelledContent
forall s. IsUnit s => [s] -> LabelledContent
tOfUnitSIName
    mkSubRef SI {_sysinfodb :: SystemInformation -> ChunkDB
_sysinfodb = ChunkDB
db} (TUnits' [TUIntro]
con [UnitDefn] -> LabelledContent
f) =
        [Contents] -> [Section] -> Section
SRS.tOfUnit [[TUIntro] -> Contents
tuIntro [TUIntro]
con, LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ [UnitDefn] -> LabelledContent
f ([UnitDefn] -> [UnitDefn]
forall a. Eq a => [a] -> [a]
nub ([UnitDefn] -> [UnitDefn]) -> [UnitDefn] -> [UnitDefn]
forall a b. (a -> b) -> a -> b
$ (UnitDefn -> UnitDefn -> Ordering) -> [UnitDefn] -> [UnitDefn]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy UnitDefn -> UnitDefn -> Ordering
compUnitDefn ([UnitDefn] -> [UnitDefn]) -> [UnitDefn] -> [UnitDefn]
forall a b. (a -> b) -> a -> b
$ [DocSection] -> ChunkDB -> [UnitDefn]
extractUnits [DocSection]
dd ChunkDB
db)] []
    -- FIXME: _quants = v should be removed from this binding and symbols should
    -- be acquired solely through document traversal, however #1658. If we do
    -- just the doc traversal here, then we lose some symbols which only appear
    -- in a table in GlassBR. If we grab symbols from tables (by removing the `isVar`)
    -- in ExtractDocDesc, then the passes which extract `DefinedQuantityDict`s will
    -- error out because some of the symbols in tables are only `QuantityDict`s, and thus
    -- missing a `Concept`.
    mkSubRef SI {_quants :: ()
_quants = [e]
v, _sysinfodb :: SystemInformation -> ChunkDB
_sysinfodb = ChunkDB
cdb} (TSymb [TSIntro]
con) =
      [Contents] -> [Section] -> Section
SRS.tOfSymb 
      [[TSIntro] -> Contents
tsIntro [TSIntro]
con,
                LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ Stage
-> [QuantityDict] -> (QuantityDict -> Sentence) -> LabelledContent
forall s.
(Quantity s, MayHaveUnit s) =>
Stage -> [s] -> (s -> Sentence) -> LabelledContent
table Stage
Equational ([QuantityDict] -> [QuantityDict]
forall a. HasSymbol a => [a] -> [a]
sortBySymbol
                ([QuantityDict] -> [QuantityDict])
-> [QuantityDict] -> [QuantityDict]
forall a b. (a -> b) -> a -> b
$ (QuantityDict -> Bool) -> [QuantityDict] -> [QuantityDict]
forall a. (a -> Bool) -> [a] -> [a]
filter (QuantityDict -> Stage -> Bool
forall q. HasSymbol q => q -> Stage -> Bool
`hasStageSymbol` Stage
Equational) 
                ([QuantityDict] -> [QuantityDict]
forall a. Eq a => [a] -> [a]
nub ([QuantityDict] -> [QuantityDict])
-> [QuantityDict] -> [QuantityDict]
forall a b. (a -> b) -> a -> b
$ (e -> QuantityDict) -> [e] -> [QuantityDict]
forall a b. (a -> b) -> [a] -> [b]
map e -> QuantityDict
forall q. (Quantity q, MayHaveUnit q) => q -> QuantityDict
qw [e]
v [QuantityDict] -> [QuantityDict] -> [QuantityDict]
forall a. [a] -> [a] -> [a]
++ [Sentence] -> [ModelExpr] -> ChunkDB -> [QuantityDict]
ccss' ([DocSection] -> [Sentence]
getDocDesc [DocSection]
dd) ([DocSection] -> [ModelExpr]
egetDocDesc [DocSection]
dd) ChunkDB
cdb))
                QuantityDict -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart] []
    mkSubRef SI {_sysinfodb :: SystemInformation -> ChunkDB
_sysinfodb = ChunkDB
cdb} (TSymb' LFunc
f [TSIntro]
con) =
      [DefinedQuantityDict] -> LFunc -> [TSIntro] -> Section
forall e.
(Quantity e, Concept e, Eq e, MayHaveUnit e) =>
[e] -> LFunc -> [TSIntro] -> Section
mkTSymb ([Sentence] -> [ModelExpr] -> ChunkDB -> [DefinedQuantityDict]
ccss ([DocSection] -> [Sentence]
getDocDesc [DocSection]
dd) ([DocSection] -> [ModelExpr]
egetDocDesc [DocSection]
dd) ChunkDB
cdb) LFunc
f [TSIntro]
con
    mkSubRef SI {_usedinfodb :: SystemInformation -> ChunkDB
_usedinfodb = ChunkDB
db} RefTab
TAandA =
      [Contents] -> [Section] -> Section
SRS.tOfAbbAcc [LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ [IdeaDict] -> LabelledContent
forall s. Idea s => [s] -> LabelledContent
tableAbbAccGen ([IdeaDict] -> LabelledContent) -> [IdeaDict] -> LabelledContent
forall a b. (a -> b) -> a -> b
$ [IdeaDict] -> [IdeaDict]
forall a. Eq a => [a] -> [a]
nub ([IdeaDict] -> [IdeaDict]) -> [IdeaDict] -> [IdeaDict]
forall a b. (a -> b) -> a -> b
$ ((IdeaDict, Int) -> IdeaDict) -> [(IdeaDict, Int)] -> [IdeaDict]
forall a b. (a -> b) -> [a] -> [b]
map (IdeaDict, Int) -> IdeaDict
forall a b. (a, b) -> a
fst ([(IdeaDict, Int)] -> [IdeaDict])
-> [(IdeaDict, Int)] -> [IdeaDict]
forall a b. (a -> b) -> a -> b
$ Map UID (IdeaDict, Int) -> [(IdeaDict, Int)]
forall k a. Map k a -> [a]
Map.elems (Map UID (IdeaDict, Int) -> [(IdeaDict, Int)])
-> Map UID (IdeaDict, Int) -> [(IdeaDict, Int)]
forall a b. (a -> b) -> a -> b
$ ChunkDB -> Map UID (IdeaDict, Int)
termTable ChunkDB
db] []

-- | Helper for creating the table of symbols.
mkTSymb :: (Quantity e, Concept e, Eq e, MayHaveUnit e) =>
  [e] -> LFunc -> [TSIntro] -> Section
mkTSymb :: forall e.
(Quantity e, Concept e, Eq e, MayHaveUnit e) =>
[e] -> LFunc -> [TSIntro] -> Section
mkTSymb [e]
v LFunc
f [TSIntro]
c = [Contents] -> [Section] -> Section
SRS.tOfSymb [[TSIntro] -> Contents
tsIntro [TSIntro]
c,
  LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ Stage -> [e] -> (e -> Sentence) -> LabelledContent
forall s.
(Quantity s, MayHaveUnit s) =>
Stage -> [s] -> (s -> Sentence) -> LabelledContent
table Stage
Equational
    ((e -> e -> Ordering) -> [e] -> [e]
forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (Symbol -> Symbol -> Ordering
compsy (Symbol -> Symbol -> Ordering)
-> (e -> Symbol) -> e -> e -> Ordering
forall b c a. (b -> b -> c) -> (a -> b) -> a -> a -> c
`on` e -> Symbol
forall q. HasSymbol q => q -> Symbol
eqSymb) ([e] -> [e]) -> [e] -> [e]
forall a b. (a -> b) -> a -> b
$ (e -> Bool) -> [e] -> [e]
forall a. (a -> Bool) -> [a] -> [a]
filter (e -> Stage -> Bool
forall q. HasSymbol q => q -> Stage -> Bool
`hasStageSymbol` Stage
Equational) ([e] -> [e]
forall a. Eq a => [a] -> [a]
nub [e]
v))
    (LFunc -> e -> Sentence
forall {n}. (NamedIdea n, Definition n) => LFunc -> n -> Sentence
lf LFunc
f)] 
    []
  where lf :: LFunc -> n -> Sentence
lf LFunc
Term = n -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart
        lf LFunc
Defn = Sentence -> Sentence
capSent (Sentence -> Sentence) -> (n -> Sentence) -> n -> Sentence
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn)
        lf (TermExcept [DefinedQuantityDict]
cs) = \n
x -> if (n
x n -> Getting UID n UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID n UID
forall c. HasUID c => Getter c UID
Getter n UID
uid) UID -> [UID] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (DefinedQuantityDict -> UID) -> [DefinedQuantityDict] -> [UID]
forall a b. (a -> b) -> [a] -> [b]
map (DefinedQuantityDict -> Getting UID DefinedQuantityDict UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID DefinedQuantityDict UID
forall c. HasUID c => Getter c UID
Getter DefinedQuantityDict UID
uid) [DefinedQuantityDict]
cs then
          Sentence -> Sentence
capSent (n
x n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn) else n -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart n
x --Compare chunk uids, since we don't
          --actually care about the chunks themselves in LFunc.
        lf (DefnExcept [DefinedQuantityDict]
cs) = \n
x -> if (n
x n -> Getting UID n UID -> UID
forall s a. s -> Getting a s a -> a
^. Getting UID n UID
forall c. HasUID c => Getter c UID
Getter n UID
uid) UID -> [UID] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (DefinedQuantityDict -> UID) -> [DefinedQuantityDict] -> [UID]
forall a b. (a -> b) -> [a] -> [b]
map (DefinedQuantityDict -> Getting UID DefinedQuantityDict UID -> UID
forall s a. s -> Getting a s a -> a
^.Getting UID DefinedQuantityDict UID
forall c. HasUID c => Getter c UID
Getter DefinedQuantityDict UID
uid) [DefinedQuantityDict]
cs then
          n -> Sentence
forall n. NamedIdea n => n -> Sentence
atStart n
x else Sentence -> Sentence
capSent (n
x n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn)
        lf LFunc
TAD = \n
tDef -> n -> Sentence
forall n. NamedIdea n => n -> Sentence
titleize n
tDef Sentence -> Sentence -> Sentence
+: Sentence
EmptyS Sentence -> Sentence -> Sentence
+:+. Sentence -> Sentence
capSent (n
tDef n -> Getting Sentence n Sentence -> Sentence
forall s a. s -> Getting a s a -> a
^. Getting Sentence n Sentence
forall c. Definition c => Lens' c Sentence
Lens' n Sentence
defn)

-- ** Introduction

-- | Makes the Introduction section into a 'Section'.
mkIntroSec :: SystemInformation -> IntroSec -> Section
mkIntroSec :: SystemInformation -> IntroSec -> Section
mkIntroSec SystemInformation
si (IntroProg Sentence
probIntro Sentence
progDefn [IntroSub]
l) =
  Sentence -> Sentence -> [Section] -> Section
Intro.introductionSection Sentence
probIntro Sentence
progDefn ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (IntroSub -> Section) -> [IntroSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (SystemInformation -> IntroSub -> Section
mkSubIntro SystemInformation
si) [IntroSub]
l
  where
    mkSubIntro :: SystemInformation -> IntroSub -> Section
    mkSubIntro :: SystemInformation -> IntroSub -> Section
mkSubIntro SystemInformation
_ (IPurpose [Sentence]
intro) = [Sentence] -> Section
Intro.purposeOfDoc [Sentence]
intro
    mkSubIntro SystemInformation
_ (IScope Sentence
main) = Sentence -> Section
Intro.scopeOfRequirements Sentence
main
    mkSubIntro SI {_sys :: ()
_sys = a
sys} (IChar [Sentence]
assumed [Sentence]
topic [Sentence]
asset) =
      a -> [Sentence] -> [Sentence] -> [Sentence] -> Section -> Section
forall a.
Idea a =>
a -> [Sentence] -> [Sentence] -> [Sentence] -> Section -> Section
Intro.charIntRdrF a
sys [Sentence]
assumed [Sentence]
topic [Sentence]
asset ([Contents] -> [Section] -> Section
SRS.userChar [] [])
    mkSubIntro SystemInformation
_ (IOrgSec CI
b Section
s Sentence
t) = CI -> Section -> Sentence -> Section
forall c. NamedIdea c => c -> Section -> Sentence -> Section
Intro.orgSec CI
b Section
s Sentence
t
    -- FIXME: s should be "looked up" using "b" once we have all sections being generated

-- ** Stakeholders

-- | Helper for making the Stakeholders section.
mkStkhldrSec :: StkhldrSec -> Section
mkStkhldrSec :: StkhldrSec -> Section
mkStkhldrSec (StkhldrProg [StkhldrSub]
l) = [Contents] -> [Section] -> Section
SRS.stakeholder [Contents
Stk.stakeholderIntro] ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (StkhldrSub -> Section) -> [StkhldrSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map StkhldrSub -> Section
mkSubs [StkhldrSub]
l
  where
    mkSubs :: StkhldrSub -> Section
    mkSubs :: StkhldrSub -> Section
mkSubs (Client CI
kWrd Sentence
details) = CI -> Sentence -> Section
forall a. Idea a => a -> Sentence -> Section
Stk.tClientF CI
kWrd Sentence
details
    mkSubs (Cstmr CI
kWrd)          = CI -> Section
forall a. Idea a => a -> Section
Stk.tCustomerF CI
kWrd

-- ** General System Description

-- | Helper for making the General System Description section.
mkGSDSec :: GSDSec -> Section
mkGSDSec :: GSDSec -> Section
mkGSDSec (GSDProg [GSDSub]
l) = [Contents] -> [Section] -> Section
SRS.genSysDes [Contents
GSD.genSysIntro] ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (GSDSub -> Section) -> [GSDSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map GSDSub -> Section
mkSubs [GSDSub]
l
   where
     mkSubs :: GSDSub -> Section
     mkSubs :: GSDSub -> Section
mkSubs (SysCntxt [Contents]
cs)            = [Contents] -> Section
GSD.sysContxt [Contents]
cs
     mkSubs (UsrChars [Contents]
intro)         = [Contents] -> Section
GSD.usrCharsF [Contents]
intro
     mkSubs (SystCons [Contents]
cntnts [Section]
subsec) = [Contents] -> [Section] -> Section
GSD.systCon [Contents]
cntnts [Section]
subsec

-- ** Specific System Description

-- | Helper for making the Specific System Description section.
mkSSDSec :: SystemInformation -> SSDSec -> Section
mkSSDSec :: SystemInformation -> SSDSec -> Section
mkSSDSec SystemInformation
si (SSDProg [SSDSub]
l) =
  [Section] -> Section
SSD.specSysDescr ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (SSDSub -> Section) -> [SSDSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (SystemInformation -> SSDSub -> Section
mkSubSSD SystemInformation
si) [SSDSub]
l
  where
    mkSubSSD :: SystemInformation -> SSDSub -> Section
    mkSubSSD :: SystemInformation -> SSDSub -> Section
mkSubSSD SystemInformation
sysi (SSDProblem ProblemDescription
pd)    = SystemInformation -> ProblemDescription -> Section
mkSSDProb SystemInformation
sysi ProblemDescription
pd
    mkSubSSD SystemInformation
sysi (SSDSolChSpec SolChSpec
scs) = SystemInformation -> SolChSpec -> Section
mkSolChSpec SystemInformation
sysi SolChSpec
scs

-- | Helper for making the Specific System Description Problem section.
mkSSDProb :: SystemInformation -> ProblemDescription -> Section
mkSSDProb :: SystemInformation -> ProblemDescription -> Section
mkSSDProb SystemInformation
_ (PDProg Sentence
prob [Section]
subSec [PDSub]
subPD) = Sentence -> [Section] -> Section
SSD.probDescF Sentence
prob ([Section]
subSec [Section] -> [Section] -> [Section]
forall a. [a] -> [a] -> [a]
++ (PDSub -> Section) -> [PDSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map PDSub -> Section
mkSubPD [PDSub]
subPD)
  where mkSubPD :: PDSub -> Section
mkSubPD (TermsAndDefs Maybe Sentence
sen [c]
concepts) = Maybe Sentence -> [c] -> Section
forall c. Concept c => Maybe Sentence -> [c] -> Section
SSD.termDefnF Maybe Sentence
sen [c]
concepts
        mkSubPD (PhySysDesc a
prog [Sentence]
parts LabelledContent
dif [Contents]
extra) = a -> [Sentence] -> LabelledContent -> [Contents] -> Section
forall a.
Idea a =>
a -> [Sentence] -> LabelledContent -> [Contents] -> Section
SSD.physSystDesc a
prog [Sentence]
parts LabelledContent
dif [Contents]
extra
        mkSubPD (Goals [Sentence]
ins [ConceptInstance]
g) = [Sentence] -> [Contents] -> Int -> Section
SSD.goalStmtF [Sentence]
ins ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
g) ([ConceptInstance] -> Int
forall a. [a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [ConceptInstance]
g)
                

-- | Helper for making the Solution Characteristics Specification section.
mkSolChSpec :: SystemInformation -> SolChSpec -> Section
mkSolChSpec :: SystemInformation -> SolChSpec -> Section
mkSolChSpec SystemInformation
si (SCSProg [SCSSub]
l) =
  [Contents] -> [Section] -> Section
SRS.solCharSpec [IdeaDict -> Section -> Contents
forall a. Idea a => a -> Section -> Contents
SSD.solutionCharSpecIntro (SystemInformation -> IdeaDict
siSys SystemInformation
si) Section
SSD.imStub] ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$
    (SCSSub -> Section) -> [SCSSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map (SystemInformation -> SCSSub -> Section
mkSubSCS SystemInformation
si) [SCSSub]
l
  where
    mkSubSCS :: SystemInformation -> SCSSub -> Section
    mkSubSCS :: SystemInformation -> SCSSub -> Section
mkSubSCS SystemInformation
si' (TMs [Sentence]
intro Fields
fields [TheoryModel]
ts) =
      IdeaDict -> [Contents] -> Section
forall a. Idea a => a -> [Contents] -> Section
SSD.thModF (SystemInformation -> IdeaDict
siSys SystemInformation
si') ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (TheoryModel -> Contents) -> [TheoryModel] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent -> Contents
LlC (LabelledContent -> Contents)
-> (TheoryModel -> LabelledContent) -> TheoryModel -> Contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fields -> SystemInformation -> TheoryModel -> LabelledContent
tmodel Fields
fields SystemInformation
si') [TheoryModel]
ts
    mkSubSCS SystemInformation
si' (DDs [Sentence]
intro Fields
fields [DataDefinition]
dds DerivationDisplay
ShowDerivation) = --FIXME: need to keep track of DD intro.
      Sentence -> [Contents] -> Section
SSD.dataDefnF Sentence
EmptyS ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (DataDefinition -> [Contents]) -> [DataDefinition] -> [Contents]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap DataDefinition -> [Contents]
f [DataDefinition]
dds
      where f :: DataDefinition -> [Contents]
f DataDefinition
e = LabelledContent -> Contents
LlC (Fields -> SystemInformation -> DataDefinition -> LabelledContent
ddefn Fields
fields SystemInformation
si' DataDefinition
e) Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: Maybe Contents -> [Contents]
forall a. Maybe a -> [a]
maybeToList (DataDefinition -> Maybe Contents
forall c.
(MayHaveDerivation c, HasShortName c, Referable c) =>
c -> Maybe Contents
derivation DataDefinition
e)
    mkSubSCS SystemInformation
si' (DDs [Sentence]
intro Fields
fields [DataDefinition]
dds DerivationDisplay
_) =
      Sentence -> [Contents] -> Section
SSD.dataDefnF Sentence
EmptyS ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (DataDefinition -> Contents) -> [DataDefinition] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map DataDefinition -> Contents
f [DataDefinition]
dds
      where f :: DataDefinition -> Contents
f DataDefinition
e = LabelledContent -> Contents
LlC (LabelledContent -> Contents) -> LabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ Fields -> SystemInformation -> DataDefinition -> LabelledContent
ddefn Fields
fields SystemInformation
si' DataDefinition
e
    mkSubSCS SystemInformation
si' (GDs [Sentence]
intro Fields
fields [GenDefn]
gs' DerivationDisplay
ShowDerivation) =
      [Contents] -> Section
SSD.genDefnF ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> [Contents]) -> [GenDefn] -> [Contents]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\GenDefn
x -> LabelledContent -> Contents
LlC (Fields -> SystemInformation -> GenDefn -> LabelledContent
gdefn Fields
fields SystemInformation
si' GenDefn
x) Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: Maybe Contents -> [Contents]
forall a. Maybe a -> [a]
maybeToList (GenDefn -> Maybe Contents
forall c.
(MayHaveDerivation c, HasShortName c, Referable c) =>
c -> Maybe Contents
derivation GenDefn
x)) [GenDefn]
gs'
    mkSubSCS SystemInformation
si' (GDs [Sentence]
intro Fields
fields [GenDefn]
gs' DerivationDisplay
_) =
      [Contents] -> Section
SSD.genDefnF ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (GenDefn -> Contents) -> [GenDefn] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent -> Contents
LlC (LabelledContent -> Contents)
-> (GenDefn -> LabelledContent) -> GenDefn -> Contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fields -> SystemInformation -> GenDefn -> LabelledContent
gdefn Fields
fields SystemInformation
si') [GenDefn]
gs'
    mkSubSCS SystemInformation
si' (IMs [Sentence]
intro Fields
fields [InstanceModel]
ims DerivationDisplay
ShowDerivation) =
      Section -> Section -> Section -> Section -> [Contents] -> Section
SSD.inModelF Section
SSD.pdStub Section
SSD.ddStub Section
SSD.tmStub Section
SSD.gdStub ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++
      (InstanceModel -> [Contents]) -> [InstanceModel] -> [Contents]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (\InstanceModel
x -> LabelledContent -> Contents
LlC (Fields -> SystemInformation -> InstanceModel -> LabelledContent
instanceModel Fields
fields SystemInformation
si' InstanceModel
x) Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: Maybe Contents -> [Contents]
forall a. Maybe a -> [a]
maybeToList (InstanceModel -> Maybe Contents
forall c.
(MayHaveDerivation c, HasShortName c, Referable c) =>
c -> Maybe Contents
derivation InstanceModel
x)) [InstanceModel]
ims
    mkSubSCS SystemInformation
si' (IMs [Sentence]
intro Fields
fields [InstanceModel]
ims DerivationDisplay
_) =
      Section -> Section -> Section -> Section -> [Contents] -> Section
SSD.inModelF Section
SSD.pdStub Section
SSD.ddStub Section
SSD.tmStub Section
SSD.gdStub ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ (Sentence -> Contents) -> [Sentence] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map Sentence -> Contents
mkParagraph [Sentence]
intro [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++
      (InstanceModel -> Contents) -> [InstanceModel] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map (LabelledContent -> Contents
LlC (LabelledContent -> Contents)
-> (InstanceModel -> LabelledContent) -> InstanceModel -> Contents
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fields -> SystemInformation -> InstanceModel -> LabelledContent
instanceModel Fields
fields SystemInformation
si') [InstanceModel]
ims
    mkSubSCS SystemInformation
si' (Assumptions [ConceptInstance]
ci) =
      [Contents] -> Section
SSD.assumpF ([Contents] -> Section) -> [Contents] -> Section
forall a b. (a -> b) -> a -> b
$ [ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD ([ConceptInstance] -> [Contents])
-> [ConceptInstance] -> [Contents]
forall a b. (a -> b) -> a -> b
$ (ConceptInstance -> ConceptInstance)
-> [ConceptInstance] -> [ConceptInstance]
forall a b. (a -> b) -> [a] -> [b]
map (ConceptInstance -> SystemInformation -> ConceptInstance
`SSD.helperCI` SystemInformation
si') [ConceptInstance]
ci
    mkSubSCS SystemInformation
_ (Constraints Sentence
end [c]
cs)  = Sentence -> [c] -> Section
forall c.
(HasUncertainty c, Quantity c, Constrained c, HasReasVal c,
 MayHaveUnit c) =>
Sentence -> [c] -> Section
SSD.datConF Sentence
end [c]
cs
    mkSubSCS SystemInformation
_ (CorrSolnPpties [c]
c [Contents]
cs) = [c] -> [Contents] -> Section
forall c.
(Quantity c, Constrained c) =>
[c] -> [Contents] -> Section
SSD.propCorSolF [c]
c [Contents]
cs
    siSys :: SystemInformation -> IdeaDict
    siSys :: SystemInformation -> IdeaDict
siSys SI {_sys :: ()
_sys = a
sys} = a -> IdeaDict
forall c. Idea c => c -> IdeaDict
nw a
sys

-- ** Requirements

-- | Helper for making the Requirements section.
mkReqrmntSec :: ReqrmntSec -> Section
mkReqrmntSec :: ReqrmntSec -> Section
mkReqrmntSec (ReqsProg [ReqsSub]
l) = [Section] -> Section
R.reqF ([Section] -> Section) -> [Section] -> Section
forall a b. (a -> b) -> a -> b
$ (ReqsSub -> Section) -> [ReqsSub] -> [Section]
forall a b. (a -> b) -> [a] -> [b]
map ReqsSub -> Section
mkSubs [ReqsSub]
l
  where
    mkSubs :: ReqsSub -> Section
    mkSubs :: ReqsSub -> Section
mkSubs (FReqsSub  [ConceptInstance]
frs [LabelledContent]
tbs) = [Contents] -> Section
R.fReqF ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
frs [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (LabelledContent -> Contents) -> [LabelledContent] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Contents
LlC [LabelledContent]
tbs)
    mkSubs (FReqsSub' [ConceptInstance]
frs [LabelledContent]
tbs) = [Contents] -> Section
R.fReqF ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
frs [Contents] -> [Contents] -> [Contents]
forall a. [a] -> [a] -> [a]
++ (LabelledContent -> Contents) -> [LabelledContent] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Contents
LlC [LabelledContent]
tbs)
    mkSubs (NonFReqsSub [ConceptInstance]
nfrs) = [Contents] -> Section
R.nfReqF ([ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
nfrs)

-- ** Likely Changes

-- | Helper for making the Likely Changes section.
mkLCsSec :: LCsSec -> Section
mkLCsSec :: LCsSec -> Section
mkLCsSec (LCsProg [ConceptInstance]
c) = [Contents] -> [Section] -> Section
SRS.likeChg (CI -> [ConceptInstance] -> Contents
forall n. NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs CI
Doc.likelyChg [ConceptInstance]
cContents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: [ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
c) []

-- ** Unlikely Changes

-- | Helper for making the Unikely Changes section.
mkUCsSec :: UCsSec -> Section
mkUCsSec :: UCsSec -> Section
mkUCsSec (UCsProg [ConceptInstance]
c) = [Contents] -> [Section] -> Section
SRS.unlikeChg (CI -> [ConceptInstance] -> Contents
forall n. NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs CI
Doc.unlikelyChg  [ConceptInstance]
c Contents -> [Contents] -> [Contents]
forall a. a -> [a] -> [a]
: [ConceptInstance] -> [Contents]
forall c.
(Referable c, HasShortName c, Definition c) =>
[c] -> [Contents]
mkEnumSimpleD [ConceptInstance]
c) []

-- | Intro paragraph for likely and unlikely changes
introChgs :: NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs :: forall n. NamedIdea n => n -> [ConceptInstance] -> Contents
introChgs n
xs [] = Sentence -> Contents
mkParagraph (Sentence -> Contents) -> Sentence -> Contents
forall a b. (a -> b) -> a -> b
$ [n] -> Sentence
forall n. NamedIdea n => [n] -> Sentence
emptySectSentPlu [n
xs]
introChgs n
xs [ConceptInstance]
_ = [Sentence] -> Contents
foldlSP [String -> Sentence
S String
"This", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
Doc.section_, String -> Sentence
S String
"lists the",
  n -> Sentence
forall n. NamedIdea n => n -> Sentence
plural n
xs, String -> Sentence
S String
"to be made to the", IdeaDict -> Sentence
forall n. NamedIdea n => n -> Sentence
phrase IdeaDict
Doc.software]

-- ** Traceability

-- | Helper for making the Traceability Matrices and Graphs section.
mkTraceabilitySec :: TraceabilitySec -> SystemInformation -> Section
mkTraceabilitySec :: TraceabilitySec -> SystemInformation -> Section
mkTraceabilitySec (TraceabilityProg [TraceConfig]
progs) si :: SystemInformation
si@SI{_sys :: ()
_sys = a
sys} = [LabelledContent]
-> [Sentence] -> [Contents] -> String -> [Section] -> Section
TG.traceMGF [LabelledContent]
trace
  ((TraceConfig -> Sentence) -> [TraceConfig] -> [Sentence]
forall a b. (a -> b) -> [a] -> [b]
map (\(TraceConfig UID
_ [Sentence]
pre Sentence
_ [TraceViewCat]
_ [TraceViewCat]
_) -> SepType -> FoldType -> [Sentence] -> Sentence
foldlList SepType
Comma FoldType
List [Sentence]
pre) [TraceConfig]
fProgs)
  ((LabelledContent -> Contents) -> [LabelledContent] -> [Contents]
forall a b. (a -> b) -> [a] -> [b]
map LabelledContent -> Contents
LlC [LabelledContent]
trace) (a -> String
forall c. CommonIdea c => c -> String
programName a
sys) []
  where
    trace :: [LabelledContent]
trace = (TraceConfig -> LabelledContent)
-> [TraceConfig] -> [LabelledContent]
forall a b. (a -> b) -> [a] -> [b]
map (\(TraceConfig UID
u [Sentence]
_ Sentence
desc [TraceViewCat]
cols [TraceViewCat]
rows) -> UID
-> Sentence
-> [TraceViewCat]
-> [TraceViewCat]
-> SystemInformation
-> LabelledContent
TM.generateTraceTableView
      UID
u Sentence
desc [TraceViewCat]
cols [TraceViewCat]
rows SystemInformation
si) [TraceConfig]
fProgs
    fProgs :: [TraceConfig]
fProgs = (TraceConfig -> Bool) -> [TraceConfig] -> [TraceConfig]
forall a. (a -> Bool) -> [a] -> [a]
filter (\(TraceConfig UID
_ [Sentence]
_ Sentence
_ [TraceViewCat]
cols [TraceViewCat]
rows) -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ [Sentence] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null 
      (([UID] -> [UID]) -> SystemInformation -> [Sentence]
header ([TraceViewCat] -> ChunkDB -> [UID] -> [UID]
TM.layoutUIDs [TraceViewCat]
rows ChunkDB
sidb) SystemInformation
si) Bool -> Bool -> Bool
|| [Sentence] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (([UID] -> [UID]) -> SystemInformation -> [Sentence]
header ([TraceViewCat] -> ChunkDB -> [UID] -> [UID]
TM.layoutUIDs [TraceViewCat]
cols ChunkDB
sidb) SystemInformation
si)) [TraceConfig]
progs
    sidb :: ChunkDB
sidb = SystemInformation -> ChunkDB
_sysinfodb SystemInformation
si

-- | Helper to get headers of rows and columns
header :: ([UID] -> [UID]) -> SystemInformation -> [Sentence]
header :: ([UID] -> [UID]) -> SystemInformation -> [Sentence]
header [UID] -> [UID]
f = (ChunkDB -> [UID]) -> SystemInformation -> [Sentence]
TM.traceMHeader ([UID] -> [UID]
f ([UID] -> [UID]) -> (ChunkDB -> [UID]) -> ChunkDB -> [UID]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map UID [UID] -> [UID]
forall k a. Map k a -> [k]
Map.keys (Map UID [UID] -> [UID])
-> (ChunkDB -> Map UID [UID]) -> ChunkDB -> [UID]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ChunkDB
-> Getting (Map UID [UID]) ChunkDB (Map UID [UID]) -> Map UID [UID]
forall s a. s -> Getting a s a -> a
^. Getting (Map UID [UID]) ChunkDB (Map UID [UID])
Lens' ChunkDB (Map UID [UID])
refbyTable))

-- ** Off the Shelf Solutions

-- | Helper for making the Off-the-Shelf Solutions section.
mkOffShelfSolnSec :: OffShelfSolnsSec -> Section
mkOffShelfSolnSec :: OffShelfSolnsSec -> Section
mkOffShelfSolnSec (OffShelfSolnsProg [Contents]
cs) = [Contents] -> [Section] -> Section
SRS.offShelfSol [Contents]
cs [] 

-- ** Auxiliary Constants

-- | Helper for making the Values of Auxiliary Constants section.
mkAuxConsSec :: AuxConstntSec -> Section
mkAuxConsSec :: AuxConstntSec -> Section
mkAuxConsSec (AuxConsProg CI
key [ConstQDef]
listOfCons) = CI -> [ConstQDef] -> Section
forall a. Idea a => a -> [ConstQDef] -> Section
AC.valsOfAuxConstantsF CI
key ([ConstQDef] -> Section) -> [ConstQDef] -> Section
forall a b. (a -> b) -> a -> b
$ [ConstQDef] -> [ConstQDef]
forall a. HasSymbol a => [a] -> [a]
sortBySymbol [ConstQDef]
listOfCons

-- ** References

-- | Helper for making the References section.
mkBib :: BibRef -> Section
mkBib :: BibRef -> Section
mkBib BibRef
bib = [Contents] -> [Section] -> Section
SRS.reference [UnlabelledContent -> Contents
UlC (UnlabelledContent -> Contents) -> UnlabelledContent -> Contents
forall a b. (a -> b) -> a -> b
$ RawContent -> UnlabelledContent
ulcc (BibRef -> RawContent
Bib BibRef
bib)] []

-- ** Appendix

-- | Helper for making the Appendix section.
mkAppndxSec :: AppndxSec -> Section
mkAppndxSec :: AppndxSec -> Section
mkAppndxSec (AppndxProg [Contents]
cs) = [Contents] -> [Section] -> Section
SRS.appendix [Contents]
cs []