-- |

module Modelling.CdOd.SelectValidCd.Instance where

import qualified Data.Map                         as M (fromList)

import Modelling.CdOd.Common (validClassDiagramAdvice)
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),
  ExtraText (..),
  Language (English, German),
  )
import Control.OutputCapable.Blocks.Generic.Type (
  GenericOutput (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 = Maybe (Int, Maybe Int)
forall a. Maybe a
Nothing
      },
    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?"),
        (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind gültige Klassendiagramme?")
        ])
      ]
    ],
  addText :: ExtraText
addText = ExtraText
NoExtraText
  }

{-|
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?"),
          (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind gültige Klassendiagramme?")
          ])
        ]
      ],
    addText :: ExtraText
addText = ExtraText
NoExtraText
    },
  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?"),
          (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind gültige Klassendiagramme?")
          ])
        ]
      ],
    addText :: ExtraText
addText = ExtraText
validClassDiagramAdvice
    },
  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?"),
          (Language
German, String
"Welche dieser Klassendiagrammkandidaten sind gültige Klassendiagramme?")
          ])
        ]
      ],
    addText :: ExtraText
addText = ExtraText
NoExtraText
    },
  allowLayoutMangling :: Bool
allowLayoutMangling = Bool
True,
  shuffleNames :: Bool
shuffleNames = Bool
False,
  shuffleOptions :: Bool
shuffleOptions = Bool
True
  }

{-|
points: 0.15
-}
task2025_07 :: ShuffleInstance SelectValidCdInstance
task2025_07 :: ShuffleInstance SelectValidCdInstance
task2025_07 = ShuffleInstance SelectValidCdInstance
task2024_09