{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-|
Provides an Algebraic Data Type to represent 'GenericOutput'.
This can be useful in cases where the raw representation needs to be persisted
or for converting the type of 'GenericOutputCapable'.
-}
module Control.OutputCapable.Blocks.Generic.Type
    ( GenericOutput (..)
    , foldMapOutputBy
    , getOutputSequence
    , getOutputSequenceWithResult
    , getOutputSequenceWithRating
    , inspectTranslations
    , toOutputCapable
    ) where

import Control.OutputCapable.Blocks.Generic (
  GenericLangM,
  GenericOutputCapable (..),
  GenericReportT,
  alignOutput,
  collapsed,
  combineReports,
  combineTwoReports,
  format,
  runLangMReportMultiLang,
  toAbort,
  translate,
  translateCode,
  )
import Control.Monad.Trans.State    (put)
import Data.Data                    (Data)
import Data.Foldable                (for_)
import Data.Map                     (Map)
import Data.Tuple.Extra             (dupe, both, first, second)
import GHC.Generics                 (Generic)

import qualified Data.Map as Map


{-|
Data type miming the OutputCapable class interface.
Can be used to Prototype without defining additional instances.
The result can be converted into any member of the class.
-}
data GenericOutput language element
    = YesNo Bool [GenericOutput language element]
    -- ^ output condition check, but continue afterwards
    | Image FilePath
    -- ^ a single image
    | Images (Map String FilePath)
    -- ^ multiple images with a text tag that is to be printed (e.g. a number)
    | Paragraph [GenericOutput language element]
    -- ^ to group (and separate) output
    | Enumerated [([GenericOutput language element], [GenericOutput language element])]
    -- ^ an enumeration with the enumerator first and content second
    | Itemized [[GenericOutput language element]]
    -- ^ like enumeration (but without enumerator)
    | Indented [GenericOutput language element]
    -- ^ for indenting output
    | Latex String
    -- ^ latex code (for formulas and text blocks only)
    | Folded Bool (Map language String) [GenericOutput language element]
    -- ^ minimisable output with default open-state, title and content
    | Code (Map language String)
    -- ^ to output as text with fixed width, providing translations
    | Translated (Map language String)
    -- ^ normal text with translations
    | Special element
    -- ^ allows abbreviating several complex parts
    --   which have special rendering functions
    --   which are not easily representable as ADT
    deriving (GenericOutput language element
-> GenericOutput language element -> Bool
(GenericOutput language element
 -> GenericOutput language element -> Bool)
-> (GenericOutput language element
    -> GenericOutput language element -> Bool)
-> Eq (GenericOutput language element)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall language element.
(Eq language, Eq element) =>
GenericOutput language element
-> GenericOutput language element -> Bool
$c== :: forall language element.
(Eq language, Eq element) =>
GenericOutput language element
-> GenericOutput language element -> Bool
== :: GenericOutput language element
-> GenericOutput language element -> Bool
$c/= :: forall language element.
(Eq language, Eq element) =>
GenericOutput language element
-> GenericOutput language element -> Bool
/= :: GenericOutput language element
-> GenericOutput language element -> Bool
Eq, (forall a b.
 (a -> b) -> GenericOutput language a -> GenericOutput language b)
-> (forall a b.
    a -> GenericOutput language b -> GenericOutput language a)
-> Functor (GenericOutput language)
forall a b.
a -> GenericOutput language b -> GenericOutput language a
forall a b.
(a -> b) -> GenericOutput language a -> GenericOutput language b
forall language a b.
a -> GenericOutput language b -> GenericOutput language a
forall language a b.
(a -> b) -> GenericOutput language a -> GenericOutput language b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall language a b.
(a -> b) -> GenericOutput language a -> GenericOutput language b
fmap :: forall a b.
(a -> b) -> GenericOutput language a -> GenericOutput language b
$c<$ :: forall language a b.
a -> GenericOutput language b -> GenericOutput language a
<$ :: forall a b.
a -> GenericOutput language b -> GenericOutput language a
Functor, (forall m. Monoid m => GenericOutput language m -> m)
-> (forall m a.
    Monoid m =>
    (a -> m) -> GenericOutput language a -> m)
-> (forall m a.
    Monoid m =>
    (a -> m) -> GenericOutput language a -> m)
-> (forall a b.
    (a -> b -> b) -> b -> GenericOutput language a -> b)
-> (forall a b.
    (a -> b -> b) -> b -> GenericOutput language a -> b)
-> (forall b a.
    (b -> a -> b) -> b -> GenericOutput language a -> b)
-> (forall b a.
    (b -> a -> b) -> b -> GenericOutput language a -> b)
-> (forall a. (a -> a -> a) -> GenericOutput language a -> a)
-> (forall a. (a -> a -> a) -> GenericOutput language a -> a)
-> (forall a. GenericOutput language a -> [a])
-> (forall a. GenericOutput language a -> Bool)
-> (forall a. GenericOutput language a -> Int)
-> (forall a. Eq a => a -> GenericOutput language a -> Bool)
-> (forall a. Ord a => GenericOutput language a -> a)
-> (forall a. Ord a => GenericOutput language a -> a)
-> (forall a. Num a => GenericOutput language a -> a)
-> (forall a. Num a => GenericOutput language a -> a)
-> Foldable (GenericOutput language)
forall a. Eq a => a -> GenericOutput language a -> Bool
forall a. Num a => GenericOutput language a -> a
forall a. Ord a => GenericOutput language a -> a
forall m. Monoid m => GenericOutput language m -> m
forall a. GenericOutput language a -> Bool
forall a. GenericOutput language a -> Int
forall a. GenericOutput language a -> [a]
forall a. (a -> a -> a) -> GenericOutput language a -> a
forall language a. Eq a => a -> GenericOutput language a -> Bool
forall language a. Num a => GenericOutput language a -> a
forall language a. Ord a => GenericOutput language a -> a
forall language m. Monoid m => GenericOutput language m -> m
forall m a. Monoid m => (a -> m) -> GenericOutput language a -> m
forall language a. GenericOutput language a -> Bool
forall language a. GenericOutput language a -> Int
forall language a. GenericOutput language a -> [a]
forall b a. (b -> a -> b) -> b -> GenericOutput language a -> b
forall a b. (a -> b -> b) -> b -> GenericOutput language a -> b
forall language a. (a -> a -> a) -> GenericOutput language a -> a
forall language m a.
Monoid m =>
(a -> m) -> GenericOutput language a -> m
forall language b a.
(b -> a -> b) -> b -> GenericOutput language a -> b
forall language a b.
(a -> b -> b) -> b -> GenericOutput language a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall language m. Monoid m => GenericOutput language m -> m
fold :: forall m. Monoid m => GenericOutput language m -> m
$cfoldMap :: forall language m a.
Monoid m =>
(a -> m) -> GenericOutput language a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> GenericOutput language a -> m
$cfoldMap' :: forall language m a.
Monoid m =>
(a -> m) -> GenericOutput language a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> GenericOutput language a -> m
$cfoldr :: forall language a b.
(a -> b -> b) -> b -> GenericOutput language a -> b
foldr :: forall a b. (a -> b -> b) -> b -> GenericOutput language a -> b
$cfoldr' :: forall language a b.
(a -> b -> b) -> b -> GenericOutput language a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> GenericOutput language a -> b
$cfoldl :: forall language b a.
(b -> a -> b) -> b -> GenericOutput language a -> b
foldl :: forall b a. (b -> a -> b) -> b -> GenericOutput language a -> b
$cfoldl' :: forall language b a.
(b -> a -> b) -> b -> GenericOutput language a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> GenericOutput language a -> b
$cfoldr1 :: forall language a. (a -> a -> a) -> GenericOutput language a -> a
foldr1 :: forall a. (a -> a -> a) -> GenericOutput language a -> a
$cfoldl1 :: forall language a. (a -> a -> a) -> GenericOutput language a -> a
foldl1 :: forall a. (a -> a -> a) -> GenericOutput language a -> a
$ctoList :: forall language a. GenericOutput language a -> [a]
toList :: forall a. GenericOutput language a -> [a]
$cnull :: forall language a. GenericOutput language a -> Bool
null :: forall a. GenericOutput language a -> Bool
$clength :: forall language a. GenericOutput language a -> Int
length :: forall a. GenericOutput language a -> Int
$celem :: forall language a. Eq a => a -> GenericOutput language a -> Bool
elem :: forall a. Eq a => a -> GenericOutput language a -> Bool
$cmaximum :: forall language a. Ord a => GenericOutput language a -> a
maximum :: forall a. Ord a => GenericOutput language a -> a
$cminimum :: forall language a. Ord a => GenericOutput language a -> a
minimum :: forall a. Ord a => GenericOutput language a -> a
$csum :: forall language a. Num a => GenericOutput language a -> a
sum :: forall a. Num a => GenericOutput language a -> a
$cproduct :: forall language a. Num a => GenericOutput language a -> a
product :: forall a. Num a => GenericOutput language a -> a
Foldable, (forall x.
 GenericOutput language element
 -> Rep (GenericOutput language element) x)
-> (forall x.
    Rep (GenericOutput language element) x
    -> GenericOutput language element)
-> Generic (GenericOutput language element)
forall x.
Rep (GenericOutput language element) x
-> GenericOutput language element
forall x.
GenericOutput language element
-> Rep (GenericOutput language element) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall language element x.
Rep (GenericOutput language element) x
-> GenericOutput language element
forall language element x.
GenericOutput language element
-> Rep (GenericOutput language element) x
$cfrom :: forall language element x.
GenericOutput language element
-> Rep (GenericOutput language element) x
from :: forall x.
GenericOutput language element
-> Rep (GenericOutput language element) x
$cto :: forall language element x.
Rep (GenericOutput language element) x
-> GenericOutput language element
to :: forall x.
Rep (GenericOutput language element) x
-> GenericOutput language element
Generic, ReadPrec [GenericOutput language element]
ReadPrec (GenericOutput language element)
Int -> ReadS (GenericOutput language element)
ReadS [GenericOutput language element]
(Int -> ReadS (GenericOutput language element))
-> ReadS [GenericOutput language element]
-> ReadPrec (GenericOutput language element)
-> ReadPrec [GenericOutput language element]
-> Read (GenericOutput language element)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall language element.
(Ord language, Read language, Read element) =>
ReadPrec [GenericOutput language element]
forall language element.
(Ord language, Read language, Read element) =>
ReadPrec (GenericOutput language element)
forall language element.
(Ord language, Read language, Read element) =>
Int -> ReadS (GenericOutput language element)
forall language element.
(Ord language, Read language, Read element) =>
ReadS [GenericOutput language element]
$creadsPrec :: forall language element.
(Ord language, Read language, Read element) =>
Int -> ReadS (GenericOutput language element)
readsPrec :: Int -> ReadS (GenericOutput language element)
$creadList :: forall language element.
(Ord language, Read language, Read element) =>
ReadS [GenericOutput language element]
readList :: ReadS [GenericOutput language element]
$creadPrec :: forall language element.
(Ord language, Read language, Read element) =>
ReadPrec (GenericOutput language element)
readPrec :: ReadPrec (GenericOutput language element)
$creadListPrec :: forall language element.
(Ord language, Read language, Read element) =>
ReadPrec [GenericOutput language element]
readListPrec :: ReadPrec [GenericOutput language element]
Read, Int -> GenericOutput language element -> ShowS
[GenericOutput language element] -> ShowS
GenericOutput language element -> FilePath
(Int -> GenericOutput language element -> ShowS)
-> (GenericOutput language element -> FilePath)
-> ([GenericOutput language element] -> ShowS)
-> Show (GenericOutput language element)
forall a.
(Int -> a -> ShowS) -> (a -> FilePath) -> ([a] -> ShowS) -> Show a
forall language element.
(Show language, Show element) =>
Int -> GenericOutput language element -> ShowS
forall language element.
(Show language, Show element) =>
[GenericOutput language element] -> ShowS
forall language element.
(Show language, Show element) =>
GenericOutput language element -> FilePath
$cshowsPrec :: forall language element.
(Show language, Show element) =>
Int -> GenericOutput language element -> ShowS
showsPrec :: Int -> GenericOutput language element -> ShowS
$cshow :: forall language element.
(Show language, Show element) =>
GenericOutput language element -> FilePath
show :: GenericOutput language element -> FilePath
$cshowList :: forall language element.
(Show language, Show element) =>
[GenericOutput language element] -> ShowS
showList :: [GenericOutput language element] -> ShowS
Show, Typeable (GenericOutput language element)
Typeable (GenericOutput language element) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> GenericOutput language element
 -> c (GenericOutput language element))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (GenericOutput language element))
-> (GenericOutput language element -> Constr)
-> (GenericOutput language element -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (GenericOutput language element)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (GenericOutput language element)))
-> ((forall b. Data b => b -> b)
    -> GenericOutput language element
    -> GenericOutput language element)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> GenericOutput language element
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> GenericOutput language element
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> GenericOutput language element -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> GenericOutput language element
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> GenericOutput language element
    -> m (GenericOutput language element))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenericOutput language element
    -> m (GenericOutput language element))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> GenericOutput language element
    -> m (GenericOutput language element))
-> Data (GenericOutput language element)
GenericOutput language element -> Constr
GenericOutput language element -> DataType
(forall b. Data b => b -> b)
-> GenericOutput language element -> GenericOutput language element
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)
-> GenericOutput language element
-> u
forall u.
(forall d. Data d => d -> u)
-> GenericOutput language element -> [u]
forall language element.
(Ord language, Data language, Data element) =>
Typeable (GenericOutput language element)
forall language element.
(Ord language, Data language, Data element) =>
GenericOutput language element -> Constr
forall language element.
(Ord language, Data language, Data element) =>
GenericOutput language element -> DataType
forall language element.
(Ord language, Data language, Data element) =>
(forall b. Data b => b -> b)
-> GenericOutput language element -> GenericOutput language element
forall language element u.
(Ord language, Data language, Data element) =>
Int
-> (forall d. Data d => d -> u)
-> GenericOutput language element
-> u
forall language element u.
(Ord language, Data language, Data element) =>
(forall d. Data d => d -> u)
-> GenericOutput language element -> [u]
forall language element r r'.
(Ord language, Data language, Data element) =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
forall language element r r'.
(Ord language, Data language, Data element) =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
forall language element (m :: * -> *).
(Ord language, Data language, Data element, Monad m) =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
forall language element (m :: * -> *).
(Ord language, Data language, Data element, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
forall language element (c :: * -> *).
(Ord language, Data language, Data element) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (GenericOutput language element)
forall language element (c :: * -> *).
(Ord language, Data language, Data element) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GenericOutput language element
-> c (GenericOutput language element)
forall language element (t :: * -> *) (c :: * -> *).
(Ord language, Data language, Data element, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (GenericOutput language element))
forall language element (t :: * -> * -> *) (c :: * -> *).
(Ord language, Data language, Data element, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenericOutput language element))
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (GenericOutput language element)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GenericOutput language element
-> c (GenericOutput language element)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (GenericOutput language element))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenericOutput language element))
$cgfoldl :: forall language element (c :: * -> *).
(Ord language, Data language, Data element) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GenericOutput language element
-> c (GenericOutput language element)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> GenericOutput language element
-> c (GenericOutput language element)
$cgunfold :: forall language element (c :: * -> *).
(Ord language, Data language, Data element) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (GenericOutput language element)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (GenericOutput language element)
$ctoConstr :: forall language element.
(Ord language, Data language, Data element) =>
GenericOutput language element -> Constr
toConstr :: GenericOutput language element -> Constr
$cdataTypeOf :: forall language element.
(Ord language, Data language, Data element) =>
GenericOutput language element -> DataType
dataTypeOf :: GenericOutput language element -> DataType
$cdataCast1 :: forall language element (t :: * -> *) (c :: * -> *).
(Ord language, Data language, Data element, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (GenericOutput language element))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (GenericOutput language element))
$cdataCast2 :: forall language element (t :: * -> * -> *) (c :: * -> *).
(Ord language, Data language, Data element, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenericOutput language element))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (GenericOutput language element))
$cgmapT :: forall language element.
(Ord language, Data language, Data element) =>
(forall b. Data b => b -> b)
-> GenericOutput language element -> GenericOutput language element
gmapT :: (forall b. Data b => b -> b)
-> GenericOutput language element -> GenericOutput language element
$cgmapQl :: forall language element r r'.
(Ord language, Data language, Data element) =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
$cgmapQr :: forall language element r r'.
(Ord language, Data language, Data element) =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> GenericOutput language element
-> r
$cgmapQ :: forall language element u.
(Ord language, Data language, Data element) =>
(forall d. Data d => d -> u)
-> GenericOutput language element -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u)
-> GenericOutput language element -> [u]
$cgmapQi :: forall language element u.
(Ord language, Data language, Data element) =>
Int
-> (forall d. Data d => d -> u)
-> GenericOutput language element
-> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> GenericOutput language element
-> u
$cgmapM :: forall language element (m :: * -> *).
(Ord language, Data language, Data element, Monad m) =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
$cgmapMp :: forall language element (m :: * -> *).
(Ord language, Data language, Data element, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
$cgmapMo :: forall language element (m :: * -> *).
(Ord language, Data language, Data element, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> GenericOutput language element
-> m (GenericOutput language element)
Data)

{-|
OutputCapable instances for 'GenericOutput',
allowing for free conversion between ADT and interface.
-}
instance
  (Bounded language, Enum language, Monad m, Ord language)
  => GenericOutputCapable language (
    GenericReportT language (GenericOutput language element) m
    )
  where
  assertion :: Bool
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
assertion Bool
b = (if Bool
b then GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall a. a -> a
id else GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) l o a b.
Monad m =>
GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) b
toAbort) (GenericLangM
   language
   (GenericReportT language (GenericOutput language element) m)
   ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
    -> GenericLangM
         language
         (GenericReportT language (GenericOutput language element) m)
         ())
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([GenericOutput language element]
 -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a.
Monad m =>
([o] -> o)
-> GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) ()
alignOutput (Bool
-> [GenericOutput language element]
-> GenericOutput language element
forall language element.
Bool
-> [GenericOutput language element]
-> GenericOutput language element
YesNo Bool
b)

  image :: FilePath
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
image = GenericOutput language element
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l.
Monad m =>
o -> GenericLangM l (GenericReportT l o m) ()
format (GenericOutput language element
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (FilePath -> GenericOutput language element)
-> FilePath
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> GenericOutput language element
forall language element. FilePath -> GenericOutput language element
Image

  images :: forall k a.
(k -> FilePath)
-> (a -> FilePath)
-> Map k a
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
images k -> FilePath
descF a -> FilePath
fileF = GenericOutput language element
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l.
Monad m =>
o -> GenericLangM l (GenericReportT l o m) ()
format (GenericOutput language element
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (Map k a -> GenericOutput language element)
-> Map k a
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map FilePath FilePath -> GenericOutput language element
forall language element.
Map FilePath FilePath -> GenericOutput language element
Images (Map FilePath FilePath -> GenericOutput language element)
-> (Map k a -> Map FilePath FilePath)
-> Map k a
-> GenericOutput language element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> FilePath) -> Map k FilePath -> Map FilePath FilePath
forall k2 k1 a. Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
Map.mapKeys k -> FilePath
descF (Map k FilePath -> Map FilePath FilePath)
-> (Map k a -> Map k FilePath) -> Map k a -> Map FilePath FilePath
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> FilePath) -> Map k a -> Map k FilePath
forall a b k. (a -> b) -> Map k a -> Map k b
Map.map a -> FilePath
fileF

  paragraph :: GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
paragraph = ([GenericOutput language element]
 -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a.
Monad m =>
([o] -> o)
-> GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) ()
alignOutput [GenericOutput language element] -> GenericOutput language element
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph

  refuse :: GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
refuse = GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) l o a b.
Monad m =>
GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) b
toAbort

  enumerateM :: forall a.
(a
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> [(a,
     GenericLangM
       language
       (GenericReportT language (GenericOutput language element) m)
       ())]
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
enumerateM a
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
f [(a,
  GenericLangM
    language
    (GenericReportT language (GenericOutput language element) m)
    ())]
tups = ([[GenericOutput language element]]
 -> GenericOutput language element)
-> [GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()]
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a.
Monad m =>
([[o]] -> o)
-> [GenericLangM l (GenericReportT l o m) a]
-> GenericLangM l (GenericReportT l o m) ()
combineReports
                        ([([GenericOutput language element],
  [GenericOutput language element])]
-> GenericOutput language element
forall language element.
[([GenericOutput language element],
  [GenericOutput language element])]
-> GenericOutput language element
Enumerated ([([GenericOutput language element],
   [GenericOutput language element])]
 -> GenericOutput language element)
-> ([[GenericOutput language element]]
    -> [([GenericOutput language element],
         [GenericOutput language element])])
-> [[GenericOutput language element]]
-> GenericOutput language element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenericOutput language element
 -> [([GenericOutput language element],
      [GenericOutput language element])])
-> [GenericOutput language element]
-> [([GenericOutput language element],
     [GenericOutput language element])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap GenericOutput language element
-> [([GenericOutput language element],
     [GenericOutput language element])]
forall {language} {element}.
GenericOutput language element
-> [([GenericOutput language element],
     [GenericOutput language element])]
expose ([GenericOutput language element]
 -> [([GenericOutput language element],
      [GenericOutput language element])])
-> ([[GenericOutput language element]]
    -> [GenericOutput language element])
-> [[GenericOutput language element]]
-> [([GenericOutput language element],
     [GenericOutput language element])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[GenericOutput language element]]
-> [GenericOutput language element]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat)
                         [GenericLangM
   language
   (GenericReportT language (GenericOutput language element) m)
   ()]
combine
    where
      combine :: [GenericLangM
   language
   (GenericReportT language (GenericOutput language element) m)
   ()]
combine = (GenericLangM
   language
   (GenericReportT language (GenericOutput language element) m)
   ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      (),
    GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry (([GenericOutput language element]
 -> [GenericOutput language element]
 -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a b.
Monad m =>
([o] -> [o] -> o)
-> GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) b
-> GenericLangM l (GenericReportT l o m) ()
combineTwoReports (([GenericOutput language element]
  -> [GenericOutput language element]
  -> GenericOutput language element)
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> ((([GenericOutput language element],
      [GenericOutput language element])
     -> GenericOutput language element)
    -> [GenericOutput language element]
    -> [GenericOutput language element]
    -> GenericOutput language element)
-> (([GenericOutput language element],
     [GenericOutput language element])
    -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([GenericOutput language element],
  [GenericOutput language element])
 -> GenericOutput language element)
-> [GenericOutput language element]
-> [GenericOutput language element]
-> GenericOutput language element
forall a b c. ((a, b) -> c) -> a -> b -> c
curry ((([GenericOutput language element],
   [GenericOutput language element])
  -> GenericOutput language element)
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (([GenericOutput language element],
     [GenericOutput language element])
    -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall a b. (a -> b) -> a -> b
$ [([GenericOutput language element],
  [GenericOutput language element])]
-> GenericOutput language element
forall language element.
[([GenericOutput language element],
  [GenericOutput language element])]
-> GenericOutput language element
Enumerated ([([GenericOutput language element],
   [GenericOutput language element])]
 -> GenericOutput language element)
-> (([GenericOutput language element],
     [GenericOutput language element])
    -> [([GenericOutput language element],
         [GenericOutput language element])])
-> ([GenericOutput language element],
    [GenericOutput language element])
-> GenericOutput language element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (([GenericOutput language element],
 [GenericOutput language element])
-> [([GenericOutput language element],
     [GenericOutput language element])]
-> [([GenericOutput language element],
     [GenericOutput language element])]
forall a. a -> [a] -> [a]
:[]))
              ((GenericLangM
    language
    (GenericReportT language (GenericOutput language element) m)
    (),
  GenericLangM
    language
    (GenericReportT language (GenericOutput language element) m)
    ())
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> ((a,
     GenericLangM
       language
       (GenericReportT language (GenericOutput language element) m)
       ())
    -> (GenericLangM
          language
          (GenericReportT language (GenericOutput language element) m)
          (),
        GenericLangM
          language
          (GenericReportT language (GenericOutput language element) m)
          ()))
-> (a,
    GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (a,
    GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      (),
    GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
forall a a' b. (a -> a') -> (a, b) -> (a', b)
first a
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
f
            ((a,
  GenericLangM
    language
    (GenericReportT language (GenericOutput language element) m)
    ())
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> [(a,
     GenericLangM
       language
       (GenericReportT language (GenericOutput language element) m)
       ())]
-> [GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(a,
  GenericLangM
    language
    (GenericReportT language (GenericOutput language element) m)
    ())]
tups

      expose :: GenericOutput language element
-> [([GenericOutput language element],
     [GenericOutput language element])]
expose (Enumerated [([GenericOutput language element],
  [GenericOutput language element])]
list) = [([GenericOutput language element],
  [GenericOutput language element])]
list
      expose GenericOutput language element
_                 = FilePath
-> [([GenericOutput language element],
     [GenericOutput language element])]
forall a. HasCallStack => FilePath -> a
error FilePath
"This is impossible"

  itemizeM :: [GenericLangM
   language
   (GenericReportT language (GenericOutput language element) m)
   ()]
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
itemizeM = ([[GenericOutput language element]]
 -> GenericOutput language element)
-> [GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()]
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a.
Monad m =>
([[o]] -> o)
-> [GenericLangM l (GenericReportT l o m) a]
-> GenericLangM l (GenericReportT l o m) ()
combineReports [[GenericOutput language element]]
-> GenericOutput language element
forall language element.
[[GenericOutput language element]]
-> GenericOutput language element
Itemized

  indent :: GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
indent = ([GenericOutput language element]
 -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a.
Monad m =>
([o] -> o)
-> GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) ()
alignOutput [GenericOutput language element] -> GenericOutput language element
forall language element.
[GenericOutput language element] -> GenericOutput language element
Indented

  latex :: FilePath
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
latex = GenericOutput language element
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l.
Monad m =>
o -> GenericLangM l (GenericReportT l o m) ()
format (GenericOutput language element
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> (FilePath -> GenericOutput language element)
-> FilePath
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FilePath -> GenericOutput language element
forall language element. FilePath -> GenericOutput language element
Latex

  folded :: Bool
-> (language -> FilePath)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
folded Bool
b language -> FilePath
t = ([GenericOutput language element]
 -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l a.
Monad m =>
([o] -> o)
-> GenericLangM l (GenericReportT l o m) a
-> GenericLangM l (GenericReportT l o m) ()
alignOutput (Bool
-> Map language FilePath
-> [GenericOutput language element]
-> GenericOutput language element
forall language element.
Bool
-> Map language FilePath
-> [GenericOutput language element]
-> GenericOutput language element
Folded Bool
b (Map language FilePath
 -> [GenericOutput language element]
 -> GenericOutput language element)
-> Map language FilePath
-> [GenericOutput language element]
-> GenericOutput language element
forall a b. (a -> b) -> a -> b
$ (language -> FilePath) -> Map language FilePath
forall l o. (Bounded l, Enum l, Ord l) => (l -> o) -> Map l o
toMap language -> FilePath
t)

  translatedCode :: (language -> FilePath)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
translatedCode =  GenericOutput language element
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l.
Monad m =>
o -> GenericLangM l (GenericReportT l o m) ()
format (GenericOutput language element
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> ((language -> FilePath) -> GenericOutput language element)
-> (language -> FilePath)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map language FilePath -> GenericOutput language element
forall language element.
Map language FilePath -> GenericOutput language element
Code (Map language FilePath -> GenericOutput language element)
-> ((language -> FilePath) -> Map language FilePath)
-> (language -> FilePath)
-> GenericOutput language element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (language -> FilePath) -> Map language FilePath
forall l o. (Bounded l, Enum l, Ord l) => (l -> o) -> Map l o
toMap

  translated :: (language -> FilePath)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
translated = GenericOutput language element
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall (m :: * -> *) o l.
Monad m =>
o -> GenericLangM l (GenericReportT l o m) ()
format (GenericOutput language element
 -> GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ())
-> ((language -> FilePath) -> GenericOutput language element)
-> (language -> FilePath)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map language FilePath -> GenericOutput language element
forall language element.
Map language FilePath -> GenericOutput language element
Translated (Map language FilePath -> GenericOutput language element)
-> ((language -> FilePath) -> Map language FilePath)
-> (language -> FilePath)
-> GenericOutput language element
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (language -> FilePath) -> Map language FilePath
forall l o. (Bounded l, Enum l, Ord l) => (l -> o) -> Map l o
toMap



{- |
Convert a list of 'GenericOutput' into any member of 'GenericOutputCapable'
-}
toOutputCapable
  :: GenericOutputCapable language m
  => (element -> GenericLangM language m ())
  -> (Bool -> GenericLangM language m () -> GenericLangM language m ())
  -> [GenericOutput language element]
  -> GenericLangM language m ()
toOutputCapable :: forall language (m :: * -> *) element.
GenericOutputCapable language m =>
(element -> GenericLangM language m ())
-> (Bool
    -> GenericLangM language m () -> GenericLangM language m ())
-> [GenericOutput language element]
-> GenericLangM language m ()
toOutputCapable element -> GenericLangM language m ()
toOutputPart Bool -> GenericLangM language m () -> GenericLangM language m ()
yesNoDisplay [GenericOutput language element]
parts = [GenericOutput language element]
-> (GenericOutput language element -> GenericLangM language m ())
-> GenericLangM language m ()
forall (t :: * -> *) (f :: * -> *) a b.
(Foldable t, Applicative f) =>
t a -> (a -> f b) -> f ()
for_ [GenericOutput language element]
parts GenericOutput language element -> GenericLangM language m ()
toInterface
  where
    toInterface :: GenericOutput language element -> GenericLangM language m ()
toInterface GenericOutput language element
res = case GenericOutput language element
res of
      YesNo Bool
b [GenericOutput language element]
xs       -> Bool -> GenericLangM language m () -> GenericLangM language m ()
yesNoDisplay Bool
b (GenericLangM language m () -> GenericLangM language m ())
-> GenericLangM language m () -> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable' [GenericOutput language element]
xs
      Image FilePath
path       -> FilePath -> GenericLangM language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
FilePath -> GenericLangM l m ()
image FilePath
path
      Images Map FilePath FilePath
m         -> ShowS
-> ShowS -> Map FilePath FilePath -> GenericLangM language m ()
forall k a.
(k -> FilePath)
-> (a -> FilePath) -> Map k a -> GenericLangM language m ()
forall l (m :: * -> *) k a.
GenericOutputCapable l m =>
(k -> FilePath)
-> (a -> FilePath) -> Map k a -> GenericLangM l m ()
images ShowS
forall a. a -> a
id ShowS
forall a. a -> a
id Map FilePath FilePath
m
      Paragraph [GenericOutput language element]
xs     -> 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
$ [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable' [GenericOutput language element]
xs
      Enumerated [([GenericOutput language element],
  [GenericOutput language element])]
list  -> (GenericLangM language m () -> GenericLangM language m ())
-> [(GenericLangM language m (), GenericLangM language m ())]
-> GenericLangM language m ()
forall a.
(a -> GenericLangM language m ())
-> [(a, GenericLangM language m ())] -> GenericLangM language m ()
forall l (m :: * -> *) a.
GenericOutputCapable l m =>
(a -> GenericLangM l m ())
-> [(a, GenericLangM l m ())] -> GenericLangM l m ()
enumerateM GenericLangM language m () -> GenericLangM language m ()
forall a. a -> a
id ([(GenericLangM language m (), GenericLangM language m ())]
 -> GenericLangM language m ())
-> [(GenericLangM language m (), GenericLangM language m ())]
-> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ (([GenericOutput language element],
  [GenericOutput language element])
 -> (GenericLangM language m (), GenericLangM language m ()))
-> [([GenericOutput language element],
     [GenericOutput language element])]
-> [(GenericLangM language m (), GenericLangM language m ())]
forall a b. (a -> b) -> [a] -> [b]
map (([GenericOutput language element] -> GenericLangM language m ())
-> ([GenericOutput language element],
    [GenericOutput language element])
-> (GenericLangM language m (), GenericLangM language m ())
forall a b. (a -> b) -> (a, a) -> (b, b)
both [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable') [([GenericOutput language element],
  [GenericOutput language element])]
list
      Itemized [[GenericOutput language element]]
xs      -> [GenericLangM language m ()] -> GenericLangM language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
[GenericLangM l m ()] -> GenericLangM l m ()
itemizeM ([GenericLangM language m ()] -> GenericLangM language m ())
-> [GenericLangM language m ()] -> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ ([GenericOutput language element] -> GenericLangM language m ())
-> [[GenericOutput language element]]
-> [GenericLangM language m ()]
forall a b. (a -> b) -> [a] -> [b]
map [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable' [[GenericOutput language element]]
xs
      Indented [GenericOutput language element]
xs      -> GenericLangM language m () -> GenericLangM language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
GenericLangM l m () -> GenericLangM l m ()
indent (GenericLangM language m () -> GenericLangM language m ())
-> GenericLangM language m () -> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable' [GenericOutput language element]
xs
      Latex FilePath
s          -> FilePath -> GenericLangM language m ()
forall l (m :: * -> *).
GenericOutputCapable l m =>
FilePath -> GenericLangM l m ()
latex FilePath
s
      Folded Bool
b Map language FilePath
t [GenericOutput language element]
c     -> Bool
-> State (Map language FilePath) ()
-> GenericLangM language m ()
-> GenericLangM language m ()
forall language (m :: * -> *) a1.
GenericOutputCapable language m =>
Bool
-> State (Map language FilePath) a1
-> GenericLangM language m ()
-> GenericLangM language m ()
collapsed Bool
b (Map language FilePath -> State (Map language FilePath) ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put Map language FilePath
t) (GenericLangM language m () -> GenericLangM language m ())
-> GenericLangM language m () -> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable' [GenericOutput language element]
c
      Code Map language FilePath
m           -> State (Map language FilePath) () -> GenericLangM language m ()
forall language (m :: * -> *) a.
GenericOutputCapable language m =>
State (Map language FilePath) a -> GenericLangM language m ()
translateCode (State (Map language FilePath) () -> GenericLangM language m ())
-> State (Map language FilePath) () -> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ Map language FilePath -> State (Map language FilePath) ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put Map language FilePath
m
      Translated Map language FilePath
m     -> State (Map language FilePath) () -> GenericLangM language m ()
forall language (m :: * -> *) a.
GenericOutputCapable language m =>
State (Map language FilePath) a -> GenericLangM language m ()
translate (State (Map language FilePath) () -> GenericLangM language m ())
-> State (Map language FilePath) () -> GenericLangM language m ()
forall a b. (a -> b) -> a -> b
$ Map language FilePath -> State (Map language FilePath) ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
put Map language FilePath
m
      Special element
element  -> element -> GenericLangM language m ()
toOutputPart element
element
    toOutputCapable' :: [GenericOutput language element] -> GenericLangM language m ()
toOutputCapable' = (element -> GenericLangM language m ())
-> (Bool
    -> GenericLangM language m () -> GenericLangM language m ())
-> [GenericOutput language element]
-> GenericLangM language m ()
forall language (m :: * -> *) element.
GenericOutputCapable language m =>
(element -> GenericLangM language m ())
-> (Bool
    -> GenericLangM language m () -> GenericLangM language m ())
-> [GenericOutput language element]
-> GenericLangM language m ()
toOutputCapable element -> GenericLangM language m ()
toOutputPart Bool -> GenericLangM language m () -> GenericLangM language m ()
yesNoDisplay



{-|
Converts non graded 'GenericOutputCapable' value using 'GenericOutput'
into a list of 'GenericOutput'
-}
getOutputSequence
  :: Functor m
  => language
  -> GenericLangM language (GenericReportT language (GenericOutput language element) m) ()
  -> m [GenericOutput language element]
getOutputSequence :: forall (m :: * -> *) language element.
Functor m =>
language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> m [GenericOutput language element]
getOutputSequence language
f = ((Maybe (), [GenericOutput language element])
-> [GenericOutput language element]
forall a b. (a, b) -> b
snd ((Maybe (), [GenericOutput language element])
 -> [GenericOutput language element])
-> m (Maybe (), [GenericOutput language element])
-> m [GenericOutput language element]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>) (m (Maybe (), [GenericOutput language element])
 -> m [GenericOutput language element])
-> (GenericLangM
      language
      (GenericReportT language (GenericOutput language element) m)
      ()
    -> m (Maybe (), [GenericOutput language element]))
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> m [GenericOutput language element]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     ()
-> m (Maybe (), [GenericOutput language element])
forall (m :: * -> *) language element a.
Functor m =>
language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     a
-> m (Maybe a, [GenericOutput language element])
getOutputSequenceWithResult language
f



{-|
More concretely typed alias of 'getOutputSequenceWithResult'

Converts graded 'GenericOutputCapable' value using 'GenericOutput'
into a rating and a list of 'GenericOutput'
-}
getOutputSequenceWithRating
  :: Functor m
  => language
  -> GenericLangM language (GenericReportT language (GenericOutput language element) m) Rational
  -> m (Maybe Rational, [GenericOutput language element])
getOutputSequenceWithRating :: forall (m :: * -> *) language element.
Functor m =>
language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     Rational
-> m (Maybe Rational, [GenericOutput language element])
getOutputSequenceWithRating = language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     Rational
-> m (Maybe Rational, [GenericOutput language element])
forall (m :: * -> *) language element a.
Functor m =>
language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     a
-> m (Maybe a, [GenericOutput language element])
getOutputSequenceWithResult


{-|
Converts 'GenericOutputCapable' value using 'GenericOutput'
into a result and a list of 'GenericOutput'

Consider using 'getOutputSequenceWithRating'
or even more specific versions of 'Control.OutputCapable.Blocks.Type'
in order to get better error messages on implementation errors.
-}
getOutputSequenceWithResult
  :: Functor m
  => language
  -> GenericLangM language (GenericReportT language (GenericOutput language element) m) a
  -> m (Maybe a, [GenericOutput language element])
getOutputSequenceWithResult :: forall (m :: * -> *) language element a.
Functor m =>
language
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     a
-> m (Maybe a, [GenericOutput language element])
getOutputSequenceWithResult language
language GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  a
lm = (GenericOutput language element
 -> [GenericOutput language element])
-> (Maybe a, GenericOutput language element)
-> (Maybe a, [GenericOutput language element])
forall b b' a. (b -> b') -> (a, b) -> (a, b')
second GenericOutput language element -> [GenericOutput language element]
forall {language} {element}.
GenericOutput language element -> [GenericOutput language element]
unbox ((Maybe a, GenericOutput language element)
 -> (Maybe a, [GenericOutput language element]))
-> m (Maybe a, GenericOutput language element)
-> m (Maybe a, [GenericOutput language element])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    GenericOutput language element
-> (GenericOutput language element
    -> GenericOutput language element
    -> GenericOutput language element)
-> ((language -> GenericOutput language element)
    -> GenericOutput language element)
-> GenericLangM
     language
     (GenericReportT language (GenericOutput language element) m)
     a
-> m (Maybe a, GenericOutput language element)
forall (m :: * -> *) o l a.
Functor m =>
o
-> (o -> o -> o)
-> ((l -> o) -> o)
-> GenericLangM l (GenericReportT l o m) a
-> m (Maybe a, o)
runLangMReportMultiLang ([GenericOutput language element] -> GenericOutput language element
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph []) GenericOutput language element
-> GenericOutput language element -> GenericOutput language element
forall {language} {element}.
GenericOutput language element
-> GenericOutput language element -> GenericOutput language element
gather ((language -> GenericOutput language element)
-> language -> GenericOutput language element
forall a b. (a -> b) -> a -> b
$ language
language) GenericLangM
  language
  (GenericReportT language (GenericOutput language element) m)
  a
lm
  where
    gather :: GenericOutput language element
-> GenericOutput language element -> GenericOutput language element
gather (Paragraph [GenericOutput language element]
xs) GenericOutput language element
x = [GenericOutput language element] -> GenericOutput language element
forall language element.
[GenericOutput language element] -> GenericOutput language element
Paragraph ([GenericOutput language element]
xs [GenericOutput language element]
-> [GenericOutput language element]
-> [GenericOutput language element]
forall a. [a] -> [a] -> [a]
++ [GenericOutput language element
x])
    gather  GenericOutput language element
_ GenericOutput language element
_ = FilePath -> GenericOutput language element
forall a. HasCallStack => FilePath -> a
error FilePath
"this is impossible"

    unbox :: GenericOutput language element -> [GenericOutput language element]
unbox (Paragraph [GenericOutput language element]
xs) = [GenericOutput language element]
xs
    unbox  GenericOutput language element
_ = FilePath -> [GenericOutput language element]
forall a. HasCallStack => FilePath -> a
error FilePath
"this is impossible"


{-|
A right fold with the possibility to inspect every node.

@since: 0.4
-}
foldMapOutputBy
  :: (a -> a -> a)
  -> (GenericOutput language element -> a)
  -> GenericOutput language element
  -> a
foldMapOutputBy :: forall a language element.
(a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
foldMapOutputBy a -> a -> a
f GenericOutput language element -> a
evaluate GenericOutput language element
x = case GenericOutput language element
x of
  YesNo Bool
_ [GenericOutput language element]
xs        -> (GenericOutput language element -> a -> a)
-> a -> [GenericOutput language element] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a -> a -> a
f (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericOutput language element -> a
descend) (GenericOutput language element -> a
evaluate GenericOutput language element
x) [GenericOutput language element]
xs
  Image {}          -> GenericOutput language element -> a
evaluate GenericOutput language element
x
  Images {}         -> GenericOutput language element -> a
evaluate GenericOutput language element
x
  Paragraph [GenericOutput language element]
xs      -> (GenericOutput language element -> a -> a)
-> a -> [GenericOutput language element] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a -> a -> a
f (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericOutput language element -> a
descend) (GenericOutput language element -> a
evaluate GenericOutput language element
x) [GenericOutput language element]
xs
  Enumerated [([GenericOutput language element],
  [GenericOutput language element])]
xs   ->
    (([GenericOutput language element],
  [GenericOutput language element])
 -> a -> a)
-> a
-> [([GenericOutput language element],
     [GenericOutput language element])]
-> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr
    (\([GenericOutput language element],
 [GenericOutput language element])
next a
done -> (a -> a -> a) -> (a, a) -> a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> a -> a
f ((a, a) -> a) -> (a, a) -> a
forall a b. (a -> b) -> a -> b
$ ([GenericOutput language element] -> a)
-> ([GenericOutput language element],
    [GenericOutput language element])
-> (a, a)
forall a b. (a -> b) -> (a, a) -> (b, b)
both ((GenericOutput language element -> a -> a)
-> a -> [GenericOutput language element] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a -> a -> a
f (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericOutput language element -> a
descend) a
done) ([GenericOutput language element],
 [GenericOutput language element])
next)
    (GenericOutput language element -> a
evaluate GenericOutput language element
x)
    [([GenericOutput language element],
  [GenericOutput language element])]
xs
  Itemized [[GenericOutput language element]]
xs       -> ([GenericOutput language element] -> a -> a)
-> a -> [[GenericOutput language element]] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((a -> [GenericOutput language element] -> a)
-> [GenericOutput language element] -> a -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip ((GenericOutput language element -> a -> a)
-> a -> [GenericOutput language element] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a -> a -> a
f (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericOutput language element -> a
descend))) (GenericOutput language element -> a
evaluate GenericOutput language element
x) [[GenericOutput language element]]
xs
  Indented [GenericOutput language element]
xs       -> (GenericOutput language element -> a -> a)
-> a -> [GenericOutput language element] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a -> a -> a
f (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericOutput language element -> a
descend) (GenericOutput language element -> a
evaluate GenericOutput language element
x) [GenericOutput language element]
xs
  Latex {}          -> GenericOutput language element -> a
evaluate GenericOutput language element
x
  Folded Bool
_ Map language FilePath
_ [GenericOutput language element]
xs     -> (GenericOutput language element -> a -> a)
-> a -> [GenericOutput language element] -> a
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (a -> a -> a
f (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. GenericOutput language element -> a
descend) (GenericOutput language element -> a
evaluate GenericOutput language element
x) [GenericOutput language element]
xs
  Code {}           -> GenericOutput language element -> a
evaluate GenericOutput language element
x
  Translated {}     -> GenericOutput language element -> a
evaluate GenericOutput language element
x
  Special {}        -> GenericOutput language element -> a
evaluate GenericOutput language element
x
  where
    descend :: GenericOutput language element -> a
descend = (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
forall a language element.
(a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
foldMapOutputBy a -> a -> a
f GenericOutput language element -> a
evaluate

{-|
Inspects translations provided the given inspect and combining functions.

@since: 0.3.0.1
-}
inspectTranslations
  :: (element -> a)
  -> (Map language String -> a)
  -> (a -> a -> a)
  -> a
  -> GenericOutput language element
  -> a
inspectTranslations :: forall element a language.
(element -> a)
-> (Map language FilePath -> a)
-> (a -> a -> a)
-> a
-> GenericOutput language element
-> a
inspectTranslations element -> a
inspectSpecial Map language FilePath -> a
inspectTranslation a -> a -> a
f a
z = (a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
forall a language element.
(a -> a -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
foldMapOutputBy a -> a -> a
f ((GenericOutput language element -> a)
 -> GenericOutput language element -> a)
-> (GenericOutput language element -> a)
-> GenericOutput language element
-> a
forall a b. (a -> b) -> a -> b
$ \case
  YesNo {}          -> a
z
  Image {}          -> a
z
  Images {}         -> a
z
  Paragraph {}      -> a
z
  Enumerated {}     -> a
z
  Itemized {}       -> a
z
  Indented {}       -> a
z
  Latex {}          -> a
z
  Folded Bool
_ Map language FilePath
t [GenericOutput language element]
_      -> Map language FilePath -> a
inspectTranslation Map language FilePath
t
  Code Map language FilePath
ts           -> Map language FilePath -> a
inspectTranslation Map language FilePath
ts
  Translated Map language FilePath
ts     -> Map language FilePath -> a
inspectTranslation Map language FilePath
ts
  Special element
element   -> element -> a
inspectSpecial element
element

toMap :: (Bounded l, Enum l, Ord l) => (l -> o) -> Map l o
toMap :: forall l o. (Bounded l, Enum l, Ord l) => (l -> o) -> Map l o
toMap l -> o
f = [(l, o)] -> Map l o
forall k a. Ord k => [(k, a)] -> Map k a
Map.fromList ([(l, o)] -> Map l o) -> [(l, o)] -> Map l o
forall a b. (a -> b) -> a -> b
$ (l -> (l, o)) -> [l] -> [(l, o)]
forall a b. (a -> b) -> [a] -> [b]
map ((l -> o) -> (l, l) -> (l, o)
forall b b' a. (b -> b') -> (a, b) -> (a, b')
second l -> o
f ((l, l) -> (l, o)) -> (l -> (l, l)) -> l -> (l, o)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. l -> (l, l)
forall a. a -> (a, a)
dupe) [l
forall a. Bounded a => a
minBound .. l
forall a. Bounded a => a
maxBound]