{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE RecordWildCards #-}
-- | Phrasing relationships and changes in German
module Modelling.CdOd.Phrasing.German (
  phraseChange,
  phraseRelationship,
  trailingComma,
  numberWords,
  ) where

import Modelling.Types (
  Change (..),
  )
import Modelling.CdOd.Auxiliary.Util    (oneAndOther)
import Modelling.CdOd.Phrasing.Common   (phraseChangeWith, PhrasingStrings (..))
import Modelling.CdOd.Types (
  AnyRelationship,
  DefaultedLimitedLinking (..),
  InvalidRelationship (..),
  LimitedLinking (..),
  NonInheritancePhrasing (..),
  OmittedDefaultMultiplicities (..),
  PhrasingKind (..),
  Relationship (..),
  defaultedLimitedLinking,
  sortLimits,
  toPhrasing,
  )

import Control.OutputCapable.Blocks     (ArticleToUse (..))
import Data.String.Interpolate          (iii)
import Data.Tuple.Extra                 (curry3)

import Data.Map                         (Map)
import qualified Data.Map          as M (fromList)

numberWords :: Map Int String
numberWords :: Map Int String
numberWords = [(Int, String)] -> Map Int String
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList [
  (Int
2, String
"zwei"),
  (Int
3, String
"drei"),
  (Int
4, String
"vier"),
  (Int
5, String
"fünf"),
  (Int
6, String
"sechs"),
  (Int
7, String
"sieben"),
  (Int
8, String
"acht"),
  (Int
9, String
"neun"),
  (Int
10, String
"zehn")
  ]

phraseChange
  :: OmittedDefaultMultiplicities
  -> ArticleToUse
  -> Bool
  -> Bool
  -> Change (AnyRelationship String String)
  -> String
phraseChange :: OmittedDefaultMultiplicities
-> ArticleToUse
-> Bool
-> Bool
-> Change (AnyRelationship String String)
-> String
phraseChange = PhrasingStrings
-> OmittedDefaultMultiplicities
-> ArticleToUse
-> Bool
-> Bool
-> Change (AnyRelationship String String)
-> String
phraseChangeWith PhrasingStrings
germanStrings

-- | German phrasing strings
germanStrings :: PhrasingStrings
germanStrings :: PhrasingStrings
germanStrings = PhrasingStrings
  { changeNothing :: String
changeNothing = String
"verändere nichts"
  , addPrefix :: String
addPrefix = String
"ergänze "
  , removePrefix :: String
removePrefix = String
"entferne "
  , replacePrefix :: String
replacePrefix = String
"ersetze "
  , byInfix :: String
byInfix = String
" durch "
  , postProcess :: String -> String
postProcess = String -> String
trailingComma
  , phraseRelationWith :: OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> NonInheritancePhrasing
-> AnyRelationship String String
-> String
phraseRelationWith = OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> NonInheritancePhrasing
-> AnyRelationship String String
-> String
phraseRelation
  }

trailingComma :: String -> String
trailingComma :: String -> String
trailingComma String
xs
      | Char
',' Char -> String -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` String
xs = String
xs String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
","
      | Bool
otherwise     = String
xs

femaleArticle :: ArticleToUse -> String
femaleArticle :: ArticleToUse -> String
femaleArticle = \case
  ArticleToUse
DefiniteArticle -> String
"die"
  ArticleToUse
IndefiniteArticle -> String
"eine"

phraseRelationship
  :: OmittedDefaultMultiplicities
  -> ArticleToUse
  -> PhrasingKind
  -> Bool
  -> Bool
  -> AnyRelationship String String
  -> String
phraseRelationship :: OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> Bool
-> Bool
-> AnyRelationship String String
-> String
phraseRelationship OmittedDefaultMultiplicities
defaultMultiplicities ArticleToUse
article PhrasingKind
kind Bool
byName Bool
withDir =
  OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> NonInheritancePhrasing
-> AnyRelationship String String
-> String
phraseRelation OmittedDefaultMultiplicities
defaultMultiplicities ArticleToUse
article PhrasingKind
kind NonInheritancePhrasing
phrasing
  where
    phrasing :: NonInheritancePhrasing
phrasing = Bool -> Bool -> NonInheritancePhrasing
toPhrasing Bool
byName Bool
withDir

phraseRelation
  :: OmittedDefaultMultiplicities
  -> ArticleToUse
  -> PhrasingKind
  -> NonInheritancePhrasing
  -> AnyRelationship String String
  -> String
phraseRelation :: OmittedDefaultMultiplicities
-> ArticleToUse
-> PhrasingKind
-> NonInheritancePhrasing
-> AnyRelationship String String
-> String
phraseRelation OmittedDefaultMultiplicities {Maybe (Int, Maybe Int)
aggregationWholeOmittedDefaultMultiplicity :: Maybe (Int, Maybe Int)
associationOmittedDefaultMultiplicity :: Maybe (Int, Maybe Int)
compositionWholeOmittedDefaultMultiplicity :: Maybe (Int, Maybe Int)
compositionWholeOmittedDefaultMultiplicity :: OmittedDefaultMultiplicities -> Maybe (Int, Maybe Int)
associationOmittedDefaultMultiplicity :: OmittedDefaultMultiplicities -> Maybe (Int, Maybe Int)
aggregationWholeOmittedDefaultMultiplicity :: OmittedDefaultMultiplicities -> Maybe (Int, Maybe Int)
..} ArticleToUse
article = ((PhrasingKind, NonInheritancePhrasing,
  AnyRelationship String String)
 -> String)
-> PhrasingKind
-> NonInheritancePhrasing
-> AnyRelationship String String
-> String
forall a b c d. ((a, b, c) -> d) -> a -> b -> c -> d
curry3 (((PhrasingKind, NonInheritancePhrasing,
   AnyRelationship String String)
  -> String)
 -> PhrasingKind
 -> NonInheritancePhrasing
 -> AnyRelationship String String
 -> String)
-> ((PhrasingKind, NonInheritancePhrasing,
     AnyRelationship String String)
    -> String)
-> PhrasingKind
-> NonInheritancePhrasing
-> AnyRelationship String String
-> String
forall a b. (a -> b) -> a -> b
$ \case
  (PhrasingKind
kind,NonInheritancePhrasing
_, Left InvalidInheritance {LimitedLinking String
invalidSubClass :: LimitedLinking String
invalidSuperClass :: LimitedLinking String
invalidSuperClass :: forall className relationshipName.
InvalidRelationship className relationshipName
-> LimitedLinking className
invalidSubClass :: forall className relationshipName.
InvalidRelationship className relationshipName
-> LimitedLinking className
..}) -> [iii|
    #{femaleArticle article} Vererbung,
    bei der #{linking invalidSubClass} von #{linking invalidSuperClass} erbt
    |]
    String -> String -> String
forall a. [a] -> [a] -> [a]
++ PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
phraseParticipations
      PhrasingKind
kind
      (LimitedLinking String -> DefaultedLimitedLinking
defaultedInheritance LimitedLinking String
invalidSubClass)
      (LimitedLinking String -> DefaultedLimitedLinking
defaultedInheritance LimitedLinking String
invalidSuperClass)
  (PhrasingKind
_, NonInheritancePhrasing
_, Right Inheritance {String
subClass :: String
superClass :: String
superClass :: forall className relationshipName.
Relationship className relationshipName -> className
subClass :: forall className relationshipName.
Relationship className relationshipName -> className
..}) -> [iii|
    #{femaleArticle article} Vererbung,
    bei der #{subClass} von #{superClass} erbt
    |]
  (PhrasingKind
_, NonInheritancePhrasing
ByName, Right Association {String
LimitedLinking String
associationName :: String
associationFrom :: LimitedLinking String
associationTo :: LimitedLinking String
associationTo :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
associationFrom :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
associationName :: forall className relationshipName.
Relationship className relationshipName -> relationshipName
..}) -> String
"Assoziation " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
associationName
  (PhrasingKind
_, NonInheritancePhrasing
ByName, Right Aggregation {String
LimitedLinking String
aggregationName :: String
aggregationPart :: LimitedLinking String
aggregationWhole :: LimitedLinking String
aggregationWhole :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
aggregationPart :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
aggregationName :: forall className relationshipName.
Relationship className relationshipName -> relationshipName
..}) -> String
"Aggregation " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
aggregationName
  (PhrasingKind
_, NonInheritancePhrasing
ByName, Right Composition {String
LimitedLinking String
compositionName :: String
compositionPart :: LimitedLinking String
compositionWhole :: LimitedLinking String
compositionWhole :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
compositionPart :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
compositionName :: forall className relationshipName.
Relationship className relationshipName -> relationshipName
..}) -> String
"Komposition " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
compositionName
  (PhrasingKind
kind, NonInheritancePhrasing
how, Right Association {String
LimitedLinking String
associationTo :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
associationFrom :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
associationName :: forall className relationshipName.
Relationship className relationshipName -> relationshipName
associationName :: String
associationFrom :: LimitedLinking String
associationTo :: LimitedLinking String
..})
    | DefaultedLimitedLinking
from <- LimitedLinking String -> DefaultedLimitedLinking
defaultedAssociation LimitedLinking String
associationFrom
    , DefaultedLimitedLinking
to <- LimitedLinking String -> DefaultedLimitedLinking
defaultedAssociation LimitedLinking String
associationTo
    -> case (NonInheritancePhrasing
how, PhrasingKind
kind, LimitedLinking String -> String
forall nodeName. LimitedLinking nodeName -> nodeName
linking LimitedLinking String
associationFrom String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== LimitedLinking String -> String
forall nodeName. LimitedLinking nodeName -> nodeName
linking LimitedLinking String
associationTo) of
      (NonInheritancePhrasing
Lengthy, PhrasingKind
Participations, Bool
True) -> [iii|
        #{femaleArticle article} Selbst-Assoziation
        für #{linking associationFrom},
        bei der #{linking associationFrom}
        an einem Ende #{phraseLimitDefault $ defaultedLimits from}
        und am anderen Ende #{phraseLimitDefault $ defaultedLimits to}
        beteiligt ist
        |]
      (NonInheritancePhrasing
Lengthy, PhrasingKind
Denoted, Bool
True)
        | String
denoted <- (DefaultedLimitedLinking -> DefaultedLimitedLinking -> String)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking) -> String
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
denotions
          ((DefaultedLimitedLinking, DefaultedLimitedLinking) -> String)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking) -> String
forall a b. (a -> b) -> a -> b
$ String
-> String
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
oneAndOther String
"einem Ende" String
"dem anderen Ende"
          ((DefaultedLimitedLinking, DefaultedLimitedLinking)
 -> (DefaultedLimitedLinking, DefaultedLimitedLinking))
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
forall a b. (a -> b) -> a -> b
$ DefaultedLimitedLinking
-> DefaultedLimitedLinking
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
sortLimits DefaultedLimitedLinking
from DefaultedLimitedLinking
to
        -> [iii|
          #{femaleArticle article} Selbst-Assoziation
          für #{linking associationFrom}
          |] String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
denoted
      (NonInheritancePhrasing
Lengthy, PhrasingKind
_, Bool
False) -> ArticleToUse -> String
femaleArticle ArticleToUse
article String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" Assoziation"
        String -> String -> String
forall a. [a] -> [a] -> [a]
++ PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
phraseParticipations PhrasingKind
kind DefaultedLimitedLinking
from DefaultedLimitedLinking
to
      (NonInheritancePhrasing
ByDirection, PhrasingKind
Participations, Bool
True) -> [iii|
        #{femaleArticle article} Selbst-Assoziation
        für #{linking associationFrom},
        bei der #{linking associationFrom}
        am Anfang #{phraseLimitDefault $ defaultedLimits from}
        und am Ende #{phraseLimitDefault $ defaultedLimits to} beteiligt ist
        |]
      (NonInheritancePhrasing
ByDirection, PhrasingKind
Denoted, Bool
True)
        | String
denoted <- (DefaultedLimitedLinking -> DefaultedLimitedLinking -> String)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking) -> String
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
denotions
          ((DefaultedLimitedLinking, DefaultedLimitedLinking) -> String)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking) -> String
forall a b. (a -> b) -> a -> b
$ (DefaultedLimitedLinking
 -> DefaultedLimitedLinking
 -> (DefaultedLimitedLinking, DefaultedLimitedLinking))
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry DefaultedLimitedLinking
-> DefaultedLimitedLinking
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
sortLimits
          ((DefaultedLimitedLinking, DefaultedLimitedLinking)
 -> (DefaultedLimitedLinking, DefaultedLimitedLinking))
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
forall a b. (a -> b) -> a -> b
$ String
-> String
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
oneAndOther String
"seinem Anfang" String
"seinem Pfeilende" (DefaultedLimitedLinking
from, DefaultedLimitedLinking
to)
        -> [iii|
          #{femaleArticle article} Selbst-Assoziation
          für #{linking associationFrom}
          |] String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
denoted
      (NonInheritancePhrasing
ByDirection, PhrasingKind
_, Bool
False) -> [iii|
        #{femaleArticle article} Assoziation von #{linking associationFrom}
        nach #{linking associationTo}
        |] String -> String -> String
forall a. [a] -> [a] -> [a]
++ PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
phraseParticipations PhrasingKind
kind DefaultedLimitedLinking
from DefaultedLimitedLinking
to
  (PhrasingKind
kind, NonInheritancePhrasing
_, Right Aggregation {String
LimitedLinking String
aggregationWhole :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
aggregationPart :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
aggregationName :: forall className relationshipName.
Relationship className relationshipName -> relationshipName
aggregationName :: String
aggregationPart :: LimitedLinking String
aggregationWhole :: LimitedLinking String
..})
    | DefaultedLimitedLinking
part <- LimitedLinking String -> DefaultedLimitedLinking
defaultedAssociation LimitedLinking String
aggregationPart
    , DefaultedLimitedLinking
whole <- LimitedLinking String -> DefaultedLimitedLinking
defaultedAssociation LimitedLinking String
aggregationWhole
    ->
      if LimitedLinking String -> String
forall nodeName. LimitedLinking nodeName -> nodeName
linking LimitedLinking String
aggregationPart String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== LimitedLinking String -> String
forall nodeName. LimitedLinking nodeName -> nodeName
linking LimitedLinking String
aggregationWhole
      then [iii|
        #{femaleArticle article} Selbst-Aggregation
        #{selfParticipatesPartWhole kind part whole}
        |]
      else [iii|
        #{femaleArticle article} Beziehung, die #{linking aggregationWhole}
        eine Aggregation aus #{linking aggregationPart}s macht
        |] String -> String -> String
forall a. [a] -> [a] -> [a]
++ PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
phraseParticipations PhrasingKind
kind DefaultedLimitedLinking
whole DefaultedLimitedLinking
part
  (PhrasingKind
kind, NonInheritancePhrasing
_, Right Composition {String
LimitedLinking String
compositionWhole :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
compositionPart :: forall className relationshipName.
Relationship className relationshipName -> LimitedLinking className
compositionName :: forall className relationshipName.
Relationship className relationshipName -> relationshipName
compositionName :: String
compositionPart :: LimitedLinking String
compositionWhole :: LimitedLinking String
..})
    | DefaultedLimitedLinking
part <- LimitedLinking String -> DefaultedLimitedLinking
defaultedAssociation LimitedLinking String
compositionPart
    , DefaultedLimitedLinking
whole <- LimitedLinking String -> DefaultedLimitedLinking
defaultedCompositionWhole LimitedLinking String
compositionWhole
    ->
      if LimitedLinking String -> String
forall nodeName. LimitedLinking nodeName -> nodeName
linking LimitedLinking String
compositionPart String -> String -> Bool
forall a. Eq a => a -> a -> Bool
== LimitedLinking String -> String
forall nodeName. LimitedLinking nodeName -> nodeName
linking LimitedLinking String
compositionWhole
      then [iii|
        #{femaleArticle article} Selbst-Komposition
        #{selfParticipatesPartWhole kind part whole}
        |]
      else [iii|
        #{femaleArticle article} Beziehung, die #{linking compositionWhole}
        eine Komposition aus #{linking compositionPart}s macht
        |] String -> String -> String
forall a. [a] -> [a] -> [a]
++ PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
phraseParticipations PhrasingKind
kind DefaultedLimitedLinking
whole DefaultedLimitedLinking
part
  where
    defaultedCompositionWhole :: LimitedLinking String -> DefaultedLimitedLinking
defaultedCompositionWhole =
      Maybe (Int, Maybe Int)
-> LimitedLinking String -> DefaultedLimitedLinking
defaultedLimitedLinking Maybe (Int, Maybe Int)
compositionWholeOmittedDefaultMultiplicity
    defaultedAssociation :: LimitedLinking String -> DefaultedLimitedLinking
defaultedAssociation =
      Maybe (Int, Maybe Int)
-> LimitedLinking String -> DefaultedLimitedLinking
defaultedLimitedLinking Maybe (Int, Maybe Int)
associationOmittedDefaultMultiplicity
    defaultedInheritance :: LimitedLinking String -> DefaultedLimitedLinking
defaultedInheritance = Maybe (Int, Maybe Int)
-> LimitedLinking String -> DefaultedLimitedLinking
defaultedLimitedLinking Maybe (Int, Maybe Int)
forall a. Maybe a
Nothing

selfParticipatesPartWhole
  :: PhrasingKind
  -> DefaultedLimitedLinking
  -> DefaultedLimitedLinking
  -> String
selfParticipatesPartWhole :: PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
selfParticipatesPartWhole PhrasingKind
Denoted DefaultedLimitedLinking
part DefaultedLimitedLinking
whole = [iii|
  für #{defaultedLinking part},
  #{which}
  |]
  where
    which :: String
which = (DefaultedLimitedLinking -> DefaultedLimitedLinking -> String)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking) -> String
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
denotions ((DefaultedLimitedLinking, DefaultedLimitedLinking) -> String)
-> (DefaultedLimitedLinking, DefaultedLimitedLinking) -> String
forall a b. (a -> b) -> a -> b
$ DefaultedLimitedLinking
-> DefaultedLimitedLinking
-> (DefaultedLimitedLinking, DefaultedLimitedLinking)
sortLimits
      DefaultedLimitedLinking
part {defaultedLinking = "dem Teil-Ende"}
      DefaultedLimitedLinking
whole {defaultedLinking = "dem Ganzen-Ende"}
selfParticipatesPartWhole PhrasingKind
Participations DefaultedLimitedLinking
part DefaultedLimitedLinking
whole = [iii|
  für #{defaultedLinking part},
  wobei es #{phraseLimitDefault $ defaultedLimits part} als Teil
  und #{phraseLimitDefault $ defaultedLimits whole} als Ganzes beteiligt ist
  |]

phraseParticipations
  :: PhrasingKind
  -> DefaultedLimitedLinking
  -> DefaultedLimitedLinking
  -> String
phraseParticipations :: PhrasingKind
-> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
phraseParticipations = \case
  PhrasingKind
Denoted -> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
denotions
  PhrasingKind
Participations -> DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
participations

denotions
  :: DefaultedLimitedLinking
  -> DefaultedLimitedLinking
  -> String
denotions :: DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
denotions DefaultedLimitedLinking
one DefaultedLimitedLinking
other = case (DefaultedLimitedLinking -> Maybe String
defaultedRange DefaultedLimitedLinking
one, DefaultedLimitedLinking -> Maybe String
defaultedRange DefaultedLimitedLinking
other) of
  (Maybe String
Nothing, Maybe String
Nothing) -> [iii|, bei der keine Multiplizitäten angegeben sind|]
  (Maybe String
Nothing, Just String
otherRange) -> [iii|
     , bei der keine Multiplizität neben #{defaultedLinking one}
     und #{otherRange} neben #{defaultedLinking other} angegeben ist
     |]
  (Just String
oneRange, Maybe String
Nothing) -> [iii|
     , bei der keine Multiplizität neben #{defaultedLinking other}
     und #{oneRange} neben #{defaultedLinking one} angegeben ist
     |]
  (Just String
oneRange, Just String
otherRange) -> [iii|
     , bei der die Multiplizität
     #{oneRange} neben #{defaultedLinking one}
     und #{otherRange} neben #{defaultedLinking other} angegeben ist
     |]

participations
  :: DefaultedLimitedLinking
  -> DefaultedLimitedLinking
  -> String
participations :: DefaultedLimitedLinking -> DefaultedLimitedLinking -> String
participations DefaultedLimitedLinking
one DefaultedLimitedLinking
other = [iii|
  , wobei #{defaultedLinking one} #{phraseLimitDefault $ defaultedLimits one}
  und #{defaultedLinking other} #{phraseLimitDefault $ defaultedLimits other}
  beteiligt ist
  |]

phraseLimitDefault :: Maybe (Int, Maybe Int) -> String
phraseLimitDefault :: Maybe (Int, Maybe Int) -> String
phraseLimitDefault = String
-> ((Int, Maybe Int) -> String) -> Maybe (Int, Maybe Int) -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String
"mit der Standardmultiplizität" (Int, Maybe Int) -> String
phraseLimit

phraseLimit :: (Int, Maybe Int) -> String
phraseLimit :: (Int, Maybe Int) -> String
phraseLimit (Int
0, Just Int
0)  = String
"gar nicht"
phraseLimit (Int
1, Just Int
1)  = String
"genau einmal"
phraseLimit (Int
2, Just Int
2)  = String
"genau zweimal"
phraseLimit (-1, Just Int
n) = String
"*.." String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-mal"
phraseLimit (Int
m, Maybe Int
Nothing) = Int -> String
forall a. Show a => a -> String
show Int
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"..*-mal"
phraseLimit (Int
m, Just Int
n)  = Int -> String
forall a. Show a => a -> String
show Int
m String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
".." String -> String -> String
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show Int
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"-mal"