{-# LANGUAGE ApplicativeDo #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}
module Modelling.CdOd.SelectValidCd (
  SelectValidCdConfig (..),
  SelectValidCdInstance (..),
  SelectValidCdTaskTextElement (..),
  checkSelectValidCdConfig,
  checkSelectValidCdInstance,
  defaultSelectValidCdConfig,
  defaultSelectValidCdInstance,
  selectValidCd,
  selectValidCdEvaluation,
  selectValidCdSolution,
  selectValidCdSyntax,
  selectValidCdTask,
  ) where

import qualified Data.Bimap                       as BM (fromList)
import qualified Data.Map                         as M (
  elems,
  filter,
  foldrWithKey,
  fromAscList,
  fromList,
  insert,
  keys,
  toList,
  traverseWithKey,
  )

import Capabilities.Alloy               (MonadAlloy)
import Capabilities.Cache               (MonadCache)
import Capabilities.Diagrams            (MonadDiagrams)
import Capabilities.Graphviz            (MonadGraphviz)
import Modelling.Auxiliary.Common (
  ModellingTasksException (NeverHappens),
  Randomise (randomise),
  RandomiseLayout (randomiseLayout),
  RandomiseNames (randomiseNames),
  )
import Modelling.Auxiliary.Output (
  addPretext,
  checkTaskText,
  hoveringInformation,
  simplifiedInformation,
  uniform,
  extra,
  )
import Modelling.Auxiliary.Shuffle.All  (shuffleEverything)
import Modelling.CdOd.CdAndChanges.Instance (
  AnnotatedChangeAndCd (..),
  )
import Modelling.CdOd.Phrasing (
  phraseRelationship,
  trailingCommaGerman,
  )
import Modelling.CdOd.RepairCd (
  InValidOption (..),
  RelationshipChangeWithArticle,
  WeakeningKind (..),
  checkClassConfigAndChanges,
  generateSetOfCds,
  mapInValidOption,
  mapInValidOptionM,
  )
import Modelling.CdOd.Output            (cacheCd, cacheOd)
import Modelling.CdOd.Types (
  AllowedProperties (..),
  Annotation (..),
  AnyCd,
  AnyClassDiagram (..),
  ArticlePreference (..),
  CdConstraints (..),
  CdDrawSettings (..),
  CdMutation,
  ClassConfig (..),
  InvalidRelationship (..),
  Object (..),
  ObjectDiagram (..),
  ObjectProperties (..),
  Od,
  OmittedDefaultMultiplicities (..),
  PhrasingKind (Denoted),
  Relationship (..),
  allowNothing,
  allCdMutations,
  anyAssociationNames,
  anyRelationshipName,
  checkCdConstraints,
  checkCdDrawProperties,
  checkCdDrawSettings,
  checkCdMutations,
  checkClassConfigAndObjectProperties,
  checkObjectProperties,
  defaultCdConstraints,
  defaultCdDrawSettings,
  linkLabels,
  shuffleAnyClassAndConnectionOrder,
  renameClassesAndRelationships,
  renameObjectsWithClassesAndLinksInOd,
  shuffleObjectAndLinkOrder,
  )
import Modelling.Types                  (Change (..))

import Control.Applicative              (Alternative ((<|>)))
import Control.Functor.Trans            (FunctorTrans (lift))
import Control.Monad                    ((>=>), unless, void, when)
import Control.Monad.Catch              (MonadCatch, MonadThrow (throwM))
import Control.OutputCapable.Blocks (
  ArticleToUse (DefiniteArticle),
  GenericOutputCapable (..),
  LangM,
  Language (English, German),
  OutputCapable,
  Rated,
  ($=<<),
  english,
  german,
  multipleChoice,
  multipleChoiceSyntax,
  reRefuse,
  translate,
  translations,
  )
import Control.OutputCapable.Blocks.Generic.Type (
  GenericOutput (Code, Paragraph, Special, Translated),
  )
import Control.OutputCapable.Blocks.Type (
  SpecialOutput,
  specialToOutputCapable,
  )
import Control.Monad.Random             (evalRandT, mkStdGen)
import Control.Monad.Random.Class       (MonadRandom)
import Data.Bitraversable               (bimapM)
import Data.Containers.ListUtils        (nubOrd)
import Data.Either                      (isRight, partitionEithers)
import Data.GraphViz                    (DirType (Forward, NoDir))
import Data.List                        (singleton)
import Data.Map                         (Map)
import Data.Maybe                       (mapMaybe)
import Data.Ratio                       ((%))
import Data.String.Interpolate          (i, iii)
import GHC.Generics                     (Generic)
import System.Random.Shuffle            (shuffleM)

data SelectValidCdConfig
  = SelectValidCdConfig {
    SelectValidCdConfig -> [CdMutation]
allowedCdMutations :: ![CdMutation],
    SelectValidCdConfig -> AllowedProperties
allowedProperties :: AllowedProperties,
    -- | the preferred article to use when referring to relationships
    SelectValidCdConfig -> ArticlePreference
articleToUse      :: ArticlePreference,
    -- | influences the validity of the base class diagram (see 'WeakeningKind')
    SelectValidCdConfig -> WeakeningKind
basePropertiesOfBaseCdOn :: !WeakeningKind,
    SelectValidCdConfig -> CdConstraints
cdConstraints :: CdConstraints,
    SelectValidCdConfig -> ClassConfig
classConfig      :: ClassConfig,
    SelectValidCdConfig -> CdDrawSettings
drawSettings     :: !CdDrawSettings,
    SelectValidCdConfig -> Maybe Integer
maxInstances     :: Maybe Integer,
    SelectValidCdConfig -> ObjectProperties
objectProperties :: ObjectProperties,
    -- | when enabled feedback for wrong answers will be shown
    -- this might include ODs
    SelectValidCdConfig -> Bool
printExtendedFeedback :: Bool,
    SelectValidCdConfig -> Bool
printSolution    :: Bool,
    SelectValidCdConfig -> Bool
shuffleEachCd    :: Bool,
    SelectValidCdConfig -> Maybe Int
timeout          :: Maybe Int,
    SelectValidCdConfig -> Maybe (Map Language String)
extraText        :: Maybe (Map Language String)
  } deriving ((forall x. SelectValidCdConfig -> Rep SelectValidCdConfig x)
-> (forall x. Rep SelectValidCdConfig x -> SelectValidCdConfig)
-> Generic SelectValidCdConfig
forall x. Rep SelectValidCdConfig x -> SelectValidCdConfig
forall x. SelectValidCdConfig -> Rep SelectValidCdConfig x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectValidCdConfig -> Rep SelectValidCdConfig x
from :: forall x. SelectValidCdConfig -> Rep SelectValidCdConfig x
$cto :: forall x. Rep SelectValidCdConfig x -> SelectValidCdConfig
to :: forall x. Rep SelectValidCdConfig x -> SelectValidCdConfig
Generic, ReadPrec [SelectValidCdConfig]
ReadPrec SelectValidCdConfig
Int -> ReadS SelectValidCdConfig
ReadS [SelectValidCdConfig]
(Int -> ReadS SelectValidCdConfig)
-> ReadS [SelectValidCdConfig]
-> ReadPrec SelectValidCdConfig
-> ReadPrec [SelectValidCdConfig]
-> Read SelectValidCdConfig
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SelectValidCdConfig
readsPrec :: Int -> ReadS SelectValidCdConfig
$creadList :: ReadS [SelectValidCdConfig]
readList :: ReadS [SelectValidCdConfig]
$creadPrec :: ReadPrec SelectValidCdConfig
readPrec :: ReadPrec SelectValidCdConfig
$creadListPrec :: ReadPrec [SelectValidCdConfig]
readListPrec :: ReadPrec [SelectValidCdConfig]
Read, Int -> SelectValidCdConfig -> ShowS
[SelectValidCdConfig] -> ShowS
SelectValidCdConfig -> String
(Int -> SelectValidCdConfig -> ShowS)
-> (SelectValidCdConfig -> String)
-> ([SelectValidCdConfig] -> ShowS)
-> Show SelectValidCdConfig
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectValidCdConfig -> ShowS
showsPrec :: Int -> SelectValidCdConfig -> ShowS
$cshow :: SelectValidCdConfig -> String
show :: SelectValidCdConfig -> String
$cshowList :: [SelectValidCdConfig] -> ShowS
showList :: [SelectValidCdConfig] -> ShowS
Show)

defaultSelectValidCdConfig :: SelectValidCdConfig
defaultSelectValidCdConfig :: SelectValidCdConfig
defaultSelectValidCdConfig
  = SelectValidCdConfig {
    allowedCdMutations :: [CdMutation]
allowedCdMutations = [CdMutation]
allCdMutations,
    allowedProperties :: AllowedProperties
allowedProperties = AllowedProperties
allowNothing {
      inheritanceCycles :: Bool
inheritanceCycles = Bool
True,
      reverseInheritances :: Bool
reverseInheritances = Bool
True
      },
    articleToUse :: ArticlePreference
articleToUse = ArticlePreference
UseDefiniteArticleWherePossible,
    basePropertiesOfBaseCdOn :: WeakeningKind
basePropertiesOfBaseCdOn = WeakeningKind
AnyStructuralWeakening,
    cdConstraints :: CdConstraints
cdConstraints = CdConstraints
defaultCdConstraints,
    classConfig :: ClassConfig
classConfig = ClassConfig {
        classLimits :: (Int, Int)
classLimits        = (Int
4, Int
4),
        aggregationLimits :: (Int, Maybe Int)
aggregationLimits  = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0),
        associationLimits :: (Int, Maybe Int)
associationLimits  = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0),
        compositionLimits :: (Int, Maybe Int)
compositionLimits  = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0),
        inheritanceLimits :: (Int, Maybe Int)
inheritanceLimits  = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4),
        relationshipLimits :: (Int, Maybe Int)
relationshipLimits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
4)
      },
    drawSettings :: CdDrawSettings
drawSettings = CdDrawSettings
defaultCdDrawSettings,
    maxInstances :: Maybe Integer
maxInstances     = Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
200,
    objectProperties :: ObjectProperties
objectProperties = ObjectProperties {
      anonymousObjectProportion :: Rational
anonymousObjectProportion = Integer
0 Integer -> Integer -> Rational
forall a. Integral a => a -> a -> Ratio a
% Integer
1,
      completelyInhabited :: Maybe Bool
completelyInhabited = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True,
      hasLimitedIsolatedObjects :: Bool
hasLimitedIsolatedObjects = Bool
False,
      hasSelfLoops :: Maybe Bool
hasSelfLoops = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False,
      usesEveryRelationshipName :: Maybe Bool
usesEveryRelationshipName = Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
      },
    printExtendedFeedback :: Bool
printExtendedFeedback = Bool
True,
    printSolution :: Bool
printSolution    = Bool
True,
    shuffleEachCd :: Bool
shuffleEachCd    = Bool
False,
    timeout :: Maybe Int
timeout          = Maybe Int
forall a. Maybe a
Nothing,
    extraText :: Maybe (Map Language String)
extraText        = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }

checkSelectValidCdConfig :: SelectValidCdConfig -> Maybe String
checkSelectValidCdConfig :: SelectValidCdConfig -> Maybe String
checkSelectValidCdConfig SelectValidCdConfig {Bool
[CdMutation]
Maybe Int
Maybe Integer
Maybe (Map Language String)
ArticlePreference
AllowedProperties
ObjectProperties
CdDrawSettings
CdConstraints
ClassConfig
WeakeningKind
allowedCdMutations :: SelectValidCdConfig -> [CdMutation]
allowedProperties :: SelectValidCdConfig -> AllowedProperties
articleToUse :: SelectValidCdConfig -> ArticlePreference
basePropertiesOfBaseCdOn :: SelectValidCdConfig -> WeakeningKind
cdConstraints :: SelectValidCdConfig -> CdConstraints
classConfig :: SelectValidCdConfig -> ClassConfig
drawSettings :: SelectValidCdConfig -> CdDrawSettings
maxInstances :: SelectValidCdConfig -> Maybe Integer
objectProperties :: SelectValidCdConfig -> ObjectProperties
printExtendedFeedback :: SelectValidCdConfig -> Bool
printSolution :: SelectValidCdConfig -> Bool
shuffleEachCd :: SelectValidCdConfig -> Bool
timeout :: SelectValidCdConfig -> Maybe Int
extraText :: SelectValidCdConfig -> Maybe (Map Language String)
allowedCdMutations :: [CdMutation]
allowedProperties :: AllowedProperties
articleToUse :: ArticlePreference
basePropertiesOfBaseCdOn :: WeakeningKind
cdConstraints :: CdConstraints
classConfig :: ClassConfig
drawSettings :: CdDrawSettings
maxInstances :: Maybe Integer
objectProperties :: ObjectProperties
printExtendedFeedback :: Bool
printSolution :: Bool
shuffleEachCd :: Bool
timeout :: Maybe Int
extraText :: Maybe (Map Language String)
..}
  | ObjectProperties -> Maybe Bool
completelyInhabited ObjectProperties
objectProperties Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
  = String -> Maybe String
forall a. a -> Maybe a
Just String
"completelyInhabited needs to be set to 'Just True' for this task type"
  | ObjectProperties -> Maybe Bool
usesEveryRelationshipName ObjectProperties
objectProperties Maybe Bool -> Maybe Bool -> Bool
forall a. Eq a => a -> a -> Bool
/= Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      usesEveryRelationshipName needs to be set to 'Just True' for this task type
      |]
  | Bool
printExtendedFeedback Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
printSolution
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      printExtendedFeedback leaks the correct solution
      and thus can only be enabled when printSolution is set to True
      |]
  | Bool
otherwise
  = ClassConfig -> AllowedProperties -> Maybe String
checkClassConfigAndChanges ClassConfig
classConfig AllowedProperties
allowedProperties
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> AllowedProperties -> CdConstraints -> Maybe String
checkCdConstraints AllowedProperties
allowedProperties CdConstraints
cdConstraints
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [CdMutation] -> Maybe String
checkCdMutations [CdMutation]
allowedCdMutations
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> CdDrawSettings -> Maybe String
checkCdDrawSettings CdDrawSettings
drawSettings
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ObjectProperties -> Maybe String
checkObjectProperties ObjectProperties
objectProperties
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ClassConfig -> ObjectProperties -> Maybe String
checkClassConfigAndObjectProperties ClassConfig
classConfig ObjectProperties
objectProperties
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> CdDrawSettings -> AllowedProperties -> Maybe String
checkCdDrawProperties CdDrawSettings
drawSettings AllowedProperties
allowedProperties

type CdChange = InValidOption
  AnyCd
  RelationshipChangeWithArticle
  Od

data SelectValidCdInstance
  = SelectValidCdInstance {
    SelectValidCdInstance -> CdDrawSettings
cdDrawSettings  :: !CdDrawSettings,
    SelectValidCdInstance -> Map Int CdChange
classDiagrams   :: Map Int CdChange,
    -- | when enabled feedback for wrong answers will be shown
    -- this might include ODs
    SelectValidCdInstance -> Bool
showExtendedFeedback :: Bool,
    SelectValidCdInstance -> Bool
showSolution    :: !Bool,
    SelectValidCdInstance -> SelectValidCdTaskText
taskText        :: !SelectValidCdTaskText,
    SelectValidCdInstance -> Maybe (Map Language String)
addText         :: Maybe (Map Language String)
  } deriving (SelectValidCdInstance -> SelectValidCdInstance -> Bool
(SelectValidCdInstance -> SelectValidCdInstance -> Bool)
-> (SelectValidCdInstance -> SelectValidCdInstance -> Bool)
-> Eq SelectValidCdInstance
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectValidCdInstance -> SelectValidCdInstance -> Bool
== :: SelectValidCdInstance -> SelectValidCdInstance -> Bool
$c/= :: SelectValidCdInstance -> SelectValidCdInstance -> Bool
/= :: SelectValidCdInstance -> SelectValidCdInstance -> Bool
Eq, (forall x. SelectValidCdInstance -> Rep SelectValidCdInstance x)
-> (forall x. Rep SelectValidCdInstance x -> SelectValidCdInstance)
-> Generic SelectValidCdInstance
forall x. Rep SelectValidCdInstance x -> SelectValidCdInstance
forall x. SelectValidCdInstance -> Rep SelectValidCdInstance x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SelectValidCdInstance -> Rep SelectValidCdInstance x
from :: forall x. SelectValidCdInstance -> Rep SelectValidCdInstance x
$cto :: forall x. Rep SelectValidCdInstance x -> SelectValidCdInstance
to :: forall x. Rep SelectValidCdInstance x -> SelectValidCdInstance
Generic, ReadPrec [SelectValidCdInstance]
ReadPrec SelectValidCdInstance
Int -> ReadS SelectValidCdInstance
ReadS [SelectValidCdInstance]
(Int -> ReadS SelectValidCdInstance)
-> ReadS [SelectValidCdInstance]
-> ReadPrec SelectValidCdInstance
-> ReadPrec [SelectValidCdInstance]
-> Read SelectValidCdInstance
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SelectValidCdInstance
readsPrec :: Int -> ReadS SelectValidCdInstance
$creadList :: ReadS [SelectValidCdInstance]
readList :: ReadS [SelectValidCdInstance]
$creadPrec :: ReadPrec SelectValidCdInstance
readPrec :: ReadPrec SelectValidCdInstance
$creadListPrec :: ReadPrec [SelectValidCdInstance]
readListPrec :: ReadPrec [SelectValidCdInstance]
Read, Int -> SelectValidCdInstance -> ShowS
[SelectValidCdInstance] -> ShowS
SelectValidCdInstance -> String
(Int -> SelectValidCdInstance -> ShowS)
-> (SelectValidCdInstance -> String)
-> ([SelectValidCdInstance] -> ShowS)
-> Show SelectValidCdInstance
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectValidCdInstance -> ShowS
showsPrec :: Int -> SelectValidCdInstance -> ShowS
$cshow :: SelectValidCdInstance -> String
show :: SelectValidCdInstance -> String
$cshowList :: [SelectValidCdInstance] -> ShowS
showList :: [SelectValidCdInstance] -> ShowS
Show)

checkSelectValidCdInstance :: SelectValidCdInstance -> Maybe String
checkSelectValidCdInstance :: SelectValidCdInstance -> Maybe String
checkSelectValidCdInstance SelectValidCdInstance {Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..}
  | Bool
showExtendedFeedback Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
showSolution
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      showExtendedFeedback leaks the correct solution
      and thus can only be enabled when showSolution is set to True
      |]
  | Bool
otherwise
  = SelectValidCdTaskText -> Maybe String
forall element.
(Bounded element, Enum element, Eq element, Show element) =>
[SpecialOutput element] -> Maybe String
checkTaskText SelectValidCdTaskText
taskText
  Maybe String -> Maybe String -> Maybe String
forall a. Maybe a -> Maybe a -> Maybe a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> CdDrawSettings -> Maybe String
checkCdDrawSettings CdDrawSettings
cdDrawSettings

selectValidCdSyntax
  :: OutputCapable m
  => SelectValidCdInstance
  -> [Int]
  -> LangM m
selectValidCdSyntax :: forall (m :: * -> *).
OutputCapable m =>
SelectValidCdInstance -> [Int] -> LangM m
selectValidCdSyntax SelectValidCdInstance
inst =
  Bool -> [Int] -> [Int] -> LangM m
forall (m :: * -> *) a.
(OutputCapable m, Ord a, Show a) =>
Bool -> [a] -> [a] -> LangM m
multipleChoiceSyntax Bool
False (Map Int CdChange -> [Int]
forall k a. Map k a -> [k]
M.keys (Map Int CdChange -> [Int]) -> Map Int CdChange -> [Int]
forall a b. (a -> b) -> a -> b
$ SelectValidCdInstance -> Map Int CdChange
classDiagrams SelectValidCdInstance
inst)

type SelectValidCdTaskText = [SpecialOutput SelectValidCdTaskTextElement]

data SelectValidCdTaskTextElement
  = CdCandidates
  deriving (SelectValidCdTaskTextElement
SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> Bounded SelectValidCdTaskTextElement
forall a. a -> a -> Bounded a
$cminBound :: SelectValidCdTaskTextElement
minBound :: SelectValidCdTaskTextElement
$cmaxBound :: SelectValidCdTaskTextElement
maxBound :: SelectValidCdTaskTextElement
Bounded, Int -> SelectValidCdTaskTextElement
SelectValidCdTaskTextElement -> Int
SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> [SelectValidCdTaskTextElement]
(SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement)
-> (SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement)
-> (Int -> SelectValidCdTaskTextElement)
-> (SelectValidCdTaskTextElement -> Int)
-> (SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement])
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement])
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement])
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement
    -> [SelectValidCdTaskTextElement])
-> Enum SelectValidCdTaskTextElement
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
succ :: SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
$cpred :: SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
pred :: SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
$ctoEnum :: Int -> SelectValidCdTaskTextElement
toEnum :: Int -> SelectValidCdTaskTextElement
$cfromEnum :: SelectValidCdTaskTextElement -> Int
fromEnum :: SelectValidCdTaskTextElement -> Int
$cenumFrom :: SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
enumFrom :: SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
$cenumFromThen :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
enumFromThen :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
$cenumFromTo :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
enumFromTo :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> [SelectValidCdTaskTextElement]
$cenumFromThenTo :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> [SelectValidCdTaskTextElement]
enumFromThenTo :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement
-> [SelectValidCdTaskTextElement]
Enum, SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
(SelectValidCdTaskTextElement
 -> SelectValidCdTaskTextElement -> Bool)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> Bool)
-> Eq SelectValidCdTaskTextElement
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
== :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
$c/= :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
/= :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
Eq, (forall x.
 SelectValidCdTaskTextElement -> Rep SelectValidCdTaskTextElement x)
-> (forall x.
    Rep SelectValidCdTaskTextElement x -> SelectValidCdTaskTextElement)
-> Generic SelectValidCdTaskTextElement
forall x.
Rep SelectValidCdTaskTextElement x -> SelectValidCdTaskTextElement
forall x.
SelectValidCdTaskTextElement -> Rep SelectValidCdTaskTextElement x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
SelectValidCdTaskTextElement -> Rep SelectValidCdTaskTextElement x
from :: forall x.
SelectValidCdTaskTextElement -> Rep SelectValidCdTaskTextElement x
$cto :: forall x.
Rep SelectValidCdTaskTextElement x -> SelectValidCdTaskTextElement
to :: forall x.
Rep SelectValidCdTaskTextElement x -> SelectValidCdTaskTextElement
Generic, Eq SelectValidCdTaskTextElement
Eq SelectValidCdTaskTextElement
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> Ordering)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> Bool)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> Bool)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> Bool)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> Bool)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement)
-> (SelectValidCdTaskTextElement
    -> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement)
-> Ord SelectValidCdTaskTextElement
SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Ordering
SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Ordering
compare :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Ordering
$c< :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
< :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
$c<= :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
<= :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
$c> :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
> :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
$c>= :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
>= :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> Bool
$cmax :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
max :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
$cmin :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
min :: SelectValidCdTaskTextElement
-> SelectValidCdTaskTextElement -> SelectValidCdTaskTextElement
Ord, ReadPrec [SelectValidCdTaskTextElement]
ReadPrec SelectValidCdTaskTextElement
Int -> ReadS SelectValidCdTaskTextElement
ReadS [SelectValidCdTaskTextElement]
(Int -> ReadS SelectValidCdTaskTextElement)
-> ReadS [SelectValidCdTaskTextElement]
-> ReadPrec SelectValidCdTaskTextElement
-> ReadPrec [SelectValidCdTaskTextElement]
-> Read SelectValidCdTaskTextElement
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS SelectValidCdTaskTextElement
readsPrec :: Int -> ReadS SelectValidCdTaskTextElement
$creadList :: ReadS [SelectValidCdTaskTextElement]
readList :: ReadS [SelectValidCdTaskTextElement]
$creadPrec :: ReadPrec SelectValidCdTaskTextElement
readPrec :: ReadPrec SelectValidCdTaskTextElement
$creadListPrec :: ReadPrec [SelectValidCdTaskTextElement]
readListPrec :: ReadPrec [SelectValidCdTaskTextElement]
Read, Int -> SelectValidCdTaskTextElement -> ShowS
[SelectValidCdTaskTextElement] -> ShowS
SelectValidCdTaskTextElement -> String
(Int -> SelectValidCdTaskTextElement -> ShowS)
-> (SelectValidCdTaskTextElement -> String)
-> ([SelectValidCdTaskTextElement] -> ShowS)
-> Show SelectValidCdTaskTextElement
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SelectValidCdTaskTextElement -> ShowS
showsPrec :: Int -> SelectValidCdTaskTextElement -> ShowS
$cshow :: SelectValidCdTaskTextElement -> String
show :: SelectValidCdTaskTextElement -> String
$cshowList :: [SelectValidCdTaskTextElement] -> ShowS
showList :: [SelectValidCdTaskTextElement] -> ShowS
Show)

selectValidCdTask
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, OutputCapable m)
  => FilePath
  -> SelectValidCdInstance
  -> LangM m
selectValidCdTask :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> SelectValidCdInstance -> LangM m
selectValidCdTask String
path SelectValidCdInstance
task = do
  String -> SelectValidCdInstance -> LangM m
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> SelectValidCdInstance -> LangM m
toTaskText String
path SelectValidCdInstance
task
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph LangM m
forall (m :: * -> *). OutputCapable m => LangM m
simplifiedInformation
  LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph LangM m
forall (m :: * -> *). OutputCapable m => LangM m
hoveringInformation
  pure ()

toTaskText
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, OutputCapable m)
  => FilePath
  -> SelectValidCdInstance
  -> LangM m
toTaskText :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String -> SelectValidCdInstance -> LangM m
toTaskText String
path SelectValidCdInstance
task = do
  (SelectValidCdTaskTextElement -> LangM m)
-> SelectValidCdTaskText -> LangM m
forall (m :: * -> *) element.
OutputCapable m =>
(element -> LangM m) -> [SpecialOutput element] -> LangM m
specialToOutputCapable (String
-> SelectValidCdInstance -> SelectValidCdTaskTextElement -> LangM m
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String
-> SelectValidCdInstance -> SelectValidCdTaskTextElement -> LangM m
toTaskSpecificText String
path SelectValidCdInstance
task) (SelectValidCdInstance -> SelectValidCdTaskText
taskText SelectValidCdInstance
task)
  Maybe (Map Language String) -> LangM m
forall (m :: * -> *).
OutputCapable m =>
Maybe (Map Language String) -> LangM m
extra (Maybe (Map Language String) -> LangM m)
-> Maybe (Map Language String) -> LangM m
forall a b. (a -> b) -> a -> b
$ SelectValidCdInstance -> Maybe (Map Language String)
addText SelectValidCdInstance
task
  pure ()

toTaskSpecificText
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, OutputCapable m)
  => FilePath
  -> SelectValidCdInstance
  -> SelectValidCdTaskTextElement
  -> LangM m
toTaskSpecificText :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m,
 OutputCapable m) =>
String
-> SelectValidCdInstance -> SelectValidCdTaskTextElement -> LangM m
toTaskSpecificText String
path SelectValidCdInstance {Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..} = \case
  SelectValidCdTaskTextElement
CdCandidates -> (Int -> String)
-> ((Bool, String) -> String) -> Map Int (Bool, String) -> LangM m
forall k a. (k -> String) -> (a -> String) -> Map k a -> LangM m
forall l (m :: * -> *) k a.
GenericOutputCapable l m =>
(k -> String) -> (a -> String) -> Map k a -> GenericLangM l m ()
images Int -> String
forall a. Show a => a -> String
show (Bool, String) -> String
forall a b. (a, b) -> b
snd (Map Int (Bool, String) -> LangM m)
-> m (Map Int (Bool, String)) -> LangM m
forall (m :: * -> *) a l b.
Monad m =>
(a -> GenericLangM l m b) -> m a -> GenericLangM l m b
$=<< Map Int (m (Bool, String)) -> m (Map Int (Bool, String))
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => Map Int (m a) -> m (Map Int a)
sequence
    (Map Int (m (Bool, String)) -> m (Map Int (Bool, String)))
-> Map Int (m (Bool, String)) -> m (Map Int (Bool, String))
forall a b. (a -> b) -> a -> b
$ (Int
 -> CdChange
 -> Map Int (m (Bool, String))
 -> Map Int (m (Bool, String)))
-> Map Int (m (Bool, String))
-> Map Int CdChange
-> Map Int (m (Bool, String))
forall k a b. (k -> a -> b -> b) -> b -> Map k a -> b
M.foldrWithKey Int
-> CdChange
-> Map Int (m (Bool, String))
-> Map Int (m (Bool, String))
forall {k} {f :: * -> *} {a} {b}.
(Ord k, MonadCache f, MonadDiagrams f, MonadGraphviz f) =>
k
-> InValidOption (AnyClassDiagram String String) a b
-> Map k (f (Bool, String))
-> Map k (f (Bool, String))
drawCd Map Int (m (Bool, String))
forall a. Monoid a => a
mempty Map Int CdChange
classDiagrams
  where
    drawCd :: k
-> InValidOption (AnyClassDiagram String String) a b
-> Map k (f (Bool, String))
-> Map k (f (Bool, String))
drawCd k
x InValidOption (AnyClassDiagram String String) a b
theChange Map k (f (Bool, String))
cds =
      let f :: f String
f = CdDrawSettings
-> Style V2 Double
-> AnyClassDiagram String String
-> String
-> f String
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m) =>
CdDrawSettings
-> Style V2 Double
-> AnyClassDiagram String String
-> String
-> m String
cacheCd
            CdDrawSettings
cdDrawSettings
            Style V2 Double
forall a. Monoid a => a
mempty
            (InValidOption (AnyClassDiagram String String) a b
-> AnyClassDiagram String String
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity -> option
option InValidOption (AnyClassDiagram String String) a b
theChange)
            String
path
      in k
-> f (Bool, String)
-> Map k (f (Bool, String))
-> Map k (f (Bool, String))
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert k
x ((Either a b -> Bool
forall a b. Either a b -> Bool
isRight (Either a b -> Bool) -> Either a b -> Bool
forall a b. (a -> b) -> a -> b
$ InValidOption (AnyClassDiagram String String) a b -> Either a b
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity
-> Either forInvalidity forValidity
hint InValidOption (AnyClassDiagram String String) a b
theChange,) (String -> (Bool, String)) -> f String -> f (Bool, String)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f String
f) Map k (f (Bool, String))
cds

defaultSelectValidCdTaskText :: SelectValidCdTaskText
defaultSelectValidCdTaskText :: SelectValidCdTaskText
defaultSelectValidCdTaskText = [
  SelectValidCdTaskText
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph (SelectValidCdTaskText
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> SelectValidCdTaskText
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ GenericOutput Language SelectValidCdTaskTextElement
-> SelectValidCdTaskText
forall a. a -> [a]
singleton (GenericOutput Language SelectValidCdTaskTextElement
 -> SelectValidCdTaskText)
-> GenericOutput Language SelectValidCdTaskTextElement
-> SelectValidCdTaskText
forall a b. (a -> b) -> a -> b
$ Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
    String -> State (Map Language String) ()
english [i|Consider the following class diagram candidates:|]
    String -> State (Map Language String) ()
german [i|Betrachten Sie die folgenden Klassendiagrammkandidaten:|],
  SelectValidCdTaskTextElement
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element. element -> GenericOutput language element
Special SelectValidCdTaskTextElement
CdCandidates,
  SelectValidCdTaskText
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph (SelectValidCdTaskText
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> SelectValidCdTaskText
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ GenericOutput Language SelectValidCdTaskTextElement
-> SelectValidCdTaskText
forall a. a -> [a]
singleton (GenericOutput Language SelectValidCdTaskTextElement
 -> SelectValidCdTaskText)
-> GenericOutput Language SelectValidCdTaskTextElement
-> SelectValidCdTaskText
forall a b. (a -> b) -> a -> b
$ Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
    String -> State (Map Language String) ()
english [i|Which of these class diagram candidates are valid class diagrams?
Please state your answer by giving a list of numbers, indicating all valid class diagrams.|]
    String -> State (Map Language String) ()
german [i|Welche dieser Klassendiagrammkandidaten sind gültige Klassendiagramme?
Bitte geben Sie Ihre Antwort in Form einer Liste von Zahlen an, die alle gültigen Klassendiagramme enthält.|],
  SelectValidCdTaskText
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph [
    Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
      String -> State (Map Language String) ()
english [i|For example,|]
      String -> State (Map Language String) ()
german [i|Zum Beispiel würde|],
    Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Code (Map Language String
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ String -> Map Language String
forall a. a -> Map Language a
uniform String
"[1, 2]",
    Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated (Map Language String
 -> GenericOutput Language SelectValidCdTaskTextElement)
-> Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
      String -> State (Map Language String) ()
english [i|would mean that only class diagram candidates 1 and 2 of the given ones are valid class diagrams.|]
      String -> State (Map Language String) ()
german [i|bedeuten, dass nur die Klassendiagrammkandidaten 1 und 2 der gegebenen Klassendiagrammkandidaten gültige Klassendiagramme sind.|]
    ]
  ]

selectValidCdEvaluation
  :: (
    Alternative m,
    MonadCache m,
    MonadDiagrams m,
    MonadGraphviz m,
    MonadThrow m,
    OutputCapable m
    )
  => FilePath
  -> SelectValidCdInstance
  -> [Int]
  -> Rated m
selectValidCdEvaluation :: forall (m :: * -> *).
(Alternative m, MonadCache m, MonadDiagrams m, MonadGraphviz m,
 MonadThrow m, OutputCapable m) =>
String -> SelectValidCdInstance -> [Int] -> Rated m
selectValidCdEvaluation String
path inst :: SelectValidCdInstance
inst@SelectValidCdInstance{Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..} [Int]
xs = LangM' m Rational -> LangM' m Rational
forall (m :: * -> *) a. OutputCapable m => LangM' m a -> LangM' m a
addPretext (LangM' m Rational -> LangM' m Rational)
-> LangM' m Rational -> LangM' m Rational
forall a b. (a -> b) -> a -> b
$ do
  let cds :: Map Language String
cds = [(Language, String)] -> Map Language String
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [
        (Language
English, String
"class diagrams"),
        (Language
German, String
"Klassendiagramme")
        ]
      solution :: Map Int Bool
solution = Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
-> Bool
forall a b. Either a b -> Bool
isRight (Either
   (Annotation ArticleToUse (Change (AnyRelationship String String)))
   (ObjectDiagram String String String)
 -> Bool)
-> (CdChange
    -> Either
         (Annotation ArticleToUse (Change (AnyRelationship String String)))
         (ObjectDiagram String String String))
-> CdChange
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CdChange
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity
-> Either forInvalidity forValidity
hint (CdChange -> Bool) -> Map Int CdChange -> Map Int Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Int CdChange
classDiagrams
      correctAnswer :: Maybe String
correctAnswer
        | Bool
showSolution = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ [Int] -> String
forall a. Show a => a -> String
show ([Int] -> String) -> [Int] -> String
forall a b. (a -> b) -> a -> b
$ SelectValidCdInstance -> [Int]
selectValidCdSolution SelectValidCdInstance
inst
        | Bool
otherwise = Maybe String
forall a. Maybe a
Nothing
  LangM' m Rational -> LangM m -> LangM' m Rational
forall (m :: * -> *).
(Alternative m, Monad m, OutputCapable m) =>
Rated m -> LangM m -> Rated m
reRefuse (ArticleToUse
-> Map Language String
-> Maybe String
-> Map Int Bool
-> [Int]
-> LangM' m Rational
forall (m :: * -> *) a.
(OutputCapable m, Ord a) =>
ArticleToUse
-> Map Language String
-> Maybe String
-> Map a Bool
-> [a]
-> Rated m
multipleChoice ArticleToUse
DefiniteArticle Map Language String
cds Maybe String
correctAnswer Map Int Bool
solution [Int]
xs)
    (LangM m -> LangM' m Rational) -> LangM m -> LangM' m Rational
forall a b. (a -> b) -> a -> b
$ Bool -> LangM m -> LangM m
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
showExtendedFeedback
    (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ GenericLangM Language m (Map Int ()) -> LangM m
forall (f :: * -> *) a. Functor f => f a -> f ()
void (GenericLangM Language m (Map Int ()) -> LangM m)
-> GenericLangM Language m (Map Int ()) -> LangM m
forall a b. (a -> b) -> a -> b
$ (Int -> CdChange -> LangM m)
-> Map Int CdChange -> GenericLangM Language m (Map Int ())
forall (t :: * -> *) k a b.
Applicative t =>
(k -> a -> t b) -> Map k a -> t (Map k b)
M.traverseWithKey
      (String -> CdDrawSettings -> [Int] -> Int -> CdChange -> LangM m
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m, MonadThrow m,
 OutputCapable m) =>
String -> CdDrawSettings -> [Int] -> Int -> CdChange -> LangM m
selectValidCdFeedback String
path CdDrawSettings
cdDrawSettings [Int]
xs)
      Map Int CdChange
classDiagrams

selectValidCdFeedback
  :: (MonadCache m, MonadDiagrams m, MonadGraphviz m, MonadThrow m, OutputCapable m)
  => FilePath
  -> CdDrawSettings
  -> [Int]
  -> Int
  -> CdChange
  -> LangM m
selectValidCdFeedback :: forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m, MonadThrow m,
 OutputCapable m) =>
String -> CdDrawSettings -> [Int] -> Int -> CdChange -> LangM m
selectValidCdFeedback String
path CdDrawSettings
drawSettings [Int]
xs Int
x CdChange
cdChange =
  case CdChange
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity
-> Either forInvalidity forValidity
hint CdChange
cdChange of
    Left Annotation ArticleToUse (Change (AnyRelationship String String))
articleAndChange | Int
x Int -> [Int] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int]
xs -> do
      let change :: Change (AnyRelationship String String)
change = Annotation ArticleToUse (Change (AnyRelationship String String))
-> Change (AnyRelationship String String)
forall annotation annotated.
Annotation annotation annotated -> annotated
annotated Annotation ArticleToUse (Change (AnyRelationship String String))
articleAndChange
          article :: ArticleToUse
article = Annotation ArticleToUse (Change (AnyRelationship String String))
-> ArticleToUse
forall annotation annotated.
Annotation annotation annotated -> annotation
annotation Annotation ArticleToUse (Change (AnyRelationship String String))
articleAndChange
      LangM m
notCorrect
      LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
        String -> State (Map Language String) ()
english [iii|
          Class diagram candidate #{x} is invalid.
          |]
        String -> State (Map Language String) ()
german [iii|
          Klassendiagrammkandidat #{x} ist ungültig.
          |]
      let sufficient :: Bool
sufficient = Bool
byName Bool -> Bool -> Bool
|| Bool
-> (AnyRelationship String String -> Bool)
-> Maybe (AnyRelationship String String)
-> Bool
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Bool
True AnyRelationship String String -> Bool
forall {className} {relationshipName} {className}
       {relationshipName}.
Either
  (InvalidRelationship className relationshipName)
  (Relationship className relationshipName)
-> Bool
isInheritance (Change (AnyRelationship String String)
-> Maybe (AnyRelationship String String)
forall a. Change a -> Maybe a
remove Change (AnyRelationship String String)
change)
      Bool -> LangM m -> LangM m
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
sufficient LangM m
showNamedCd
      LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ case Change (AnyRelationship String String)
-> Maybe (AnyRelationship String String)
forall a. Change a -> Maybe a
remove Change (AnyRelationship String String)
change of
        Maybe (AnyRelationship String String)
Nothing -> m () -> LangM m
forall (f :: * -> *) a.
Functor f =>
f a -> GenericLangM Language f a
forall (t :: (* -> *) -> * -> *) (f :: * -> *) a.
(FunctorTrans t, Functor f) =>
f a -> t f a
lift (m () -> LangM m) -> m () -> LangM m
forall a b. (a -> b) -> a -> b
$ ModellingTasksException -> m ()
forall e a. Exception e => e -> m a
forall (m :: * -> *) e a. (MonadThrow m, Exception e) => e -> m a
throwM ModellingTasksException
NeverHappens
        Just AnyRelationship String String
relation -> State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
          let phrase :: Language -> String
phrase Language
l = Language
-> OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> Bool
-> Bool
-> AnyRelationship String String
-> String
phraseRelationship
                Language
l
                (CdDrawSettings -> OmittedDefaultMultiplicities
omittedDefaults CdDrawSettings
drawSettings)
                ArticleToUse
article
                PhrasingKind
Denoted
                Bool
True
                Bool
withDir
                AnyRelationship String String
relation
          String -> State (Map Language String) ()
english [iii|
            If for example #{phrase English} would not be there,
            it would be valid.
            |]
          String -> State (Map Language String) ()
german [iii|
            Wenn es zum Beispiel
            #{trailingCommaGerman $ phrase German}
            nicht gäbe, wäre er gültig.
            |]
      pure ()
    Right ObjectDiagram String String String
od | Int
x Int -> [Int] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Int]
xs -> do
      LangM m
notCorrect
      LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
        String -> State (Map Language String) ()
english [iii|
          Class diagram #{x} is valid.
          |]
        String -> State (Map Language String) ()
german [iii|
          Klassendiagramm #{x} ist gültig.
          |]
      let sufficient :: Bool
sufficient = Bool
byName Bool -> Bool -> Bool
|| AnyClassDiagram String String -> Bool
forall {className} {relationshipName}.
AnyClassDiagram className relationshipName -> Bool
onlyInheritances (CdChange -> AnyClassDiagram String String
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity -> option
option CdChange
cdChange)
      Bool -> LangM m -> LangM m
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless Bool
sufficient LangM m
showNamedCd
      LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
        String -> State (Map Language String) ()
english [iii|
          #{if sufficient then "Consider" else "Now consider"} the following object diagram, which is an instance of this
          class diagram:
          |]
        String -> State (Map Language String) ()
german [iii|
          #{if sufficient then "Betrachten Sie" else "Betrachten Sie nun"} das folgende Objektdiagramm,
          welches eine Instanz dieses Klassendiagramms ist:
          |]
      LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ String -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
String -> GenericLangM l m ()
image (String -> LangM m) -> m String -> LangM m
forall (m :: * -> *) a l b.
Monad m =>
(a -> GenericLangM l m b) -> m a -> GenericLangM l m b
$=<< ObjectDiagram String String String
-> DirType -> Bool -> String -> m String
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m, MonadThrow m) =>
ObjectDiagram String String String
-> DirType -> Bool -> String -> m String
cacheOd ObjectDiagram String String String
od DirType
dir Bool
True String
path
      pure ()
    Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
_ -> () -> LangM m
forall a. a -> GenericLangM Language m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
  where
    byName :: Bool
byName = CdDrawSettings -> Bool
printNames CdDrawSettings
drawSettings
    withDir :: Bool
withDir = CdDrawSettings -> Bool
printNavigations CdDrawSettings
drawSettings
    dir :: DirType
dir
      | Bool
withDir = DirType
Forward
      | Bool
otherwise = DirType
NoDir
    notCorrect :: LangM m
notCorrect = LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
      String -> State (Map Language String) ()
english [iii|Your answer about class diagram candidate #{x} is not right.|]
      String -> State (Map Language String) ()
german [iii|Ihre Antwort zu Klassendiagrammkandidat #{x} ist nicht richtig.|]
    isInheritance :: Either
  (InvalidRelationship className relationshipName)
  (Relationship className relationshipName)
-> Bool
isInheritance = \case
      Right Inheritance {} -> Bool
True
      Right {} -> Bool
False
      Left InvalidInheritance {} -> Bool
True
    onlyInheritances :: AnyClassDiagram className relationshipName -> Bool
onlyInheritances = (Either
   (InvalidRelationship className relationshipName)
   (Relationship className relationshipName)
 -> Bool)
-> [Either
      (InvalidRelationship className relationshipName)
      (Relationship className relationshipName)]
-> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Either
  (InvalidRelationship className relationshipName)
  (Relationship className relationshipName)
-> Bool
forall {className} {relationshipName} {className}
       {relationshipName}.
Either
  (InvalidRelationship className relationshipName)
  (Relationship className relationshipName)
-> Bool
isInheritance ([Either
    (InvalidRelationship className relationshipName)
    (Relationship className relationshipName)]
 -> Bool)
-> (AnyClassDiagram className relationshipName
    -> [Either
          (InvalidRelationship className relationshipName)
          (Relationship className relationshipName)])
-> AnyClassDiagram className relationshipName
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. AnyClassDiagram className relationshipName
-> [Either
      (InvalidRelationship className relationshipName)
      (Relationship className relationshipName)]
forall className relationshipName.
AnyClassDiagram className relationshipName
-> [AnyRelationship className relationshipName]
anyRelationships
    showNamedCd :: LangM m
showNamedCd = do
        LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> LangM m)
-> State (Map Language String) () -> LangM m
forall a b. (a -> b) -> a -> b
$ do
          String -> State (Map Language String) ()
english [iii|
            The relationships in the class diagram could be named in the following way:
            |]
          String -> State (Map Language String) ()
german [iii|
            Die Beziehungen in dem Klassendiagramm könnten auf folgende Weise
            mit Namen versehen werden:
            |]
        let withNames :: CdDrawSettings
withNames = CdDrawSettings
drawSettings {printNames :: Bool
printNames = Bool
True}
        LangM m -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (LangM m -> LangM m) -> LangM m -> LangM m
forall a b. (a -> b) -> a -> b
$ String -> LangM m
forall l (m :: * -> *).
GenericOutputCapable l m =>
String -> GenericLangM l m ()
image (String -> LangM m) -> m String -> LangM m
forall (m :: * -> *) a l b.
Monad m =>
(a -> GenericLangM l m b) -> m a -> GenericLangM l m b
$=<< CdDrawSettings
-> Style V2 Double
-> AnyClassDiagram String String
-> String
-> m String
forall (m :: * -> *).
(MonadCache m, MonadDiagrams m, MonadGraphviz m) =>
CdDrawSettings
-> Style V2 Double
-> AnyClassDiagram String String
-> String
-> m String
cacheCd CdDrawSettings
withNames Style V2 Double
forall a. Monoid a => a
mempty (CdChange -> AnyClassDiagram String String
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity -> option
option CdChange
cdChange) String
path
        pure ()

selectValidCdSolution :: SelectValidCdInstance -> [Int]
selectValidCdSolution :: SelectValidCdInstance -> [Int]
selectValidCdSolution =
  Map Int Bool -> [Int]
forall k a. Map k a -> [k]
M.keys (Map Int Bool -> [Int])
-> (SelectValidCdInstance -> Map Int Bool)
-> SelectValidCdInstance
-> [Int]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> Bool) -> Map Int Bool -> Map Int Bool
forall a k. (a -> Bool) -> Map k a -> Map k a
M.filter Bool -> Bool
forall a. a -> a
id (Map Int Bool -> Map Int Bool)
-> (SelectValidCdInstance -> Map Int Bool)
-> SelectValidCdInstance
-> Map Int Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CdChange -> Bool) -> Map Int CdChange -> Map Int Bool
forall a b. (a -> b) -> Map Int a -> Map Int b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
-> Bool
forall a b. Either a b -> Bool
isRight (Either
   (Annotation ArticleToUse (Change (AnyRelationship String String)))
   (ObjectDiagram String String String)
 -> Bool)
-> (CdChange
    -> Either
         (Annotation ArticleToUse (Change (AnyRelationship String String)))
         (ObjectDiagram String String String))
-> CdChange
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CdChange
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity
-> Either forInvalidity forValidity
hint) (Map Int CdChange -> Map Int Bool)
-> (SelectValidCdInstance -> Map Int CdChange)
-> SelectValidCdInstance
-> Map Int Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SelectValidCdInstance -> Map Int CdChange
classDiagrams

selectValidCd
  :: (MonadAlloy m, MonadCatch m)
  => SelectValidCdConfig
  -> Int
  -> Int
  -> m SelectValidCdInstance
selectValidCd :: forall (m :: * -> *).
(MonadAlloy m, MonadCatch m) =>
SelectValidCdConfig -> Int -> Int -> m SelectValidCdInstance
selectValidCd SelectValidCdConfig {Bool
[CdMutation]
Maybe Int
Maybe Integer
Maybe (Map Language String)
ArticlePreference
AllowedProperties
ObjectProperties
CdDrawSettings
CdConstraints
ClassConfig
WeakeningKind
allowedCdMutations :: SelectValidCdConfig -> [CdMutation]
allowedProperties :: SelectValidCdConfig -> AllowedProperties
articleToUse :: SelectValidCdConfig -> ArticlePreference
basePropertiesOfBaseCdOn :: SelectValidCdConfig -> WeakeningKind
cdConstraints :: SelectValidCdConfig -> CdConstraints
classConfig :: SelectValidCdConfig -> ClassConfig
drawSettings :: SelectValidCdConfig -> CdDrawSettings
maxInstances :: SelectValidCdConfig -> Maybe Integer
objectProperties :: SelectValidCdConfig -> ObjectProperties
printExtendedFeedback :: SelectValidCdConfig -> Bool
printSolution :: SelectValidCdConfig -> Bool
shuffleEachCd :: SelectValidCdConfig -> Bool
timeout :: SelectValidCdConfig -> Maybe Int
extraText :: SelectValidCdConfig -> Maybe (Map Language String)
allowedCdMutations :: [CdMutation]
allowedProperties :: AllowedProperties
articleToUse :: ArticlePreference
basePropertiesOfBaseCdOn :: WeakeningKind
cdConstraints :: CdConstraints
classConfig :: ClassConfig
drawSettings :: CdDrawSettings
maxInstances :: Maybe Integer
objectProperties :: ObjectProperties
printExtendedFeedback :: Bool
printSolution :: Bool
shuffleEachCd :: Bool
timeout :: Maybe Int
extraText :: Maybe (Map Language String)
..} Int
segment Int
seed = (RandT StdGen m SelectValidCdInstance
 -> StdGen -> m SelectValidCdInstance)
-> StdGen
-> RandT StdGen m SelectValidCdInstance
-> m SelectValidCdInstance
forall a b c. (a -> b -> c) -> b -> a -> c
flip RandT StdGen m SelectValidCdInstance
-> StdGen -> m SelectValidCdInstance
forall (m :: * -> *) g a. Monad m => RandT g m a -> g -> m a
evalRandT StdGen
g (RandT StdGen m SelectValidCdInstance -> m SelectValidCdInstance)
-> RandT StdGen m SelectValidCdInstance -> m SelectValidCdInstance
forall a b. (a -> b) -> a -> b
$ do
  (AnyClassDiagram String String
_, [CdChangeAndCd]
chs)  <- WeakeningKind
-> AllowedProperties
-> ClassConfig
-> CdConstraints
-> [CdMutation]
-> ObjectProperties
-> ArticlePreference
-> Maybe Integer
-> Maybe Int
-> RandT StdGen m (AnyClassDiagram String String, [CdChangeAndCd])
forall (m :: * -> *) g.
(MonadAlloy m, MonadCatch m, RandomGen g) =>
WeakeningKind
-> AllowedProperties
-> ClassConfig
-> CdConstraints
-> [CdMutation]
-> ObjectProperties
-> ArticlePreference
-> Maybe Integer
-> Maybe Int
-> RandT g m (AnyClassDiagram String String, [CdChangeAndCd])
generateSetOfCds
    WeakeningKind
basePropertiesOfBaseCdOn
    AllowedProperties
allowedProperties
    ClassConfig
classConfig
    CdConstraints
cdConstraints
    [CdMutation]
allowedCdMutations
    ObjectProperties
objectProperties
    ArticlePreference
articleToUse
    Maybe Integer
maxInstances
    Maybe Int
timeout
  let cds :: [CdChange]
cds = (CdChangeAndCd -> CdChange) -> [CdChangeAndCd] -> [CdChange]
forall a b. (a -> b) -> [a] -> [b]
map ((AnnotatedChangeAndCd ArticleToUse String String
 -> AnyClassDiagram String String)
-> (Annotation
      ArticleToUse (Change (AnyRelationship String String))
    -> Annotation
         ArticleToUse (Change (AnyRelationship String String)))
-> (ObjectDiagram String String String
    -> ObjectDiagram String String String)
-> CdChangeAndCd
-> CdChange
forall a b c d e f.
(a -> b)
-> (c -> d)
-> (e -> f)
-> InValidOption a c e
-> InValidOption b d f
mapInValidOption AnnotatedChangeAndCd ArticleToUse String String
-> AnyClassDiagram String String
forall annotation className relationshipName.
AnnotatedChangeAndCd annotation className relationshipName
-> AnyClassDiagram className relationshipName
annotatedChangeClassDiagram Annotation ArticleToUse (Change (AnyRelationship String String))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
forall a. a -> a
id ObjectDiagram String String String
-> ObjectDiagram String String String
forall a. a -> a
id) [CdChangeAndCd]
chs
  SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance
shuffleCds (SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance)
-> (SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance)
-> SelectValidCdInstance
-> RandT StdGen m SelectValidCdInstance
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance
forall (m :: * -> *) a.
(MonadRandom m, MonadThrow m, Randomise a, RandomiseLayout a,
 RandomiseNames a) =>
a -> m a
shuffleEverything (SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance)
-> SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance
forall a b. (a -> b) -> a -> b
$ SelectValidCdInstance {
    cdDrawSettings :: CdDrawSettings
cdDrawSettings  = CdDrawSettings
drawSettings,
    classDiagrams :: Map Int CdChange
classDiagrams   = [(Int, CdChange)] -> Map Int CdChange
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Int, CdChange)] -> Map Int CdChange)
-> [(Int, CdChange)] -> Map Int CdChange
forall a b. (a -> b) -> a -> b
$ [Int] -> [CdChange] -> [(Int, CdChange)]
forall a b. [a] -> [b] -> [(a, b)]
zip [Int
1 ..] [CdChange]
cds,
    showExtendedFeedback :: Bool
showExtendedFeedback = Bool
printExtendedFeedback,
    showSolution :: Bool
showSolution    = Bool
printSolution,
    taskText :: SelectValidCdTaskText
taskText        = SelectValidCdTaskText
defaultSelectValidCdTaskText,
    addText :: Maybe (Map Language String)
addText          = Maybe (Map Language String)
extraText
    }
  where
    g :: StdGen
g = Int -> StdGen
mkStdGen (Int -> StdGen) -> Int -> StdGen
forall a b. (a -> b) -> a -> b
$ (Int
segment Int -> Int -> Int
forall a. Num a => a -> a -> a
+) (Int -> Int) -> Int -> Int
forall a b. (a -> b) -> a -> b
$ Int
4 Int -> Int -> Int
forall a. Num a => a -> a -> a
* Int
seed
    shuffleCds :: SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance
shuffleCds
      | Bool
shuffleEachCd        = SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance
forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> m SelectValidCdInstance
shuffleEach
      | Bool
otherwise            = SelectValidCdInstance -> RandT StdGen m SelectValidCdInstance
forall a. a -> RandT StdGen m a
forall (m :: * -> *) a. Monad m => a -> m a
return

instance Randomise SelectValidCdInstance where
  randomise :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> m SelectValidCdInstance
randomise = SelectValidCdInstance -> m SelectValidCdInstance
forall (m :: * -> *).
MonadRandom m =>
SelectValidCdInstance -> m SelectValidCdInstance
shuffleInstance

instance RandomiseNames SelectValidCdInstance where
  randomiseNames :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> m SelectValidCdInstance
randomiseNames SelectValidCdInstance
inst = do
    let ([String]
names, [String]
nonInheritances) = SelectValidCdInstance -> ([String], [String])
classAndNonInheritanceNames SelectValidCdInstance
inst
    [String]
names' <- [String] -> m [String]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [String]
names
    [String]
nonInheritances' <- [String] -> m [String]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [String]
nonInheritances
    SelectValidCdInstance
-> [String] -> [String] -> m SelectValidCdInstance
forall (m :: * -> *).
MonadThrow m =>
SelectValidCdInstance
-> [String] -> [String] -> m SelectValidCdInstance
renameInstance SelectValidCdInstance
inst [String]
names' [String]
nonInheritances'

instance RandomiseLayout SelectValidCdInstance where
  randomiseLayout :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> m SelectValidCdInstance
randomiseLayout SelectValidCdInstance {Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..} = do
    Map Int CdChange
cds <- (AnyClassDiagram String String
 -> m (AnyClassDiagram String String))
-> (Annotation
      ArticleToUse (Change (AnyRelationship String String))
    -> m (Annotation
            ArticleToUse (Change (AnyRelationship String String))))
-> (ObjectDiagram String String String
    -> m (ObjectDiagram String String String))
-> CdChange
-> m CdChange
forall (m :: * -> *) a b c d e f.
Applicative m =>
(a -> m b)
-> (c -> m d)
-> (e -> m f)
-> InValidOption a c e
-> m (InValidOption b d f)
mapInValidOptionM
      AnyClassDiagram String String -> m (AnyClassDiagram String String)
forall (m :: * -> *).
MonadRandom m =>
AnyClassDiagram String String -> m (AnyClassDiagram String String)
shuffleAnyClassAndConnectionOrder
      Annotation ArticleToUse (Change (AnyRelationship String String))
-> m (Annotation
        ArticleToUse (Change (AnyRelationship String String)))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
      ObjectDiagram String String String
-> m (ObjectDiagram String String String)
forall (m :: * -> *) objectName className linkLabel.
MonadRandom m =>
ObjectDiagram objectName className linkLabel
-> m (ObjectDiagram objectName className linkLabel)
shuffleObjectAndLinkOrder
      (CdChange -> m CdChange)
-> Map Int CdChange -> m (Map Int CdChange)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Map Int a -> m (Map Int b)
`mapM` Map Int CdChange
classDiagrams
    return $ SelectValidCdInstance {
      cdDrawSettings :: CdDrawSettings
cdDrawSettings          = CdDrawSettings
cdDrawSettings,
      classDiagrams :: Map Int CdChange
classDiagrams           = Map Int CdChange
cds,
      showExtendedFeedback :: Bool
showExtendedFeedback    = Bool
showExtendedFeedback,
      showSolution :: Bool
showSolution            = Bool
showSolution,
      taskText :: SelectValidCdTaskText
taskText                = SelectValidCdTaskText
taskText,
      addText :: Maybe (Map Language String)
addText                 = Maybe (Map Language String)
addText
      }

shuffleEach
  :: (MonadRandom m, MonadThrow m)
  => SelectValidCdInstance
  -> m SelectValidCdInstance
shuffleEach :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> m SelectValidCdInstance
shuffleEach inst :: SelectValidCdInstance
inst@SelectValidCdInstance {Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..} = do
  Map Int CdChange
cds <- SelectValidCdInstance -> CdChange -> m CdChange
forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> CdChange -> m CdChange
shuffleCdChange SelectValidCdInstance
inst (CdChange -> m CdChange)
-> Map Int CdChange -> m (Map Int CdChange)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Map Int a -> m (Map Int b)
`mapM` Map Int CdChange
classDiagrams
  return $ SelectValidCdInstance {
    cdDrawSettings :: CdDrawSettings
cdDrawSettings          = CdDrawSettings
cdDrawSettings,
    classDiagrams :: Map Int CdChange
classDiagrams           = Map Int CdChange
cds,
    showExtendedFeedback :: Bool
showExtendedFeedback    = Bool
showExtendedFeedback,
    showSolution :: Bool
showSolution            = Bool
showSolution,
    taskText :: SelectValidCdTaskText
taskText                = SelectValidCdTaskText
taskText,
    addText :: Maybe (Map Language String)
addText                 = Maybe (Map Language String)
addText
    }

shuffleCdChange
  :: (MonadRandom m, MonadThrow m)
  => SelectValidCdInstance
  -> CdChange
  -> m CdChange
shuffleCdChange :: forall (m :: * -> *).
(MonadRandom m, MonadThrow m) =>
SelectValidCdInstance -> CdChange -> m CdChange
shuffleCdChange SelectValidCdInstance
inst CdChange
x = do
  [String]
names' <- [String] -> m [String]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [String]
names
  [String]
nonInheritances' <- [String] -> m [String]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM [String]
nonInheritances
  let bmNames :: Bimap String String
bmNames  = [(String, String)] -> Bimap String String
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList ([(String, String)] -> Bimap String String)
-> [(String, String)] -> Bimap String String
forall a b. (a -> b) -> a -> b
$ [String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
names [String]
names'
      bmNonInheritances :: Bimap String String
bmNonInheritances = [(String, String)] -> Bimap String String
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList ([(String, String)] -> Bimap String String)
-> [(String, String)] -> Bimap String String
forall a b. (a -> b) -> a -> b
$ [String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
nonInheritances [String]
nonInheritances'
      renameCd :: AnyClassDiagram String String -> m (AnyClassDiagram String String)
renameCd = Bimap String String
-> Bimap String String
-> AnyClassDiagram String String
-> m (AnyClassDiagram String String)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
      renameOd :: ObjectDiagram String String String
-> m (ObjectDiagram String String String)
renameOd = Bimap String String
-> Bimap String String
-> ObjectDiagram String String String
-> m (ObjectDiagram String String String)
forall (m :: * -> *) linkLabels linkLabels'.
(MonadThrow m, Ord linkLabels, Ord linkLabels') =>
Bimap String String
-> Bimap linkLabels linkLabels'
-> ObjectDiagram String String linkLabels
-> m (ObjectDiagram String String linkLabels')
renameObjectsWithClassesAndLinksInOd Bimap String String
bmNames Bimap String String
bmNonInheritances
      renameEdge :: InvalidRelationship String String
-> m (InvalidRelationship String String)
renameEdge = Bimap String String
-> Bimap String String
-> InvalidRelationship String String
-> m (InvalidRelationship String String)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
      renameEdge' :: Relationship String String -> m (Relationship String String)
renameEdge' = Bimap String String
-> Bimap String String
-> Relationship String String
-> m (Relationship String String)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
  (AnyClassDiagram String String
 -> m (AnyClassDiagram String String))
-> (Annotation
      ArticleToUse (Change (AnyRelationship String String))
    -> m (Annotation
            ArticleToUse (Change (AnyRelationship String String))))
-> (ObjectDiagram String String String
    -> m (ObjectDiagram String String String))
-> CdChange
-> m CdChange
forall (m :: * -> *) a b c d e f.
Applicative m =>
(a -> m b)
-> (c -> m d)
-> (e -> m f)
-> InValidOption a c e
-> m (InValidOption b d f)
mapInValidOptionM
    AnyClassDiagram String String -> m (AnyClassDiagram String String)
renameCd
    ((Change (AnyRelationship String String)
 -> m (Change (AnyRelationship String String)))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> m (Annotation
        ArticleToUse (Change (AnyRelationship String String)))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b)
-> Annotation ArticleToUse a -> m (Annotation ArticleToUse b)
mapM ((Change (AnyRelationship String String)
  -> m (Change (AnyRelationship String String)))
 -> Annotation ArticleToUse (Change (AnyRelationship String String))
 -> m (Annotation
         ArticleToUse (Change (AnyRelationship String String))))
-> (Change (AnyRelationship String String)
    -> m (Change (AnyRelationship String String)))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> m (Annotation
        ArticleToUse (Change (AnyRelationship String String)))
forall a b. (a -> b) -> a -> b
$ (AnyRelationship String String
 -> m (AnyRelationship String String))
-> Change (AnyRelationship String String)
-> m (Change (AnyRelationship String String))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Change a -> m (Change b)
mapM ((AnyRelationship String String
  -> m (AnyRelationship String String))
 -> Change (AnyRelationship String String)
 -> m (Change (AnyRelationship String String)))
-> (AnyRelationship String String
    -> m (AnyRelationship String String))
-> Change (AnyRelationship String String)
-> m (Change (AnyRelationship String String))
forall a b. (a -> b) -> a -> b
$ (InvalidRelationship String String
 -> m (InvalidRelationship String String))
-> (Relationship String String -> m (Relationship String String))
-> AnyRelationship String String
-> m (AnyRelationship String String)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bimapM InvalidRelationship String String
-> m (InvalidRelationship String String)
renameEdge Relationship String String -> m (Relationship String String)
renameEdge')
    ObjectDiagram String String String
-> m (ObjectDiagram String String String)
renameOd
    CdChange
x
  where
    ([String]
names, [String]
nonInheritances) = SelectValidCdInstance -> ([String], [String])
classAndNonInheritanceNames SelectValidCdInstance
inst

shuffleInstance
  :: MonadRandom m
  => SelectValidCdInstance
  -> m SelectValidCdInstance
shuffleInstance :: forall (m :: * -> *).
MonadRandom m =>
SelectValidCdInstance -> m SelectValidCdInstance
shuffleInstance SelectValidCdInstance {Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..} =
  (CdDrawSettings
-> Map Int CdChange
-> Bool
-> Bool
-> SelectValidCdTaskText
-> Maybe (Map Language String)
-> SelectValidCdInstance
SelectValidCdInstance CdDrawSettings
cdDrawSettings
    (Map Int CdChange
 -> Bool
 -> Bool
 -> SelectValidCdTaskText
 -> Maybe (Map Language String)
 -> SelectValidCdInstance)
-> ([(Int, CdChange)] -> Map Int CdChange)
-> [(Int, CdChange)]
-> Bool
-> Bool
-> SelectValidCdTaskText
-> Maybe (Map Language String)
-> SelectValidCdInstance
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Int, CdChange)] -> Map Int CdChange
forall k a. Eq k => [(k, a)] -> Map k a
M.fromAscList ([(Int, CdChange)] -> Map Int CdChange)
-> ([(Int, CdChange)] -> [(Int, CdChange)])
-> [(Int, CdChange)]
-> Map Int CdChange
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Int -> (Int, CdChange) -> (Int, CdChange))
-> [Int] -> [(Int, CdChange)] -> [(Int, CdChange)]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
zipWith Int -> (Int, CdChange) -> (Int, CdChange)
forall {a} {a} {b}. a -> (a, b) -> (a, b)
replaceId [Int
1..]
       ([(Int, CdChange)]
 -> Bool
 -> Bool
 -> SelectValidCdTaskText
 -> Maybe (Map Language String)
 -> SelectValidCdInstance)
-> m [(Int, CdChange)]
-> m (Bool
      -> Bool
      -> SelectValidCdTaskText
      -> Maybe (Map Language String)
      -> SelectValidCdInstance)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, CdChange)] -> m [(Int, CdChange)]
forall (m :: * -> *) a. MonadRandom m => [a] -> m [a]
shuffleM (Map Int CdChange -> [(Int, CdChange)]
forall k a. Map k a -> [(k, a)]
M.toList Map Int CdChange
classDiagrams))
  m (Bool
   -> Bool
   -> SelectValidCdTaskText
   -> Maybe (Map Language String)
   -> SelectValidCdInstance)
-> m Bool
-> m (Bool
      -> SelectValidCdTaskText
      -> Maybe (Map Language String)
      -> SelectValidCdInstance)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
showExtendedFeedback
  m (Bool
   -> SelectValidCdTaskText
   -> Maybe (Map Language String)
   -> SelectValidCdInstance)
-> m Bool
-> m (SelectValidCdTaskText
      -> Maybe (Map Language String) -> SelectValidCdInstance)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> m Bool
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Bool
showSolution
  m (SelectValidCdTaskText
   -> Maybe (Map Language String) -> SelectValidCdInstance)
-> m SelectValidCdTaskText
-> m (Maybe (Map Language String) -> SelectValidCdInstance)
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> SelectValidCdTaskText -> m SelectValidCdTaskText
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SelectValidCdTaskText
taskText
  m (Maybe (Map Language String) -> SelectValidCdInstance)
-> m (Maybe (Map Language String)) -> m SelectValidCdInstance
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe (Map Language String) -> m (Maybe (Map Language String))
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe (Map Language String)
addText
  where
    replaceId :: a -> (a, b) -> (a, b)
replaceId a
x (a
_, b
cd) = (a
x, b
cd)

classAndNonInheritanceNames :: SelectValidCdInstance -> ([String], [String])
classAndNonInheritanceNames :: SelectValidCdInstance -> ([String], [String])
classAndNonInheritanceNames SelectValidCdInstance
inst =
  let cds :: Map Int CdChange
cds = SelectValidCdInstance -> Map Int CdChange
classDiagrams SelectValidCdInstance
inst
      ([Annotation ArticleToUse (Change (AnyRelationship String String))]
improves, [ObjectDiagram String String String]
evidences) = [Either
   (Annotation ArticleToUse (Change (AnyRelationship String String)))
   (ObjectDiagram String String String)]
-> ([Annotation
       ArticleToUse (Change (AnyRelationship String String))],
    [ObjectDiagram String String String])
forall a b. [Either a b] -> ([a], [b])
partitionEithers ([Either
    (Annotation ArticleToUse (Change (AnyRelationship String String)))
    (ObjectDiagram String String String)]
 -> ([Annotation
        ArticleToUse (Change (AnyRelationship String String))],
     [ObjectDiagram String String String]))
-> [Either
      (Annotation ArticleToUse (Change (AnyRelationship String String)))
      (ObjectDiagram String String String)]
-> ([Annotation
       ArticleToUse (Change (AnyRelationship String String))],
    [ObjectDiagram String String String])
forall a b. (a -> b) -> a -> b
$ (CdChange
 -> Either
      (Annotation ArticleToUse (Change (AnyRelationship String String)))
      (ObjectDiagram String String String))
-> [CdChange]
-> [Either
      (Annotation ArticleToUse (Change (AnyRelationship String String)))
      (ObjectDiagram String String String)]
forall a b. (a -> b) -> [a] -> [b]
map CdChange
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity
-> Either forInvalidity forValidity
hint ([CdChange]
 -> [Either
       (Annotation ArticleToUse (Change (AnyRelationship String String)))
       (ObjectDiagram String String String)])
-> [CdChange]
-> [Either
      (Annotation ArticleToUse (Change (AnyRelationship String String)))
      (ObjectDiagram String String String)]
forall a b. (a -> b) -> a -> b
$ Map Int CdChange -> [CdChange]
forall k a. Map k a -> [a]
M.elems Map Int CdChange
cds
      names :: [String]
names = [String] -> [String]
forall a. Ord a => [a] -> [a]
nubOrd ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ (CdChange -> [String]) -> Map Int CdChange -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (AnyClassDiagram String String -> [String]
forall className relationshipName.
AnyClassDiagram className relationshipName -> [className]
anyClassNames (AnyClassDiagram String String -> [String])
-> (CdChange -> AnyClassDiagram String String)
-> CdChange
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CdChange -> AnyClassDiagram String String
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity -> option
option) Map Int CdChange
cds
      nonInheritances :: [String]
nonInheritances = [String] -> [String]
forall a. Ord a => [a] -> [a]
nubOrd ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ (CdChange -> [String]) -> Map Int CdChange -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (AnyClassDiagram String String -> [String]
anyAssociationNames (AnyClassDiagram String String -> [String])
-> (CdChange -> AnyClassDiagram String String)
-> CdChange
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CdChange -> AnyClassDiagram String String
forall option forInvalidity forValidity.
InValidOption option forInvalidity forValidity -> option
option) Map Int CdChange
cds
        [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ (Annotation ArticleToUse (Change (AnyRelationship String String))
 -> Maybe String)
-> [Annotation
      ArticleToUse (Change (AnyRelationship String String))]
-> [String]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Change (AnyRelationship String String)
-> Maybe (AnyRelationship String String)
forall a. Change a -> Maybe a
add (Change (AnyRelationship String String)
 -> Maybe (AnyRelationship String String))
-> (Annotation
      ArticleToUse (Change (AnyRelationship String String))
    -> Change (AnyRelationship String String))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> Maybe (AnyRelationship String String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation ArticleToUse (Change (AnyRelationship String String))
-> Change (AnyRelationship String String)
forall annotation annotated.
Annotation annotation annotated -> annotated
annotated (Annotation ArticleToUse (Change (AnyRelationship String String))
 -> Maybe (AnyRelationship String String))
-> (AnyRelationship String String -> Maybe String)
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> Maybe String
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> AnyRelationship String String -> Maybe String
forall className relationshipName.
AnyRelationship className relationshipName
-> Maybe relationshipName
anyRelationshipName) [Annotation ArticleToUse (Change (AnyRelationship String String))]
improves
        [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ (Annotation ArticleToUse (Change (AnyRelationship String String))
 -> Maybe String)
-> [Annotation
      ArticleToUse (Change (AnyRelationship String String))]
-> [String]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe (Change (AnyRelationship String String)
-> Maybe (AnyRelationship String String)
forall a. Change a -> Maybe a
remove (Change (AnyRelationship String String)
 -> Maybe (AnyRelationship String String))
-> (Annotation
      ArticleToUse (Change (AnyRelationship String String))
    -> Change (AnyRelationship String String))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> Maybe (AnyRelationship String String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Annotation ArticleToUse (Change (AnyRelationship String String))
-> Change (AnyRelationship String String)
forall annotation annotated.
Annotation annotation annotated -> annotated
annotated (Annotation ArticleToUse (Change (AnyRelationship String String))
 -> Maybe (AnyRelationship String String))
-> (AnyRelationship String String -> Maybe String)
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> Maybe String
forall (m :: * -> *) a b c.
Monad m =>
(a -> m b) -> (b -> m c) -> a -> m c
>=> AnyRelationship String String -> Maybe String
forall className relationshipName.
AnyRelationship className relationshipName
-> Maybe relationshipName
anyRelationshipName) [Annotation ArticleToUse (Change (AnyRelationship String String))]
improves
        [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ (ObjectDiagram String String String -> [String])
-> [ObjectDiagram String String String] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ObjectDiagram String String String -> [String]
forall linkLabel objectName className.
Ord linkLabel =>
ObjectDiagram objectName className linkLabel -> [linkLabel]
linkLabels [ObjectDiagram String String String]
evidences
  in ([String]
names, [String]
nonInheritances)

renameInstance
  :: MonadThrow m
  => SelectValidCdInstance
  -> [String]
  -> [String]
  -> m SelectValidCdInstance
renameInstance :: forall (m :: * -> *).
MonadThrow m =>
SelectValidCdInstance
-> [String] -> [String] -> m SelectValidCdInstance
renameInstance inst :: SelectValidCdInstance
inst@SelectValidCdInstance {Bool
SelectValidCdTaskText
Maybe (Map Language String)
Map Int CdChange
CdDrawSettings
cdDrawSettings :: SelectValidCdInstance -> CdDrawSettings
classDiagrams :: SelectValidCdInstance -> Map Int CdChange
showExtendedFeedback :: SelectValidCdInstance -> Bool
showSolution :: SelectValidCdInstance -> Bool
taskText :: SelectValidCdInstance -> SelectValidCdTaskText
addText :: SelectValidCdInstance -> Maybe (Map Language String)
cdDrawSettings :: CdDrawSettings
classDiagrams :: Map Int CdChange
showExtendedFeedback :: Bool
showSolution :: Bool
taskText :: SelectValidCdTaskText
addText :: Maybe (Map Language String)
..} [String]
names' [String]
nonInheritances' = do
  let ([String]
names, [String]
nonInheritances) = SelectValidCdInstance -> ([String], [String])
classAndNonInheritanceNames SelectValidCdInstance
inst
      bmNames :: Bimap String String
bmNames  = [(String, String)] -> Bimap String String
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList ([(String, String)] -> Bimap String String)
-> [(String, String)] -> Bimap String String
forall a b. (a -> b) -> a -> b
$ [String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
names [String]
names'
      bmNonInheritances :: Bimap String String
bmNonInheritances = [(String, String)] -> Bimap String String
forall a b. (Ord a, Ord b) => [(a, b)] -> Bimap a b
BM.fromList ([(String, String)] -> Bimap String String)
-> [(String, String)] -> Bimap String String
forall a b. (a -> b) -> a -> b
$ [String] -> [String] -> [(String, String)]
forall a b. [a] -> [b] -> [(a, b)]
zip [String]
nonInheritances [String]
nonInheritances'
      renameCd :: AnyClassDiagram String String -> m (AnyClassDiagram String String)
renameCd = Bimap String String
-> Bimap String String
-> AnyClassDiagram String String
-> m (AnyClassDiagram String String)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
      renameEdge :: InvalidRelationship String String
-> m (InvalidRelationship String String)
renameEdge = Bimap String String
-> Bimap String String
-> InvalidRelationship String String
-> m (InvalidRelationship String String)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
      renameEdge' :: Relationship String String -> m (Relationship String String)
renameEdge' = Bimap String String
-> Bimap String String
-> Relationship String String
-> m (Relationship String String)
forall (f :: * -> * -> *) (m :: * -> *) c c' r r'.
(Bitraversable f, MonadThrow m, Ord c, Ord c', Ord r, Ord r') =>
Bimap c c' -> Bimap r r' -> f c r -> m (f c' r')
renameClassesAndRelationships Bimap String String
bmNames Bimap String String
bmNonInheritances
      renameOd :: ObjectDiagram String String String
-> m (ObjectDiagram String String String)
renameOd = Bimap String String
-> Bimap String String
-> ObjectDiagram String String String
-> m (ObjectDiagram String String String)
forall (m :: * -> *) linkLabels linkLabels'.
(MonadThrow m, Ord linkLabels, Ord linkLabels') =>
Bimap String String
-> Bimap linkLabels linkLabels'
-> ObjectDiagram String String linkLabels
-> m (ObjectDiagram String String linkLabels')
renameObjectsWithClassesAndLinksInOd Bimap String String
bmNames Bimap String String
bmNonInheritances
  Map Int CdChange
cds <- (CdChange -> m CdChange)
-> Map Int CdChange -> m (Map Int CdChange)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Map Int a -> m (Map Int b)
mapM
    ((AnyClassDiagram String String
 -> m (AnyClassDiagram String String))
-> (Annotation
      ArticleToUse (Change (AnyRelationship String String))
    -> m (Annotation
            ArticleToUse (Change (AnyRelationship String String))))
-> (ObjectDiagram String String String
    -> m (ObjectDiagram String String String))
-> CdChange
-> m CdChange
forall (m :: * -> *) a b c d e f.
Applicative m =>
(a -> m b)
-> (c -> m d)
-> (e -> m f)
-> InValidOption a c e
-> m (InValidOption b d f)
mapInValidOptionM AnyClassDiagram String String -> m (AnyClassDiagram String String)
renameCd ((Change (AnyRelationship String String)
 -> m (Change (AnyRelationship String String)))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> m (Annotation
        ArticleToUse (Change (AnyRelationship String String)))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b)
-> Annotation ArticleToUse a -> m (Annotation ArticleToUse b)
mapM ((Change (AnyRelationship String String)
  -> m (Change (AnyRelationship String String)))
 -> Annotation ArticleToUse (Change (AnyRelationship String String))
 -> m (Annotation
         ArticleToUse (Change (AnyRelationship String String))))
-> (Change (AnyRelationship String String)
    -> m (Change (AnyRelationship String String)))
-> Annotation ArticleToUse (Change (AnyRelationship String String))
-> m (Annotation
        ArticleToUse (Change (AnyRelationship String String)))
forall a b. (a -> b) -> a -> b
$ (AnyRelationship String String
 -> m (AnyRelationship String String))
-> Change (AnyRelationship String String)
-> m (Change (AnyRelationship String String))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Change a -> m (Change b)
mapM ((AnyRelationship String String
  -> m (AnyRelationship String String))
 -> Change (AnyRelationship String String)
 -> m (Change (AnyRelationship String String)))
-> (AnyRelationship String String
    -> m (AnyRelationship String String))
-> Change (AnyRelationship String String)
-> m (Change (AnyRelationship String String))
forall a b. (a -> b) -> a -> b
$ (InvalidRelationship String String
 -> m (InvalidRelationship String String))
-> (Relationship String String -> m (Relationship String String))
-> AnyRelationship String String
-> m (AnyRelationship String String)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bimapM InvalidRelationship String String
-> m (InvalidRelationship String String)
renameEdge Relationship String String -> m (Relationship String String)
renameEdge') ObjectDiagram String String String
-> m (ObjectDiagram String String String)
renameOd)
    Map Int CdChange
classDiagrams
  return $ SelectValidCdInstance {
    cdDrawSettings :: CdDrawSettings
cdDrawSettings  = CdDrawSettings
cdDrawSettings,
    classDiagrams :: Map Int CdChange
classDiagrams   = Map Int CdChange
cds,
    showExtendedFeedback :: Bool
showExtendedFeedback = Bool
showExtendedFeedback,
    showSolution :: Bool
showSolution    = Bool
showSolution,
    taskText :: SelectValidCdTaskText
taskText        = SelectValidCdTaskText
taskText,
    addText :: Maybe (Map Language String)
addText         = Maybe (Map Language String)
addText
    }

defaultSelectValidCdInstance :: SelectValidCdInstance
defaultSelectValidCdInstance :: SelectValidCdInstance
defaultSelectValidCdInstance = SelectValidCdInstance {
  cdDrawSettings :: CdDrawSettings
cdDrawSettings = CdDrawSettings {
    omittedDefaults :: OmittedDefaultMultiplicities
omittedDefaults = OmittedDefaultMultiplicities {
      aggregationWholeOmittedDefaultMultiplicity :: Maybe (Int, Maybe Int)
aggregationWholeOmittedDefaultMultiplicity = (Int, Maybe Int) -> Maybe (Int, Maybe Int)
forall a. a -> Maybe a
Just (Int
0, Maybe Int
forall a. Maybe a
Nothing),
      associationOmittedDefaultMultiplicity :: Maybe (Int, Maybe Int)
associationOmittedDefaultMultiplicity = (Int, Maybe Int) -> Maybe (Int, Maybe Int)
forall a. a -> Maybe a
Just (Int
0, Maybe Int
forall a. Maybe a
Nothing),
      compositionWholeOmittedDefaultMultiplicity :: Maybe (Int, Maybe Int)
compositionWholeOmittedDefaultMultiplicity = (Int, Maybe Int) -> Maybe (Int, Maybe Int)
forall a. a -> Maybe a
Just (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
      },
    printNames :: Bool
printNames = Bool
True,
    printNavigations :: Bool
printNavigations = Bool
True
    },
  classDiagrams :: Map Int CdChange
classDiagrams = [(Int, CdChange)] -> Map Int CdChange
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [
    (Int
1, InValidOption {
      hint :: Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
hint = ObjectDiagram String String String
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall a b. b -> Either a b
Right ObjectDiagram {
        objects :: [Object String String]
objects = [
          Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"a", objectClass :: String
objectClass = String
"A"},
          Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"c", objectClass :: String
objectClass = String
"C"},
          Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"d", objectClass :: String
objectClass = String
"D"},
          Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"b", objectClass :: String
objectClass = String
"B"}
          ],
        links :: [Link String String]
links = []
        },
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"B", String
"C", String
"D", String
"A"],
        anyRelationships :: [AnyRelationship String String]
anyRelationships = [
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"C"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"B", superClass :: String
superClass = String
"D"}
          ]
        }
      }),
    (Int
2, InValidOption {
      hint :: Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
hint = Annotation ArticleToUse (Change (AnyRelationship String String))
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall a b. a -> Either a b
Left Annotation {
        annotated :: Change (AnyRelationship String String)
annotated = Change {
          add :: Maybe (AnyRelationship String String)
add = Maybe (AnyRelationship String String)
forall a. Maybe a
Nothing,
          remove :: Maybe (AnyRelationship String String)
remove = AnyRelationship String String
-> Maybe (AnyRelationship String String)
forall a. a -> Maybe a
Just (Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {
            subClass :: String
subClass = String
"A",
            superClass :: String
superClass = String
"D"
            })
          },
        annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
        },
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"A", String
"B", String
"D", String
"C"],
        anyRelationships :: [AnyRelationship String String]
anyRelationships = [
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"D"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"A"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"B", superClass :: String
superClass = String
"D"}
          ]
        }
      }),
    (Int
3, InValidOption {
      hint :: Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
hint = Annotation ArticleToUse (Change (AnyRelationship String String))
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall a b. a -> Either a b
Left Annotation {
        annotated :: Change (AnyRelationship String String)
annotated = Change {
          add :: Maybe (AnyRelationship String String)
add = Maybe (AnyRelationship String String)
forall a. Maybe a
Nothing,
          remove :: Maybe (AnyRelationship String String)
remove = AnyRelationship String String
-> Maybe (AnyRelationship String String)
forall a. a -> Maybe a
Just (Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {
            subClass :: String
subClass = String
"B",
            superClass :: String
superClass = String
"D"
            })
          },
        annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
        },
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"A", String
"C", String
"D", String
"B"],
        anyRelationships :: [AnyRelationship String String]
anyRelationships = [
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"A"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"B", superClass :: String
superClass = String
"D"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"B"}
          ]
        }
      }),
    (Int
4, InValidOption {
      hint :: Either
  (Annotation ArticleToUse (Change (AnyRelationship String String)))
  (ObjectDiagram String String String)
hint = Annotation ArticleToUse (Change (AnyRelationship String String))
-> Either
     (Annotation ArticleToUse (Change (AnyRelationship String String)))
     (ObjectDiagram String String String)
forall a b. a -> Either a b
Left Annotation {
        annotated :: Change (AnyRelationship String String)
annotated = Change {
          add :: Maybe (AnyRelationship String String)
add = Maybe (AnyRelationship String String)
forall a. Maybe a
Nothing,
          remove :: Maybe (AnyRelationship String String)
remove = AnyRelationship String String
-> Maybe (AnyRelationship String String)
forall a. a -> Maybe a
Just (Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {
            subClass :: String
subClass = String
"A",
            superClass :: String
superClass = String
"C"
            })
          },
        annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
        },
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"B", String
"A", String
"C", String
"D"],
        anyRelationships :: [AnyRelationship String String]
anyRelationships = [
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"B", superClass :: String
superClass = String
"D"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"C"},
          Relationship String String -> AnyRelationship String String
forall a b. b -> Either a b
Right Inheritance {subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"A"}
          ]
        }
      })
    ],
  showExtendedFeedback :: Bool
showExtendedFeedback = Bool
True,
  showSolution :: Bool
showSolution = Bool
True,
  taskText :: SelectValidCdTaskText
taskText = SelectValidCdTaskText
defaultSelectValidCdTaskText,
  addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }