{-# LANGUAGE CPP #-}
{-# LANGUAGE ConstraintKinds #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE TypeSynonymInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DeriveTraversable #-}
{-# LANGUAGE DeriveFoldable #-}
{-# LANGUAGE DeriveFunctor #-}

{- |
   Module      : Text.DocTemplates.Internal
   Copyright   : Copyright (C) 2009-2019 John MacFarlane
   License     : BSD3

   Maintainer  : John MacFarlane <jgm@berkeley.edu>
   Stability   : alpha
   Portability : portable
-}

module Text.DocTemplates.Internal
      ( renderTemplate
      , TemplateMonad(..)
      , Context(..)
      , Val(..)
      , ToContext(..)
      , FromContext(..)
      , TemplateTarget
      , Template(..)
      , Variable(..)
      , Pipe(..)
      , Alignment(..)
      , Border(..)
      ) where

import Data.Text.Conversions (FromText(..), ToText(..))
import Data.Aeson (Value(..), ToJSON(..), FromJSON(..), Result(..), fromJSON)
import Data.YAML (ToYAML(..), FromYAML(..), Node(..), Scalar(..))
import Control.Monad.Identity
import qualified Control.Monad.State.Strict as S
import Data.Char (chr, ord)
import qualified Data.Text.Read as T
import qualified Data.Text as T
import qualified Data.Text.IO as TIO
import Text.DocLayout (Doc, HasChars)
import qualified Text.DocLayout as DL
import Data.String (IsString(..))
import Data.Data (Data)
import Data.Typeable (Typeable)
import GHC.Generics (Generic)
import Data.Text (Text)
import qualified Data.Map as M
import qualified Data.HashMap.Strict as H
import qualified Data.Vector as V
import Data.Scientific (floatingOrInteger)
import Data.List (intersperse)
#if MIN_VERSION_base(4,11,0)
#else
import Data.Semigroup
#endif

-- | A template.
data Template a =
       Interpolate Variable
     | Conditional Variable (Template a) (Template a)
     | Iterate Variable (Template a) (Template a)
     | Nested (Template a)
     | Partial [Pipe] (Template a)
     | Literal (Doc a)
     | Concat (Template a) (Template a)
     | Empty
     deriving (Int -> Template a -> ShowS
[Template a] -> ShowS
Template a -> String
(Int -> Template a -> ShowS)
-> (Template a -> String)
-> ([Template a] -> ShowS)
-> Show (Template a)
forall a. Show a => Int -> Template a -> ShowS
forall a. Show a => [Template a] -> ShowS
forall a. Show a => Template a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Template a] -> ShowS
$cshowList :: forall a. Show a => [Template a] -> ShowS
show :: Template a -> String
$cshow :: forall a. Show a => Template a -> String
showsPrec :: Int -> Template a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Template a -> ShowS
Show, ReadPrec [Template a]
ReadPrec (Template a)
Int -> ReadS (Template a)
ReadS [Template a]
(Int -> ReadS (Template a))
-> ReadS [Template a]
-> ReadPrec (Template a)
-> ReadPrec [Template a]
-> Read (Template a)
forall a. Read a => ReadPrec [Template a]
forall a. Read a => ReadPrec (Template a)
forall a. Read a => Int -> ReadS (Template a)
forall a. Read a => ReadS [Template a]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Template a]
$creadListPrec :: forall a. Read a => ReadPrec [Template a]
readPrec :: ReadPrec (Template a)
$creadPrec :: forall a. Read a => ReadPrec (Template a)
readList :: ReadS [Template a]
$creadList :: forall a. Read a => ReadS [Template a]
readsPrec :: Int -> ReadS (Template a)
$creadsPrec :: forall a. Read a => Int -> ReadS (Template a)
Read, Typeable (Template a)
Constr
DataType
Typeable (Template a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Template a -> c (Template a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Template a))
-> (Template a -> Constr)
-> (Template a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Template a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Template a)))
-> ((forall b. Data b => b -> b) -> Template a -> Template a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Template a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Template a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Template a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Template a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Template a -> m (Template a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Template a -> m (Template a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Template a -> m (Template a))
-> Data (Template a)
Template a -> Constr
Template a -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (Template a))
(forall b. Data b => b -> b) -> Template a -> Template a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Template a -> c (Template a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Template a)
forall a. Data a => Typeable (Template a)
forall a. Data a => Template a -> Constr
forall a. Data a => Template a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Template a -> Template a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Template a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Template a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Template a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Template a -> c (Template a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Template a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Template a))
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) -> Template a -> u
forall u. (forall d. Data d => d -> u) -> Template a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Template a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Template a -> c (Template a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Template a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Template a))
$cEmpty :: Constr
$cConcat :: Constr
$cLiteral :: Constr
$cPartial :: Constr
$cNested :: Constr
$cIterate :: Constr
$cConditional :: Constr
$cInterpolate :: Constr
$tTemplate :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Template a -> m (Template a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
gmapMp :: (forall d. Data d => d -> m d) -> Template a -> m (Template a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
gmapM :: (forall d. Data d => d -> m d) -> Template a -> m (Template a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Template a -> m (Template a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Template a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Template a -> u
gmapQ :: (forall d. Data d => d -> u) -> Template a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Template a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Template a -> r
gmapT :: (forall b. Data b => b -> b) -> Template a -> Template a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Template a -> Template a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Template a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Template a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Template a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Template a))
dataTypeOf :: Template a -> DataType
$cdataTypeOf :: forall a. Data a => Template a -> DataType
toConstr :: Template a -> Constr
$ctoConstr :: forall a. Data a => Template a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Template a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Template a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Template a -> c (Template a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Template a -> c (Template a)
$cp1Data :: forall a. Data a => Typeable (Template a)
Data, Typeable, (forall x. Template a -> Rep (Template a) x)
-> (forall x. Rep (Template a) x -> Template a)
-> Generic (Template a)
forall x. Rep (Template a) x -> Template a
forall x. Template a -> Rep (Template a) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall a x. Rep (Template a) x -> Template a
forall a x. Template a -> Rep (Template a) x
$cto :: forall a x. Rep (Template a) x -> Template a
$cfrom :: forall a x. Template a -> Rep (Template a) x
Generic, Template a -> Template a -> Bool
(Template a -> Template a -> Bool)
-> (Template a -> Template a -> Bool) -> Eq (Template a)
forall a. Eq a => Template a -> Template a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Template a -> Template a -> Bool
$c/= :: forall a. Eq a => Template a -> Template a -> Bool
== :: Template a -> Template a -> Bool
$c== :: forall a. Eq a => Template a -> Template a -> Bool
Eq, Eq (Template a)
Eq (Template a) =>
(Template a -> Template a -> Ordering)
-> (Template a -> Template a -> Bool)
-> (Template a -> Template a -> Bool)
-> (Template a -> Template a -> Bool)
-> (Template a -> Template a -> Bool)
-> (Template a -> Template a -> Template a)
-> (Template a -> Template a -> Template a)
-> Ord (Template a)
Template a -> Template a -> Bool
Template a -> Template a -> Ordering
Template a -> Template a -> Template a
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall a. Ord a => Eq (Template a)
forall a. Ord a => Template a -> Template a -> Bool
forall a. Ord a => Template a -> Template a -> Ordering
forall a. Ord a => Template a -> Template a -> Template a
min :: Template a -> Template a -> Template a
$cmin :: forall a. Ord a => Template a -> Template a -> Template a
max :: Template a -> Template a -> Template a
$cmax :: forall a. Ord a => Template a -> Template a -> Template a
>= :: Template a -> Template a -> Bool
$c>= :: forall a. Ord a => Template a -> Template a -> Bool
> :: Template a -> Template a -> Bool
$c> :: forall a. Ord a => Template a -> Template a -> Bool
<= :: Template a -> Template a -> Bool
$c<= :: forall a. Ord a => Template a -> Template a -> Bool
< :: Template a -> Template a -> Bool
$c< :: forall a. Ord a => Template a -> Template a -> Bool
compare :: Template a -> Template a -> Ordering
$ccompare :: forall a. Ord a => Template a -> Template a -> Ordering
$cp1Ord :: forall a. Ord a => Eq (Template a)
Ord,
               Template a -> Bool
(a -> m) -> Template a -> m
(a -> b -> b) -> b -> Template a -> b
(forall m. Monoid m => Template m -> m)
-> (forall m a. Monoid m => (a -> m) -> Template a -> m)
-> (forall m a. Monoid m => (a -> m) -> Template a -> m)
-> (forall a b. (a -> b -> b) -> b -> Template a -> b)
-> (forall a b. (a -> b -> b) -> b -> Template a -> b)
-> (forall b a. (b -> a -> b) -> b -> Template a -> b)
-> (forall b a. (b -> a -> b) -> b -> Template a -> b)
-> (forall a. (a -> a -> a) -> Template a -> a)
-> (forall a. (a -> a -> a) -> Template a -> a)
-> (forall a. Template a -> [a])
-> (forall a. Template a -> Bool)
-> (forall a. Template a -> Int)
-> (forall a. Eq a => a -> Template a -> Bool)
-> (forall a. Ord a => Template a -> a)
-> (forall a. Ord a => Template a -> a)
-> (forall a. Num a => Template a -> a)
-> (forall a. Num a => Template a -> a)
-> Foldable Template
forall a. Eq a => a -> Template a -> Bool
forall a. Num a => Template a -> a
forall a. Ord a => Template a -> a
forall m. Monoid m => Template m -> m
forall a. Template a -> Bool
forall a. Template a -> Int
forall a. Template a -> [a]
forall a. (a -> a -> a) -> Template a -> a
forall m a. Monoid m => (a -> m) -> Template a -> m
forall b a. (b -> a -> b) -> b -> Template a -> b
forall a b. (a -> b -> b) -> b -> Template 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
product :: Template a -> a
$cproduct :: forall a. Num a => Template a -> a
sum :: Template a -> a
$csum :: forall a. Num a => Template a -> a
minimum :: Template a -> a
$cminimum :: forall a. Ord a => Template a -> a
maximum :: Template a -> a
$cmaximum :: forall a. Ord a => Template a -> a
elem :: a -> Template a -> Bool
$celem :: forall a. Eq a => a -> Template a -> Bool
length :: Template a -> Int
$clength :: forall a. Template a -> Int
null :: Template a -> Bool
$cnull :: forall a. Template a -> Bool
toList :: Template a -> [a]
$ctoList :: forall a. Template a -> [a]
foldl1 :: (a -> a -> a) -> Template a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Template a -> a
foldr1 :: (a -> a -> a) -> Template a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Template a -> a
foldl' :: (b -> a -> b) -> b -> Template a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Template a -> b
foldl :: (b -> a -> b) -> b -> Template a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Template a -> b
foldr' :: (a -> b -> b) -> b -> Template a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Template a -> b
foldr :: (a -> b -> b) -> b -> Template a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Template a -> b
foldMap' :: (a -> m) -> Template a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Template a -> m
foldMap :: (a -> m) -> Template a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Template a -> m
fold :: Template m -> m
$cfold :: forall m. Monoid m => Template m -> m
Foldable, Functor Template
Foldable Template
(Functor Template, Foldable Template) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Template a -> f (Template b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Template (f a) -> f (Template a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Template a -> m (Template b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Template (m a) -> m (Template a))
-> Traversable Template
(a -> f b) -> Template a -> f (Template b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Template (m a) -> m (Template a)
forall (f :: * -> *) a.
Applicative f =>
Template (f a) -> f (Template a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Template a -> m (Template b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Template a -> f (Template b)
sequence :: Template (m a) -> m (Template a)
$csequence :: forall (m :: * -> *) a. Monad m => Template (m a) -> m (Template a)
mapM :: (a -> m b) -> Template a -> m (Template b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Template a -> m (Template b)
sequenceA :: Template (f a) -> f (Template a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Template (f a) -> f (Template a)
traverse :: (a -> f b) -> Template a -> f (Template b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Template a -> f (Template b)
$cp2Traversable :: Foldable Template
$cp1Traversable :: Functor Template
Traversable, a -> Template b -> Template a
(a -> b) -> Template a -> Template b
(forall a b. (a -> b) -> Template a -> Template b)
-> (forall a b. a -> Template b -> Template a) -> Functor Template
forall a b. a -> Template b -> Template a
forall a b. (a -> b) -> Template a -> Template b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Template b -> Template a
$c<$ :: forall a b. a -> Template b -> Template a
fmap :: (a -> b) -> Template a -> Template b
$cfmap :: forall a b. (a -> b) -> Template a -> Template b
Functor)

instance Semigroup a => Semigroup (Template a) where
  x :: Template a
x <> :: Template a -> Template a -> Template a
<> Empty = Template a
x
  Empty <> x :: Template a
x = Template a
x
  x :: Template a
x <> y :: Template a
y = Template a -> Template a -> Template a
forall a. Template a -> Template a -> Template a
Concat Template a
x Template a
y

instance Semigroup a => Monoid (Template a) where
  mappend :: Template a -> Template a -> Template a
mappend = Template a -> Template a -> Template a
forall a. Semigroup a => a -> a -> a
(<>)
  mempty :: Template a
mempty = Template a
forall a. Template a
Empty

data Pipe =
      ToPairs
    | ToUppercase
    | ToLowercase
    | ToLength
    | Reverse
    | Chomp
    | ToAlpha
    | ToRoman
    | NoWrap
    | Block Alignment Int Border
    deriving (Int -> Pipe -> ShowS
[Pipe] -> ShowS
Pipe -> String
(Int -> Pipe -> ShowS)
-> (Pipe -> String) -> ([Pipe] -> ShowS) -> Show Pipe
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Pipe] -> ShowS
$cshowList :: [Pipe] -> ShowS
show :: Pipe -> String
$cshow :: Pipe -> String
showsPrec :: Int -> Pipe -> ShowS
$cshowsPrec :: Int -> Pipe -> ShowS
Show, ReadPrec [Pipe]
ReadPrec Pipe
Int -> ReadS Pipe
ReadS [Pipe]
(Int -> ReadS Pipe)
-> ReadS [Pipe] -> ReadPrec Pipe -> ReadPrec [Pipe] -> Read Pipe
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Pipe]
$creadListPrec :: ReadPrec [Pipe]
readPrec :: ReadPrec Pipe
$creadPrec :: ReadPrec Pipe
readList :: ReadS [Pipe]
$creadList :: ReadS [Pipe]
readsPrec :: Int -> ReadS Pipe
$creadsPrec :: Int -> ReadS Pipe
Read, Typeable Pipe
Constr
DataType
Typeable Pipe =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Pipe -> c Pipe)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Pipe)
-> (Pipe -> Constr)
-> (Pipe -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Pipe))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipe))
-> ((forall b. Data b => b -> b) -> Pipe -> Pipe)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r)
-> (forall u. (forall d. Data d => d -> u) -> Pipe -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Pipe -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Pipe -> m Pipe)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pipe -> m Pipe)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Pipe -> m Pipe)
-> Data Pipe
Pipe -> Constr
Pipe -> DataType
(forall b. Data b => b -> b) -> Pipe -> Pipe
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipe -> c Pipe
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipe
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) -> Pipe -> u
forall u. (forall d. Data d => d -> u) -> Pipe -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pipe -> m Pipe
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipe -> m Pipe
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipe
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipe -> c Pipe
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pipe)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipe)
$cBlock :: Constr
$cNoWrap :: Constr
$cToRoman :: Constr
$cToAlpha :: Constr
$cChomp :: Constr
$cReverse :: Constr
$cToLength :: Constr
$cToLowercase :: Constr
$cToUppercase :: Constr
$cToPairs :: Constr
$tPipe :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Pipe -> m Pipe
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipe -> m Pipe
gmapMp :: (forall d. Data d => d -> m d) -> Pipe -> m Pipe
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Pipe -> m Pipe
gmapM :: (forall d. Data d => d -> m d) -> Pipe -> m Pipe
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Pipe -> m Pipe
gmapQi :: Int -> (forall d. Data d => d -> u) -> Pipe -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Pipe -> u
gmapQ :: (forall d. Data d => d -> u) -> Pipe -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Pipe -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Pipe -> r
gmapT :: (forall b. Data b => b -> b) -> Pipe -> Pipe
$cgmapT :: (forall b. Data b => b -> b) -> Pipe -> Pipe
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipe)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Pipe)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Pipe)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Pipe)
dataTypeOf :: Pipe -> DataType
$cdataTypeOf :: Pipe -> DataType
toConstr :: Pipe -> Constr
$ctoConstr :: Pipe -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipe
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Pipe
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipe -> c Pipe
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Pipe -> c Pipe
$cp1Data :: Typeable Pipe
Data, Typeable, (forall x. Pipe -> Rep Pipe x)
-> (forall x. Rep Pipe x -> Pipe) -> Generic Pipe
forall x. Rep Pipe x -> Pipe
forall x. Pipe -> Rep Pipe x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Pipe x -> Pipe
$cfrom :: forall x. Pipe -> Rep Pipe x
Generic, Pipe -> Pipe -> Bool
(Pipe -> Pipe -> Bool) -> (Pipe -> Pipe -> Bool) -> Eq Pipe
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Pipe -> Pipe -> Bool
$c/= :: Pipe -> Pipe -> Bool
== :: Pipe -> Pipe -> Bool
$c== :: Pipe -> Pipe -> Bool
Eq, Eq Pipe
Eq Pipe =>
(Pipe -> Pipe -> Ordering)
-> (Pipe -> Pipe -> Bool)
-> (Pipe -> Pipe -> Bool)
-> (Pipe -> Pipe -> Bool)
-> (Pipe -> Pipe -> Bool)
-> (Pipe -> Pipe -> Pipe)
-> (Pipe -> Pipe -> Pipe)
-> Ord Pipe
Pipe -> Pipe -> Bool
Pipe -> Pipe -> Ordering
Pipe -> Pipe -> Pipe
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Pipe -> Pipe -> Pipe
$cmin :: Pipe -> Pipe -> Pipe
max :: Pipe -> Pipe -> Pipe
$cmax :: Pipe -> Pipe -> Pipe
>= :: Pipe -> Pipe -> Bool
$c>= :: Pipe -> Pipe -> Bool
> :: Pipe -> Pipe -> Bool
$c> :: Pipe -> Pipe -> Bool
<= :: Pipe -> Pipe -> Bool
$c<= :: Pipe -> Pipe -> Bool
< :: Pipe -> Pipe -> Bool
$c< :: Pipe -> Pipe -> Bool
compare :: Pipe -> Pipe -> Ordering
$ccompare :: Pipe -> Pipe -> Ordering
$cp1Ord :: Eq Pipe
Ord)

data Alignment =
      LeftAligned
    | Centered
    | RightAligned
    deriving (Int -> Alignment -> ShowS
[Alignment] -> ShowS
Alignment -> String
(Int -> Alignment -> ShowS)
-> (Alignment -> String)
-> ([Alignment] -> ShowS)
-> Show Alignment
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Alignment] -> ShowS
$cshowList :: [Alignment] -> ShowS
show :: Alignment -> String
$cshow :: Alignment -> String
showsPrec :: Int -> Alignment -> ShowS
$cshowsPrec :: Int -> Alignment -> ShowS
Show, ReadPrec [Alignment]
ReadPrec Alignment
Int -> ReadS Alignment
ReadS [Alignment]
(Int -> ReadS Alignment)
-> ReadS [Alignment]
-> ReadPrec Alignment
-> ReadPrec [Alignment]
-> Read Alignment
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Alignment]
$creadListPrec :: ReadPrec [Alignment]
readPrec :: ReadPrec Alignment
$creadPrec :: ReadPrec Alignment
readList :: ReadS [Alignment]
$creadList :: ReadS [Alignment]
readsPrec :: Int -> ReadS Alignment
$creadsPrec :: Int -> ReadS Alignment
Read, Typeable Alignment
Constr
DataType
Typeable Alignment =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Alignment -> c Alignment)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Alignment)
-> (Alignment -> Constr)
-> (Alignment -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Alignment))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment))
-> ((forall b. Data b => b -> b) -> Alignment -> Alignment)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Alignment -> r)
-> (forall u. (forall d. Data d => d -> u) -> Alignment -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Alignment -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Alignment -> m Alignment)
-> Data Alignment
Alignment -> Constr
Alignment -> DataType
(forall b. Data b => b -> b) -> Alignment -> Alignment
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alignment -> c Alignment
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alignment
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) -> Alignment -> u
forall u. (forall d. Data d => d -> u) -> Alignment -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Alignment -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Alignment -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alignment -> m Alignment
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alignment -> m Alignment
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alignment
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alignment -> c Alignment
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Alignment)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment)
$cRightAligned :: Constr
$cCentered :: Constr
$cLeftAligned :: Constr
$tAlignment :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Alignment -> m Alignment
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alignment -> m Alignment
gmapMp :: (forall d. Data d => d -> m d) -> Alignment -> m Alignment
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Alignment -> m Alignment
gmapM :: (forall d. Data d => d -> m d) -> Alignment -> m Alignment
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Alignment -> m Alignment
gmapQi :: Int -> (forall d. Data d => d -> u) -> Alignment -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Alignment -> u
gmapQ :: (forall d. Data d => d -> u) -> Alignment -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Alignment -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Alignment -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Alignment -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Alignment -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Alignment -> r
gmapT :: (forall b. Data b => b -> b) -> Alignment -> Alignment
$cgmapT :: (forall b. Data b => b -> b) -> Alignment -> Alignment
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Alignment)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Alignment)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Alignment)
dataTypeOf :: Alignment -> DataType
$cdataTypeOf :: Alignment -> DataType
toConstr :: Alignment -> Constr
$ctoConstr :: Alignment -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alignment
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Alignment
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alignment -> c Alignment
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Alignment -> c Alignment
$cp1Data :: Typeable Alignment
Data, Typeable, (forall x. Alignment -> Rep Alignment x)
-> (forall x. Rep Alignment x -> Alignment) -> Generic Alignment
forall x. Rep Alignment x -> Alignment
forall x. Alignment -> Rep Alignment x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Alignment x -> Alignment
$cfrom :: forall x. Alignment -> Rep Alignment x
Generic, Alignment -> Alignment -> Bool
(Alignment -> Alignment -> Bool)
-> (Alignment -> Alignment -> Bool) -> Eq Alignment
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Alignment -> Alignment -> Bool
$c/= :: Alignment -> Alignment -> Bool
== :: Alignment -> Alignment -> Bool
$c== :: Alignment -> Alignment -> Bool
Eq, Eq Alignment
Eq Alignment =>
(Alignment -> Alignment -> Ordering)
-> (Alignment -> Alignment -> Bool)
-> (Alignment -> Alignment -> Bool)
-> (Alignment -> Alignment -> Bool)
-> (Alignment -> Alignment -> Bool)
-> (Alignment -> Alignment -> Alignment)
-> (Alignment -> Alignment -> Alignment)
-> Ord Alignment
Alignment -> Alignment -> Bool
Alignment -> Alignment -> Ordering
Alignment -> Alignment -> Alignment
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Alignment -> Alignment -> Alignment
$cmin :: Alignment -> Alignment -> Alignment
max :: Alignment -> Alignment -> Alignment
$cmax :: Alignment -> Alignment -> Alignment
>= :: Alignment -> Alignment -> Bool
$c>= :: Alignment -> Alignment -> Bool
> :: Alignment -> Alignment -> Bool
$c> :: Alignment -> Alignment -> Bool
<= :: Alignment -> Alignment -> Bool
$c<= :: Alignment -> Alignment -> Bool
< :: Alignment -> Alignment -> Bool
$c< :: Alignment -> Alignment -> Bool
compare :: Alignment -> Alignment -> Ordering
$ccompare :: Alignment -> Alignment -> Ordering
$cp1Ord :: Eq Alignment
Ord)

data Border = Border
     { Border -> Text
borderLeft  :: Text
     , Border -> Text
borderRight :: Text
     }
    deriving (Int -> Border -> ShowS
[Border] -> ShowS
Border -> String
(Int -> Border -> ShowS)
-> (Border -> String) -> ([Border] -> ShowS) -> Show Border
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Border] -> ShowS
$cshowList :: [Border] -> ShowS
show :: Border -> String
$cshow :: Border -> String
showsPrec :: Int -> Border -> ShowS
$cshowsPrec :: Int -> Border -> ShowS
Show, ReadPrec [Border]
ReadPrec Border
Int -> ReadS Border
ReadS [Border]
(Int -> ReadS Border)
-> ReadS [Border]
-> ReadPrec Border
-> ReadPrec [Border]
-> Read Border
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Border]
$creadListPrec :: ReadPrec [Border]
readPrec :: ReadPrec Border
$creadPrec :: ReadPrec Border
readList :: ReadS [Border]
$creadList :: ReadS [Border]
readsPrec :: Int -> ReadS Border
$creadsPrec :: Int -> ReadS Border
Read, Typeable Border
Constr
DataType
Typeable Border =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Border -> c Border)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Border)
-> (Border -> Constr)
-> (Border -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Border))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Border))
-> ((forall b. Data b => b -> b) -> Border -> Border)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Border -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Border -> r)
-> (forall u. (forall d. Data d => d -> u) -> Border -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Border -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Border -> m Border)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Border -> m Border)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Border -> m Border)
-> Data Border
Border -> Constr
Border -> DataType
(forall b. Data b => b -> b) -> Border -> Border
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Border -> c Border
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Border
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) -> Border -> u
forall u. (forall d. Data d => d -> u) -> Border -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Border -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Border -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Border -> m Border
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Border -> m Border
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Border
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Border -> c Border
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Border)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Border)
$cBorder :: Constr
$tBorder :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Border -> m Border
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Border -> m Border
gmapMp :: (forall d. Data d => d -> m d) -> Border -> m Border
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Border -> m Border
gmapM :: (forall d. Data d => d -> m d) -> Border -> m Border
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Border -> m Border
gmapQi :: Int -> (forall d. Data d => d -> u) -> Border -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Border -> u
gmapQ :: (forall d. Data d => d -> u) -> Border -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Border -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Border -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Border -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Border -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Border -> r
gmapT :: (forall b. Data b => b -> b) -> Border -> Border
$cgmapT :: (forall b. Data b => b -> b) -> Border -> Border
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Border)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Border)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Border)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Border)
dataTypeOf :: Border -> DataType
$cdataTypeOf :: Border -> DataType
toConstr :: Border -> Constr
$ctoConstr :: Border -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Border
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Border
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Border -> c Border
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Border -> c Border
$cp1Data :: Typeable Border
Data, Typeable, (forall x. Border -> Rep Border x)
-> (forall x. Rep Border x -> Border) -> Generic Border
forall x. Rep Border x -> Border
forall x. Border -> Rep Border x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Border x -> Border
$cfrom :: forall x. Border -> Rep Border x
Generic, Border -> Border -> Bool
(Border -> Border -> Bool)
-> (Border -> Border -> Bool) -> Eq Border
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Border -> Border -> Bool
$c/= :: Border -> Border -> Bool
== :: Border -> Border -> Bool
$c== :: Border -> Border -> Bool
Eq, Eq Border
Eq Border =>
(Border -> Border -> Ordering)
-> (Border -> Border -> Bool)
-> (Border -> Border -> Bool)
-> (Border -> Border -> Bool)
-> (Border -> Border -> Bool)
-> (Border -> Border -> Border)
-> (Border -> Border -> Border)
-> Ord Border
Border -> Border -> Bool
Border -> Border -> Ordering
Border -> Border -> Border
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Border -> Border -> Border
$cmin :: Border -> Border -> Border
max :: Border -> Border -> Border
$cmax :: Border -> Border -> Border
>= :: Border -> Border -> Bool
$c>= :: Border -> Border -> Bool
> :: Border -> Border -> Bool
$c> :: Border -> Border -> Bool
<= :: Border -> Border -> Bool
$c<= :: Border -> Border -> Bool
< :: Border -> Border -> Bool
$c< :: Border -> Border -> Bool
compare :: Border -> Border -> Ordering
$ccompare :: Border -> Border -> Ordering
$cp1Ord :: Eq Border
Ord)

-- | A variable which may have several parts (@foo.bar.baz@).
data Variable =
  Variable
    { Variable -> [Text]
varParts   :: [Text]
    , Variable -> [Pipe]
varPipes   :: [Pipe]
    }
  deriving (Int -> Variable -> ShowS
[Variable] -> ShowS
Variable -> String
(Int -> Variable -> ShowS)
-> (Variable -> String) -> ([Variable] -> ShowS) -> Show Variable
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Variable] -> ShowS
$cshowList :: [Variable] -> ShowS
show :: Variable -> String
$cshow :: Variable -> String
showsPrec :: Int -> Variable -> ShowS
$cshowsPrec :: Int -> Variable -> ShowS
Show, ReadPrec [Variable]
ReadPrec Variable
Int -> ReadS Variable
ReadS [Variable]
(Int -> ReadS Variable)
-> ReadS [Variable]
-> ReadPrec Variable
-> ReadPrec [Variable]
-> Read Variable
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Variable]
$creadListPrec :: ReadPrec [Variable]
readPrec :: ReadPrec Variable
$creadPrec :: ReadPrec Variable
readList :: ReadS [Variable]
$creadList :: ReadS [Variable]
readsPrec :: Int -> ReadS Variable
$creadsPrec :: Int -> ReadS Variable
Read, Typeable Variable
Constr
DataType
Typeable Variable =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Variable -> c Variable)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Variable)
-> (Variable -> Constr)
-> (Variable -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Variable))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variable))
-> ((forall b. Data b => b -> b) -> Variable -> Variable)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Variable -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Variable -> r)
-> (forall u. (forall d. Data d => d -> u) -> Variable -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Variable -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Variable -> m Variable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Variable -> m Variable)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Variable -> m Variable)
-> Data Variable
Variable -> Constr
Variable -> DataType
(forall b. Data b => b -> b) -> Variable -> Variable
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variable -> c Variable
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variable
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) -> Variable -> u
forall u. (forall d. Data d => d -> u) -> Variable -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Variable -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Variable -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Variable -> m Variable
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variable -> m Variable
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variable
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variable -> c Variable
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Variable)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variable)
$cVariable :: Constr
$tVariable :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Variable -> m Variable
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variable -> m Variable
gmapMp :: (forall d. Data d => d -> m d) -> Variable -> m Variable
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Variable -> m Variable
gmapM :: (forall d. Data d => d -> m d) -> Variable -> m Variable
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Variable -> m Variable
gmapQi :: Int -> (forall d. Data d => d -> u) -> Variable -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Variable -> u
gmapQ :: (forall d. Data d => d -> u) -> Variable -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Variable -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Variable -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Variable -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Variable -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Variable -> r
gmapT :: (forall b. Data b => b -> b) -> Variable -> Variable
$cgmapT :: (forall b. Data b => b -> b) -> Variable -> Variable
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variable)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Variable)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Variable)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Variable)
dataTypeOf :: Variable -> DataType
$cdataTypeOf :: Variable -> DataType
toConstr :: Variable -> Constr
$ctoConstr :: Variable -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variable
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Variable
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variable -> c Variable
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Variable -> c Variable
$cp1Data :: Typeable Variable
Data, Typeable, (forall x. Variable -> Rep Variable x)
-> (forall x. Rep Variable x -> Variable) -> Generic Variable
forall x. Rep Variable x -> Variable
forall x. Variable -> Rep Variable x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Variable x -> Variable
$cfrom :: forall x. Variable -> Rep Variable x
Generic, Variable -> Variable -> Bool
(Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool) -> Eq Variable
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Variable -> Variable -> Bool
$c/= :: Variable -> Variable -> Bool
== :: Variable -> Variable -> Bool
$c== :: Variable -> Variable -> Bool
Eq, Eq Variable
Eq Variable =>
(Variable -> Variable -> Ordering)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Bool)
-> (Variable -> Variable -> Variable)
-> (Variable -> Variable -> Variable)
-> Ord Variable
Variable -> Variable -> Bool
Variable -> Variable -> Ordering
Variable -> Variable -> Variable
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Variable -> Variable -> Variable
$cmin :: Variable -> Variable -> Variable
max :: Variable -> Variable -> Variable
$cmax :: Variable -> Variable -> Variable
>= :: Variable -> Variable -> Bool
$c>= :: Variable -> Variable -> Bool
> :: Variable -> Variable -> Bool
$c> :: Variable -> Variable -> Bool
<= :: Variable -> Variable -> Bool
$c<= :: Variable -> Variable -> Bool
< :: Variable -> Variable -> Bool
$c< :: Variable -> Variable -> Bool
compare :: Variable -> Variable -> Ordering
$ccompare :: Variable -> Variable -> Ordering
$cp1Ord :: Eq Variable
Ord)

instance Semigroup Variable where
  Variable xs :: [Text]
xs fs :: [Pipe]
fs <> :: Variable -> Variable -> Variable
<> Variable ys :: [Text]
ys gs :: [Pipe]
gs = [Text] -> [Pipe] -> Variable
Variable ([Text]
xs [Text] -> [Text] -> [Text]
forall a. Semigroup a => a -> a -> a
<> [Text]
ys) ([Pipe]
fs [Pipe] -> [Pipe] -> [Pipe]
forall a. Semigroup a => a -> a -> a
<> [Pipe]
gs)

instance Monoid Variable where
  mempty :: Variable
mempty = [Text] -> [Pipe] -> Variable
Variable [Text]
forall a. Monoid a => a
mempty [Pipe]
forall a. Monoid a => a
mempty
  mappend :: Variable -> Variable -> Variable
mappend = Variable -> Variable -> Variable
forall a. Semigroup a => a -> a -> a
(<>)

type TemplateTarget a =
  (Monoid a, IsString a, HasChars a, ToText a, FromText a)

-- | A 'Context' defines values for template's variables.
newtype Context a = Context { Context a -> Map Text (Val a)
unContext :: M.Map Text (Val a) }
  deriving (Int -> Context a -> ShowS
[Context a] -> ShowS
Context a -> String
(Int -> Context a -> ShowS)
-> (Context a -> String)
-> ([Context a] -> ShowS)
-> Show (Context a)
forall a. Show a => Int -> Context a -> ShowS
forall a. Show a => [Context a] -> ShowS
forall a. Show a => Context a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Context a] -> ShowS
$cshowList :: forall a. Show a => [Context a] -> ShowS
show :: Context a -> String
$cshow :: forall a. Show a => Context a -> String
showsPrec :: Int -> Context a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Context a -> ShowS
Show, b -> Context a -> Context a
NonEmpty (Context a) -> Context a
Context a -> Context a -> Context a
(Context a -> Context a -> Context a)
-> (NonEmpty (Context a) -> Context a)
-> (forall b. Integral b => b -> Context a -> Context a)
-> Semigroup (Context a)
forall b. Integral b => b -> Context a -> Context a
forall a. NonEmpty (Context a) -> Context a
forall a. Context a -> Context a -> Context a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall a b. Integral b => b -> Context a -> Context a
stimes :: b -> Context a -> Context a
$cstimes :: forall a b. Integral b => b -> Context a -> Context a
sconcat :: NonEmpty (Context a) -> Context a
$csconcat :: forall a. NonEmpty (Context a) -> Context a
<> :: Context a -> Context a -> Context a
$c<> :: forall a. Context a -> Context a -> Context a
Semigroup, Semigroup (Context a)
Context a
Semigroup (Context a) =>
Context a
-> (Context a -> Context a -> Context a)
-> ([Context a] -> Context a)
-> Monoid (Context a)
[Context a] -> Context a
Context a -> Context a -> Context a
forall a. Semigroup (Context a)
forall a. Context a
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall a. [Context a] -> Context a
forall a. Context a -> Context a -> Context a
mconcat :: [Context a] -> Context a
$cmconcat :: forall a. [Context a] -> Context a
mappend :: Context a -> Context a -> Context a
$cmappend :: forall a. Context a -> Context a -> Context a
mempty :: Context a
$cmempty :: forall a. Context a
$cp1Monoid :: forall a. Semigroup (Context a)
Monoid, Functor Context
Foldable Context
(Functor Context, Foldable Context) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Context a -> f (Context b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Context (f a) -> f (Context a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Context a -> m (Context b))
-> (forall (m :: * -> *) a.
    Monad m =>
    Context (m a) -> m (Context a))
-> Traversable Context
(a -> f b) -> Context a -> f (Context b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
forall (f :: * -> *) a.
Applicative f =>
Context (f a) -> f (Context a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Context a -> m (Context b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Context a -> f (Context b)
sequence :: Context (m a) -> m (Context a)
$csequence :: forall (m :: * -> *) a. Monad m => Context (m a) -> m (Context a)
mapM :: (a -> m b) -> Context a -> m (Context b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Context a -> m (Context b)
sequenceA :: Context (f a) -> f (Context a)
$csequenceA :: forall (f :: * -> *) a.
Applicative f =>
Context (f a) -> f (Context a)
traverse :: (a -> f b) -> Context a -> f (Context b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Context a -> f (Context b)
$cp2Traversable :: Foldable Context
$cp1Traversable :: Functor Context
Traversable, Context a -> Bool
(a -> m) -> Context a -> m
(a -> b -> b) -> b -> Context a -> b
(forall m. Monoid m => Context m -> m)
-> (forall m a. Monoid m => (a -> m) -> Context a -> m)
-> (forall m a. Monoid m => (a -> m) -> Context a -> m)
-> (forall a b. (a -> b -> b) -> b -> Context a -> b)
-> (forall a b. (a -> b -> b) -> b -> Context a -> b)
-> (forall b a. (b -> a -> b) -> b -> Context a -> b)
-> (forall b a. (b -> a -> b) -> b -> Context a -> b)
-> (forall a. (a -> a -> a) -> Context a -> a)
-> (forall a. (a -> a -> a) -> Context a -> a)
-> (forall a. Context a -> [a])
-> (forall a. Context a -> Bool)
-> (forall a. Context a -> Int)
-> (forall a. Eq a => a -> Context a -> Bool)
-> (forall a. Ord a => Context a -> a)
-> (forall a. Ord a => Context a -> a)
-> (forall a. Num a => Context a -> a)
-> (forall a. Num a => Context a -> a)
-> Foldable Context
forall a. Eq a => a -> Context a -> Bool
forall a. Num a => Context a -> a
forall a. Ord a => Context a -> a
forall m. Monoid m => Context m -> m
forall a. Context a -> Bool
forall a. Context a -> Int
forall a. Context a -> [a]
forall a. (a -> a -> a) -> Context a -> a
forall m a. Monoid m => (a -> m) -> Context a -> m
forall b a. (b -> a -> b) -> b -> Context a -> b
forall a b. (a -> b -> b) -> b -> Context 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
product :: Context a -> a
$cproduct :: forall a. Num a => Context a -> a
sum :: Context a -> a
$csum :: forall a. Num a => Context a -> a
minimum :: Context a -> a
$cminimum :: forall a. Ord a => Context a -> a
maximum :: Context a -> a
$cmaximum :: forall a. Ord a => Context a -> a
elem :: a -> Context a -> Bool
$celem :: forall a. Eq a => a -> Context a -> Bool
length :: Context a -> Int
$clength :: forall a. Context a -> Int
null :: Context a -> Bool
$cnull :: forall a. Context a -> Bool
toList :: Context a -> [a]
$ctoList :: forall a. Context a -> [a]
foldl1 :: (a -> a -> a) -> Context a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Context a -> a
foldr1 :: (a -> a -> a) -> Context a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Context a -> a
foldl' :: (b -> a -> b) -> b -> Context a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Context a -> b
foldl :: (b -> a -> b) -> b -> Context a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Context a -> b
foldr' :: (a -> b -> b) -> b -> Context a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Context a -> b
foldr :: (a -> b -> b) -> b -> Context a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Context a -> b
foldMap' :: (a -> m) -> Context a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Context a -> m
foldMap :: (a -> m) -> Context a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Context a -> m
fold :: Context m -> m
$cfold :: forall m. Monoid m => Context m -> m
Foldable, a -> Context b -> Context a
(a -> b) -> Context a -> Context b
(forall a b. (a -> b) -> Context a -> Context b)
-> (forall a b. a -> Context b -> Context a) -> Functor Context
forall a b. a -> Context b -> Context a
forall a b. (a -> b) -> Context a -> Context b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Context b -> Context a
$c<$ :: forall a b. a -> Context b -> Context a
fmap :: (a -> b) -> Context a -> Context b
$cfmap :: forall a b. (a -> b) -> Context a -> Context b
Functor,
            Typeable (Context a)
Constr
DataType
Typeable (Context a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Context a -> c (Context a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Context a))
-> (Context a -> Constr)
-> (Context a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Context a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (Context a)))
-> ((forall b. Data b => b -> b) -> Context a -> Context a)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Context a -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Context a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Context a -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Context a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Context a -> m (Context a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context a -> m (Context a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Context a -> m (Context a))
-> Data (Context a)
Context a -> Constr
Context a -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (Context a))
(forall b. Data b => b -> b) -> Context a -> Context a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context a -> c (Context a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context a)
forall a. Data a => Typeable (Context a)
forall a. Data a => Context a -> Constr
forall a. Data a => Context a -> DataType
forall a.
Data a =>
(forall b. Data b => b -> b) -> Context a -> Context a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Context a -> u
forall a u.
Data a =>
(forall d. Data d => d -> u) -> Context a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context a -> c (Context a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Context a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context a))
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) -> Context a -> u
forall u. (forall d. Data d => d -> u) -> Context a -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context a -> c (Context a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Context a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context a))
$cContext :: Constr
$tContext :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Context a -> m (Context a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
gmapMp :: (forall d. Data d => d -> m d) -> Context a -> m (Context a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
gmapM :: (forall d. Data d => d -> m d) -> Context a -> m (Context a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Context a -> m (Context a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Context a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Context a -> u
gmapQ :: (forall d. Data d => d -> u) -> Context a -> [u]
$cgmapQ :: forall a u.
Data a =>
(forall d. Data d => d -> u) -> Context a -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Context a -> r
gmapT :: (forall b. Data b => b -> b) -> Context a -> Context a
$cgmapT :: forall a.
Data a =>
(forall b. Data b => b -> b) -> Context a -> Context a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (Context a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Context a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Context a))
dataTypeOf :: Context a -> DataType
$cdataTypeOf :: forall a. Data a => Context a -> DataType
toConstr :: Context a -> Constr
$ctoConstr :: forall a. Data a => Context a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Context a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context a -> c (Context a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Context a -> c (Context a)
$cp1Data :: forall a. Data a => Typeable (Context a)
Data, Typeable)

-- | A variable value.
data Val a =
    SimpleVal  (Doc a)
  | ListVal    [Val a]
  | MapVal     (Context a)
  | NullVal
  deriving (Int -> Val a -> ShowS
[Val a] -> ShowS
Val a -> String
(Int -> Val a -> ShowS)
-> (Val a -> String) -> ([Val a] -> ShowS) -> Show (Val a)
forall a. Show a => Int -> Val a -> ShowS
forall a. Show a => [Val a] -> ShowS
forall a. Show a => Val a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Val a] -> ShowS
$cshowList :: forall a. Show a => [Val a] -> ShowS
show :: Val a -> String
$cshow :: forall a. Show a => Val a -> String
showsPrec :: Int -> Val a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> Val a -> ShowS
Show, Functor Val
Foldable Val
(Functor Val, Foldable Val) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Val a -> f (Val b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Val (f a) -> f (Val a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Val a -> m (Val b))
-> (forall (m :: * -> *) a. Monad m => Val (m a) -> m (Val a))
-> Traversable Val
(a -> f b) -> Val a -> f (Val b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Val (m a) -> m (Val a)
forall (f :: * -> *) a. Applicative f => Val (f a) -> f (Val a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Val a -> m (Val b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Val a -> f (Val b)
sequence :: Val (m a) -> m (Val a)
$csequence :: forall (m :: * -> *) a. Monad m => Val (m a) -> m (Val a)
mapM :: (a -> m b) -> Val a -> m (Val b)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Val a -> m (Val b)
sequenceA :: Val (f a) -> f (Val a)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Val (f a) -> f (Val a)
traverse :: (a -> f b) -> Val a -> f (Val b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Val a -> f (Val b)
$cp2Traversable :: Foldable Val
$cp1Traversable :: Functor Val
Traversable, Val a -> Bool
(a -> m) -> Val a -> m
(a -> b -> b) -> b -> Val a -> b
(forall m. Monoid m => Val m -> m)
-> (forall m a. Monoid m => (a -> m) -> Val a -> m)
-> (forall m a. Monoid m => (a -> m) -> Val a -> m)
-> (forall a b. (a -> b -> b) -> b -> Val a -> b)
-> (forall a b. (a -> b -> b) -> b -> Val a -> b)
-> (forall b a. (b -> a -> b) -> b -> Val a -> b)
-> (forall b a. (b -> a -> b) -> b -> Val a -> b)
-> (forall a. (a -> a -> a) -> Val a -> a)
-> (forall a. (a -> a -> a) -> Val a -> a)
-> (forall a. Val a -> [a])
-> (forall a. Val a -> Bool)
-> (forall a. Val a -> Int)
-> (forall a. Eq a => a -> Val a -> Bool)
-> (forall a. Ord a => Val a -> a)
-> (forall a. Ord a => Val a -> a)
-> (forall a. Num a => Val a -> a)
-> (forall a. Num a => Val a -> a)
-> Foldable Val
forall a. Eq a => a -> Val a -> Bool
forall a. Num a => Val a -> a
forall a. Ord a => Val a -> a
forall m. Monoid m => Val m -> m
forall a. Val a -> Bool
forall a. Val a -> Int
forall a. Val a -> [a]
forall a. (a -> a -> a) -> Val a -> a
forall m a. Monoid m => (a -> m) -> Val a -> m
forall b a. (b -> a -> b) -> b -> Val a -> b
forall a b. (a -> b -> b) -> b -> Val 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
product :: Val a -> a
$cproduct :: forall a. Num a => Val a -> a
sum :: Val a -> a
$csum :: forall a. Num a => Val a -> a
minimum :: Val a -> a
$cminimum :: forall a. Ord a => Val a -> a
maximum :: Val a -> a
$cmaximum :: forall a. Ord a => Val a -> a
elem :: a -> Val a -> Bool
$celem :: forall a. Eq a => a -> Val a -> Bool
length :: Val a -> Int
$clength :: forall a. Val a -> Int
null :: Val a -> Bool
$cnull :: forall a. Val a -> Bool
toList :: Val a -> [a]
$ctoList :: forall a. Val a -> [a]
foldl1 :: (a -> a -> a) -> Val a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Val a -> a
foldr1 :: (a -> a -> a) -> Val a -> a
$cfoldr1 :: forall a. (a -> a -> a) -> Val a -> a
foldl' :: (b -> a -> b) -> b -> Val a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Val a -> b
foldl :: (b -> a -> b) -> b -> Val a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Val a -> b
foldr' :: (a -> b -> b) -> b -> Val a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Val a -> b
foldr :: (a -> b -> b) -> b -> Val a -> b
$cfoldr :: forall a b. (a -> b -> b) -> b -> Val a -> b
foldMap' :: (a -> m) -> Val a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Val a -> m
foldMap :: (a -> m) -> Val a -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Val a -> m
fold :: Val m -> m
$cfold :: forall m. Monoid m => Val m -> m
Foldable, a -> Val b -> Val a
(a -> b) -> Val a -> Val b
(forall a b. (a -> b) -> Val a -> Val b)
-> (forall a b. a -> Val b -> Val a) -> Functor Val
forall a b. a -> Val b -> Val a
forall a b. (a -> b) -> Val a -> Val b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: a -> Val b -> Val a
$c<$ :: forall a b. a -> Val b -> Val a
fmap :: (a -> b) -> Val a -> Val b
$cfmap :: forall a b. (a -> b) -> Val a -> Val b
Functor, Typeable (Val a)
Constr
DataType
Typeable (Val a) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Val a -> c (Val a))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (Val a))
-> (Val a -> Constr)
-> (Val a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (Val a)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Val a)))
-> ((forall b. Data b => b -> b) -> Val a -> Val a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r)
-> (forall u. (forall d. Data d => d -> u) -> Val a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Val a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Val a -> m (Val a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Val a -> m (Val a))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Val a -> m (Val a))
-> Data (Val a)
Val a -> Constr
Val a -> DataType
(forall d. Data d => c (t d)) -> Maybe (c (Val a))
(forall b. Data b => b -> b) -> Val a -> Val a
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val a -> c (Val a)
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Val a)
forall a. Data a => Typeable (Val a)
forall a. Data a => Val a -> Constr
forall a. Data a => Val a -> DataType
forall a. Data a => (forall b. Data b => b -> b) -> Val a -> Val a
forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Val a -> u
forall a u. Data a => (forall d. Data d => d -> u) -> Val a -> [u]
forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Val a)
forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val a -> c (Val a)
forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Val a))
forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Val a))
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) -> Val a -> u
forall u. (forall d. Data d => d -> u) -> Val a -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Val a)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val a -> c (Val a)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (Val a))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Val a))
$cNullVal :: Constr
$cMapVal :: Constr
$cListVal :: Constr
$cSimpleVal :: Constr
$tVal :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Val a -> m (Val a)
$cgmapMo :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
gmapMp :: (forall d. Data d => d -> m d) -> Val a -> m (Val a)
$cgmapMp :: forall a (m :: * -> *).
(Data a, MonadPlus m) =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
gmapM :: (forall d. Data d => d -> m d) -> Val a -> m (Val a)
$cgmapM :: forall a (m :: * -> *).
(Data a, Monad m) =>
(forall d. Data d => d -> m d) -> Val a -> m (Val a)
gmapQi :: Int -> (forall d. Data d => d -> u) -> Val a -> u
$cgmapQi :: forall a u.
Data a =>
Int -> (forall d. Data d => d -> u) -> Val a -> u
gmapQ :: (forall d. Data d => d -> u) -> Val a -> [u]
$cgmapQ :: forall a u. Data a => (forall d. Data d => d -> u) -> Val a -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
$cgmapQr :: forall a r r'.
Data a =>
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
$cgmapQl :: forall a r r'.
Data a =>
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Val a -> r
gmapT :: (forall b. Data b => b -> b) -> Val a -> Val a
$cgmapT :: forall a. Data a => (forall b. Data b => b -> b) -> Val a -> Val a
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Val a))
$cdataCast2 :: forall a (t :: * -> * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Val a))
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c (Val a))
$cdataCast1 :: forall a (t :: * -> *) (c :: * -> *).
(Data a, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (Val a))
dataTypeOf :: Val a -> DataType
$cdataTypeOf :: forall a. Data a => Val a -> DataType
toConstr :: Val a -> Constr
$ctoConstr :: forall a. Data a => Val a -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Val a)
$cgunfold :: forall a (c :: * -> *).
Data a =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (Val a)
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val a -> c (Val a)
$cgfoldl :: forall a (c :: * -> *).
Data a =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Val a -> c (Val a)
$cp1Data :: forall a. Data a => Typeable (Val a)
Data, Typeable)

-- | The 'ToContext' class provides automatic conversion to
-- a 'Context' or 'Val'.
class ToContext a b where
  toContext :: b -> Context a
  toContext x :: b
x = case b -> Val a
forall a b. ToContext a b => b -> Val a
toVal b
x of
                  MapVal c :: Context a
c -> Context a
c
                  _        -> Context a
forall a. Monoid a => a
mempty
  toVal     :: b -> Val a

instance ToContext a (Context a) where
  toContext :: Context a -> Context a
toContext = Context a -> Context a
forall a. a -> a
id
  toVal :: Context a -> Val a
toVal     = Context a -> Val a
forall a. Context a -> Val a
MapVal

instance ToContext a (Val a) where
  toVal :: Val a -> Val a
toVal     = Val a -> Val a
forall a. a -> a
id

instance TemplateTarget a => ToContext a a where
  toVal :: a -> Val a
toVal     = Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> (a -> Doc a) -> a -> Val a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Doc a
forall a. HasChars a => a -> Doc a
DL.literal

instance ToContext a a => ToContext a (Doc a) where
  toVal :: Doc a -> Val a
toVal    = Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal

-- This is needed because otherwise the compiler tries to
-- match on ToContext a [b], with a = b = Char, even though
-- we don't have ToContext Char Char.  I don't understand why.
instance {-# OVERLAPS #-} ToContext String String where
  toVal :: String -> Val String
toVal    = Doc String -> Val String
forall a. Doc a -> Val a
SimpleVal (Doc String -> Val String)
-> (String -> Doc String) -> String -> Val String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Doc String
forall a. HasChars a => a -> Doc a
DL.literal

instance {-# OVERLAPS #-} ToContext String (Doc String) where
  toVal :: Doc String -> Val String
toVal    = Doc String -> Val String
forall a. Doc a -> Val a
SimpleVal

instance ToContext a b => ToContext a [b] where
  toVal :: [b] -> Val a
toVal     = [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> Val a) -> ([b] -> [Val a]) -> [b] -> Val a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> Val a) -> [b] -> [Val a]
forall a b. (a -> b) -> [a] -> [b]
map b -> Val a
forall a b. ToContext a b => b -> Val a
toVal

instance ToContext a b => ToContext a (M.Map Text b) where
  toVal :: Map Text b -> Val a
toVal     = Context a -> Val a
forall a. Context a -> Val a
MapVal (Context a -> Val a)
-> (Map Text b -> Context a) -> Map Text b -> Val a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Text b -> Context a
forall a b. ToContext a b => b -> Context a
toContext
  toContext :: Map Text b -> Context a
toContext = Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a)
-> (Map Text b -> Map Text (Val a)) -> Map Text b -> Context a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> Val a) -> Map Text b -> Map Text (Val a)
forall a b k. (a -> b) -> Map k a -> Map k b
M.map b -> Val a
forall a b. ToContext a b => b -> Val a
toVal

instance TemplateTarget a => ToContext a Bool where
  toVal :: Bool -> Val a
toVal True  = Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal "true"
  toVal False = Val a
forall a. Val a
NullVal

instance (IsString a, TemplateTarget a) => ToContext a Value where
  toContext :: Value -> Context a
toContext x :: Value
x = case Value -> Result (Context a)
forall a. FromJSON a => Value -> Result a
fromJSON Value
x of
                  Success y :: Context a
y -> Context a
y
                  Error _   -> Context a
forall a. Monoid a => a
mempty
  toVal :: Value -> Val a
toVal x :: Value
x = case Value -> Result (Val a)
forall a. FromJSON a => Value -> Result a
fromJSON Value
x of
                  Success y :: Val a
y -> Val a
y
                  Error _   -> Val a
forall a. Val a
NullVal

-- | The 'FromContext' class provides functions for extracting
-- values from 'Val' and 'Context'.
class FromContext a b where
  fromVal :: Val a -> Maybe b
  lookupContext :: Text -> Context a -> Maybe b
  lookupContext t :: Text
t (Context m :: Map Text (Val a)
m) = Text -> Map Text (Val a) -> Maybe (Val a)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
t Map Text (Val a)
m Maybe (Val a) -> (Val a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Val a -> Maybe b
forall a b. FromContext a b => Val a -> Maybe b
fromVal

instance TemplateTarget a => FromContext a (Val a) where
  fromVal :: Val a -> Maybe (Val a)
fromVal = Val a -> Maybe (Val a)
forall a. a -> Maybe a
Just

instance TemplateTarget a => FromContext a (Doc a) where
  fromVal :: Val a -> Maybe (Doc a)
fromVal (SimpleVal x :: Doc a
x) = Doc a -> Maybe (Doc a)
forall a. a -> Maybe a
Just Doc a
x
  fromVal _             = Maybe (Doc a)
forall a. Maybe a
Nothing

instance TemplateTarget a => FromContext a a where
  fromVal :: Val a -> Maybe a
fromVal (SimpleVal x :: Doc a
x) = a -> Maybe a
forall a. a -> Maybe a
Just (Maybe Int -> Doc a -> a
forall a. HasChars a => Maybe Int -> Doc a -> a
DL.render Maybe Int
forall a. Maybe a
Nothing Doc a
x)
  fromVal _             = Maybe a
forall a. Maybe a
Nothing

-- This is needed because otherwise the compiler tries to
-- match on FromContext a [b], with a = b = Char, even though
-- we don't have FromContext Char Char.  I don't understand why.
instance {-# OVERLAPS #-} FromContext String String where
  fromVal :: Val String -> Maybe String
fromVal (SimpleVal x :: Doc String
x) = String -> Maybe String
forall a. a -> Maybe a
Just (Maybe Int -> Doc String -> String
forall a. HasChars a => Maybe Int -> Doc a -> a
DL.render Maybe Int
forall a. Maybe a
Nothing Doc String
x)
  fromVal _             = Maybe String
forall a. Maybe a
Nothing

instance FromContext a b => FromContext a [b] where
  fromVal :: Val a -> Maybe [b]
fromVal (ListVal  xs :: [Val a]
xs) = (Val a -> Maybe b) -> [Val a] -> Maybe [b]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Val a -> Maybe b
forall a b. FromContext a b => Val a -> Maybe b
fromVal [Val a]
xs
  fromVal x :: Val a
x             = [Maybe b] -> Maybe [b]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [Val a -> Maybe b
forall a b. FromContext a b => Val a -> Maybe b
fromVal Val a
x]

instance (IsString a, TemplateTarget a) => FromJSON (Val a) where
  parseJSON :: Value -> Parser (Val a)
parseJSON v :: Value
v =
    case Value
v of
      Array vec :: Array
vec   -> [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> Val a) -> Parser [Val a] -> Parser (Val a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Parser (Val a)) -> [Value] -> Parser [Val a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> Parser (Val a)
forall a. FromJSON a => Value -> Parser a
parseJSON (Array -> [Value]
forall a. Vector a -> [a]
V.toList Array
vec)
      String t :: Text
t    -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ a -> Doc a
forall a. HasChars a => a -> Doc a
DL.literal (a -> Doc a) -> a -> Doc a
forall a b. (a -> b) -> a -> b
$ Text -> a
forall a. FromText a => Text -> a
fromText Text
t
      Number n :: Scientific
n    -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ String -> Doc a
forall a. IsString a => String -> a
fromString (String -> Doc a) -> String -> Doc a
forall a b. (a -> b) -> a -> b
$
                              case Scientific -> Either Double Integer
forall r i. (RealFloat r, Integral i) => Scientific -> Either r i
floatingOrInteger Scientific
n of
                                  Left (Double
r :: Double)   -> Double -> String
forall a. Show a => a -> String
show Double
r
                                  Right (Integer
i :: Integer) -> Integer -> String
forall a. Show a => a -> String
show Integer
i
      Bool True   -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal "true"
      Object o :: Object
o    -> Context a -> Val a
forall a. Context a -> Val a
MapVal (Context a -> Val a)
-> (HashMap Text (Val a) -> Context a)
-> HashMap Text (Val a)
-> Val a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a)
-> (HashMap Text (Val a) -> Map Text (Val a))
-> HashMap Text (Val a)
-> Context a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Text, Val a)] -> Map Text (Val a)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Text, Val a)] -> Map Text (Val a))
-> (HashMap Text (Val a) -> [(Text, Val a)])
-> HashMap Text (Val a)
-> Map Text (Val a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap Text (Val a) -> [(Text, Val a)]
forall k v. HashMap k v -> [(k, v)]
H.toList (HashMap Text (Val a) -> Val a)
-> Parser (HashMap Text (Val a)) -> Parser (Val a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                       (Value -> Parser (Val a))
-> Object -> Parser (HashMap Text (Val a))
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> Parser (Val a)
forall a. FromJSON a => Value -> Parser a
parseJSON Object
o
      _           -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return Val a
forall a. Val a
NullVal

instance (IsString a, TemplateTarget a) => FromJSON (Context a) where
  parseJSON :: Value -> Parser (Context a)
parseJSON v :: Value
v = do
    Val a
val <- Value -> Parser (Val a)
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
    case Val a
val of
      MapVal o :: Context a
o -> Context a -> Parser (Context a)
forall (m :: * -> *) a. Monad m => a -> m a
return Context a
o
      _        -> String -> Parser (Context a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "Expecting MapVal"

instance TemplateTarget a => FromYAML (Val a) where
  parseYAML :: Node Pos -> Parser (Val a)
parseYAML v :: Node Pos
v =
    case Node Pos
v of
      Mapping _ _ m :: Mapping Pos
m -> Context a -> Val a
forall a. Context a -> Val a
MapVal (Context a -> Val a)
-> ([(Text, Val a)] -> Context a) -> [(Text, Val a)] -> Val a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a)
-> ([(Text, Val a)] -> Map Text (Val a))
-> [(Text, Val a)]
-> Context a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Text, Val a)] -> Map Text (Val a)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList ([(Text, Val a)] -> Val a)
-> Parser [(Text, Val a)] -> Parser (Val a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                           ((Node Pos, Node Pos) -> Parser (Text, Val a))
-> [(Node Pos, Node Pos)] -> Parser [(Text, Val a)]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\(key :: Node Pos
key, val :: Node Pos
val) -> do
                                  Val a
val' <- Node Pos -> Parser (Val a)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
val
                                  Text
key' <- Node Pos -> Parser Text
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
key
                                  (Text, Val a) -> Parser (Text, Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text
key', Val a
val')) (Mapping Pos -> [(Node Pos, Node Pos)]
forall k a. Map k a -> [(k, a)]
M.toList Mapping Pos
m)
      Sequence _ _ xs :: [Node Pos]
xs -> [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> Val a) -> Parser [Val a] -> Parser (Val a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Node Pos -> Parser (Val a)) -> [Node Pos] -> Parser [Val a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Node Pos -> Parser (Val a)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML [Node Pos]
xs
      Scalar _ (SStr t :: Text
t) -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ String -> Doc a
forall a. IsString a => String -> a
fromString (String -> Doc a) -> (Text -> String) -> Text -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
forall a. FromText a => Text -> a
fromText (Text -> Doc a) -> Text -> Doc a
forall a b. (a -> b) -> a -> b
$ Text
t
      Scalar _ (SFloat n :: Double
n) -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ String -> Doc a
forall a. IsString a => String -> a
fromString (String -> Doc a) -> (Double -> String) -> Double -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> String
forall a. Show a => a -> String
show (Double -> Doc a) -> Double -> Doc a
forall a b. (a -> b) -> a -> b
$ Double
n
      Scalar _ (SInt n :: Integer
n) -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ String -> Doc a
forall a. IsString a => String -> a
fromString (String -> Doc a) -> (Integer -> String) -> Integer -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> String
forall a. Show a => a -> String
show (Integer -> Doc a) -> Integer -> Doc a
forall a b. (a -> b) -> a -> b
$ Integer
n
      Scalar _ (SBool True) -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Val a -> Parser (Val a)) -> Val a -> Parser (Val a)
forall a b. (a -> b) -> a -> b
$ Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal "true"
      _           -> Val a -> Parser (Val a)
forall (m :: * -> *) a. Monad m => a -> m a
return Val a
forall a. Val a
NullVal

instance (IsString a, TemplateTarget a) => FromYAML (Context a) where
  parseYAML :: Node Pos -> Parser (Context a)
parseYAML v :: Node Pos
v = do
    Val a
val <- Node Pos -> Parser (Val a)
forall a. FromYAML a => Node Pos -> Parser a
parseYAML Node Pos
v
    case Val a
val of
      MapVal o :: Context a
o -> Context a -> Parser (Context a)
forall (m :: * -> *) a. Monad m => a -> m a
return Context a
o
      _        -> String -> Parser (Context a)
forall (m :: * -> *) a. MonadFail m => String -> m a
fail "Expecting MapVal"

instance TemplateTarget a => ToJSON (Context a) where
  toJSON :: Context a -> Value
toJSON (Context m :: Map Text (Val a)
m) = Map Text (Val a) -> Value
forall a. ToJSON a => a -> Value
toJSON Map Text (Val a)
m

instance TemplateTarget a => ToJSON (Val a) where
  toJSON :: Val a -> Value
toJSON NullVal = Value
Null
  toJSON (MapVal m :: Context a
m) = Context a -> Value
forall a. ToJSON a => a -> Value
toJSON Context a
m
  toJSON (ListVal xs :: [Val a]
xs) = [Val a] -> Value
forall a. ToJSON a => a -> Value
toJSON [Val a]
xs
  toJSON (SimpleVal d :: Doc a
d) = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> Text -> Value
forall a b. (a -> b) -> a -> b
$ a -> Text
forall a. ToText a => a -> Text
toText (a -> Text) -> a -> Text
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Doc a -> a
forall a. HasChars a => Maybe Int -> Doc a -> a
DL.render Maybe Int
forall a. Maybe a
Nothing Doc a
d

instance TemplateTarget a => ToYAML (Context a) where
  toYAML :: Context a -> Node ()
toYAML (Context m :: Map Text (Val a)
m) = Map Text (Val a) -> Node ()
forall a. ToYAML a => a -> Node ()
toYAML Map Text (Val a)
m

instance TemplateTarget a => ToYAML (Val a) where
  toYAML :: Val a -> Node ()
toYAML NullVal = Maybe Text -> Node ()
forall a. ToYAML a => a -> Node ()
toYAML (Maybe Text
forall a. Maybe a
Nothing :: Maybe Text)
  toYAML (MapVal m :: Context a
m) = Context a -> Node ()
forall a. ToYAML a => a -> Node ()
toYAML Context a
m
  toYAML (ListVal xs :: [Val a]
xs) = [Val a] -> Node ()
forall a. ToYAML a => a -> Node ()
toYAML [Val a]
xs
  toYAML (SimpleVal d :: Doc a
d) = Text -> Node ()
forall a. ToYAML a => a -> Node ()
toYAML (Text -> Node ()) -> Text -> Node ()
forall a b. (a -> b) -> a -> b
$ a -> Text
forall a. ToText a => a -> Text
toText (a -> Text) -> a -> Text
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Doc a -> a
forall a. HasChars a => Maybe Int -> Doc a -> a
DL.render Maybe Int
forall a. Maybe a
Nothing Doc a
d

mapDoc :: TemplateTarget a => (Doc a -> Doc a) -> Val a -> Val a
mapDoc :: (Doc a -> Doc a) -> Val a -> Val a
mapDoc f :: Doc a -> Doc a
f val :: Val a
val =
  case Val a
val of
    SimpleVal d :: Doc a
d        -> Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Doc a
f Doc a
d)
    MapVal (Context m :: Map Text (Val a)
m) -> Context a -> Val a
forall a. Context a -> Val a
MapVal (Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a) -> Map Text (Val a) -> Context a
forall a b. (a -> b) -> a -> b
$ (Val a -> Val a) -> Map Text (Val a) -> Map Text (Val a)
forall a b k. (a -> b) -> Map k a -> Map k b
M.map ((Doc a -> Doc a) -> Val a -> Val a
forall a. TemplateTarget a => (Doc a -> Doc a) -> Val a -> Val a
mapDoc Doc a -> Doc a
f) Map Text (Val a)
m)
    ListVal xs :: [Val a]
xs         -> [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> Val a) -> [Val a] -> Val a
forall a b. (a -> b) -> a -> b
$ (Val a -> Val a) -> [Val a] -> [Val a]
forall a b. (a -> b) -> [a] -> [b]
map ((Doc a -> Doc a) -> Val a -> Val a
forall a. TemplateTarget a => (Doc a -> Doc a) -> Val a -> Val a
mapDoc Doc a -> Doc a
f) [Val a]
xs
    NullVal            -> Val a
forall a. Val a
NullVal

mapText :: TemplateTarget a => (Text -> Text) -> Val a -> Val a
mapText :: (Text -> Text) -> Val a -> Val a
mapText f :: Text -> Text
f val :: Val a
val =
  Identity (Val a) -> Val a
forall a. Identity a -> a
runIdentity ((a -> Identity a) -> Val a -> Identity (Val a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
traverse (a -> Identity a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> Identity a) -> (a -> a) -> a -> Identity a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> a
forall a. FromText a => Text -> a
fromText (Text -> a) -> (a -> Text) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
f (Text -> Text) -> (a -> Text) -> a -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Text
forall a. ToText a => a -> Text
toText) Val a
val)

applyPipe :: TemplateTarget a => Pipe -> Val a -> Val a
applyPipe :: Pipe -> Val a -> Val a
applyPipe ToLength val :: Val a
val = Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ String -> Doc a
forall a. IsString a => String -> a
fromString (String -> Doc a) -> (Int -> String) -> Int -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String
forall a. Show a => a -> String
show (Int -> Doc a) -> Int -> Doc a
forall a b. (a -> b) -> a -> b
$ Int
len
  where
   len :: Int
len = case Val a
val of
           SimpleVal d :: Doc a
d        -> Text -> Int
T.length (Text -> Int) -> (a -> Text) -> a -> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Text
forall a. ToText a => a -> Text
toText (a -> Int) -> a -> Int
forall a b. (a -> b) -> a -> b
$ Maybe Int -> Doc a -> a
forall a. HasChars a => Maybe Int -> Doc a -> a
DL.render Maybe Int
forall a. Maybe a
Nothing Doc a
d
           MapVal (Context m :: Map Text (Val a)
m) -> Map Text (Val a) -> Int
forall k a. Map k a -> Int
M.size Map Text (Val a)
m
           ListVal xs :: [Val a]
xs         -> [Val a] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Val a]
xs
           NullVal            -> 0
applyPipe ToUppercase val :: Val a
val = (Text -> Text) -> Val a -> Val a
forall a. TemplateTarget a => (Text -> Text) -> Val a -> Val a
mapText Text -> Text
T.toUpper Val a
val
applyPipe ToLowercase val :: Val a
val = (Text -> Text) -> Val a -> Val a
forall a. TemplateTarget a => (Text -> Text) -> Val a -> Val a
mapText Text -> Text
T.toLower Val a
val
applyPipe ToPairs val :: Val a
val =
  case Val a
val of
    MapVal (Context m :: Map Text (Val a)
m) ->
      [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> Val a) -> [Val a] -> Val a
forall a b. (a -> b) -> a -> b
$ ((Text, Val a) -> Val a) -> [(Text, Val a)] -> [Val a]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Val a) -> Val a
forall a. HasChars a => (Text, Val a) -> Val a
toPair ([(Text, Val a)] -> [Val a]) -> [(Text, Val a)] -> [Val a]
forall a b. (a -> b) -> a -> b
$ Map Text (Val a) -> [(Text, Val a)]
forall k a. Map k a -> [(k, a)]
M.toList Map Text (Val a)
m
    ListVal xs :: [Val a]
xs         ->
      [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> Val a) -> [Val a] -> Val a
forall a b. (a -> b) -> a -> b
$ ((Text, Val a) -> Val a) -> [(Text, Val a)] -> [Val a]
forall a b. (a -> b) -> [a] -> [b]
map (Text, Val a) -> Val a
forall a. HasChars a => (Text, Val a) -> Val a
toPair ([(Text, Val a)] -> [Val a]) -> [(Text, Val a)] -> [Val a]
forall a b. (a -> b) -> a -> b
$ [Text] -> [Val a] -> [(Text, Val a)]
forall a b. [a] -> [b] -> [(a, b)]
zip ((Int -> Text) -> [Int] -> [Text]
forall a b. (a -> b) -> [a] -> [b]
map (String -> Text
forall a. IsString a => String -> a
fromString (String -> Text) -> (Int -> String) -> Int -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String
forall a. Show a => a -> String
show) [(1::Int)..]) [Val a]
xs
    _                  -> Val a
val
 where
  toPair :: (Text, Val a) -> Val a
toPair (k :: Text
k, v :: Val a
v) = Context a -> Val a
forall a. Context a -> Val a
MapVal (Context a -> Val a) -> Context a -> Val a
forall a b. (a -> b) -> a -> b
$ Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a) -> Map Text (Val a) -> Context a
forall a b. (a -> b) -> a -> b
$ [(Text, Val a)] -> Map Text (Val a)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
                    [ ("key", Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$ String -> Doc a
forall a. IsString a => String -> a
fromString (String -> Doc a) -> (Text -> String) -> Text -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> String
T.unpack (Text -> Doc a) -> Text -> Doc a
forall a b. (a -> b) -> a -> b
$ Text
k)
                    , ("value", Val a
v) ]
applyPipe Reverse val :: Val a
val =
  case Val a
val of
    ListVal xs :: [Val a]
xs  -> [Val a] -> Val a
forall a. [Val a] -> Val a
ListVal ([Val a] -> [Val a]
forall a. [a] -> [a]
reverse [Val a]
xs)
    SimpleVal{} -> (Text -> Text) -> Val a -> Val a
forall a. TemplateTarget a => (Text -> Text) -> Val a -> Val a
mapText Text -> Text
T.reverse Val a
val
    _           -> Val a
val
applyPipe Chomp val :: Val a
val = (Doc a -> Doc a) -> Val a -> Val a
forall a. TemplateTarget a => (Doc a -> Doc a) -> Val a -> Val a
mapDoc Doc a -> Doc a
forall a. Doc a -> Doc a
DL.chomp Val a
val
applyPipe ToAlpha val :: Val a
val = (Text -> Text) -> Val a -> Val a
forall a. TemplateTarget a => (Text -> Text) -> Val a -> Val a
mapText Text -> Text
toAlpha Val a
val
  where toAlpha :: Text -> Text
toAlpha t :: Text
t =
          case Reader Int
forall a. Integral a => Reader a
T.decimal Text
t of
            Right (y :: Int
y,"") -> String -> Text
forall a. IsString a => String -> a
fromString [Int -> Char
chr (Char -> Int
ord 'a' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Int
y Int -> Int -> Int
forall a. Integral a => a -> a -> a
`mod` 26) Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1)]
            _            -> Text
t
applyPipe ToRoman val :: Val a
val = (Text -> Text) -> Val a -> Val a
forall a. TemplateTarget a => (Text -> Text) -> Val a -> Val a
mapText Text -> Text
toRoman' Val a
val
  where toRoman' :: Text -> Text
toRoman' t :: Text
t =
         case Reader Int
forall a. Integral a => Reader a
T.decimal Text
t of
           Right (y :: Int
y,"") -> Text -> (Text -> Text) -> Maybe Text -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
t Text -> Text
forall a. a -> a
id (Int -> Maybe Text
toRoman Int
y)
           _            -> Text
t
applyPipe NoWrap val :: Val a
val = (Doc a -> Doc a) -> Val a -> Val a
forall a. TemplateTarget a => (Doc a -> Doc a) -> Val a -> Val a
mapDoc Doc a -> Doc a
forall a. IsString a => Doc a -> Doc a
DL.nowrap Val a
val
applyPipe (Block align :: Alignment
align n :: Int
n border :: Border
border) val :: Val a
val =
  let constructor :: Int -> Doc a -> Doc a
constructor = case Alignment
align of
                      LeftAligned  -> Int -> Doc a -> Doc a
forall a. HasChars a => Int -> Doc a -> Doc a
DL.lblock
                      Centered     -> Int -> Doc a -> Doc a
forall a. HasChars a => Int -> Doc a -> Doc a
DL.cblock
                      RightAligned -> Int -> Doc a -> Doc a
forall a. HasChars a => Int -> Doc a -> Doc a
DL.rblock
      toBorder :: Text -> Doc a
toBorder y :: Text
y = if Text -> Bool
T.null Text
y
                      then Doc a
forall a. Monoid a => a
mempty
                      else a -> Doc a
forall a. HasChars a => a -> Doc a
DL.vfill (Text -> a
forall a. FromText a => Text -> a
fromText Text
y)
  in case Val a -> Val a
forall a. Monoid a => Val a -> Val a
nullToSimple Val a
val of
       SimpleVal d :: Doc a
d -> Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal (Doc a -> Val a) -> Doc a -> Val a
forall a b. (a -> b) -> a -> b
$
                        Text -> Doc a
forall a. (HasChars a, FromText a) => Text -> Doc a
toBorder (Border -> Text
borderLeft Border
border) Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<>
                        Int -> Doc a -> Doc a
constructor Int
n Doc a
d Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<>
                        Text -> Doc a
forall a. (HasChars a, FromText a) => Text -> Doc a
toBorder (Border -> Text
borderRight Border
border)
       _           -> Val a
val

nullToSimple :: Monoid a => Val a -> Val a
nullToSimple :: Val a -> Val a
nullToSimple NullVal = Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal Doc a
forall a. Monoid a => a
mempty
nullToSimple x :: Val a
x = Val a
x

-- | Convert number 0 < x < 4000 to lowercase roman numeral.
toRoman :: Int -> Maybe Text
toRoman :: Int -> Maybe Text
toRoman x :: Int
x
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 1000
  , Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< 4000  = ("m" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1000)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 900  = ("cm" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 900)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 500  = ("d" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 500)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 400  = ("cd" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 400)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 100  = ("c" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 100)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 90   = ("xc" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 90)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 50   = ("l" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 50)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 40   = ("xl" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 40)
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 10   = ("x" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 10)
  | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 9    = Text -> Maybe Text
forall (m :: * -> *) a. Monad m => a -> m a
return "ix"
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 5    = ("v" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 5)
  | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 4    = Text -> Maybe Text
forall (m :: * -> *) a. Monad m => a -> m a
return "iv"
  | Int
x Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= 1    = ("i" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> Maybe Text -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Maybe Text
toRoman (Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- 1)
  | Int
x Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== 0    = Text -> Maybe Text
forall (m :: * -> *) a. Monad m => a -> m a
return ""
  | Bool
otherwise = Maybe Text
forall a. Maybe a
Nothing

applyPipes :: TemplateTarget a => [Pipe] -> Val a -> Val a
applyPipes :: [Pipe] -> Val a -> Val a
applyPipes fs :: [Pipe]
fs x :: Val a
x = (Pipe -> Val a -> Val a) -> Val a -> [Pipe] -> Val a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Pipe -> Val a -> Val a
forall a. TemplateTarget a => Pipe -> Val a -> Val a
applyPipe Val a
x ([Pipe] -> Val a) -> [Pipe] -> Val a
forall a b. (a -> b) -> a -> b
$ [Pipe] -> [Pipe]
forall a. [a] -> [a]
reverse [Pipe]
fs

multiLookup :: TemplateTarget a => [Text] -> Val a -> Val a
multiLookup :: [Text] -> Val a -> Val a
multiLookup [] x :: Val a
x = Val a
x
multiLookup (t :: Text
t:vs :: [Text]
vs) (MapVal (Context o :: Map Text (Val a)
o)) =
  case Text -> Map Text (Val a) -> Maybe (Val a)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
t Map Text (Val a)
o of
    Nothing -> Val a
forall a. Val a
NullVal
    Just v' :: Val a
v' -> [Text] -> Val a -> Val a
forall a. TemplateTarget a => [Text] -> Val a -> Val a
multiLookup [Text]
vs Val a
v'
multiLookup _ _ = Val a
forall a. Val a
NullVal

resolveVariable :: TemplateTarget a => Variable -> Context a -> [Doc a]
resolveVariable :: Variable -> Context a -> [Doc a]
resolveVariable v :: Variable
v ctx :: Context a
ctx = Variable -> Val a -> [Doc a]
forall a. TemplateTarget a => Variable -> Val a -> [Doc a]
resolveVariable' Variable
v (Context a -> Val a
forall a. Context a -> Val a
MapVal Context a
ctx)

resolveVariable' :: TemplateTarget a => Variable -> Val a -> [Doc a]
resolveVariable' :: Variable -> Val a -> [Doc a]
resolveVariable' v :: Variable
v val :: Val a
val =
  case [Pipe] -> Val a -> Val a
forall a. TemplateTarget a => [Pipe] -> Val a -> Val a
applyPipes (Variable -> [Pipe]
varPipes Variable
v) (Val a -> Val a) -> Val a -> Val a
forall a b. (a -> b) -> a -> b
$ [Text] -> Val a -> Val a
forall a. TemplateTarget a => [Text] -> Val a -> Val a
multiLookup (Variable -> [Text]
varParts Variable
v) Val a
val of
    ListVal xs :: [Val a]
xs    -> (Val a -> [Doc a]) -> [Val a] -> [Doc a]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Variable -> Val a -> [Doc a]
forall a. TemplateTarget a => Variable -> Val a -> [Doc a]
resolveVariable' Variable
forall a. Monoid a => a
mempty) [Val a]
xs
    SimpleVal d :: Doc a
d
      | Doc a -> Bool
forall a. Doc a -> Bool
DL.isEmpty Doc a
d -> []
      | Bool
otherwise    -> [Doc a -> Doc a
forall a. Doc a -> Doc a
removeFinalNl Doc a
d]
    MapVal _      -> ["true"]
    NullVal       -> []

removeFinalNl :: Doc a -> Doc a
removeFinalNl :: Doc a -> Doc a
removeFinalNl DL.NewLine        = Doc a
forall a. Monoid a => a
mempty
removeFinalNl DL.CarriageReturn = Doc a
forall a. Monoid a => a
mempty
removeFinalNl (DL.Concat d1 :: Doc a
d1 d2 :: Doc a
d2) = Doc a
d1 Doc a -> Doc a -> Doc a
forall a. Semigroup a => a -> a -> a
<> Doc a -> Doc a
forall a. Doc a -> Doc a
removeFinalNl Doc a
d2
removeFinalNl x :: Doc a
x                 = Doc a
x

withVariable :: (Monad m, TemplateTarget a)
             => Variable -> Context a -> (Context a -> m (Doc a))
             -> m [Doc a]
withVariable :: Variable -> Context a -> (Context a -> m (Doc a)) -> m [Doc a]
withVariable  v :: Variable
v ctx :: Context a
ctx f :: Context a -> m (Doc a)
f =
  case [Pipe] -> Val a -> Val a
forall a. TemplateTarget a => [Pipe] -> Val a -> Val a
applyPipes (Variable -> [Pipe]
varPipes Variable
v) (Val a -> Val a) -> Val a -> Val a
forall a b. (a -> b) -> a -> b
$ [Text] -> Val a -> Val a
forall a. TemplateTarget a => [Text] -> Val a -> Val a
multiLookup (Variable -> [Text]
varParts Variable
v) (Context a -> Val a
forall a. Context a -> Val a
MapVal Context a
ctx) of
    NullVal     -> [Doc a] -> m [Doc a]
forall (m :: * -> *) a. Monad m => a -> m a
return [Doc a]
forall a. Monoid a => a
mempty
    ListVal xs :: [Val a]
xs  -> (Val a -> m (Doc a)) -> [Val a] -> m [Doc a]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\iterval :: Val a
iterval -> Context a -> m (Doc a)
f (Context a -> m (Doc a)) -> Context a -> m (Doc a)
forall a b. (a -> b) -> a -> b
$
                    Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a) -> Map Text (Val a) -> Context a
forall a b. (a -> b) -> a -> b
$ Text -> Val a -> Map Text (Val a) -> Map Text (Val a)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert "it" Val a
iterval (Map Text (Val a) -> Map Text (Val a))
-> Map Text (Val a) -> Map Text (Val a)
forall a b. (a -> b) -> a -> b
$ Context a -> Map Text (Val a)
forall a. Context a -> Map Text (Val a)
unContext Context a
ctx) [Val a]
xs
    MapVal ctx' :: Context a
ctx' -> (Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:[]) (Doc a -> [Doc a]) -> m (Doc a) -> m [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context a -> m (Doc a)
f
                    (Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a) -> Map Text (Val a) -> Context a
forall a b. (a -> b) -> a -> b
$ Text -> Val a -> Map Text (Val a) -> Map Text (Val a)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert "it" (Context a -> Val a
forall a. Context a -> Val a
MapVal Context a
ctx') (Map Text (Val a) -> Map Text (Val a))
-> Map Text (Val a) -> Map Text (Val a)
forall a b. (a -> b) -> a -> b
$ Context a -> Map Text (Val a)
forall a. Context a -> Map Text (Val a)
unContext Context a
ctx)
    val' :: Val a
val' -> (Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
:[]) (Doc a -> [Doc a]) -> m (Doc a) -> m [Doc a]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Context a -> m (Doc a)
f (Map Text (Val a) -> Context a
forall a. Map Text (Val a) -> Context a
Context (Map Text (Val a) -> Context a) -> Map Text (Val a) -> Context a
forall a b. (a -> b) -> a -> b
$ Text -> Val a -> Map Text (Val a) -> Map Text (Val a)
forall k a. Ord k => k -> a -> Map k a -> Map k a
M.insert "it" Val a
val' (Map Text (Val a) -> Map Text (Val a))
-> Map Text (Val a) -> Map Text (Val a)
forall a b. (a -> b) -> a -> b
$ Context a -> Map Text (Val a)
forall a. Context a -> Map Text (Val a)
unContext Context a
ctx)

type RenderState = S.State Int

-- | Render a compiled template in a "context" which provides
-- values for the template's variables.
renderTemplate :: (TemplateTarget a, ToContext a b)
               => Template a -> b -> Doc a
renderTemplate :: Template a -> b -> Doc a
renderTemplate t :: Template a
t x :: b
x = State Int (Doc a) -> Int -> Doc a
forall s a. State s a -> s -> a
S.evalState (Template a -> Context a -> State Int (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
t (b -> Context a
forall a b. ToContext a b => b -> Context a
toContext b
x)) 0

updateColumn :: TemplateTarget a => Doc a -> RenderState (Doc a)
updateColumn :: Doc a -> RenderState (Doc a)
updateColumn x :: Doc a
x = do
  (Int -> Int) -> StateT Int Identity ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
S.modify ((Int -> Int) -> StateT Int Identity ())
-> (Int -> Int) -> StateT Int Identity ()
forall a b. (a -> b) -> a -> b
$ Doc a -> Int -> Int
forall a. HasChars a => Doc a -> Int -> Int
DL.updateColumn Doc a
x
  Doc a -> RenderState (Doc a)
forall (m :: * -> *) a. Monad m => a -> m a
return Doc a
x

renderTemp :: forall a . TemplateTarget a
           => Template a -> Context a -> RenderState (Doc a)
renderTemp :: Template a -> Context a -> RenderState (Doc a)
renderTemp (Literal t :: Doc a
t) _ = Doc a -> RenderState (Doc a)
forall a. TemplateTarget a => Doc a -> RenderState (Doc a)
updateColumn (Doc a -> RenderState (Doc a)) -> Doc a -> RenderState (Doc a)
forall a b. (a -> b) -> a -> b
$ Doc a
t
renderTemp (Interpolate v :: Variable
v) ctx :: Context a
ctx = Doc a -> RenderState (Doc a)
forall a. TemplateTarget a => Doc a -> RenderState (Doc a)
updateColumn (Doc a -> RenderState (Doc a)) -> Doc a -> RenderState (Doc a)
forall a b. (a -> b) -> a -> b
$ [Doc a] -> Doc a
forall a. Monoid a => [a] -> a
mconcat ([Doc a] -> Doc a) -> [Doc a] -> Doc a
forall a b. (a -> b) -> a -> b
$ Variable -> Context a -> [Doc a]
forall a. TemplateTarget a => Variable -> Context a -> [Doc a]
resolveVariable Variable
v Context a
ctx
renderTemp (Conditional v :: Variable
v ift :: Template a
ift elset :: Template a
elset) ctx :: Context a
ctx =
  let res :: [Doc a]
res = Variable -> Context a -> [Doc a]
forall a. TemplateTarget a => Variable -> Context a -> [Doc a]
resolveVariable Variable
v Context a
ctx
   in case [Doc a]
res of
        [] -> Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
elset Context a
ctx
        _  -> Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
ift Context a
ctx
renderTemp (Iterate v :: Variable
v t :: Template a
t sep :: Template a
sep) ctx :: Context a
ctx = do
  [Doc a]
xs <- Variable
-> Context a
-> (Context a -> RenderState (Doc a))
-> StateT Int Identity [Doc a]
forall (m :: * -> *) a.
(Monad m, TemplateTarget a) =>
Variable -> Context a -> (Context a -> m (Doc a)) -> m [Doc a]
withVariable Variable
v Context a
ctx (Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
t)
  Doc a
sep' <- Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
sep Context a
ctx
  Doc a -> RenderState (Doc a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Doc a -> RenderState (Doc a))
-> ([Doc a] -> Doc a) -> [Doc a] -> RenderState (Doc a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Doc a] -> Doc a
forall a. Monoid a => [a] -> a
mconcat ([Doc a] -> Doc a) -> ([Doc a] -> [Doc a]) -> [Doc a] -> Doc a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc a -> [Doc a] -> [Doc a]
forall a. a -> [a] -> [a]
intersperse Doc a
sep' ([Doc a] -> RenderState (Doc a)) -> [Doc a] -> RenderState (Doc a)
forall a b. (a -> b) -> a -> b
$ [Doc a]
xs
renderTemp (Nested t :: Template a
t) ctx :: Context a
ctx = do
  Int
n <- StateT Int Identity Int
forall s (m :: * -> *). MonadState s m => m s
S.get
  Int -> Doc a -> Doc a
forall a. IsString a => Int -> Doc a -> Doc a
DL.nest Int
n (Doc a -> Doc a) -> RenderState (Doc a) -> RenderState (Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
t Context a
ctx
renderTemp (Partial fs :: [Pipe]
fs t :: Template a
t) ctx :: Context a
ctx = do
    Doc a
val' <- Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
t Context a
ctx
    Doc a -> RenderState (Doc a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Doc a -> RenderState (Doc a)) -> Doc a -> RenderState (Doc a)
forall a b. (a -> b) -> a -> b
$ case [Pipe] -> Val a -> Val a
forall a. TemplateTarget a => [Pipe] -> Val a -> Val a
applyPipes [Pipe]
fs (Doc a -> Val a
forall a. Doc a -> Val a
SimpleVal Doc a
val') of
      SimpleVal x :: Doc a
x -> Doc a
x
      _           -> Doc a
forall a. Monoid a => a
mempty
renderTemp (Concat t1 :: Template a
t1 t2 :: Template a
t2) ctx :: Context a
ctx =
  Doc a -> Doc a -> Doc a
forall a. Monoid a => a -> a -> a
mappend (Doc a -> Doc a -> Doc a)
-> RenderState (Doc a) -> StateT Int Identity (Doc a -> Doc a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
t1 Context a
ctx StateT Int Identity (Doc a -> Doc a)
-> RenderState (Doc a) -> RenderState (Doc a)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Template a -> Context a -> RenderState (Doc a)
forall a.
TemplateTarget a =>
Template a -> Context a -> RenderState (Doc a)
renderTemp Template a
t2 Context a
ctx
renderTemp Empty _ = Doc a -> RenderState (Doc a)
forall (m :: * -> *) a. Monad m => a -> m a
return Doc a
forall a. Monoid a => a
mempty

-- | A 'TemplateMonad' defines a function to retrieve a partial
-- (from the file system, from a database, or using a default
-- value).
class Monad m => TemplateMonad m where
  getPartial  :: FilePath -> m Text

instance TemplateMonad Identity where
  getPartial :: String -> Identity Text
getPartial _  = Text -> Identity Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
forall a. Monoid a => a
mempty

instance TemplateMonad IO where
  getPartial :: String -> IO Text
getPartial = String -> IO Text
TIO.readFile