-- |

module Modelling.CdOd.SelectValidCd.Instance where

import qualified Data.Map                         as M (fromList)

import Modelling.CdOd.SelectValidCd (
  SelectValidCdInstance (..),
  SelectValidCdTaskTextElement (..),
  )

import Modelling.Auxiliary.Shuffle.All  (ShuffleInstance (..))
import Modelling.CdOd.RepairCd          (InValidOption (..))
import Modelling.CdOd.Types (
  Annotation (..),
  AnyClassDiagram (..),
  CdDrawSettings (..),
  LimitedLinking (..),
  Link (..),
  Object (..),
  ObjectDiagram (..),
  OmittedDefaultMultiplicities (..),
  Relationship (..),
  )
import Modelling.Types                  (Change (..))

import Control.OutputCapable.Blocks (
  ArticleToUse (DefiniteArticle),
  Language (English, German),
  )
import Control.OutputCapable.Blocks.Generic.Type (
  GenericOutput (Code, Paragraph, Special, Translated),
  )
import Data.Map                         (Map)

listToFM :: Ord a => [(a, b)] -> Map a b
listToFM :: forall a b. Ord a => [(a, b)] -> Map a b
listToFM = [(a, b)] -> Map a b
forall a b. Ord a => [(a, b)] -> Map a b
M.fromList

{-|
demo task
-}
task2024_05 :: SelectValidCdInstance
task2024_05 :: SelectValidCdInstance
task2024_05 = 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 a b. Ord a => [(a, b)] -> Map a b
listToFM [
    (Int
1, InValidOption {
      hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
        annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
          add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
          remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {
            subClass :: String
subClass = String
"D",
            superClass :: String
superClass = String
"C"
            }))
          },
        annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
        }),
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"B", String
"C", String
"D", String
"A"],
        anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"C"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"D"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"B", superClass :: String
superClass = String
"D"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"B"})
          ]
        }
      }),
    (Int
2, InValidOption {
      hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. b -> Either a b
Right (ObjectDiagram {
        objects :: [Object String String]
objects = [
          Object {
            isAnonymous :: Bool
isAnonymous = Bool
False,
            objectName :: String
objectName = String
"b",
            objectClass :: String
objectClass = String
"B"
            },
          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
"a",
            objectClass :: String
objectClass = String
"A"
            }
          ],
        links :: [Link String String]
links = []
        }),
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"B", String
"A", String
"D", String
"C"],
        anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"D"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"B"})
          ]
        }
      }),
    (Int
3, InValidOption {
      hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
        annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
          add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
          remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {
            subClass :: String
subClass = String
"D",
            superClass :: String
superClass = String
"C"
            }))
          },
        annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
        }),
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"B", String
"D", String
"C", String
"A"],
        anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"B", superClass :: String
superClass = String
"A"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"D"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"C"})
          ]
        }
    }),
    (Int
4, InValidOption {
      hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
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
"d",
            objectClass :: String
objectClass = String
"D"
            },
          Object {
            isAnonymous :: Bool
isAnonymous = Bool
False,
            objectName :: String
objectName = String
"b",
            objectClass :: String
objectClass = String
"B"
            },
          Object {
            isAnonymous :: Bool
isAnonymous = Bool
False,
            objectName :: String
objectName = String
"c",
            objectClass :: String
objectClass = String
"C"
            }
          ],
        links :: [Link String String]
links = []
        }),
      option :: AnyClassDiagram String String
option = AnyClassDiagram {
        anyClassNames :: [String]
anyClassNames = [String
"D", String
"C", String
"B", String
"A"],
        anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"B"}),
          Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"C"})
          ]
        }
      })
    ],
  showExtendedFeedback :: Bool
showExtendedFeedback = Bool
True,
  showSolution :: Bool
showSolution = Bool
True,
  taskText :: SelectValidCdTaskText
taskText = [
    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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
        (Language
English, String
"Consider the following class diagram candidates:"),
        (Language
German, String
"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 [
      Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
        (Language
English, String
"Which of these class diagram candidates are valid class diagrams?\nPlease state your answer by giving a list of numbers, indicating all valid class diagrams."),
        (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind valide Klassendiagramme?\nBitte 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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
        (Language
English, String
"For example,"),
        (Language
German, String
"Zum Beispiel würde")
        ]),
      Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Code ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
        (Language
English, String
"[1, 2]"),
        (Language
German, String
"[1, 2]")
        ]),
      Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
        (Language
English, String
"would indicate that only class diagram candidates 1 and 2 of the given ones are valid class diagrams."),
        (Language
German, String
"bedeuten, dass nur die Klassendiagrammkandidaten 1 und 2 der angegebenen Klassendiagrammkandidaten gültige Klassendiagramme sind.")
        ])
      ]
    ],
  addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
  }

{-|
Picked because generation for @task2024_06@ took too long to generate.
-}
task2024_06picked :: ShuffleInstance SelectValidCdInstance
task2024_06picked :: ShuffleInstance SelectValidCdInstance
task2024_06picked = ShuffleInstance {
  taskInstance :: SelectValidCdInstance
taskInstance = 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 = Maybe (Int, Maybe Int)
forall a. Maybe a
Nothing
        },
      printNames :: Bool
printNames = Bool
True,
      printNavigations :: Bool
printNavigations = Bool
False
      },
    classDiagrams :: Map Int CdChange
classDiagrams = [(Int, CdChange)] -> Map Int CdChange
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
      (Int
1, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. b -> Either a b
Right (ObjectDiagram {
          objects :: [Object String String]
objects = [
            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
"a", objectClass :: String
objectClass = String
"A" },
            Object { isAnonymous :: Bool
isAnonymous = Bool
True, objectName :: String
objectName = String
"e", objectClass :: String
objectClass = String
"E" },
            Object { isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"b", objectClass :: String
objectClass = String
"B" },
            Object { isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"d", objectClass :: String
objectClass = String
"D" }
            ],
          links :: [Link String String]
links = [
            Link { linkLabel :: String
linkLabel = String
"s", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"b" },
            Link { linkLabel :: String
linkLabel = String
"z", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"d" },
            Link { linkLabel :: String
linkLabel = String
"v", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"c" },
            Link { linkLabel :: String
linkLabel = String
"y", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"c" },
            Link { linkLabel :: String
linkLabel = String
"u", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"b" }
            ]
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"B", String
"C", String
"D", String
"A", String
"E"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"z",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"v",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"u",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"y",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"E" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"E" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"s",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              })
            ]
          }
        }),
      (Int
2, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
          annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
            add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
            remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"B" }))
            },
          annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"B", String
"A", String
"C", String
"D", String
"E"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"y",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"s",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"w",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"u",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"t",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"A", superClass :: String
superClass = String
"B" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship 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
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
          annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
            add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
            remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"E" }))
            },
          annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"A", String
"D", String
"C", String
"E", String
"B"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"t",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"u",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"C", superClass :: String
superClass = String
"D" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"v",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"y",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"x",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"w",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"E" })
            ]
          }
        }),
      (Int
4, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. b -> Either a b
Right (ObjectDiagram {
          objects :: [Object String String]
objects = [
            Object { isAnonymous :: Bool
isAnonymous = Bool
True, objectName :: String
objectName = String
"e", objectClass :: String
objectClass = String
"E" },
            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
"a", objectClass :: String
objectClass = String
"A" },
            Object { isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"b", objectClass :: String
objectClass = String
"B" },
            Object { isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"c", objectClass :: String
objectClass = String
"C" }
            ],
          links :: [Link String String]
links = [
            Link { linkLabel :: String
linkLabel = String
"w", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"d" },
            Link { linkLabel :: String
linkLabel = String
"x", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"e" },
            Link { linkLabel :: String
linkLabel = String
"v", linkFrom :: String
linkFrom = String
"c", linkTo :: String
linkTo = String
"d" },
            Link { linkLabel :: String
linkLabel = String
"t", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"a" },
            Link { linkLabel :: String
linkLabel = String
"s", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"a" },
            Link { linkLabel :: String
linkLabel = String
"z", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"d" }
            ]
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"D", String
"E", String
"A", String
"B", String
"C"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"s",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"w",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"x",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking { linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"z",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking { linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"E", superClass :: String
superClass = String
"C" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"t",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking { linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"v",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking { linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing) },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking { linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) }
              })
            ]
          }
        })
      ],
    showExtendedFeedback :: Bool
showExtendedFeedback = Bool
True,
    showSolution :: Bool
showSolution = Bool
True,
    taskText :: SelectValidCdTaskText
taskText = [
      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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"Consider the following class diagram candidates:"),
          (Language
German, String
"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 [
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"Which of these class diagram candidates are valid class diagrams?\nPlease state your answer by giving a list of numbers, indicating all valid class diagrams."),
          (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind valide Klassendiagramme?\nBitte 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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"For example,"),
          (Language
German, String
"Zum Beispiel würde")
          ]),
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Code ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"[1, 2]"),
          (Language
German, String
"[1, 2]")
          ]),
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"would indicate that only class diagram candidates 1 and 2 of the given ones are valid class diagrams."),
          (Language
German, String
"bedeuten, dass nur die Klassendiagrammkandidaten 1 und 2 der angegebenen Klassendiagrammkandidaten gültige Klassendiagramme sind.")
          ])
        ]
      ],
    addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
    },
  allowLayoutMangling :: Bool
allowLayoutMangling = Bool
True,
  shuffleNames :: Bool
shuffleNames = Bool
True,
  shuffleOptions :: Bool
shuffleOptions = Bool
True
  }

{-|
points: 0.15
-}
task2024_09 :: ShuffleInstance SelectValidCdInstance
task2024_09 :: ShuffleInstance SelectValidCdInstance
task2024_09 = ShuffleInstance {
  taskInstance :: SelectValidCdInstance
taskInstance = 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 = Maybe (Int, Maybe Int)
forall a. Maybe a
Nothing
        },
      printNames :: Bool
printNames = Bool
False,
      printNavigations :: Bool
printNavigations = Bool
True
      },
    classDiagrams :: Map Int CdChange
classDiagrams = [(Int, CdChange)] -> Map Int CdChange
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
      (Int
1, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
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
"b",
              objectClass :: String
objectClass = String
"B"
              },
            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
"e",
              objectClass :: String
objectClass = String
"E"
              },
            Object {
              isAnonymous :: Bool
isAnonymous = Bool
False,
              objectName :: String
objectName = String
"c",
              objectClass :: String
objectClass = String
"C"
              }
            ],
          links :: [Link String String]
links = [
            Link { linkLabel :: String
linkLabel = String
"u", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"d" },
            Link { linkLabel :: String
linkLabel = String
"r", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"b" },
            Link { linkLabel :: String
linkLabel = String
"t", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"e" },
            Link { linkLabel :: String
linkLabel = String
"y", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"c" },
            Link { linkLabel :: String
linkLabel = String
"z", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"e" },
            Link { linkLabel :: String
linkLabel = String
"r", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"b" },
            Link { linkLabel :: String
linkLabel = String
"q", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"c" }
            ]
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"C", String
"B", String
"E", String
"D", String
"A"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"y",
              associationFrom :: LimitedLinking String
associationFrom = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              associationTo :: LimitedLinking String
associationTo = (LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"r",
              compositionPart :: LimitedLinking String
compositionPart = (LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }),
              compositionWhole :: LimitedLinking String
compositionWhole = (LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"q",
              associationFrom :: LimitedLinking String
associationFrom = (LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              associationTo :: LimitedLinking String
associationTo = (LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"E", superClass :: String
superClass = String
"D" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"t",
              aggregationPart :: LimitedLinking String
aggregationPart = (LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              aggregationWhole :: LimitedLinking String
aggregationWhole = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"u",
              compositionPart :: LimitedLinking String
compositionPart = (LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                }),
              compositionWhole :: LimitedLinking String
compositionWhole = (LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"z",
              aggregationPart :: LimitedLinking String
aggregationPart = (LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              aggregationWhole :: LimitedLinking String
aggregationWhole = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              })
            ]
          }
        }),
      (Int
2, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
          annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
            add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
            remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"z",
              compositionPart :: LimitedLinking String
compositionPart = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }),
              compositionWhole :: LimitedLinking String
compositionWhole = (LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              }))
            },
          annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"B", String
"D", String
"E", String
"C", String
"A"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"s",
              aggregationPart :: LimitedLinking String
aggregationPart = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              aggregationWhole :: LimitedLinking String
aggregationWhole = (LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"v",
              associationFrom :: LimitedLinking String
associationFrom = (LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              associationTo :: LimitedLinking String
associationTo = (LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance { subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A" }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"r",
              compositionPart :: LimitedLinking String
compositionPart = (LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                }),
              compositionWhole :: LimitedLinking String
compositionWhole = (LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"w",
              aggregationPart :: LimitedLinking String
aggregationPart = (LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              aggregationWhole :: LimitedLinking String
aggregationWhole = (LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"u",
              associationFrom :: LimitedLinking String
associationFrom = (LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }),
              associationTo :: LimitedLinking String
associationTo = (LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"q",
              compositionPart :: LimitedLinking String
compositionPart = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }),
              compositionWhole :: LimitedLinking String
compositionWhole = (LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"z",
              compositionPart :: LimitedLinking String
compositionPart = (LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }),
              compositionWhole :: LimitedLinking String
compositionWhole = (LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                })
              })
            ]
          }
        }),
      (Int
3, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
          annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
            add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
            remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"z",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }
              }))
            },
          annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"B", String
"A", String
"E", String
"C", String
"D"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"w",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"u",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"x",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"z",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"s",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"t",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {
              subClass :: String
subClass = String
"B",
              superClass :: String
superClass = String
"A"
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"v",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                }
              })
            ]
          }
        }),
      (Int
4, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. b -> Either a b
Right (ObjectDiagram {
          objects :: [Object String String]
objects = [
            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
"e",
              objectClass :: String
objectClass = String
"E"
              },
            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
"b",
              objectClass :: String
objectClass = String
"B"
              },
            Object {
              isAnonymous :: Bool
isAnonymous = Bool
False,
              objectName :: String
objectName = String
"d",
              objectClass :: String
objectClass = String
"D"
              }
            ],
          links :: [Link String String]
links = [
            Link { linkLabel :: String
linkLabel = String
"s", linkFrom :: String
linkFrom = String
"c", linkTo :: String
linkTo = String
"d" },
            Link { linkLabel :: String
linkLabel = String
"t", linkFrom :: String
linkFrom = String
"c", linkTo :: String
linkTo = String
"e" },
            Link { linkLabel :: String
linkLabel = String
"r", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"b" },
            Link { linkLabel :: String
linkLabel = String
"t", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"e" },
            Link { linkLabel :: String
linkLabel = String
"q", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"c" },
            Link { linkLabel :: String
linkLabel = String
"y", linkFrom :: String
linkFrom = String
"c", linkTo :: String
linkTo = String
"d" },
            Link { linkLabel :: String
linkLabel = String
"z", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"c" }
            ]
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"D", String
"C", String
"B", String
"E", String
"A"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"q",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"s",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"y",
              associationFrom :: LimitedLinking String
associationFrom = LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              associationTo :: LimitedLinking String
associationTo = LimitedLinking {
                linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"r",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking {
                linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)
                },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {
              subClass :: String
subClass = String
"C",
              superClass :: String
superClass = String
"B"
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"t",
              compositionPart :: LimitedLinking String
compositionPart = LimitedLinking {
                linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
2, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)
                },
              compositionWhole :: LimitedLinking String
compositionWhole = LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"z",
              aggregationPart :: LimitedLinking String
aggregationPart = LimitedLinking {
                linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                },
              aggregationWhole :: LimitedLinking String
aggregationWhole = LimitedLinking {
                linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)
                }
              })
            ]
          }
        })
      ],
    showExtendedFeedback :: Bool
showExtendedFeedback = Bool
True,
    showSolution :: Bool
showSolution = Bool
True,
    taskText :: SelectValidCdTaskText
taskText = [
      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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"Consider the following class diagram candidates:"),
          (Language
German, String
"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 [
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"Which of these class diagram candidates are valid class diagrams?\nPlease state your answer by giving a list of numbers, indicating all valid class diagrams."),
          (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind valide Klassendiagramme?\nBitte 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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"For example,"), (Language
German, String
"Zum Beispiel würde")
          ]),
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Code ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"[1, 2]"), (Language
German, String
"[1, 2]")
          ]),
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"would indicate that only class diagram candidates 1 and 2 of the given ones are valid class diagrams."),
          (Language
German, String
"bedeuten, dass nur die Klassendiagrammkandidaten 1 und 2 der angegebenen Klassendiagrammkandidaten gültige Klassendiagramme sind.")
          ])
        ]
      ],
    addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
    },
  allowLayoutMangling :: Bool
allowLayoutMangling = Bool
True,
  shuffleNames :: Bool
shuffleNames = Bool
True,
  shuffleOptions :: Bool
shuffleOptions = Bool
True
  }

{-|
points: 0.08
-}
task2024_53 :: ShuffleInstance SelectValidCdInstance
task2024_53 :: ShuffleInstance SelectValidCdInstance
task2024_53 = ShuffleInstance {
  taskInstance :: SelectValidCdInstance
taskInstance = 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 = Maybe (Int, Maybe Int)
forall a. Maybe a
Nothing
        },
      printNames :: Bool
printNames = Bool
False,
      printNavigations :: Bool
printNavigations = Bool
False
      },
    classDiagrams :: Map Int CdChange
classDiagrams = [(Int, CdChange)] -> Map Int CdChange
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
      (Int
1, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
          annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
            add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
            remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"u",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }))
            },
          annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"E", String
"C", String
"B", String
"A", String
"D"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"E", superClass :: String
superClass = String
"C"}),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"y",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"t",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"u",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"v",
              associationFrom :: LimitedLinking String
associationFrom =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              associationTo :: LimitedLinking String
associationTo =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"w",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"})
            ]
          }
        }),
      (Int
2, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Annotation
  ArticleToUse
  (Change
     (Either
        (InvalidRelationship String String) (Relationship String String)))
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. a -> Either a b
Left (Annotation {
          annotated :: Change
  (Either
     (InvalidRelationship String String) (Relationship String String))
annotated = Change {
            add :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
add = Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
forall a. Maybe a
Nothing,
            remove :: Maybe
  (Either
     (InvalidRelationship String String) (Relationship String String))
remove = Either
  (InvalidRelationship String String) (Relationship String String)
-> Maybe
     (Either
        (InvalidRelationship String String) (Relationship String String))
forall a. a -> Maybe a
Just (Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"u",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }))
            },
          annotation :: ArticleToUse
annotation = ArticleToUse
DefiniteArticle
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"E", String
"C", String
"B", String
"D", String
"A"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"E", superClass :: String
superClass = String
"C"}),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"}),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"y",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"t",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"r",
              associationFrom :: LimitedLinking String
associationFrom =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              associationTo :: LimitedLinking String
associationTo =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
2, Maybe Int
forall a. Maybe a
Nothing)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"u",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"x",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              })
            ]
          }
        }),
      (Int
3, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. b -> Either a b
Right (ObjectDiagram {
          objects :: [Object String String]
objects = [
            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"},
            Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"e", objectClass :: String
objectClass = String
"E"},
            Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"a", objectClass :: String
objectClass = String
"A"}
            ],
          links :: [Link String String]
links = [
            Link {linkLabel :: String
linkLabel = String
"z", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"b"},
            Link {linkLabel :: String
linkLabel = String
"t", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"d"},
            Link {linkLabel :: String
linkLabel = String
"x", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"c"},
            Link {linkLabel :: String
linkLabel = String
"y", linkFrom :: String
linkFrom = String
"c", linkTo :: String
linkTo = String
"d"},
            Link {linkLabel :: String
linkLabel = String
"x", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"e"},
            Link {linkLabel :: String
linkLabel = String
"v", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"b"}
            ]
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"E", String
"A", String
"B", String
"C", String
"D"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"y",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"z",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"v",
              associationFrom :: LimitedLinking String
associationFrom =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              associationTo :: LimitedLinking String
associationTo =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"}),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"E", superClass :: String
superClass = String
"C"}),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"x",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"t",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              })
            ]
          }
        }),
      (Int
4, InValidOption {
        hint :: Either
  (Annotation
     ArticleToUse
     (Change
        (Either
           (InvalidRelationship String String) (Relationship String String))))
  Od
hint = Od
-> Either
     (Annotation
        ArticleToUse
        (Change
           (Either
              (InvalidRelationship String String) (Relationship String String))))
     Od
forall a b. b -> Either a b
Right (ObjectDiagram {
          objects :: [Object String String]
objects = [
            Object {isAnonymous :: Bool
isAnonymous = Bool
False, objectName :: String
objectName = String
"b", objectClass :: String
objectClass = String
"B"},
            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
"e", objectClass :: String
objectClass = String
"E"},
            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"}
            ],
          links :: [Link String String]
links = [
            Link {linkLabel :: String
linkLabel = String
"y", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"c"},
            Link {linkLabel :: String
linkLabel = String
"v", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"b"},
            Link {linkLabel :: String
linkLabel = String
"s", linkFrom :: String
linkFrom = String
"e", linkTo :: String
linkTo = String
"b"},
            Link {linkLabel :: String
linkLabel = String
"t", linkFrom :: String
linkFrom = String
"b", linkTo :: String
linkTo = String
"d"},
            Link {linkLabel :: String
linkLabel = String
"x", linkFrom :: String
linkFrom = String
"d", linkTo :: String
linkTo = String
"c"},
            Link {linkLabel :: String
linkLabel = String
"x", linkFrom :: String
linkFrom = String
"a", linkTo :: String
linkTo = String
"e"}
            ]
          }),
        option :: AnyClassDiagram String String
option = AnyClassDiagram {
          anyClassNames :: [String]
anyClassNames = [String
"C", String
"E", String
"B", String
"A", String
"D"],
          anyRelationships :: [Either
   (InvalidRelationship String String) (Relationship String String)]
anyRelationships = [
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {subClass :: String
subClass = String
"D", superClass :: String
superClass = String
"A"}),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"t",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"s",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"E", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Aggregation {
              aggregationName :: String
aggregationName = String
"x",
              aggregationPart :: LimitedLinking String
aggregationPart =
                LimitedLinking {linking :: String
linking = String
"A", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              aggregationWhole :: LimitedLinking String
aggregationWhole =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Association {
              associationName :: String
associationName = String
"v",
              associationFrom :: LimitedLinking String
associationFrom =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
1, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)},
              associationTo :: LimitedLinking String
associationTo =
                LimitedLinking {linking :: String
linking = String
"B", limits :: (Int, Maybe Int)
limits = (Int
1, Maybe Int
forall a. Maybe a
Nothing)}
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Inheritance {
              subClass :: String
subClass = String
"E",
              superClass :: String
superClass = String
"C"
              }),
            Relationship String String
-> Either
     (InvalidRelationship String String) (Relationship String String)
forall a b. b -> Either a b
Right (Composition {
              compositionName :: String
compositionName = String
"y",
              compositionPart :: LimitedLinking String
compositionPart =
                LimitedLinking {linking :: String
linking = String
"D", limits :: (Int, Maybe Int)
limits = (Int
0, Maybe Int
forall a. Maybe a
Nothing)},
              compositionWhole :: LimitedLinking String
compositionWhole =
                LimitedLinking {linking :: String
linking = String
"C", limits :: (Int, Maybe Int)
limits = (Int
0, Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1)}
              })
            ]
          }
        })
      ],
    showExtendedFeedback :: Bool
showExtendedFeedback = Bool
True,
    showSolution :: Bool
showSolution = Bool
True,
    taskText :: SelectValidCdTaskText
taskText = [
      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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"Consider the following class diagram candidates:"),
          (Language
German, String
"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 [
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"Which of these class diagram candidates are valid class diagrams?\nPlease state your answer by giving a list of numbers, indicating all valid class diagrams."),
          (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind valide Klassendiagramme?\nBitte 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 ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"For example,"),
          (Language
German, String
"Zum Beispiel würde")
          ]),
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Code ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"[1, 2]"),
          (Language
German, String
"[1, 2]")
          ]),
        Map Language String
-> GenericOutput Language SelectValidCdTaskTextElement
forall language element.
Map language String -> GenericOutput language element
Translated ([(Language, String)] -> Map Language String
forall a b. Ord a => [(a, b)] -> Map a b
listToFM [
          (Language
English, String
"would indicate that only class diagram candidates 1 and 2 of the given ones are valid class diagrams."),
          (Language
German, String
"bedeuten, dass nur die Klassendiagrammkandidaten 1 und 2 der angegebenen Klassendiagrammkandidaten gültige Klassendiagramme sind.")
          ])
        ]
      ],
    addText :: Maybe (Map Language String)
addText = Maybe (Map Language String)
forall a. Maybe a
Nothing
    },
  allowLayoutMangling :: Bool
allowLayoutMangling = Bool
True,
  shuffleNames :: Bool
shuffleNames = Bool
False,
  shuffleOptions :: Bool
shuffleOptions = Bool
True
  }