{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE QuasiQuotes #-}
{-# LANGUAGE DeriveDataTypeable #-}
-- | This module provides common skeletons for printing tasks
module Modelling.Auxiliary.Output (
  ExtraText(..),
  addPretext,
  checkTaskText,
  directionsAdvice,
  extra,
  hoveringInformation,
  simplifiedInformation,
  uniform,
  ) where

import qualified Data.Map                         as M (empty, insert)

import Control.Monad.State (put)
import Control.OutputCapable.Blocks     (
  GenericOutputCapable (paragraph),
  Language(..),
  LangM,
  LangM',
  OutputCapable,
  english,
  german,
  translate,
  translations,
  collapsed,
  )
import Control.OutputCapable.Blocks.Type (
  SpecialOutput,
  checkTranslations,
  )
import Data.List                        ((\\), singleton)
import Data.Map                         (Map)
import Data.String.Interpolate          (iii)
import Data.Data (Data)

hoveringInformation :: OutputCapable m => LangM m
hoveringInformation :: forall (m :: * -> *). OutputCapable m => LangM m
hoveringInformation = Bool
-> State (Map Language String) ()
-> GenericLangM Language m ()
-> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
Bool
-> State (Map l String) ()
-> GenericLangM l m ()
-> GenericLangM l m ()
collapsed Bool
True (Map Language String -> State (Map Language String) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Map Language String -> State (Map Language String) ())
-> Map Language String -> State (Map Language String) ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
  String -> State (Map Language String) ()
english String
"Note on hovering"
  String -> State (Map Language String) ()
german String
"Anmerkung zum Hovern"
  ) (GenericLangM Language m () -> GenericLangM Language m ())
-> GenericLangM Language m () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ do
  String -> State (Map Language String) ()
english [iii|
    When hovering over or clicking on edges / nodes or their
    labels, the respective components that belong together are highlighted.
    |]
  String -> State (Map Language String) ()
german [iii|
    Beim Bewegen über oder Klicken auf
    Kanten / Knoten bzw. ihre Beschriftungen
    werden die jeweils zusammengehörenden Komponenten hervorgehoben.
    |]

directionsAdvice :: OutputCapable m => LangM m
directionsAdvice :: forall (m :: * -> *). OutputCapable m => LangM m
directionsAdvice = Bool
-> State (Map Language String) ()
-> GenericLangM Language m ()
-> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
Bool
-> State (Map l String) ()
-> GenericLangM l m ()
-> GenericLangM l m ()
collapsed Bool
True (Map Language String -> State (Map Language String) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Map Language String -> State (Map Language String) ())
-> Map Language String -> State (Map Language String) ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
  String -> State (Map Language String) ()
english String
"Note on navigation directions"
  String -> State (Map Language String) ()
german String
"Anmerkung zu Navigationsrichtungen"
  ) (GenericLangM Language m () -> GenericLangM Language m ())
-> GenericLangM Language m () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ do
  String -> State (Map Language String) ()
english [iii|
    Aggregations and compositions are only navigable
    from the "part" toward the "whole",
    i.e., they are not navigable in the opposite direction!
    |]
  String -> State (Map Language String) ()
german [iii|
    Aggregationen und Kompositionen
    sind nur vom "Teil" zum "Ganzen" navigierbar,
    d.h., sie sind nicht in der entgegengesetzten Richtung navigierbar!
    |]

simplifiedInformation :: OutputCapable m => LangM m
simplifiedInformation :: forall (m :: * -> *). OutputCapable m => LangM m
simplifiedInformation = Bool
-> State (Map Language String) ()
-> GenericLangM Language m ()
-> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
Bool
-> State (Map l String) ()
-> GenericLangM l m ()
-> GenericLangM l m ()
collapsed Bool
True (Map Language String -> State (Map Language String) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put (Map Language String -> State (Map Language String) ())
-> Map Language String -> State (Map Language String) ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> Map Language String
forall l a. State (Map l a) () -> Map l a
translations (State (Map Language String) () -> Map Language String)
-> State (Map Language String) () -> Map Language String
forall a b. (a -> b) -> a -> b
$ do
  String -> State (Map Language String) ()
english String
"Note on class representation"
  String -> State (Map Language String) ()
german String
"Anmerkung zur Klassendarstellung"
  ) (GenericLangM Language m () -> GenericLangM Language m ())
-> GenericLangM Language m () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ do
  String -> State (Map Language String) ()
english [iii|
    Classes are represented simplified here.
    #{endLine}
    That means they consist of a single box containing only the class name
    but no sections for attributes or methods.
    #{endLine}
    Nevertheless you should treat these simplified class representations
    as valid classes.
    |]
  String -> State (Map Language String) ()
german [iii|
    Klassen werden hier vereinfacht dargestellt.
    #{endLine}
    Das heißt, sie bestehen aus einer einfachen Box,
    die nur den Klassennamen enthält,
    aber keine Abschnitte für Attribute oder Methoden.
    #{endLine}
    Trotzdem sollten Sie diese vereinfachten Klassendarstellungen
    als gültige Klassen ansehen.
    |]
  where
    endLine :: String
    endLine :: String
endLine = String
"\n"

addPretext :: OutputCapable m => LangM' m a -> LangM' m a
addPretext :: forall (m :: * -> *) a. OutputCapable m => LangM' m a -> LangM' m a
addPretext = GenericLangM Language m ()
-> GenericLangM Language m a -> GenericLangM Language m a
forall a b.
GenericLangM Language m a
-> GenericLangM Language m b -> GenericLangM Language m b
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
(*>) (GenericLangM Language m ()
 -> GenericLangM Language m a -> GenericLangM Language m a)
-> GenericLangM Language m ()
-> GenericLangM Language m a
-> GenericLangM Language m a
forall a b. (a -> b) -> a -> b
$
  GenericLangM Language m () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (GenericLangM Language m () -> GenericLangM Language m ())
-> GenericLangM Language m () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ do
    String -> State (Map Language String) ()
english String
"Remarks on your solution:"
    String -> State (Map Language String) ()
german String
"Anmerkungen zur eingereichten Lösung:"

uniform :: a -> Map Language a
uniform :: forall a. a -> Map Language a
uniform a
x = (Language -> Map Language a -> Map Language a)
-> Map Language a -> [Language] -> Map Language a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (Language -> a -> Map Language a -> Map Language a
forall k a. Ord k => k -> a -> Map k a -> Map k a
`M.insert` a
x) Map Language a
forall k a. Map k a
M.empty [Language
forall a. Bounded a => a
minBound ..]

checkTaskText
  :: (Bounded element, Enum element, Eq element, Show element)
  => [SpecialOutput element]
  -> Maybe String
checkTaskText :: forall element.
(Bounded element, Enum element, Eq element, Show element) =>
[SpecialOutput element] -> Maybe String
checkTaskText [SpecialOutput element]
taskText
  | element
x:[element]
_ <- [element]
allElements [element] -> [element] -> [element]
forall a. Eq a => [a] -> [a] -> [a]
\\ [element]
usedElements
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|Your task text is incomplete as it is missing '#{show x}'.|]
  | element
x:[element]
_ <- [element]
usedElements [element] -> [element] -> [element]
forall a. Eq a => [a] -> [a] -> [a]
\\ [element]
allElements
  = String -> Maybe String
forall a. a -> Maybe a
Just [iii|
      Your task text is using '#{show x}' at least twice,
      but it should appear exactly once.
      |]
  | String
x:[String]
_ <- (SpecialOutput element -> [String])
-> [SpecialOutput element] -> [String]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((element -> [String]) -> SpecialOutput element -> [String]
forall element.
(element -> [String]) -> SpecialOutput element -> [String]
checkTranslations ([String] -> element -> [String]
forall a b. a -> b -> a
const [])) [SpecialOutput element]
taskText
  = String -> Maybe String
forall a. a -> Maybe a
Just (String -> Maybe String) -> String -> Maybe String
forall a b. (a -> b) -> a -> b
$ [iii|Problem within your task text: |] String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
x
  | Bool
otherwise
  = Maybe String
forall a. Maybe a
Nothing
  where
    usedElements :: [element]
usedElements = (SpecialOutput element -> [element])
-> [SpecialOutput element] -> [element]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((element -> [element]) -> SpecialOutput element -> [element]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap element -> [element]
forall a. a -> [a]
singleton) [SpecialOutput element]
taskText
    allElements :: [element]
allElements = [element
forall a. Bounded a => a
minBound ..]

-- | Configuration options for additional text
data ExtraText
  = NoExtraText              -- ^ Provide no additional text.
  | Static                   -- ^ Provide additional text that is always shown.
      (Map Language String)  -- ^ The text do be displayed.
  | Collapsible              -- ^ Provide additional text that can be collapsed.
      Bool                   -- ^ The default collapse status of the text.
      (Map Language String)  -- ^ The description of the text to be shown.
      (Map Language String)  -- ^ The text to be shown when not collapsed.
  deriving (Typeable ExtraText
Typeable ExtraText
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> ExtraText -> c ExtraText)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ExtraText)
-> (ExtraText -> Constr)
-> (ExtraText -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ExtraText))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraText))
-> ((forall b. Data b => b -> b) -> ExtraText -> ExtraText)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtraText -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ExtraText -> r)
-> (forall u. (forall d. Data d => d -> u) -> ExtraText -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ExtraText -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ExtraText -> m ExtraText)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtraText -> m ExtraText)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ExtraText -> m ExtraText)
-> Data ExtraText
ExtraText -> Constr
ExtraText -> DataType
(forall b. Data b => b -> b) -> ExtraText -> ExtraText
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> ExtraText -> u
forall u. (forall d. Data d => d -> u) -> ExtraText -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraText -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraText -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraText
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraText -> c ExtraText
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraText)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraText)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraText -> c ExtraText
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ExtraText -> c ExtraText
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraText
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ExtraText
$ctoConstr :: ExtraText -> Constr
toConstr :: ExtraText -> Constr
$cdataTypeOf :: ExtraText -> DataType
dataTypeOf :: ExtraText -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraText)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ExtraText)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraText)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ExtraText)
$cgmapT :: (forall b. Data b => b -> b) -> ExtraText -> ExtraText
gmapT :: (forall b. Data b => b -> b) -> ExtraText -> ExtraText
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraText -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraText -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraText -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ExtraText -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ExtraText -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ExtraText -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtraText -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ExtraText -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ExtraText -> m ExtraText
Data, ExtraText -> ExtraText -> Bool
(ExtraText -> ExtraText -> Bool)
-> (ExtraText -> ExtraText -> Bool) -> Eq ExtraText
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ExtraText -> ExtraText -> Bool
== :: ExtraText -> ExtraText -> Bool
$c/= :: ExtraText -> ExtraText -> Bool
/= :: ExtraText -> ExtraText -> Bool
Eq, ReadPrec [ExtraText]
ReadPrec ExtraText
Int -> ReadS ExtraText
ReadS [ExtraText]
(Int -> ReadS ExtraText)
-> ReadS [ExtraText]
-> ReadPrec ExtraText
-> ReadPrec [ExtraText]
-> Read ExtraText
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS ExtraText
readsPrec :: Int -> ReadS ExtraText
$creadList :: ReadS [ExtraText]
readList :: ReadS [ExtraText]
$creadPrec :: ReadPrec ExtraText
readPrec :: ReadPrec ExtraText
$creadListPrec :: ReadPrec [ExtraText]
readListPrec :: ReadPrec [ExtraText]
Read, Int -> ExtraText -> String -> String
[ExtraText] -> String -> String
ExtraText -> String
(Int -> ExtraText -> String -> String)
-> (ExtraText -> String)
-> ([ExtraText] -> String -> String)
-> Show ExtraText
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
$cshowsPrec :: Int -> ExtraText -> String -> String
showsPrec :: Int -> ExtraText -> String -> String
$cshow :: ExtraText -> String
show :: ExtraText -> String
$cshowList :: [ExtraText] -> String -> String
showList :: [ExtraText] -> String -> String
Show)

extra :: OutputCapable m => ExtraText -> LangM m
extra :: forall (m :: * -> *). OutputCapable m => ExtraText -> LangM m
extra ExtraText
NoExtraText = () -> GenericLangM Language m ()
forall a. a -> GenericLangM Language m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()
extra (Static Map Language String
textMap) = GenericLangM Language m () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
paragraph (GenericLangM Language m () -> GenericLangM Language m ())
-> GenericLangM Language m () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ Map Language String -> State (Map Language String) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put Map Language String
textMap
extra (Collapsible Bool
defaultState Map Language String
titleText Map Language String
contentText) =
  Bool
-> State (Map Language String) ()
-> GenericLangM Language m ()
-> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
Bool
-> State (Map l String) ()
-> GenericLangM l m ()
-> GenericLangM l m ()
collapsed
    Bool
defaultState
    (Map Language String -> State (Map Language String) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put Map Language String
titleText)
    (State (Map Language String) () -> GenericLangM Language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
State (Map l String) () -> GenericLangM l m ()
translate (State (Map Language String) () -> GenericLangM Language m ())
-> State (Map Language String) () -> GenericLangM Language m ()
forall a b. (a -> b) -> a -> b
$ Map Language String -> State (Map Language String) ()
forall s (m :: * -> *). MonadState s m => s -> m ()
put Map Language String
contentText)