{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE CPP                        #-}
{-# LANGUAGE DeriveDataTypeable         #-}
{-# LANGUAGE DeriveGeneric              #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE ViewPatterns               #-}

{-# LANGUAGE MultiParamTypeClasses      #-}
{-# LANGUAGE OverloadedStrings          #-}
{-# LANGUAGE PatternGuards              #-}
{-# LANGUAGE ScopedTypeVariables        #-}
#if MIN_VERSION_base(4,8,0)
#define OVERLAPS {-# OVERLAPPING #-}
#else
{-# LANGUAGE OverlappingInstances       #-}
#define OVERLAPS
#endif
-----------------------------------------------------------------------------
-- |
-- Module      :  Text.CSL.Style
-- Copyright   :  (c) Andrea Rossato
-- License     :  BSD-style (see LICENSE)
--
-- Maintainer  :  Andrea Rossato <andrea.rossato@unitn.it>
-- Stability   :  unstable
-- Portability :  unportable
--
-- The Style types
--
-----------------------------------------------------------------------------

module Text.CSL.Style ( readCSLString
                      , writeCSLString
                      , Formatted(..)
                      , Style(..)
                      , Locale(..)
                      , mergeLocales
                      , CslTerm(..)
                      , newTerm
                      , findTerm
                      , findTerm'
                      , Abbreviations(..)
                      , MacroMap
                      , Citation(..)
                      , Bibliography(..)
                      , Option
                      , mergeOptions
                      , Layout(..)
                      , Element(..)
                      , IfThen(..)
                      , Condition(..)
                      , Delimiter
                      , Match(..)
                      , match
                      , DatePart(..)
                      , defaultDate
                      , Sort(..)
                      , Sorting(..)
                      , compare'
                      , Form(..)
                      , Gender(..)
                      , NumericForm(..)
                      , DateForm(..)
                      , Plural(..)
                      , Name(..)
                      , NameAttrs
                      , NamePart(..)
                      , isPlural
                      , isName
                      , isNames
                      , hasEtAl
                      , Formatting(..)
                      , emptyFormatting
                      , rmTitleCase
                      , rmTitleCase'
                      , Quote(..)
                      , mergeFM
                      , CSInfo(..)
                      , CSAuthor(..)
                      , CSCategory(..)
                      , CiteprocError(..)
                      , Output(..)
                      , Citations
                      , Cite(..)
                      , emptyCite
                      , CitationGroup(..)
                      , BiblioData(..)
                      , CiteData(..)
                      , NameData(..)
                      , isPunctuationInQuote
                      , object'
                      , Agent(..)
                      , emptyAgent
                      )
where

import Prelude
import           Control.Applicative    ((<|>), (<$>))
import           Control.Arrow          hiding (left, right)
import           Control.Monad          (mplus)
import           Data.Aeson             hiding (Number)
import qualified Data.Aeson             as Aeson
import           Data.Aeson.Types       (Pair)
import           Data.Char              (isLetter, isPunctuation, isUpper, toLower, isDigit)
import qualified Data.Char              as Char
import           Data.Generics          (Data, Typeable)
import           Data.List              (intercalate, intersperse, nubBy)
import           Data.List.Split        (wordsBy)
import qualified Data.Map               as M
import           Data.Maybe             (listToMaybe, isNothing)
import           Data.String
import           Data.Text              (Text)
import qualified Data.Text              as T
import           Data.Yaml.Builder      (ToYaml (..))
import qualified Data.Yaml.Builder      as Y
import           GHC.Generics           (Generic)
import           Text.CSL.Compat.Pandoc (readHtml, writeMarkdown)
import           Text.CSL.Util          (headInline, initInline,
                                         lastInline, mapping', mb, parseBool,
                                         parseString, query, splitWhen,
                                         splitStrWhen, tailInline, trimr,
                                         (.#:), (.#?),
                                         AddYaml(..), addSpaceAfterPeriod)
import qualified Text.Pandoc.Builder    as B
import           Text.Pandoc.Definition hiding (Citation, Cite)
import qualified Text.Pandoc.Walk       as Walk
import           Text.Pandoc.XML        (fromEntities)

#ifdef UNICODE_COLLATION
import qualified Data.Text              as T
import qualified Data.Text.ICU          as T
#else
import           Data.RFC5051           (compareUnicode)
#endif
import qualified Data.Vector            as V

-- Note:  FromJSON reads HTML, ToJSON writes Markdown.
-- This means that they aren't proper inverses of each other, which
-- is odd, but it makes sense given the uses here.  FromJSON is used
-- for reading JSON citeproc bibliographies.  ToJSON is used to create
-- pandoc metadata bibliographies.

readCSLString :: Text -> [Inline]
readCSLString :: Text -> [Inline]
readCSLString s :: Text
s = (Inline -> Inline) -> [Inline] -> [Inline]
forall a b. Walkable a b => (a -> a) -> b -> b
Walk.walk Inline -> Inline
handleSmallCapsSpans
                ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall a b. (a -> b) -> a -> b
$ case Text -> Pandoc
readHtml (Text -> Text
adjustScTags Text
s) of
                        Pandoc _ [Plain ils :: [Inline]
ils] -> [Inline]
ils
                        Pandoc _ [Para  ils :: [Inline]
ils] -> [Inline]
ils
                        Pandoc _ x :: [Block]
x           -> (Inline -> [Inline]) -> [Block] -> [Inline]
forall a b c. (Walkable a b, Monoid c) => (a -> c) -> b -> c
Walk.query (Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
:[]) [Block]
x
  -- this is needed for versions of pandoc that don't turn
  -- a span with font-variant:small-caps into a SmallCaps element:
  where handleSmallCapsSpans :: Inline -> Inline
handleSmallCapsSpans (Span ("",[],[("style",sty :: Text
sty)]) ils :: [Inline]
ils)
            | (Char -> Bool) -> Text -> Text
T.filter (Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` (" \t;" :: String)) Text
sty Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "font-variant:small-caps" =
              [Inline] -> Inline
SmallCaps [Inline]
ils
        handleSmallCapsSpans x :: Inline
x = Inline
x

-- <sc> is not a real HTML tag, but a CSL convention.  So we
-- replace it with a real tag that the HTML reader will understand.
adjustScTags :: Text -> Text
adjustScTags :: Text -> Text
adjustScTags zs :: Text
zs
  | Just xs :: Text
xs <- Text -> Text -> Maybe Text
T.stripPrefix "<sc>" Text
zs =
      "<span style=\"font-variant:small-caps;\">" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
adjustScTags Text
xs
  | Just xs :: Text
xs <- Text -> Text -> Maybe Text
T.stripPrefix "</sc>" Text
zs =
      "</span>" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text -> Text
adjustScTags Text
xs
  | Just (x :: Char
x, xs :: Text
xs) <- Text -> Maybe (Char, Text)
T.uncons Text
zs =
    Char -> Text -> Text
T.cons Char
x (Text -> Text
adjustScTags Text
xs)
  | Bool
otherwise = ""

writeYAMLString :: [Inline] -> Text
writeYAMLString :: [Inline] -> Text
writeYAMLString ils :: [Inline]
ils =
  Text -> Text
trimr (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Pandoc -> Text
writeMarkdown
        (Pandoc -> Text) -> Pandoc -> Text
forall a b. (a -> b) -> a -> b
$ Meta -> [Block] -> Pandoc
Pandoc Meta
nullMeta
          [[Inline] -> Block
Plain ([Inline] -> Block) -> [Inline] -> Block
forall a b. (a -> b) -> a -> b
$ ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall a b. Walkable a b => (a -> a) -> b -> b
Walk.walk ((Inline -> [Inline]) -> [Inline] -> [Inline]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Bool -> Inline -> [Inline]
adjustCSL Bool
False)) [Inline]
ils]

writeCSLString :: [Inline] -> Text
writeCSLString :: [Inline] -> Text
writeCSLString ils :: [Inline]
ils =
  Text -> Text
trimr (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Pandoc -> Text
writeMarkdown
        (Pandoc -> Text) -> Pandoc -> Text
forall a b. (a -> b) -> a -> b
$ Meta -> [Block] -> Pandoc
Pandoc Meta
nullMeta
          [[Inline] -> Block
Plain ([Inline] -> Block) -> [Inline] -> Block
forall a b. (a -> b) -> a -> b
$ ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall a b. Walkable a b => (a -> a) -> b -> b
Walk.walk ((Inline -> [Inline]) -> [Inline] -> [Inline]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Bool -> Inline -> [Inline]
adjustCSL Bool
True)) [Inline]
ils]

-- If the first param is True, we use special rich text conventions
-- for CSL JSON, described here:
-- http://docs.citationstyles.org/en/1.0/release-notes.html#rich-text-markup-within-fields
adjustCSL :: Bool -> Inline -> [Inline]
adjustCSL :: Bool -> Inline -> [Inline]
adjustCSL _ (Span ("",[],[]) xs :: [Inline]
xs) = [Inline]
xs
adjustCSL _ (Span ("",["citeproc-no-output"],[]) _) =
  [Text -> Inline
Str "[CSL STYLE ERROR: reference with no printed form.]"]
adjustCSL True (SmallCaps xs :: [Inline]
xs) =
  Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "<sc>" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
    [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "</sc>"]
adjustCSL True (Subscript xs :: [Inline]
xs) =
  Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "<sub>" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
    [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "</sub>"]
adjustCSL True (Superscript xs :: [Inline]
xs) =
  Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "<sup>" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
    [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "</sup>"]
adjustCSL True (Emph xs :: [Inline]
xs) =
  Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "<i>" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
    [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "</i>"]
adjustCSL True (Strong xs :: [Inline]
xs) =
  Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "<b>" Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline]
xs
    [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Format -> Text -> Inline
RawInline (Text -> Format
Format "html") "</b>"]
adjustCSL _ x :: Inline
x = [Inline
x]

-- We use a newtype wrapper so we can have custom ToJSON, FromJSON
-- instances.
newtype Formatted = Formatted { Formatted -> [Inline]
unFormatted :: [Inline] }
  deriving ( Int -> Formatted -> ShowS
[Formatted] -> ShowS
Formatted -> [Char]
(Int -> Formatted -> ShowS)
-> (Formatted -> [Char])
-> ([Formatted] -> ShowS)
-> Show Formatted
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Formatted] -> ShowS
$cshowList :: [Formatted] -> ShowS
show :: Formatted -> [Char]
$cshow :: Formatted -> [Char]
showsPrec :: Int -> Formatted -> ShowS
$cshowsPrec :: Int -> Formatted -> ShowS
Show, ReadPrec [Formatted]
ReadPrec Formatted
Int -> ReadS Formatted
ReadS [Formatted]
(Int -> ReadS Formatted)
-> ReadS [Formatted]
-> ReadPrec Formatted
-> ReadPrec [Formatted]
-> Read Formatted
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Formatted]
$creadListPrec :: ReadPrec [Formatted]
readPrec :: ReadPrec Formatted
$creadPrec :: ReadPrec Formatted
readList :: ReadS [Formatted]
$creadList :: ReadS [Formatted]
readsPrec :: Int -> ReadS Formatted
$creadsPrec :: Int -> ReadS Formatted
Read, Formatted -> Formatted -> Bool
(Formatted -> Formatted -> Bool)
-> (Formatted -> Formatted -> Bool) -> Eq Formatted
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Formatted -> Formatted -> Bool
$c/= :: Formatted -> Formatted -> Bool
== :: Formatted -> Formatted -> Bool
$c== :: Formatted -> Formatted -> Bool
Eq, Eq Formatted
Eq Formatted =>
(Formatted -> Formatted -> Ordering)
-> (Formatted -> Formatted -> Bool)
-> (Formatted -> Formatted -> Bool)
-> (Formatted -> Formatted -> Bool)
-> (Formatted -> Formatted -> Bool)
-> (Formatted -> Formatted -> Formatted)
-> (Formatted -> Formatted -> Formatted)
-> Ord Formatted
Formatted -> Formatted -> Bool
Formatted -> Formatted -> Ordering
Formatted -> Formatted -> Formatted
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 :: Formatted -> Formatted -> Formatted
$cmin :: Formatted -> Formatted -> Formatted
max :: Formatted -> Formatted -> Formatted
$cmax :: Formatted -> Formatted -> Formatted
>= :: Formatted -> Formatted -> Bool
$c>= :: Formatted -> Formatted -> Bool
> :: Formatted -> Formatted -> Bool
$c> :: Formatted -> Formatted -> Bool
<= :: Formatted -> Formatted -> Bool
$c<= :: Formatted -> Formatted -> Bool
< :: Formatted -> Formatted -> Bool
$c< :: Formatted -> Formatted -> Bool
compare :: Formatted -> Formatted -> Ordering
$ccompare :: Formatted -> Formatted -> Ordering
$cp1Ord :: Eq Formatted
Ord, Typeable Formatted
Constr
DataType
Typeable Formatted =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Formatted -> c Formatted)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Formatted)
-> (Formatted -> Constr)
-> (Formatted -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Formatted))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatted))
-> ((forall b. Data b => b -> b) -> Formatted -> Formatted)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Formatted -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Formatted -> r)
-> (forall u. (forall d. Data d => d -> u) -> Formatted -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Formatted -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Formatted -> m Formatted)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formatted -> m Formatted)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formatted -> m Formatted)
-> Data Formatted
Formatted -> Constr
Formatted -> DataType
(forall b. Data b => b -> b) -> Formatted -> Formatted
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatted -> c Formatted
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatted
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) -> Formatted -> u
forall u. (forall d. Data d => d -> u) -> Formatted -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formatted -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formatted -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formatted -> m Formatted
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formatted -> m Formatted
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatted
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatted -> c Formatted
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formatted)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatted)
$cFormatted :: Constr
$tFormatted :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Formatted -> m Formatted
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formatted -> m Formatted
gmapMp :: (forall d. Data d => d -> m d) -> Formatted -> m Formatted
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formatted -> m Formatted
gmapM :: (forall d. Data d => d -> m d) -> Formatted -> m Formatted
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formatted -> m Formatted
gmapQi :: Int -> (forall d. Data d => d -> u) -> Formatted -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Formatted -> u
gmapQ :: (forall d. Data d => d -> u) -> Formatted -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Formatted -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formatted -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formatted -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formatted -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formatted -> r
gmapT :: (forall b. Data b => b -> b) -> Formatted -> Formatted
$cgmapT :: (forall b. Data b => b -> b) -> Formatted -> Formatted
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatted)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatted)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Formatted)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formatted)
dataTypeOf :: Formatted -> DataType
$cdataTypeOf :: Formatted -> DataType
toConstr :: Formatted -> Constr
$ctoConstr :: Formatted -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatted
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatted
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatted -> c Formatted
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatted -> c Formatted
$cp1Data :: Typeable Formatted
Data, Typeable, (forall x. Formatted -> Rep Formatted x)
-> (forall x. Rep Formatted x -> Formatted) -> Generic Formatted
forall x. Rep Formatted x -> Formatted
forall x. Formatted -> Rep Formatted x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Formatted x -> Formatted
$cfrom :: forall x. Formatted -> Rep Formatted x
Generic )

instance FromJSON Formatted where
  parseJSON :: Value -> Parser Formatted
parseJSON v :: Value
v@(Array _) =
   [Inline] -> Formatted
Formatted ([Inline] -> Formatted) -> Parser [Inline] -> Parser Formatted
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Value -> Parser [Inline]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v
             Parser [Inline] -> Parser [Inline] -> Parser [Inline]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (((Inline -> [Inline]) -> [Block] -> [Inline]
forall a b m. (Typeable a, Data b, Monoid m) => (a -> m) -> b -> m
query (Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
:[]) :: [Block] -> [Inline]) ([Block] -> [Inline]) -> Parser [Block] -> Parser [Inline]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser [Block]
forall a. FromJSON a => Value -> Parser a
parseJSON Value
v))
  parseJSON v :: Value
v           = ([Inline] -> Formatted
Formatted ([Inline] -> Formatted) -> (Text -> [Inline]) -> Text -> Formatted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Inline]
readCSLString) (Text -> Formatted) -> Parser Text -> Parser Formatted
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Control.Applicative.<$> Value -> Parser Text
parseString Value
v

instance ToJSON Formatted where
  toJSON :: Formatted -> Value
toJSON = Text -> Value
forall a. ToJSON a => a -> Value
toJSON (Text -> Value) -> (Formatted -> Text) -> Formatted -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Inline] -> Text
writeCSLString ([Inline] -> Text) -> (Formatted -> [Inline]) -> Formatted -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatted -> [Inline]
unFormatted

instance ToYaml Formatted where
  toYaml :: Formatted -> YamlBuilder
toYaml = Text -> YamlBuilder
Y.string (Text -> YamlBuilder)
-> (Formatted -> Text) -> Formatted -> YamlBuilder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Inline] -> Text
writeYAMLString ([Inline] -> Text) -> (Formatted -> [Inline]) -> Formatted -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatted -> [Inline]
unFormatted

instance IsString Formatted where
  fromString :: [Char] -> Formatted
fromString = [Inline] -> Formatted
Formatted ([Inline] -> Formatted)
-> ([Char] -> [Inline]) -> [Char] -> Formatted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Inline]
toStr

instance AddYaml Formatted where
  x :: Text
x &= :: Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= (Formatted y :: [Inline]
y) =
           \acc :: [(Text, YamlBuilder)]
acc -> if [Inline] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Inline]
y
                      then [(Text, YamlBuilder)]
acc
                      else (Text
x Text -> Formatted -> (Text, YamlBuilder)
forall a. ToYaml a => Text -> a -> (Text, YamlBuilder)
Y..= [Inline] -> Formatted
Formatted [Inline]
y) (Text, YamlBuilder)
-> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a. a -> [a] -> [a]
: [(Text, YamlBuilder)]
acc

instance Semigroup Formatted where
  <> :: Formatted -> Formatted -> Formatted
(<>) = Formatted -> Formatted -> Formatted
appendWithPunct

instance Monoid Formatted where
  mempty :: Formatted
mempty = [Inline] -> Formatted
Formatted []
  mappend :: Formatted -> Formatted -> Formatted
mappend = Formatted -> Formatted -> Formatted
forall a. Semigroup a => a -> a -> a
(<>)
  mconcat :: [Formatted] -> Formatted
mconcat = (Formatted -> Formatted -> Formatted)
-> Formatted -> [Formatted] -> Formatted
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Formatted -> Formatted -> Formatted
forall a. Monoid a => a -> a -> a
mappend Formatted
forall a. Monoid a => a
mempty

instance Walk.Walkable Inline Formatted where
  walk :: (Inline -> Inline) -> Formatted -> Formatted
walk f :: Inline -> Inline
f  = [Inline] -> Formatted
Formatted ([Inline] -> Formatted)
-> (Formatted -> [Inline]) -> Formatted -> Formatted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Inline) -> [Inline] -> [Inline]
forall a b. Walkable a b => (a -> a) -> b -> b
Walk.walk Inline -> Inline
f ([Inline] -> [Inline])
-> (Formatted -> [Inline]) -> Formatted -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatted -> [Inline]
unFormatted
  walkM :: (Inline -> m Inline) -> Formatted -> m Formatted
walkM f :: Inline -> m Inline
f = ([Inline] -> Formatted) -> m [Inline] -> m Formatted
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Inline] -> Formatted
Formatted (m [Inline] -> m Formatted)
-> (Formatted -> m [Inline]) -> Formatted -> m Formatted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> m Inline) -> [Inline] -> m [Inline]
forall a b (m :: * -> *).
(Walkable a b, Monad m, Applicative m, Functor m) =>
(a -> m a) -> b -> m b
Walk.walkM Inline -> m Inline
f ([Inline] -> m [Inline])
-> (Formatted -> [Inline]) -> Formatted -> m [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatted -> [Inline]
unFormatted
  query :: (Inline -> c) -> Formatted -> c
query f :: Inline -> c
f = (Inline -> c) -> [Inline] -> c
forall a b c. (Walkable a b, Monoid c) => (a -> c) -> b -> c
Walk.query Inline -> c
f ([Inline] -> c) -> (Formatted -> [Inline]) -> Formatted -> c
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatted -> [Inline]
unFormatted

instance Walk.Walkable Formatted Formatted where
  walk :: (Formatted -> Formatted) -> Formatted -> Formatted
walk f :: Formatted -> Formatted
f  = Formatted -> Formatted
f
  walkM :: (Formatted -> m Formatted) -> Formatted -> m Formatted
walkM f :: Formatted -> m Formatted
f = Formatted -> m Formatted
f
  query :: (Formatted -> c) -> Formatted -> c
query f :: Formatted -> c
f = Formatted -> c
f

toStr :: String -> [Inline]
toStr :: [Char] -> [Inline]
toStr = [Inline] -> [[Inline]] -> [Inline]
forall a. [a] -> [[a]] -> [a]
intercalate [Text -> Inline
Str "\n"] ([[Inline]] -> [Inline])
-> ([Char] -> [[Inline]]) -> [Char] -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
        (Text -> [Inline]) -> [Text] -> [[Inline]]
forall a b. (a -> b) -> [a] -> [b]
map (Many Inline -> [Inline]
forall a. Many a -> [a]
B.toList (Many Inline -> [Inline])
-> (Text -> Many Inline) -> Text -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Many Inline
B.text (Text -> Many Inline) -> (Text -> Text) -> Text -> Many Inline
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
T.pack ([Char] -> Text) -> (Text -> [Char]) -> Text -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
tweak ShowS -> (Text -> [Char]) -> Text -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack (Text -> [Char]) -> (Text -> Text) -> Text -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Text
fromEntities) ([Text] -> [[Inline]])
-> ([Char] -> [Text]) -> [Char] -> [[Inline]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
        (Char -> Bool) -> Text -> [Text]
splitWhen (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
=='\n') (Text -> [Text]) -> ([Char] -> Text) -> [Char] -> [Text]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
T.pack
    where
      tweak :: ShowS
tweak ('«':' ':xs :: [Char]
xs) = "«\8239" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
tweak [Char]
xs
      tweak (' ':'»':xs :: [Char]
xs) = "\8239»" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
tweak [Char]
xs
      tweak (' ':';':xs :: [Char]
xs) = "\8239;" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
tweak [Char]
xs
      tweak (' ':':':xs :: [Char]
xs) = "\8239:" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
tweak [Char]
xs
      tweak (' ':'!':xs :: [Char]
xs) = "\8239!" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
tweak [Char]
xs
      tweak (' ':'?':xs :: [Char]
xs) = "\8239?" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ ShowS
tweak [Char]
xs
      tweak ( x :: Char
x :xs :: [Char]
xs    ) = Char
x Char -> ShowS
forall a. a -> [a] -> [a]
: ShowS
tweak [Char]
xs
      tweak []           = []

appendWithPunct :: Formatted -> Formatted -> Formatted
appendWithPunct :: Formatted -> Formatted -> Formatted
appendWithPunct (Formatted left :: [Inline]
left) (Formatted right :: [Inline]
right) =
  [Inline] -> Formatted
Formatted ([Inline] -> Formatted) -> [Inline] -> Formatted
forall a b. (a -> b) -> a -> b
$
  case (,) (Char -> Char -> (Char, Char))
-> Maybe Char -> Maybe (Char -> (Char, Char))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Char
lastleft Maybe (Char -> (Char, Char)) -> Maybe Char -> Maybe (Char, Char)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Char
firstright of
    Just (' ', d :: Char
d) | Char
d Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",.:;" :: String) -> [Inline] -> [Inline]
initInline [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline]
right
    Just (c :: Char
c,d :: Char
d) | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (" ,.:;" :: String), Char
d Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
c -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right
    Just (c :: Char
c,'.') | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",.!:;?" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right
    Just (c :: Char
c,':') | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",!:;?" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right  -- Mich.: 2005
    Just (c :: Char
c,'!') | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",.!:;?" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right
    Just (c :: Char
c,'?') | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",.!:;?" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right
    Just (c :: Char
c,';') | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",:;" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right -- et al.;
    Just (':',c :: Char
c) | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",.!:;?" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right
    Just (';',c :: Char
c) | Char
c Char -> [Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (",.!:;?" :: String) -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
tailInline [Inline]
right
    -- ".;" -> right  -- e.g. et al.;
    _    -> [Inline]
left [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline]
right
  where lastleft :: Maybe Char
lastleft     = [Inline] -> Maybe Char
lastInline [Inline]
left
        firstright :: Maybe Char
firstright   = [Inline] -> Maybe Char
headInline [Inline]
right

-- | The representation of a parsed CSL style.
data Style
    = Style
      { Style -> Text
styleVersion       ::  Text
      , Style -> Text
styleClass         ::  Text
      , Style -> Maybe CSInfo
styleInfo          ::  Maybe CSInfo
      , Style -> Text
styleDefaultLocale ::  Text
      , Style -> [Locale]
styleLocale        :: [Locale]
      , Style -> Abbreviations
styleAbbrevs       :: Abbreviations
      , Style -> [Option]
csOptions          :: [Option]
      , Style -> [MacroMap]
csMacros           :: [MacroMap]
      , Style -> Citation
citation           ::  Citation
      , Style -> Maybe Bibliography
biblio             ::  Maybe Bibliography
      } deriving ( Int -> Style -> ShowS
[Style] -> ShowS
Style -> [Char]
(Int -> Style -> ShowS)
-> (Style -> [Char]) -> ([Style] -> ShowS) -> Show Style
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Style] -> ShowS
$cshowList :: [Style] -> ShowS
show :: Style -> [Char]
$cshow :: Style -> [Char]
showsPrec :: Int -> Style -> ShowS
$cshowsPrec :: Int -> Style -> ShowS
Show, ReadPrec [Style]
ReadPrec Style
Int -> ReadS Style
ReadS [Style]
(Int -> ReadS Style)
-> ReadS [Style]
-> ReadPrec Style
-> ReadPrec [Style]
-> Read Style
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Style]
$creadListPrec :: ReadPrec [Style]
readPrec :: ReadPrec Style
$creadPrec :: ReadPrec Style
readList :: ReadS [Style]
$creadList :: ReadS [Style]
readsPrec :: Int -> ReadS Style
$creadsPrec :: Int -> ReadS Style
Read, Typeable, Typeable Style
Constr
DataType
Typeable Style =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Style -> c Style)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Style)
-> (Style -> Constr)
-> (Style -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Style))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Style))
-> ((forall b. Data b => b -> b) -> Style -> Style)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r)
-> (forall u. (forall d. Data d => d -> u) -> Style -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Style -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Style -> m Style)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Style -> m Style)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Style -> m Style)
-> Data Style
Style -> Constr
Style -> DataType
(forall b. Data b => b -> b) -> Style -> Style
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Style -> c Style
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Style
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) -> Style -> u
forall u. (forall d. Data d => d -> u) -> Style -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Style -> m Style
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Style -> m Style
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Style
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Style -> c Style
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Style)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Style)
$cStyle :: Constr
$tStyle :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Style -> m Style
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Style -> m Style
gmapMp :: (forall d. Data d => d -> m d) -> Style -> m Style
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Style -> m Style
gmapM :: (forall d. Data d => d -> m d) -> Style -> m Style
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Style -> m Style
gmapQi :: Int -> (forall d. Data d => d -> u) -> Style -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Style -> u
gmapQ :: (forall d. Data d => d -> u) -> Style -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Style -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Style -> r
gmapT :: (forall b. Data b => b -> b) -> Style -> Style
$cgmapT :: (forall b. Data b => b -> b) -> Style -> Style
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Style)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Style)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Style)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Style)
dataTypeOf :: Style -> DataType
$cdataTypeOf :: Style -> DataType
toConstr :: Style -> Constr
$ctoConstr :: Style -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Style
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Style
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Style -> c Style
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Style -> c Style
$cp1Data :: Typeable Style
Data, (forall x. Style -> Rep Style x)
-> (forall x. Rep Style x -> Style) -> Generic Style
forall x. Rep Style x -> Style
forall x. Style -> Rep Style x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Style x -> Style
$cfrom :: forall x. Style -> Rep Style x
Generic )

data Locale
    = Locale
      { Locale -> Text
localeVersion :: Text
      , Locale -> Text
localeLang    :: Text
      , Locale -> [Option]
localeOptions :: [Option]
      , Locale -> [CslTerm]
localeTerms   :: [CslTerm]
      , Locale -> [Element]
localeDate    :: [Element]
      } deriving ( Int -> Locale -> ShowS
[Locale] -> ShowS
Locale -> [Char]
(Int -> Locale -> ShowS)
-> (Locale -> [Char]) -> ([Locale] -> ShowS) -> Show Locale
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Locale] -> ShowS
$cshowList :: [Locale] -> ShowS
show :: Locale -> [Char]
$cshow :: Locale -> [Char]
showsPrec :: Int -> Locale -> ShowS
$cshowsPrec :: Int -> Locale -> ShowS
Show, ReadPrec [Locale]
ReadPrec Locale
Int -> ReadS Locale
ReadS [Locale]
(Int -> ReadS Locale)
-> ReadS [Locale]
-> ReadPrec Locale
-> ReadPrec [Locale]
-> Read Locale
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Locale]
$creadListPrec :: ReadPrec [Locale]
readPrec :: ReadPrec Locale
$creadPrec :: ReadPrec Locale
readList :: ReadS [Locale]
$creadList :: ReadS [Locale]
readsPrec :: Int -> ReadS Locale
$creadsPrec :: Int -> ReadS Locale
Read, Locale -> Locale -> Bool
(Locale -> Locale -> Bool)
-> (Locale -> Locale -> Bool) -> Eq Locale
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Locale -> Locale -> Bool
$c/= :: Locale -> Locale -> Bool
== :: Locale -> Locale -> Bool
$c== :: Locale -> Locale -> Bool
Eq, Typeable, Typeable Locale
Constr
DataType
Typeable Locale =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Locale -> c Locale)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Locale)
-> (Locale -> Constr)
-> (Locale -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Locale))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Locale))
-> ((forall b. Data b => b -> b) -> Locale -> Locale)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Locale -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Locale -> r)
-> (forall u. (forall d. Data d => d -> u) -> Locale -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Locale -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Locale -> m Locale)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Locale -> m Locale)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Locale -> m Locale)
-> Data Locale
Locale -> Constr
Locale -> DataType
(forall b. Data b => b -> b) -> Locale -> Locale
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Locale -> c Locale
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Locale
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) -> Locale -> u
forall u. (forall d. Data d => d -> u) -> Locale -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Locale -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Locale -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Locale -> m Locale
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Locale -> m Locale
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Locale
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Locale -> c Locale
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Locale)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Locale)
$cLocale :: Constr
$tLocale :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Locale -> m Locale
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Locale -> m Locale
gmapMp :: (forall d. Data d => d -> m d) -> Locale -> m Locale
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Locale -> m Locale
gmapM :: (forall d. Data d => d -> m d) -> Locale -> m Locale
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Locale -> m Locale
gmapQi :: Int -> (forall d. Data d => d -> u) -> Locale -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Locale -> u
gmapQ :: (forall d. Data d => d -> u) -> Locale -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Locale -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Locale -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Locale -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Locale -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Locale -> r
gmapT :: (forall b. Data b => b -> b) -> Locale -> Locale
$cgmapT :: (forall b. Data b => b -> b) -> Locale -> Locale
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Locale)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Locale)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Locale)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Locale)
dataTypeOf :: Locale -> DataType
$cdataTypeOf :: Locale -> DataType
toConstr :: Locale -> Constr
$ctoConstr :: Locale -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Locale
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Locale
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Locale -> c Locale
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Locale -> c Locale
$cp1Data :: Typeable Locale
Data, (forall x. Locale -> Rep Locale x)
-> (forall x. Rep Locale x -> Locale) -> Generic Locale
forall x. Rep Locale x -> Locale
forall x. Locale -> Rep Locale x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Locale x -> Locale
$cfrom :: forall x. Locale -> Rep Locale x
Generic )

-- | With the 'defaultLocale', the locales-xx-XX.xml loaded file and
-- the parsed 'Style' cs:locale elements, produce the final 'Locale'
-- as the only element of a list, taking into account CSL locale
-- prioritization.
mergeLocales :: Text -> Locale -> [Locale] -> [Locale]
mergeLocales :: Text -> Locale -> [Locale] -> [Locale]
mergeLocales s :: Text
s l :: Locale
l ls :: [Locale]
ls = [Locale] -> [Locale]
forall (m :: * -> *) (t :: * -> *).
(Monad m, Foldable t) =>
t Locale -> m Locale
doMerge [Locale]
list
    where
      list :: [Locale]
list = (Locale -> Bool) -> [Locale] -> [Locale]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
(==) Text
s (Text -> Bool) -> (Locale -> Text) -> Locale -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Locale -> Text
localeLang) [Locale]
ls [Locale] -> [Locale] -> [Locale]
forall a. [a] -> [a] -> [a]
++
             (Locale -> Bool) -> [Locale] -> [Locale]
forall a. (a -> Bool) -> [a] -> [a]
filter ((\x :: Text
x -> Text
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= "" Bool -> Bool -> Bool
&& Text
x Text -> Text -> Bool
`T.isPrefixOf` Text
s) (Text -> Bool) -> (Locale -> Text) -> Locale -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Locale -> Text
localeLang) [Locale]
ls [Locale] -> [Locale] -> [Locale]
forall a. [a] -> [a] -> [a]
++
             (Locale -> Bool) -> [Locale] -> [Locale]
forall a. (a -> Bool) -> [a] -> [a]
filter (Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
(==) "" (Text -> Bool) -> (Locale -> Text) -> Locale -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Locale -> Text
localeLang) [Locale]
ls
      doMerge :: t Locale -> m Locale
doMerge x :: t Locale
x = Locale -> m Locale
forall (m :: * -> *) a. Monad m => a -> m a
return Locale
l { localeOptions :: [Option]
localeOptions = t Locale -> [Option]
forall (t :: * -> *). Foldable t => t Locale -> [Option]
newOpt     t Locale
x
                           , localeTerms :: [CslTerm]
localeTerms   = t Locale -> [CslTerm]
forall (t :: * -> *). Foldable t => t Locale -> [CslTerm]
newTerms   t Locale
x
                           , localeDate :: [Element]
localeDate    = t Locale -> [Element]
forall (t :: * -> *). Foldable t => t Locale -> [Element]
newDate    t Locale
x
                           }
      cht :: CslTerm -> (Text, (Form, Gender))
cht          = CslTerm -> Text
cslTerm (CslTerm -> Text)
-> (CslTerm -> (Form, Gender)) -> CslTerm -> (Text, (Form, Gender))
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& CslTerm -> Form
termForm (CslTerm -> Form)
-> (CslTerm -> Gender) -> CslTerm -> (Form, Gender)
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& CslTerm -> Gender
termGenderForm
      checkedLoc :: [CslTerm]
checkedLoc   = if [Locale] -> Bool
hasOrdinals [Locale]
ls then [CslTerm] -> [CslTerm]
rmOrdinals (Locale -> [CslTerm]
localeTerms Locale
l) else Locale -> [CslTerm]
localeTerms Locale
l
      newTerms :: t Locale -> [CslTerm]
newTerms   x :: t Locale
x = (CslTerm -> CslTerm -> Bool) -> [CslTerm] -> [CslTerm]
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy (\a :: CslTerm
a b :: CslTerm
b -> CslTerm -> (Text, (Form, Gender))
cht CslTerm
a (Text, (Form, Gender)) -> (Text, (Form, Gender)) -> Bool
forall a. Eq a => a -> a -> Bool
== CslTerm -> (Text, (Form, Gender))
cht CslTerm
b) ((Locale -> [CslTerm]) -> t Locale -> [CslTerm]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Locale -> [CslTerm]
localeTerms   t Locale
x [CslTerm] -> [CslTerm] -> [CslTerm]
forall a. [a] -> [a] -> [a]
++ [CslTerm]
checkedLoc)
      newOpt :: t Locale -> [Option]
newOpt     x :: t Locale
x = (Option -> Option -> Bool) -> [Option] -> [Option]
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy (\a :: Option
a b :: Option
b -> Option -> Text
forall a b. (a, b) -> a
fst Option
a Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Option -> Text
forall a b. (a, b) -> a
fst Option
b) ((Locale -> [Option]) -> t Locale -> [Option]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Locale -> [Option]
localeOptions t Locale
x [Option] -> [Option] -> [Option]
forall a. [a] -> [a] -> [a]
++ Locale -> [Option]
localeOptions Locale
l)
      newDate :: t Locale -> [Element]
newDate    x :: t Locale
x = (Element -> Element -> Bool) -> [Element] -> [Element]
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy (\(Date _ a :: DateForm
a _ _ _ _)
                             (Date _ b :: DateForm
b _ _ _ _) -> DateForm
a DateForm -> DateForm -> Bool
forall a. Eq a => a -> a -> Bool
== DateForm
b) ((Locale -> [Element]) -> t Locale -> [Element]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Locale -> [Element]
localeDate t Locale
x [Element] -> [Element] -> [Element]
forall a. [a] -> [a] -> [a]
++ Locale -> [Element]
localeDate Locale
l)

data CslTerm
    = CT
      { CslTerm -> Text
cslTerm        :: Text
      , CslTerm -> Form
termForm       :: Form
      , CslTerm -> Gender
termGender     :: Gender
      , CslTerm -> Gender
termGenderForm :: Gender
      , CslTerm -> Text
termSingular   :: Text
      , CslTerm -> Text
termPlural     :: Text
      , CslTerm -> Text
termMatch      :: Text
      } deriving ( Int -> CslTerm -> ShowS
[CslTerm] -> ShowS
CslTerm -> [Char]
(Int -> CslTerm -> ShowS)
-> (CslTerm -> [Char]) -> ([CslTerm] -> ShowS) -> Show CslTerm
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [CslTerm] -> ShowS
$cshowList :: [CslTerm] -> ShowS
show :: CslTerm -> [Char]
$cshow :: CslTerm -> [Char]
showsPrec :: Int -> CslTerm -> ShowS
$cshowsPrec :: Int -> CslTerm -> ShowS
Show, ReadPrec [CslTerm]
ReadPrec CslTerm
Int -> ReadS CslTerm
ReadS [CslTerm]
(Int -> ReadS CslTerm)
-> ReadS [CslTerm]
-> ReadPrec CslTerm
-> ReadPrec [CslTerm]
-> Read CslTerm
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CslTerm]
$creadListPrec :: ReadPrec [CslTerm]
readPrec :: ReadPrec CslTerm
$creadPrec :: ReadPrec CslTerm
readList :: ReadS [CslTerm]
$creadList :: ReadS [CslTerm]
readsPrec :: Int -> ReadS CslTerm
$creadsPrec :: Int -> ReadS CslTerm
Read, CslTerm -> CslTerm -> Bool
(CslTerm -> CslTerm -> Bool)
-> (CslTerm -> CslTerm -> Bool) -> Eq CslTerm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CslTerm -> CslTerm -> Bool
$c/= :: CslTerm -> CslTerm -> Bool
== :: CslTerm -> CslTerm -> Bool
$c== :: CslTerm -> CslTerm -> Bool
Eq, Typeable, Typeable CslTerm
Constr
DataType
Typeable CslTerm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CslTerm -> c CslTerm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CslTerm)
-> (CslTerm -> Constr)
-> (CslTerm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CslTerm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CslTerm))
-> ((forall b. Data b => b -> b) -> CslTerm -> CslTerm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CslTerm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CslTerm -> r)
-> (forall u. (forall d. Data d => d -> u) -> CslTerm -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CslTerm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CslTerm -> m CslTerm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CslTerm -> m CslTerm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CslTerm -> m CslTerm)
-> Data CslTerm
CslTerm -> Constr
CslTerm -> DataType
(forall b. Data b => b -> b) -> CslTerm -> CslTerm
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CslTerm -> c CslTerm
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CslTerm
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) -> CslTerm -> u
forall u. (forall d. Data d => d -> u) -> CslTerm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CslTerm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CslTerm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CslTerm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CslTerm -> c CslTerm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CslTerm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CslTerm)
$cCT :: Constr
$tCslTerm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
gmapMp :: (forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
gmapM :: (forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CslTerm -> m CslTerm
gmapQi :: Int -> (forall d. Data d => d -> u) -> CslTerm -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CslTerm -> u
gmapQ :: (forall d. Data d => d -> u) -> CslTerm -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CslTerm -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CslTerm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CslTerm -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CslTerm -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CslTerm -> r
gmapT :: (forall b. Data b => b -> b) -> CslTerm -> CslTerm
$cgmapT :: (forall b. Data b => b -> b) -> CslTerm -> CslTerm
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CslTerm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CslTerm)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CslTerm)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CslTerm)
dataTypeOf :: CslTerm -> DataType
$cdataTypeOf :: CslTerm -> DataType
toConstr :: CslTerm -> Constr
$ctoConstr :: CslTerm -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CslTerm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CslTerm
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CslTerm -> c CslTerm
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CslTerm -> c CslTerm
$cp1Data :: Typeable CslTerm
Data, (forall x. CslTerm -> Rep CslTerm x)
-> (forall x. Rep CslTerm x -> CslTerm) -> Generic CslTerm
forall x. Rep CslTerm x -> CslTerm
forall x. CslTerm -> Rep CslTerm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CslTerm x -> CslTerm
$cfrom :: forall x. CslTerm -> Rep CslTerm x
Generic )

newTerm :: CslTerm
newTerm :: CslTerm
newTerm = Text -> Form -> Gender -> Gender -> Text -> Text -> Text -> CslTerm
CT "" Form
Long Gender
Neuter Gender
Neuter "" "" ""

findTerm :: Text -> Form -> [CslTerm] -> Maybe CslTerm
findTerm :: Text -> Form -> [CslTerm] -> Maybe CslTerm
findTerm s :: Text
s f :: Form
f = Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' Text
s Form
f Maybe Gender
forall a. Maybe a
Nothing

findTerm' :: Text -> Form -> Gender -> [CslTerm] -> Maybe CslTerm
findTerm' :: Text -> Form -> Gender -> [CslTerm] -> Maybe CslTerm
findTerm' s :: Text
s f :: Form
f g :: Gender
g = Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' Text
s Form
f (Gender -> Maybe Gender
forall a. a -> Maybe a
Just Gender
g)

findTerm'' :: Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' :: Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' s :: Text
s f :: Form
f mbg :: Maybe Gender
mbg ts :: [CslTerm]
ts
  = [CslTerm] -> Maybe CslTerm
forall a. [a] -> Maybe a
listToMaybe [ CslTerm
t | CslTerm
t <- [CslTerm]
ts, CslTerm -> Text
cslTerm CslTerm
t Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
s, CslTerm -> Form
termForm CslTerm
t Form -> Form -> Bool
forall a. Eq a => a -> a -> Bool
== Form
f,
                         Maybe Gender -> Bool
forall a. Maybe a -> Bool
isNothing Maybe Gender
mbg Bool -> Bool -> Bool
|| Maybe Gender
mbg Maybe Gender -> Maybe Gender -> Bool
forall a. Eq a => a -> a -> Bool
== Gender -> Maybe Gender
forall a. a -> Maybe a
Just (CslTerm -> Gender
termGenderForm CslTerm
t) ]
  Maybe CslTerm -> Maybe CslTerm -> Maybe CslTerm
forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
`mplus`
  -- fallback: http://citationstyles.org/downloads/specification.html#terms
  case Form
f of
       VerbShort -> Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' Text
s Form
Verb Maybe Gender
forall a. Maybe a
Nothing [CslTerm]
ts
       Symbol    -> Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' Text
s Form
Short Maybe Gender
forall a. Maybe a
Nothing [CslTerm]
ts
       Verb      -> Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' Text
s Form
Long Maybe Gender
forall a. Maybe a
Nothing [CslTerm]
ts
       Short     -> Text -> Form -> Maybe Gender -> [CslTerm] -> Maybe CslTerm
findTerm'' Text
s Form
Long Maybe Gender
forall a. Maybe a
Nothing [CslTerm]
ts
       _         -> Maybe CslTerm
forall a. Maybe a
Nothing

hasOrdinals :: [Locale] -> Bool
hasOrdinals :: [Locale] -> Bool
hasOrdinals = (Locale -> Bool) -> [Locale] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any ((CslTerm -> Bool) -> [CslTerm] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any CslTerm -> Bool
hasOrd ([CslTerm] -> Bool) -> (Locale -> [CslTerm]) -> Locale -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Locale -> [CslTerm]
localeTerms)
    where
      hasOrd :: CslTerm -> Bool
hasOrd o :: CslTerm
o
          | CT {cslTerm :: CslTerm -> Text
cslTerm = Text
t} <- CslTerm
o
          , "ordinal" Text -> Text -> Bool
`T.isInfixOf` Text
t = Bool
True
          | Bool
otherwise                 = Bool
False

rmOrdinals :: [CslTerm] -> [CslTerm]
rmOrdinals :: [CslTerm] -> [CslTerm]
rmOrdinals [] = []
rmOrdinals (o :: CslTerm
o:os :: [CslTerm]
os)
  | CT {cslTerm :: CslTerm -> Text
cslTerm = Text
t} <- CslTerm
o
  , "ordinal" Text -> Text -> Bool
`T.isInfixOf` Text
t =   [CslTerm] -> [CslTerm]
rmOrdinals [CslTerm]
os
  | Bool
otherwise                 = CslTerm
oCslTerm -> [CslTerm] -> [CslTerm]
forall a. a -> [a] -> [a]
:[CslTerm] -> [CslTerm]
rmOrdinals [CslTerm]
os

newtype Abbreviations = Abbreviations {
           Abbreviations -> Map Text (Map Text (Map Text Text))
unAbbreviations :: M.Map Text (M.Map Text (M.Map Text Text))
           } deriving ( Int -> Abbreviations -> ShowS
[Abbreviations] -> ShowS
Abbreviations -> [Char]
(Int -> Abbreviations -> ShowS)
-> (Abbreviations -> [Char])
-> ([Abbreviations] -> ShowS)
-> Show Abbreviations
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Abbreviations] -> ShowS
$cshowList :: [Abbreviations] -> ShowS
show :: Abbreviations -> [Char]
$cshow :: Abbreviations -> [Char]
showsPrec :: Int -> Abbreviations -> ShowS
$cshowsPrec :: Int -> Abbreviations -> ShowS
Show, ReadPrec [Abbreviations]
ReadPrec Abbreviations
Int -> ReadS Abbreviations
ReadS [Abbreviations]
(Int -> ReadS Abbreviations)
-> ReadS [Abbreviations]
-> ReadPrec Abbreviations
-> ReadPrec [Abbreviations]
-> Read Abbreviations
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Abbreviations]
$creadListPrec :: ReadPrec [Abbreviations]
readPrec :: ReadPrec Abbreviations
$creadPrec :: ReadPrec Abbreviations
readList :: ReadS [Abbreviations]
$creadList :: ReadS [Abbreviations]
readsPrec :: Int -> ReadS Abbreviations
$creadsPrec :: Int -> ReadS Abbreviations
Read, Typeable, Typeable Abbreviations
Constr
DataType
Typeable Abbreviations =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Abbreviations -> c Abbreviations)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Abbreviations)
-> (Abbreviations -> Constr)
-> (Abbreviations -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Abbreviations))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Abbreviations))
-> ((forall b. Data b => b -> b) -> Abbreviations -> Abbreviations)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Abbreviations -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Abbreviations -> r)
-> (forall u. (forall d. Data d => d -> u) -> Abbreviations -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Abbreviations -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations)
-> Data Abbreviations
Abbreviations -> Constr
Abbreviations -> DataType
(forall b. Data b => b -> b) -> Abbreviations -> Abbreviations
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abbreviations -> c Abbreviations
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abbreviations
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) -> Abbreviations -> u
forall u. (forall d. Data d => d -> u) -> Abbreviations -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Abbreviations -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Abbreviations -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abbreviations
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abbreviations -> c Abbreviations
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Abbreviations)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Abbreviations)
$cAbbreviations :: Constr
$tAbbreviations :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
gmapMp :: (forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
gmapM :: (forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Abbreviations -> m Abbreviations
gmapQi :: Int -> (forall d. Data d => d -> u) -> Abbreviations -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Abbreviations -> u
gmapQ :: (forall d. Data d => d -> u) -> Abbreviations -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Abbreviations -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Abbreviations -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Abbreviations -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Abbreviations -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Abbreviations -> r
gmapT :: (forall b. Data b => b -> b) -> Abbreviations -> Abbreviations
$cgmapT :: (forall b. Data b => b -> b) -> Abbreviations -> Abbreviations
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Abbreviations)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Abbreviations)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Abbreviations)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Abbreviations)
dataTypeOf :: Abbreviations -> DataType
$cdataTypeOf :: Abbreviations -> DataType
toConstr :: Abbreviations -> Constr
$ctoConstr :: Abbreviations -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abbreviations
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Abbreviations
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abbreviations -> c Abbreviations
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Abbreviations -> c Abbreviations
$cp1Data :: Typeable Abbreviations
Data, (forall x. Abbreviations -> Rep Abbreviations x)
-> (forall x. Rep Abbreviations x -> Abbreviations)
-> Generic Abbreviations
forall x. Rep Abbreviations x -> Abbreviations
forall x. Abbreviations -> Rep Abbreviations x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Abbreviations x -> Abbreviations
$cfrom :: forall x. Abbreviations -> Rep Abbreviations x
Generic )

instance FromJSON Abbreviations where
  parseJSON :: Value -> Parser Abbreviations
parseJSON (Object v :: Object
v)   = Map Text (Map Text (Map Text Text)) -> Abbreviations
Abbreviations (Map Text (Map Text (Map Text Text)) -> Abbreviations)
-> Parser (Map Text (Map Text (Map Text Text)))
-> Parser Abbreviations
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Value -> Parser (Map Text (Map Text (Map Text Text)))
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
  parseJSON (Bool False) = Abbreviations -> Parser Abbreviations
forall (m :: * -> *) a. Monad m => a -> m a
return (Abbreviations -> Parser Abbreviations)
-> Abbreviations -> Parser Abbreviations
forall a b. (a -> b) -> a -> b
$ Map Text (Map Text (Map Text Text)) -> Abbreviations
Abbreviations Map Text (Map Text (Map Text Text))
forall k a. Map k a
M.empty
  parseJSON _            = [Char] -> Parser Abbreviations
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail "Could not read Abbreviations"

type MacroMap
    = (Text,[Element])

data Citation
    = Citation
      { Citation -> [Option]
citOptions :: [Option]
      , Citation -> [Sort]
citSort    :: [Sort]
      , Citation -> Layout
citLayout  ::  Layout
      } deriving ( Int -> Citation -> ShowS
[Citation] -> ShowS
Citation -> [Char]
(Int -> Citation -> ShowS)
-> (Citation -> [Char]) -> ([Citation] -> ShowS) -> Show Citation
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Citation] -> ShowS
$cshowList :: [Citation] -> ShowS
show :: Citation -> [Char]
$cshow :: Citation -> [Char]
showsPrec :: Int -> Citation -> ShowS
$cshowsPrec :: Int -> Citation -> ShowS
Show, ReadPrec [Citation]
ReadPrec Citation
Int -> ReadS Citation
ReadS [Citation]
(Int -> ReadS Citation)
-> ReadS [Citation]
-> ReadPrec Citation
-> ReadPrec [Citation]
-> Read Citation
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Citation]
$creadListPrec :: ReadPrec [Citation]
readPrec :: ReadPrec Citation
$creadPrec :: ReadPrec Citation
readList :: ReadS [Citation]
$creadList :: ReadS [Citation]
readsPrec :: Int -> ReadS Citation
$creadsPrec :: Int -> ReadS Citation
Read, Typeable, Typeable Citation
Constr
DataType
Typeable Citation =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Citation -> c Citation)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Citation)
-> (Citation -> Constr)
-> (Citation -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Citation))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation))
-> ((forall b. Data b => b -> b) -> Citation -> Citation)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Citation -> r)
-> (forall u. (forall d. Data d => d -> u) -> Citation -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Citation -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Citation -> m Citation)
-> Data Citation
Citation -> Constr
Citation -> DataType
(forall b. Data b => b -> b) -> Citation -> Citation
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Citation -> c Citation
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Citation
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) -> Citation -> u
forall u. (forall d. Data d => d -> u) -> Citation -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Citation -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Citation -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Citation -> m Citation
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Citation -> m Citation
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Citation
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Citation -> c Citation
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Citation)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation)
$cCitation :: Constr
$tCitation :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Citation -> m Citation
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Citation -> m Citation
gmapMp :: (forall d. Data d => d -> m d) -> Citation -> m Citation
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Citation -> m Citation
gmapM :: (forall d. Data d => d -> m d) -> Citation -> m Citation
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Citation -> m Citation
gmapQi :: Int -> (forall d. Data d => d -> u) -> Citation -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Citation -> u
gmapQ :: (forall d. Data d => d -> u) -> Citation -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Citation -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Citation -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Citation -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Citation -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Citation -> r
gmapT :: (forall b. Data b => b -> b) -> Citation -> Citation
$cgmapT :: (forall b. Data b => b -> b) -> Citation -> Citation
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Citation)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Citation)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Citation)
dataTypeOf :: Citation -> DataType
$cdataTypeOf :: Citation -> DataType
toConstr :: Citation -> Constr
$ctoConstr :: Citation -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Citation
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Citation
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Citation -> c Citation
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Citation -> c Citation
$cp1Data :: Typeable Citation
Data, (forall x. Citation -> Rep Citation x)
-> (forall x. Rep Citation x -> Citation) -> Generic Citation
forall x. Rep Citation x -> Citation
forall x. Citation -> Rep Citation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Citation x -> Citation
$cfrom :: forall x. Citation -> Rep Citation x
Generic )

data Bibliography
    = Bibliography
      { Bibliography -> [Option]
bibOptions :: [Option]
      , Bibliography -> [Sort]
bibSort    :: [Sort]
      , Bibliography -> Layout
bibLayout  ::  Layout
      } deriving ( Int -> Bibliography -> ShowS
[Bibliography] -> ShowS
Bibliography -> [Char]
(Int -> Bibliography -> ShowS)
-> (Bibliography -> [Char])
-> ([Bibliography] -> ShowS)
-> Show Bibliography
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Bibliography] -> ShowS
$cshowList :: [Bibliography] -> ShowS
show :: Bibliography -> [Char]
$cshow :: Bibliography -> [Char]
showsPrec :: Int -> Bibliography -> ShowS
$cshowsPrec :: Int -> Bibliography -> ShowS
Show, ReadPrec [Bibliography]
ReadPrec Bibliography
Int -> ReadS Bibliography
ReadS [Bibliography]
(Int -> ReadS Bibliography)
-> ReadS [Bibliography]
-> ReadPrec Bibliography
-> ReadPrec [Bibliography]
-> Read Bibliography
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Bibliography]
$creadListPrec :: ReadPrec [Bibliography]
readPrec :: ReadPrec Bibliography
$creadPrec :: ReadPrec Bibliography
readList :: ReadS [Bibliography]
$creadList :: ReadS [Bibliography]
readsPrec :: Int -> ReadS Bibliography
$creadsPrec :: Int -> ReadS Bibliography
Read, Typeable, Typeable Bibliography
Constr
DataType
Typeable Bibliography =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Bibliography -> c Bibliography)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Bibliography)
-> (Bibliography -> Constr)
-> (Bibliography -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Bibliography))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Bibliography))
-> ((forall b. Data b => b -> b) -> Bibliography -> Bibliography)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Bibliography -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Bibliography -> r)
-> (forall u. (forall d. Data d => d -> u) -> Bibliography -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Bibliography -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Bibliography -> m Bibliography)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bibliography -> m Bibliography)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Bibliography -> m Bibliography)
-> Data Bibliography
Bibliography -> Constr
Bibliography -> DataType
(forall b. Data b => b -> b) -> Bibliography -> Bibliography
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bibliography -> c Bibliography
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bibliography
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) -> Bibliography -> u
forall u. (forall d. Data d => d -> u) -> Bibliography -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bibliography -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bibliography -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bibliography
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bibliography -> c Bibliography
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bibliography)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Bibliography)
$cBibliography :: Constr
$tBibliography :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
gmapMp :: (forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
gmapM :: (forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Bibliography -> m Bibliography
gmapQi :: Int -> (forall d. Data d => d -> u) -> Bibliography -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Bibliography -> u
gmapQ :: (forall d. Data d => d -> u) -> Bibliography -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Bibliography -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bibliography -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Bibliography -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bibliography -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Bibliography -> r
gmapT :: (forall b. Data b => b -> b) -> Bibliography -> Bibliography
$cgmapT :: (forall b. Data b => b -> b) -> Bibliography -> Bibliography
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Bibliography)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Bibliography)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Bibliography)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Bibliography)
dataTypeOf :: Bibliography -> DataType
$cdataTypeOf :: Bibliography -> DataType
toConstr :: Bibliography -> Constr
$ctoConstr :: Bibliography -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bibliography
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Bibliography
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bibliography -> c Bibliography
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Bibliography -> c Bibliography
$cp1Data :: Typeable Bibliography
Data, (forall x. Bibliography -> Rep Bibliography x)
-> (forall x. Rep Bibliography x -> Bibliography)
-> Generic Bibliography
forall x. Rep Bibliography x -> Bibliography
forall x. Bibliography -> Rep Bibliography x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Bibliography x -> Bibliography
$cfrom :: forall x. Bibliography -> Rep Bibliography x
Generic )

type Option = (Text,Text)

mergeOptions :: [Option] -> [Option] -> [Option]
mergeOptions :: [Option] -> [Option] -> [Option]
mergeOptions os :: [Option]
os = (Option -> Option -> Bool) -> [Option] -> [Option]
forall a. (a -> a -> Bool) -> [a] -> [a]
nubBy (\x :: Option
x y :: Option
y -> Option -> Text
forall a b. (a, b) -> a
fst Option
x Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Option -> Text
forall a b. (a, b) -> a
fst Option
y) ([Option] -> [Option])
-> ([Option] -> [Option]) -> [Option] -> [Option]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Option] -> [Option] -> [Option]
forall a. [a] -> [a] -> [a]
(++) [Option]
os

data Layout
    = Layout
      { Layout -> Formatting
layFormat ::  Formatting
      , Layout -> Text
layDelim  ::  Delimiter
      , Layout -> [Element]
elements  :: [Element]
      } deriving ( Int -> Layout -> ShowS
[Layout] -> ShowS
Layout -> [Char]
(Int -> Layout -> ShowS)
-> (Layout -> [Char]) -> ([Layout] -> ShowS) -> Show Layout
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Layout] -> ShowS
$cshowList :: [Layout] -> ShowS
show :: Layout -> [Char]
$cshow :: Layout -> [Char]
showsPrec :: Int -> Layout -> ShowS
$cshowsPrec :: Int -> Layout -> ShowS
Show, ReadPrec [Layout]
ReadPrec Layout
Int -> ReadS Layout
ReadS [Layout]
(Int -> ReadS Layout)
-> ReadS [Layout]
-> ReadPrec Layout
-> ReadPrec [Layout]
-> Read Layout
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Layout]
$creadListPrec :: ReadPrec [Layout]
readPrec :: ReadPrec Layout
$creadPrec :: ReadPrec Layout
readList :: ReadS [Layout]
$creadList :: ReadS [Layout]
readsPrec :: Int -> ReadS Layout
$creadsPrec :: Int -> ReadS Layout
Read, Typeable, Typeable Layout
Constr
DataType
Typeable Layout =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Layout -> c Layout)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Layout)
-> (Layout -> Constr)
-> (Layout -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Layout))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout))
-> ((forall b. Data b => b -> b) -> Layout -> Layout)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Layout -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Layout -> r)
-> (forall u. (forall d. Data d => d -> u) -> Layout -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Layout -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Layout -> m Layout)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Layout -> m Layout)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Layout -> m Layout)
-> Data Layout
Layout -> Constr
Layout -> DataType
(forall b. Data b => b -> b) -> Layout -> Layout
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
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) -> Layout -> u
forall u. (forall d. Data d => d -> u) -> Layout -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Layout)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout)
$cLayout :: Constr
$tLayout :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Layout -> m Layout
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
gmapMp :: (forall d. Data d => d -> m d) -> Layout -> m Layout
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
gmapM :: (forall d. Data d => d -> m d) -> Layout -> m Layout
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Layout -> m Layout
gmapQi :: Int -> (forall d. Data d => d -> u) -> Layout -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Layout -> u
gmapQ :: (forall d. Data d => d -> u) -> Layout -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Layout -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Layout -> r
gmapT :: (forall b. Data b => b -> b) -> Layout -> Layout
$cgmapT :: (forall b. Data b => b -> b) -> Layout -> Layout
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Layout)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Layout)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Layout)
dataTypeOf :: Layout -> DataType
$cdataTypeOf :: Layout -> DataType
toConstr :: Layout -> Constr
$ctoConstr :: Layout -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Layout
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Layout -> c Layout
$cp1Data :: Typeable Layout
Data, (forall x. Layout -> Rep Layout x)
-> (forall x. Rep Layout x -> Layout) -> Generic Layout
forall x. Rep Layout x -> Layout
forall x. Layout -> Rep Layout x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Layout x -> Layout
$cfrom :: forall x. Layout -> Rep Layout x
Generic )

data Element
    = Choose       IfThen    [IfThen]    [Element]
    | Macro        Text                   Formatting
    | Const        Text                   Formatting
    | Variable    [Text]      Form        Formatting Delimiter
    | Term         Text       Form        Formatting Bool
    | Label        Text       Form        Formatting Plural
    | Number       Text       NumericForm Formatting
    | Names       [Text  ]   [Name]       Formatting Delimiter [Element]
    | Substitute  [Element]
    | Group        Formatting Delimiter  [Element]
    | Date        [Text  ]    DateForm    Formatting Delimiter [DatePart] Text
      deriving ( Int -> Element -> ShowS
[Element] -> ShowS
Element -> [Char]
(Int -> Element -> ShowS)
-> (Element -> [Char]) -> ([Element] -> ShowS) -> Show Element
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Element] -> ShowS
$cshowList :: [Element] -> ShowS
show :: Element -> [Char]
$cshow :: Element -> [Char]
showsPrec :: Int -> Element -> ShowS
$cshowsPrec :: Int -> Element -> ShowS
Show, ReadPrec [Element]
ReadPrec Element
Int -> ReadS Element
ReadS [Element]
(Int -> ReadS Element)
-> ReadS [Element]
-> ReadPrec Element
-> ReadPrec [Element]
-> Read Element
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Element]
$creadListPrec :: ReadPrec [Element]
readPrec :: ReadPrec Element
$creadPrec :: ReadPrec Element
readList :: ReadS [Element]
$creadList :: ReadS [Element]
readsPrec :: Int -> ReadS Element
$creadsPrec :: Int -> ReadS Element
Read, Element -> Element -> Bool
(Element -> Element -> Bool)
-> (Element -> Element -> Bool) -> Eq Element
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Element -> Element -> Bool
$c/= :: Element -> Element -> Bool
== :: Element -> Element -> Bool
$c== :: Element -> Element -> Bool
Eq, Typeable, Typeable Element
Constr
DataType
Typeable Element =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Element -> c Element)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Element)
-> (Element -> Constr)
-> (Element -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Element))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element))
-> ((forall b. Data b => b -> b) -> Element -> Element)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Element -> r)
-> (forall u. (forall d. Data d => d -> u) -> Element -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Element -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Element -> m Element)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Element -> m Element)
-> Data Element
Element -> Constr
Element -> DataType
(forall b. Data b => b -> b) -> Element -> Element
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Element -> c Element
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Element
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Element -> u
forall u. (forall d. Data d => d -> u) -> Element -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Element -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Element -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Element -> m Element
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Element -> m Element
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Element
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Element -> c Element
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Element)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element)
$cDate :: Constr
$cGroup :: Constr
$cSubstitute :: Constr
$cNames :: Constr
$cNumber :: Constr
$cLabel :: Constr
$cTerm :: Constr
$cVariable :: Constr
$cConst :: Constr
$cMacro :: Constr
$cChoose :: Constr
$tElement :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Element -> m Element
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Element -> m Element
gmapMp :: (forall d. Data d => d -> m d) -> Element -> m Element
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Element -> m Element
gmapM :: (forall d. Data d => d -> m d) -> Element -> m Element
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Element -> m Element
gmapQi :: Int -> (forall d. Data d => d -> u) -> Element -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Element -> u
gmapQ :: (forall d. Data d => d -> u) -> Element -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Element -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Element -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Element -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Element -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Element -> r
gmapT :: (forall b. Data b => b -> b) -> Element -> Element
$cgmapT :: (forall b. Data b => b -> b) -> Element -> Element
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Element)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Element)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Element)
dataTypeOf :: Element -> DataType
$cdataTypeOf :: Element -> DataType
toConstr :: Element -> Constr
$ctoConstr :: Element -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Element
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Element
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Element -> c Element
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Element -> c Element
$cp1Data :: Typeable Element
Data, (forall x. Element -> Rep Element x)
-> (forall x. Rep Element x -> Element) -> Generic Element
forall x. Rep Element x -> Element
forall x. Element -> Rep Element x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Element x -> Element
$cfrom :: forall x. Element -> Rep Element x
Generic )

data IfThen
    = IfThen Condition Match [Element]
      deriving ( IfThen -> IfThen -> Bool
(IfThen -> IfThen -> Bool)
-> (IfThen -> IfThen -> Bool) -> Eq IfThen
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IfThen -> IfThen -> Bool
$c/= :: IfThen -> IfThen -> Bool
== :: IfThen -> IfThen -> Bool
$c== :: IfThen -> IfThen -> Bool
Eq, Int -> IfThen -> ShowS
[IfThen] -> ShowS
IfThen -> [Char]
(Int -> IfThen -> ShowS)
-> (IfThen -> [Char]) -> ([IfThen] -> ShowS) -> Show IfThen
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [IfThen] -> ShowS
$cshowList :: [IfThen] -> ShowS
show :: IfThen -> [Char]
$cshow :: IfThen -> [Char]
showsPrec :: Int -> IfThen -> ShowS
$cshowsPrec :: Int -> IfThen -> ShowS
Show, ReadPrec [IfThen]
ReadPrec IfThen
Int -> ReadS IfThen
ReadS [IfThen]
(Int -> ReadS IfThen)
-> ReadS [IfThen]
-> ReadPrec IfThen
-> ReadPrec [IfThen]
-> Read IfThen
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [IfThen]
$creadListPrec :: ReadPrec [IfThen]
readPrec :: ReadPrec IfThen
$creadPrec :: ReadPrec IfThen
readList :: ReadS [IfThen]
$creadList :: ReadS [IfThen]
readsPrec :: Int -> ReadS IfThen
$creadsPrec :: Int -> ReadS IfThen
Read, Typeable, Typeable IfThen
Constr
DataType
Typeable IfThen =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IfThen -> c IfThen)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IfThen)
-> (IfThen -> Constr)
-> (IfThen -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IfThen))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IfThen))
-> ((forall b. Data b => b -> b) -> IfThen -> IfThen)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IfThen -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IfThen -> r)
-> (forall u. (forall d. Data d => d -> u) -> IfThen -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IfThen -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IfThen -> m IfThen)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IfThen -> m IfThen)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IfThen -> m IfThen)
-> Data IfThen
IfThen -> Constr
IfThen -> DataType
(forall b. Data b => b -> b) -> IfThen -> IfThen
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IfThen -> c IfThen
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IfThen
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) -> IfThen -> u
forall u. (forall d. Data d => d -> u) -> IfThen -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IfThen -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IfThen -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IfThen -> m IfThen
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IfThen -> m IfThen
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IfThen
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IfThen -> c IfThen
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IfThen)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IfThen)
$cIfThen :: Constr
$tIfThen :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> IfThen -> m IfThen
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IfThen -> m IfThen
gmapMp :: (forall d. Data d => d -> m d) -> IfThen -> m IfThen
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IfThen -> m IfThen
gmapM :: (forall d. Data d => d -> m d) -> IfThen -> m IfThen
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IfThen -> m IfThen
gmapQi :: Int -> (forall d. Data d => d -> u) -> IfThen -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IfThen -> u
gmapQ :: (forall d. Data d => d -> u) -> IfThen -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IfThen -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IfThen -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IfThen -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IfThen -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IfThen -> r
gmapT :: (forall b. Data b => b -> b) -> IfThen -> IfThen
$cgmapT :: (forall b. Data b => b -> b) -> IfThen -> IfThen
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IfThen)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IfThen)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c IfThen)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IfThen)
dataTypeOf :: IfThen -> DataType
$cdataTypeOf :: IfThen -> DataType
toConstr :: IfThen -> Constr
$ctoConstr :: IfThen -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IfThen
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IfThen
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IfThen -> c IfThen
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IfThen -> c IfThen
$cp1Data :: Typeable IfThen
Data, (forall x. IfThen -> Rep IfThen x)
-> (forall x. Rep IfThen x -> IfThen) -> Generic IfThen
forall x. Rep IfThen x -> IfThen
forall x. IfThen -> Rep IfThen x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep IfThen x -> IfThen
$cfrom :: forall x. IfThen -> Rep IfThen x
Generic )

data Condition
    = Condition
      { Condition -> [Text]
isType          :: [Text]
      , Condition -> [Text]
isSet           :: [Text]
      , Condition -> [Text]
isNumeric       :: [Text]
      , Condition -> [Text]
isUncertainDate :: [Text]
      , Condition -> [Text]
isPosition      :: [Text]
      , Condition -> [Text]
disambiguation  :: [Text]
      , Condition -> [Text]
isLocator       :: [Text]
      } deriving ( Condition -> Condition -> Bool
(Condition -> Condition -> Bool)
-> (Condition -> Condition -> Bool) -> Eq Condition
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Condition -> Condition -> Bool
$c/= :: Condition -> Condition -> Bool
== :: Condition -> Condition -> Bool
$c== :: Condition -> Condition -> Bool
Eq, Int -> Condition -> ShowS
[Condition] -> ShowS
Condition -> [Char]
(Int -> Condition -> ShowS)
-> (Condition -> [Char])
-> ([Condition] -> ShowS)
-> Show Condition
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Condition] -> ShowS
$cshowList :: [Condition] -> ShowS
show :: Condition -> [Char]
$cshow :: Condition -> [Char]
showsPrec :: Int -> Condition -> ShowS
$cshowsPrec :: Int -> Condition -> ShowS
Show, ReadPrec [Condition]
ReadPrec Condition
Int -> ReadS Condition
ReadS [Condition]
(Int -> ReadS Condition)
-> ReadS [Condition]
-> ReadPrec Condition
-> ReadPrec [Condition]
-> Read Condition
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Condition]
$creadListPrec :: ReadPrec [Condition]
readPrec :: ReadPrec Condition
$creadPrec :: ReadPrec Condition
readList :: ReadS [Condition]
$creadList :: ReadS [Condition]
readsPrec :: Int -> ReadS Condition
$creadsPrec :: Int -> ReadS Condition
Read, Typeable, Typeable Condition
Constr
DataType
Typeable Condition =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Condition -> c Condition)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Condition)
-> (Condition -> Constr)
-> (Condition -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Condition))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition))
-> ((forall b. Data b => b -> b) -> Condition -> Condition)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Condition -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Condition -> r)
-> (forall u. (forall d. Data d => d -> u) -> Condition -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Condition -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Condition -> m Condition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Condition -> m Condition)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Condition -> m Condition)
-> Data Condition
Condition -> Constr
Condition -> DataType
(forall b. Data b => b -> b) -> Condition -> Condition
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
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) -> Condition -> u
forall u. (forall d. Data d => d -> u) -> Condition -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Condition)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition)
$cCondition :: Constr
$tCondition :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Condition -> m Condition
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
gmapMp :: (forall d. Data d => d -> m d) -> Condition -> m Condition
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
gmapM :: (forall d. Data d => d -> m d) -> Condition -> m Condition
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Condition -> m Condition
gmapQi :: Int -> (forall d. Data d => d -> u) -> Condition -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Condition -> u
gmapQ :: (forall d. Data d => d -> u) -> Condition -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Condition -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Condition -> r
gmapT :: (forall b. Data b => b -> b) -> Condition -> Condition
$cgmapT :: (forall b. Data b => b -> b) -> Condition -> Condition
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Condition)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Condition)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Condition)
dataTypeOf :: Condition -> DataType
$cdataTypeOf :: Condition -> DataType
toConstr :: Condition -> Constr
$ctoConstr :: Condition -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Condition
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Condition -> c Condition
$cp1Data :: Typeable Condition
Data, (forall x. Condition -> Rep Condition x)
-> (forall x. Rep Condition x -> Condition) -> Generic Condition
forall x. Rep Condition x -> Condition
forall x. Condition -> Rep Condition x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Condition x -> Condition
$cfrom :: forall x. Condition -> Rep Condition x
Generic )

type Delimiter = Text

data Match
    = Any
    | All
    | None
      deriving ( Int -> Match -> ShowS
[Match] -> ShowS
Match -> [Char]
(Int -> Match -> ShowS)
-> (Match -> [Char]) -> ([Match] -> ShowS) -> Show Match
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Match] -> ShowS
$cshowList :: [Match] -> ShowS
show :: Match -> [Char]
$cshow :: Match -> [Char]
showsPrec :: Int -> Match -> ShowS
$cshowsPrec :: Int -> Match -> ShowS
Show, ReadPrec [Match]
ReadPrec Match
Int -> ReadS Match
ReadS [Match]
(Int -> ReadS Match)
-> ReadS [Match]
-> ReadPrec Match
-> ReadPrec [Match]
-> Read Match
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Match]
$creadListPrec :: ReadPrec [Match]
readPrec :: ReadPrec Match
$creadPrec :: ReadPrec Match
readList :: ReadS [Match]
$creadList :: ReadS [Match]
readsPrec :: Int -> ReadS Match
$creadsPrec :: Int -> ReadS Match
Read, Match -> Match -> Bool
(Match -> Match -> Bool) -> (Match -> Match -> Bool) -> Eq Match
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Match -> Match -> Bool
$c/= :: Match -> Match -> Bool
== :: Match -> Match -> Bool
$c== :: Match -> Match -> Bool
Eq, Typeable, Typeable Match
Constr
DataType
Typeable Match =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Match -> c Match)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Match)
-> (Match -> Constr)
-> (Match -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Match))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match))
-> ((forall b. Data b => b -> b) -> Match -> Match)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r)
-> (forall u. (forall d. Data d => d -> u) -> Match -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Match -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Match -> m Match)
-> Data Match
Match -> Constr
Match -> DataType
(forall b. Data b => b -> b) -> Match -> Match
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
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) -> Match -> u
forall u. (forall d. Data d => d -> u) -> Match -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cNone :: Constr
$cAll :: Constr
$cAny :: Constr
$tMatch :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapMp :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapM :: (forall d. Data d => d -> m d) -> Match -> m Match
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Match -> m Match
gmapQi :: Int -> (forall d. Data d => d -> u) -> Match -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Match -> u
gmapQ :: (forall d. Data d => d -> u) -> Match -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Match -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Match -> r
gmapT :: (forall b. Data b => b -> b) -> Match -> Match
$cgmapT :: (forall b. Data b => b -> b) -> Match -> Match
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Match)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Match)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Match)
dataTypeOf :: Match -> DataType
$cdataTypeOf :: Match -> DataType
toConstr :: Match -> Constr
$ctoConstr :: Match -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Match
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Match -> c Match
$cp1Data :: Typeable Match
Data, (forall x. Match -> Rep Match x)
-> (forall x. Rep Match x -> Match) -> Generic Match
forall x. Rep Match x -> Match
forall x. Match -> Rep Match x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Match x -> Match
$cfrom :: forall x. Match -> Rep Match x
Generic )

match :: Match -> [Bool] -> Bool
match :: Match -> [Bool] -> Bool
match All  = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
and
match Any  = [Bool] -> Bool
forall (t :: * -> *). Foldable t => t Bool -> Bool
or
match None = (Bool -> Bool) -> [Bool] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Bool -> Bool
not

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

defaultDate :: [DatePart]
defaultDate :: [DatePart]
defaultDate
    = [ Text -> Text -> Text -> Formatting -> DatePart
DatePart "year"  "" "-" Formatting
emptyFormatting
      , Text -> Text -> Text -> Formatting -> DatePart
DatePart "month" "" "-" Formatting
emptyFormatting
      , Text -> Text -> Text -> Formatting -> DatePart
DatePart "day"   "" "-" Formatting
emptyFormatting]

data Sort
    = SortVariable Text Sorting
    | SortMacro    Text Sorting Int Int Text
      deriving ( Sort -> Sort -> Bool
(Sort -> Sort -> Bool) -> (Sort -> Sort -> Bool) -> Eq Sort
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Sort -> Sort -> Bool
$c/= :: Sort -> Sort -> Bool
== :: Sort -> Sort -> Bool
$c== :: Sort -> Sort -> Bool
Eq, Int -> Sort -> ShowS
[Sort] -> ShowS
Sort -> [Char]
(Int -> Sort -> ShowS)
-> (Sort -> [Char]) -> ([Sort] -> ShowS) -> Show Sort
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Sort] -> ShowS
$cshowList :: [Sort] -> ShowS
show :: Sort -> [Char]
$cshow :: Sort -> [Char]
showsPrec :: Int -> Sort -> ShowS
$cshowsPrec :: Int -> Sort -> ShowS
Show, ReadPrec [Sort]
ReadPrec Sort
Int -> ReadS Sort
ReadS [Sort]
(Int -> ReadS Sort)
-> ReadS [Sort] -> ReadPrec Sort -> ReadPrec [Sort] -> Read Sort
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Sort]
$creadListPrec :: ReadPrec [Sort]
readPrec :: ReadPrec Sort
$creadPrec :: ReadPrec Sort
readList :: ReadS [Sort]
$creadList :: ReadS [Sort]
readsPrec :: Int -> ReadS Sort
$creadsPrec :: Int -> ReadS Sort
Read, Typeable, Typeable Sort
Constr
DataType
Typeable Sort =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Sort -> c Sort)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Sort)
-> (Sort -> Constr)
-> (Sort -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Sort))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort))
-> ((forall b. Data b => b -> b) -> Sort -> Sort)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r)
-> (forall u. (forall d. Data d => d -> u) -> Sort -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Sort -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Sort -> m Sort)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sort -> m Sort)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Sort -> m Sort)
-> Data Sort
Sort -> Constr
Sort -> DataType
(forall b. Data b => b -> b) -> Sort -> Sort
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
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) -> Sort -> u
forall u. (forall d. Data d => d -> u) -> Sort -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sort)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort)
$cSortMacro :: Constr
$cSortVariable :: Constr
$tSort :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Sort -> m Sort
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
gmapMp :: (forall d. Data d => d -> m d) -> Sort -> m Sort
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
gmapM :: (forall d. Data d => d -> m d) -> Sort -> m Sort
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Sort -> m Sort
gmapQi :: Int -> (forall d. Data d => d -> u) -> Sort -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Sort -> u
gmapQ :: (forall d. Data d => d -> u) -> Sort -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Sort -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Sort -> r
gmapT :: (forall b. Data b => b -> b) -> Sort -> Sort
$cgmapT :: (forall b. Data b => b -> b) -> Sort -> Sort
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Sort)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Sort)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Sort)
dataTypeOf :: Sort -> DataType
$cdataTypeOf :: Sort -> DataType
toConstr :: Sort -> Constr
$ctoConstr :: Sort -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Sort
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Sort -> c Sort
$cp1Data :: Typeable Sort
Data, (forall x. Sort -> Rep Sort x)
-> (forall x. Rep Sort x -> Sort) -> Generic Sort
forall x. Rep Sort x -> Sort
forall x. Sort -> Rep Sort x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Sort x -> Sort
$cfrom :: forall x. Sort -> Rep Sort x
Generic )

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

instance Ord Sorting where
    compare :: Sorting -> Sorting -> Ordering
compare (Ascending  "") (Ascending  "") = Ordering
EQ
    compare (Ascending  "") (Ascending   _) = Ordering
GT
    compare (Ascending   _) (Ascending  "") = Ordering
LT
    compare (Ascending   a :: Text
a) (Ascending   b :: Text
b) = Text -> Text -> Ordering
compare' Text
a Text
b
    compare (Descending "") (Descending "") = Ordering
EQ
    compare (Descending "") (Descending  _) = Ordering
GT
    compare (Descending  _) (Descending "") = Ordering
LT
    compare (Descending  a :: Text
a) (Descending  b :: Text
b) = Text -> Text -> Ordering
compare' Text
b Text
a
    compare              _               _  = Ordering
EQ

compare' :: Text -> Text -> Ordering
compare' :: Text -> Text -> Ordering
compare' x' :: Text
x' y' :: Text
y'
    = case ([Char]
x, [Char]
y) of
        ('-':_,'-':_) -> [Char] -> [Char] -> Ordering
comp (ShowS
normalize [Char]
y) (ShowS
normalize [Char]
x)
        ('-':_, _ )   -> Ordering
LT
        (_  ,'-':_)   -> Ordering
GT
        _             -> [Char] -> [Char] -> Ordering
comp (ShowS
normalize [Char]
x) (ShowS
normalize [Char]
y)
      where
        -- FIXME: to Text
        x :: [Char]
x = Text -> [Char]
T.unpack Text
x'
        y :: [Char]
y = Text -> [Char]
T.unpack Text
y'
        -- we zero pad numbers so they're sorted numerically, see #399
        zeropad :: ShowS
zeropad [] = []
        zeropad xs :: [Char]
xs = if (Char -> Bool) -> [Char] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit [Char]
xs
                        then Int -> Char -> [Char]
forall a. Int -> a -> [a]
replicate (10 Int -> Int -> Int
forall a. Num a => a -> a -> a
- [Char] -> Int
forall (t :: * -> *) a. Foldable t => t a -> Int
length [Char]
xs) '0' [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
xs
                        else [Char]
xs
        normalize :: ShowS
normalize = ShowS
zeropad ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map (\c :: Char
c -> if Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== ',' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '.' then ' ' else Char
c) ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    (Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
filter (\c :: Char
c -> Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== ',' Bool -> Bool -> Bool
||
                                  Bool -> Bool
not (Char -> Bool
isPunctuation Char
c Bool -> Bool -> Bool
|| Char -> Bool
Char.isSpace Char
c
                                      -- ayn/hamza in transliterated arabic:
                                       Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== 'ʾ' Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== 'ʿ'
                                       ))
#ifdef UNICODE_COLLATION
        comp a b = T.collate (T.collator T.Current) (T.pack a) (T.pack b)
#else
        comp :: [Char] -> [Char] -> Ordering
comp a :: [Char]
a b :: [Char]
b = [Char] -> [Char] -> Ordering
compareUnicode ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
a) ((Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower [Char]
b)
#endif

data Form
    = Long
    | Short
    | Count
    | Verb
    | VerbShort
    | Symbol
    | NotSet
      deriving ( Form -> Form -> Bool
(Form -> Form -> Bool) -> (Form -> Form -> Bool) -> Eq Form
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Form -> Form -> Bool
$c/= :: Form -> Form -> Bool
== :: Form -> Form -> Bool
$c== :: Form -> Form -> Bool
Eq, Int -> Form -> ShowS
[Form] -> ShowS
Form -> [Char]
(Int -> Form -> ShowS)
-> (Form -> [Char]) -> ([Form] -> ShowS) -> Show Form
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Form] -> ShowS
$cshowList :: [Form] -> ShowS
show :: Form -> [Char]
$cshow :: Form -> [Char]
showsPrec :: Int -> Form -> ShowS
$cshowsPrec :: Int -> Form -> ShowS
Show, ReadPrec [Form]
ReadPrec Form
Int -> ReadS Form
ReadS [Form]
(Int -> ReadS Form)
-> ReadS [Form] -> ReadPrec Form -> ReadPrec [Form] -> Read Form
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Form]
$creadListPrec :: ReadPrec [Form]
readPrec :: ReadPrec Form
$creadPrec :: ReadPrec Form
readList :: ReadS [Form]
$creadList :: ReadS [Form]
readsPrec :: Int -> ReadS Form
$creadsPrec :: Int -> ReadS Form
Read, Typeable, Typeable Form
Constr
DataType
Typeable Form =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Form -> c Form)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Form)
-> (Form -> Constr)
-> (Form -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Form))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Form))
-> ((forall b. Data b => b -> b) -> Form -> Form)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r)
-> (forall u. (forall d. Data d => d -> u) -> Form -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Form -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Form -> m Form)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Form -> m Form)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Form -> m Form)
-> Data Form
Form -> Constr
Form -> DataType
(forall b. Data b => b -> b) -> Form -> Form
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Form -> c Form
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Form
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) -> Form -> u
forall u. (forall d. Data d => d -> u) -> Form -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Form -> m Form
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Form -> m Form
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Form
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Form -> c Form
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Form)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Form)
$cNotSet :: Constr
$cSymbol :: Constr
$cVerbShort :: Constr
$cVerb :: Constr
$cCount :: Constr
$cShort :: Constr
$cLong :: Constr
$tForm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Form -> m Form
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Form -> m Form
gmapMp :: (forall d. Data d => d -> m d) -> Form -> m Form
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Form -> m Form
gmapM :: (forall d. Data d => d -> m d) -> Form -> m Form
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Form -> m Form
gmapQi :: Int -> (forall d. Data d => d -> u) -> Form -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Form -> u
gmapQ :: (forall d. Data d => d -> u) -> Form -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Form -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Form -> r
gmapT :: (forall b. Data b => b -> b) -> Form -> Form
$cgmapT :: (forall b. Data b => b -> b) -> Form -> Form
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Form)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Form)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Form)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Form)
dataTypeOf :: Form -> DataType
$cdataTypeOf :: Form -> DataType
toConstr :: Form -> Constr
$ctoConstr :: Form -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Form
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Form
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Form -> c Form
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Form -> c Form
$cp1Data :: Typeable Form
Data, (forall x. Form -> Rep Form x)
-> (forall x. Rep Form x -> Form) -> Generic Form
forall x. Rep Form x -> Form
forall x. Form -> Rep Form x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Form x -> Form
$cfrom :: forall x. Form -> Rep Form x
Generic )

data Gender
    = Feminine
    | Masculine
    | Neuter
      deriving ( Gender -> Gender -> Bool
(Gender -> Gender -> Bool)
-> (Gender -> Gender -> Bool) -> Eq Gender
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Gender -> Gender -> Bool
$c/= :: Gender -> Gender -> Bool
== :: Gender -> Gender -> Bool
$c== :: Gender -> Gender -> Bool
Eq, Int -> Gender -> ShowS
[Gender] -> ShowS
Gender -> [Char]
(Int -> Gender -> ShowS)
-> (Gender -> [Char]) -> ([Gender] -> ShowS) -> Show Gender
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Gender] -> ShowS
$cshowList :: [Gender] -> ShowS
show :: Gender -> [Char]
$cshow :: Gender -> [Char]
showsPrec :: Int -> Gender -> ShowS
$cshowsPrec :: Int -> Gender -> ShowS
Show, ReadPrec [Gender]
ReadPrec Gender
Int -> ReadS Gender
ReadS [Gender]
(Int -> ReadS Gender)
-> ReadS [Gender]
-> ReadPrec Gender
-> ReadPrec [Gender]
-> Read Gender
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Gender]
$creadListPrec :: ReadPrec [Gender]
readPrec :: ReadPrec Gender
$creadPrec :: ReadPrec Gender
readList :: ReadS [Gender]
$creadList :: ReadS [Gender]
readsPrec :: Int -> ReadS Gender
$creadsPrec :: Int -> ReadS Gender
Read, Typeable, Typeable Gender
Constr
DataType
Typeable Gender =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Gender -> c Gender)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Gender)
-> (Gender -> Constr)
-> (Gender -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Gender))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender))
-> ((forall b. Data b => b -> b) -> Gender -> Gender)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Gender -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Gender -> r)
-> (forall u. (forall d. Data d => d -> u) -> Gender -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Gender -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Gender -> m Gender)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Gender -> m Gender)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Gender -> m Gender)
-> Data Gender
Gender -> Constr
Gender -> DataType
(forall b. Data b => b -> b) -> Gender -> Gender
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
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) -> Gender -> u
forall u. (forall d. Data d => d -> u) -> Gender -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Gender)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender)
$cNeuter :: Constr
$cMasculine :: Constr
$cFeminine :: Constr
$tGender :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Gender -> m Gender
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
gmapMp :: (forall d. Data d => d -> m d) -> Gender -> m Gender
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
gmapM :: (forall d. Data d => d -> m d) -> Gender -> m Gender
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Gender -> m Gender
gmapQi :: Int -> (forall d. Data d => d -> u) -> Gender -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Gender -> u
gmapQ :: (forall d. Data d => d -> u) -> Gender -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Gender -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Gender -> r
gmapT :: (forall b. Data b => b -> b) -> Gender -> Gender
$cgmapT :: (forall b. Data b => b -> b) -> Gender -> Gender
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Gender)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Gender)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Gender)
dataTypeOf :: Gender -> DataType
$cdataTypeOf :: Gender -> DataType
toConstr :: Gender -> Constr
$ctoConstr :: Gender -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Gender
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Gender -> c Gender
$cp1Data :: Typeable Gender
Data, (forall x. Gender -> Rep Gender x)
-> (forall x. Rep Gender x -> Gender) -> Generic Gender
forall x. Rep Gender x -> Gender
forall x. Gender -> Rep Gender x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Gender x -> Gender
$cfrom :: forall x. Gender -> Rep Gender x
Generic )

data NumericForm
    = Numeric
    | Ordinal
    | Roman
    | LongOrdinal
      deriving ( NumericForm -> NumericForm -> Bool
(NumericForm -> NumericForm -> Bool)
-> (NumericForm -> NumericForm -> Bool) -> Eq NumericForm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NumericForm -> NumericForm -> Bool
$c/= :: NumericForm -> NumericForm -> Bool
== :: NumericForm -> NumericForm -> Bool
$c== :: NumericForm -> NumericForm -> Bool
Eq, Int -> NumericForm -> ShowS
[NumericForm] -> ShowS
NumericForm -> [Char]
(Int -> NumericForm -> ShowS)
-> (NumericForm -> [Char])
-> ([NumericForm] -> ShowS)
-> Show NumericForm
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [NumericForm] -> ShowS
$cshowList :: [NumericForm] -> ShowS
show :: NumericForm -> [Char]
$cshow :: NumericForm -> [Char]
showsPrec :: Int -> NumericForm -> ShowS
$cshowsPrec :: Int -> NumericForm -> ShowS
Show, ReadPrec [NumericForm]
ReadPrec NumericForm
Int -> ReadS NumericForm
ReadS [NumericForm]
(Int -> ReadS NumericForm)
-> ReadS [NumericForm]
-> ReadPrec NumericForm
-> ReadPrec [NumericForm]
-> Read NumericForm
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NumericForm]
$creadListPrec :: ReadPrec [NumericForm]
readPrec :: ReadPrec NumericForm
$creadPrec :: ReadPrec NumericForm
readList :: ReadS [NumericForm]
$creadList :: ReadS [NumericForm]
readsPrec :: Int -> ReadS NumericForm
$creadsPrec :: Int -> ReadS NumericForm
Read, Typeable, Typeable NumericForm
Constr
DataType
Typeable NumericForm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NumericForm -> c NumericForm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NumericForm)
-> (NumericForm -> Constr)
-> (NumericForm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NumericForm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NumericForm))
-> ((forall b. Data b => b -> b) -> NumericForm -> NumericForm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NumericForm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NumericForm -> r)
-> (forall u. (forall d. Data d => d -> u) -> NumericForm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NumericForm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NumericForm -> m NumericForm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumericForm -> m NumericForm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NumericForm -> m NumericForm)
-> Data NumericForm
NumericForm -> Constr
NumericForm -> DataType
(forall b. Data b => b -> b) -> NumericForm -> NumericForm
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumericForm -> c NumericForm
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumericForm
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) -> NumericForm -> u
forall u. (forall d. Data d => d -> u) -> NumericForm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumericForm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumericForm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumericForm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumericForm -> c NumericForm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NumericForm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NumericForm)
$cLongOrdinal :: Constr
$cRoman :: Constr
$cOrdinal :: Constr
$cNumeric :: Constr
$tNumericForm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
gmapMp :: (forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
gmapM :: (forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NumericForm -> m NumericForm
gmapQi :: Int -> (forall d. Data d => d -> u) -> NumericForm -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NumericForm -> u
gmapQ :: (forall d. Data d => d -> u) -> NumericForm -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NumericForm -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumericForm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NumericForm -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumericForm -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NumericForm -> r
gmapT :: (forall b. Data b => b -> b) -> NumericForm -> NumericForm
$cgmapT :: (forall b. Data b => b -> b) -> NumericForm -> NumericForm
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NumericForm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NumericForm)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NumericForm)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NumericForm)
dataTypeOf :: NumericForm -> DataType
$cdataTypeOf :: NumericForm -> DataType
toConstr :: NumericForm -> Constr
$ctoConstr :: NumericForm -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumericForm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NumericForm
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumericForm -> c NumericForm
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NumericForm -> c NumericForm
$cp1Data :: Typeable NumericForm
Data, (forall x. NumericForm -> Rep NumericForm x)
-> (forall x. Rep NumericForm x -> NumericForm)
-> Generic NumericForm
forall x. Rep NumericForm x -> NumericForm
forall x. NumericForm -> Rep NumericForm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NumericForm x -> NumericForm
$cfrom :: forall x. NumericForm -> Rep NumericForm x
Generic )

data DateForm
    = TextDate
    | NumericDate
    | NoFormDate
      deriving ( DateForm -> DateForm -> Bool
(DateForm -> DateForm -> Bool)
-> (DateForm -> DateForm -> Bool) -> Eq DateForm
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DateForm -> DateForm -> Bool
$c/= :: DateForm -> DateForm -> Bool
== :: DateForm -> DateForm -> Bool
$c== :: DateForm -> DateForm -> Bool
Eq, Int -> DateForm -> ShowS
[DateForm] -> ShowS
DateForm -> [Char]
(Int -> DateForm -> ShowS)
-> (DateForm -> [Char]) -> ([DateForm] -> ShowS) -> Show DateForm
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [DateForm] -> ShowS
$cshowList :: [DateForm] -> ShowS
show :: DateForm -> [Char]
$cshow :: DateForm -> [Char]
showsPrec :: Int -> DateForm -> ShowS
$cshowsPrec :: Int -> DateForm -> ShowS
Show, ReadPrec [DateForm]
ReadPrec DateForm
Int -> ReadS DateForm
ReadS [DateForm]
(Int -> ReadS DateForm)
-> ReadS [DateForm]
-> ReadPrec DateForm
-> ReadPrec [DateForm]
-> Read DateForm
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [DateForm]
$creadListPrec :: ReadPrec [DateForm]
readPrec :: ReadPrec DateForm
$creadPrec :: ReadPrec DateForm
readList :: ReadS [DateForm]
$creadList :: ReadS [DateForm]
readsPrec :: Int -> ReadS DateForm
$creadsPrec :: Int -> ReadS DateForm
Read, Typeable, Typeable DateForm
Constr
DataType
Typeable DateForm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DateForm -> c DateForm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DateForm)
-> (DateForm -> Constr)
-> (DateForm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DateForm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateForm))
-> ((forall b. Data b => b -> b) -> DateForm -> DateForm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DateForm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DateForm -> r)
-> (forall u. (forall d. Data d => d -> u) -> DateForm -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DateForm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DateForm -> m DateForm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateForm -> m DateForm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DateForm -> m DateForm)
-> Data DateForm
DateForm -> Constr
DateForm -> DataType
(forall b. Data b => b -> b) -> DateForm -> DateForm
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DateForm -> c DateForm
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DateForm
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) -> DateForm -> u
forall u. (forall d. Data d => d -> u) -> DateForm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DateForm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DateForm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DateForm -> m DateForm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DateForm -> m DateForm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DateForm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DateForm -> c DateForm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DateForm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateForm)
$cNoFormDate :: Constr
$cNumericDate :: Constr
$cTextDate :: Constr
$tDateForm :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> DateForm -> m DateForm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DateForm -> m DateForm
gmapMp :: (forall d. Data d => d -> m d) -> DateForm -> m DateForm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DateForm -> m DateForm
gmapM :: (forall d. Data d => d -> m d) -> DateForm -> m DateForm
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DateForm -> m DateForm
gmapQi :: Int -> (forall d. Data d => d -> u) -> DateForm -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DateForm -> u
gmapQ :: (forall d. Data d => d -> u) -> DateForm -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DateForm -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DateForm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DateForm -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DateForm -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DateForm -> r
gmapT :: (forall b. Data b => b -> b) -> DateForm -> DateForm
$cgmapT :: (forall b. Data b => b -> b) -> DateForm -> DateForm
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateForm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DateForm)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c DateForm)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DateForm)
dataTypeOf :: DateForm -> DataType
$cdataTypeOf :: DateForm -> DataType
toConstr :: DateForm -> Constr
$ctoConstr :: DateForm -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DateForm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DateForm
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DateForm -> c DateForm
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DateForm -> c DateForm
$cp1Data :: Typeable DateForm
Data, (forall x. DateForm -> Rep DateForm x)
-> (forall x. Rep DateForm x -> DateForm) -> Generic DateForm
forall x. Rep DateForm x -> DateForm
forall x. DateForm -> Rep DateForm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep DateForm x -> DateForm
$cfrom :: forall x. DateForm -> Rep DateForm x
Generic )

data Plural
    = Contextual
    | Always
    | Never
      deriving ( Plural -> Plural -> Bool
(Plural -> Plural -> Bool)
-> (Plural -> Plural -> Bool) -> Eq Plural
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Plural -> Plural -> Bool
$c/= :: Plural -> Plural -> Bool
== :: Plural -> Plural -> Bool
$c== :: Plural -> Plural -> Bool
Eq, Int -> Plural -> ShowS
[Plural] -> ShowS
Plural -> [Char]
(Int -> Plural -> ShowS)
-> (Plural -> [Char]) -> ([Plural] -> ShowS) -> Show Plural
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Plural] -> ShowS
$cshowList :: [Plural] -> ShowS
show :: Plural -> [Char]
$cshow :: Plural -> [Char]
showsPrec :: Int -> Plural -> ShowS
$cshowsPrec :: Int -> Plural -> ShowS
Show, ReadPrec [Plural]
ReadPrec Plural
Int -> ReadS Plural
ReadS [Plural]
(Int -> ReadS Plural)
-> ReadS [Plural]
-> ReadPrec Plural
-> ReadPrec [Plural]
-> Read Plural
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Plural]
$creadListPrec :: ReadPrec [Plural]
readPrec :: ReadPrec Plural
$creadPrec :: ReadPrec Plural
readList :: ReadS [Plural]
$creadList :: ReadS [Plural]
readsPrec :: Int -> ReadS Plural
$creadsPrec :: Int -> ReadS Plural
Read, Typeable, Typeable Plural
Constr
DataType
Typeable Plural =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Plural -> c Plural)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Plural)
-> (Plural -> Constr)
-> (Plural -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Plural))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Plural))
-> ((forall b. Data b => b -> b) -> Plural -> Plural)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Plural -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Plural -> r)
-> (forall u. (forall d. Data d => d -> u) -> Plural -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Plural -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Plural -> m Plural)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Plural -> m Plural)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Plural -> m Plural)
-> Data Plural
Plural -> Constr
Plural -> DataType
(forall b. Data b => b -> b) -> Plural -> Plural
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Plural -> c Plural
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Plural
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) -> Plural -> u
forall u. (forall d. Data d => d -> u) -> Plural -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Plural -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Plural -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Plural -> m Plural
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Plural -> m Plural
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Plural
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Plural -> c Plural
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Plural)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Plural)
$cNever :: Constr
$cAlways :: Constr
$cContextual :: Constr
$tPlural :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Plural -> m Plural
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Plural -> m Plural
gmapMp :: (forall d. Data d => d -> m d) -> Plural -> m Plural
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Plural -> m Plural
gmapM :: (forall d. Data d => d -> m d) -> Plural -> m Plural
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Plural -> m Plural
gmapQi :: Int -> (forall d. Data d => d -> u) -> Plural -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Plural -> u
gmapQ :: (forall d. Data d => d -> u) -> Plural -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Plural -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Plural -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Plural -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Plural -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Plural -> r
gmapT :: (forall b. Data b => b -> b) -> Plural -> Plural
$cgmapT :: (forall b. Data b => b -> b) -> Plural -> Plural
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Plural)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Plural)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Plural)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Plural)
dataTypeOf :: Plural -> DataType
$cdataTypeOf :: Plural -> DataType
toConstr :: Plural -> Constr
$ctoConstr :: Plural -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Plural
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Plural
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Plural -> c Plural
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Plural -> c Plural
$cp1Data :: Typeable Plural
Data, (forall x. Plural -> Rep Plural x)
-> (forall x. Rep Plural x -> Plural) -> Generic Plural
forall x. Rep Plural x -> Plural
forall x. Plural -> Rep Plural x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Plural x -> Plural
$cfrom :: forall x. Plural -> Rep Plural x
Generic )

data Name
    = Name      Form Formatting NameAttrs Delimiter [NamePart]
    | NameLabel Form Formatting Plural
    | EtAl           Formatting Text
      deriving ( Name -> Name -> Bool
(Name -> Name -> Bool) -> (Name -> Name -> Bool) -> Eq Name
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Name -> Name -> Bool
$c/= :: Name -> Name -> Bool
== :: Name -> Name -> Bool
$c== :: Name -> Name -> Bool
Eq, Int -> Name -> ShowS
[Name] -> ShowS
Name -> [Char]
(Int -> Name -> ShowS)
-> (Name -> [Char]) -> ([Name] -> ShowS) -> Show Name
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Name] -> ShowS
$cshowList :: [Name] -> ShowS
show :: Name -> [Char]
$cshow :: Name -> [Char]
showsPrec :: Int -> Name -> ShowS
$cshowsPrec :: Int -> Name -> ShowS
Show, ReadPrec [Name]
ReadPrec Name
Int -> ReadS Name
ReadS [Name]
(Int -> ReadS Name)
-> ReadS [Name] -> ReadPrec Name -> ReadPrec [Name] -> Read Name
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Name]
$creadListPrec :: ReadPrec [Name]
readPrec :: ReadPrec Name
$creadPrec :: ReadPrec Name
readList :: ReadS [Name]
$creadList :: ReadS [Name]
readsPrec :: Int -> ReadS Name
$creadsPrec :: Int -> ReadS Name
Read, Typeable, Typeable Name
Constr
DataType
Typeable Name =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Name -> c Name)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Name)
-> (Name -> Constr)
-> (Name -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Name))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name))
-> ((forall b. Data b => b -> b) -> Name -> Name)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r)
-> (forall u. (forall d. Data d => d -> u) -> Name -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Name -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Name -> m Name)
-> Data Name
Name -> Constr
Name -> DataType
(forall b. Data b => b -> b) -> Name -> Name
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
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) -> Name -> u
forall u. (forall d. Data d => d -> u) -> Name -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cEtAl :: Constr
$cNameLabel :: Constr
$cName :: Constr
$tName :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapMp :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapM :: (forall d. Data d => d -> m d) -> Name -> m Name
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Name -> m Name
gmapQi :: Int -> (forall d. Data d => d -> u) -> Name -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Name -> u
gmapQ :: (forall d. Data d => d -> u) -> Name -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Name -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Name -> r
gmapT :: (forall b. Data b => b -> b) -> Name -> Name
$cgmapT :: (forall b. Data b => b -> b) -> Name -> Name
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Name)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Name)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Name)
dataTypeOf :: Name -> DataType
$cdataTypeOf :: Name -> DataType
toConstr :: Name -> Constr
$ctoConstr :: Name -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Name
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Name -> c Name
$cp1Data :: Typeable Name
Data, (forall x. Name -> Rep Name x)
-> (forall x. Rep Name x -> Name) -> Generic Name
forall x. Rep Name x -> Name
forall x. Name -> Rep Name x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Name x -> Name
$cfrom :: forall x. Name -> Rep Name x
Generic )

type NameAttrs = [(Text, Text)]

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

isPlural :: Plural -> Int -> Bool
isPlural :: Plural -> Int -> Bool
isPlural p :: Plural
p l :: Int
l
    = case Plural
p of
        Always     -> Bool
True
        Never      -> Bool
False
        Contextual -> Int
l Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> 1

isName :: Name -> Bool
isName :: Name -> Bool
isName x :: Name
x = case Name
x of Name {} -> Bool
True; _ -> Bool
False

isNames :: Element -> Bool
isNames :: Element -> Bool
isNames x :: Element
x = case Element
x of Names {} -> Bool
True; _ -> Bool
False

hasEtAl :: [Name] -> Bool
hasEtAl :: [Name] -> Bool
hasEtAl = (Name -> Bool) -> [Name] -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Name -> Bool
isEtAl
    where isEtAl :: Name -> Bool
isEtAl (EtAl _ _) = Bool
True
          isEtAl _          = Bool
False

data Formatting
    = Formatting
      { Formatting -> Text
prefix         :: Text
      , Formatting -> Text
suffix         :: Text
      , Formatting -> Text
fontFamily     :: Text
      , Formatting -> Text
fontStyle      :: Text
      , Formatting -> Text
fontVariant    :: Text
      , Formatting -> Text
fontWeight     :: Text
      , Formatting -> Text
textDecoration :: Text
      , Formatting -> Text
verticalAlign  :: Text
      , Formatting -> Text
textCase       :: Text
      , Formatting -> Text
display        :: Text
      , Formatting -> Quote
quotes         :: Quote
      , Formatting -> Bool
stripPeriods   :: Bool
      , Formatting -> Bool
noCase         :: Bool
      , Formatting -> Bool
noDecor        :: Bool
      , Formatting -> Text
hyperlink      :: Text  -- null for no link
      } deriving ( ReadPrec [Formatting]
ReadPrec Formatting
Int -> ReadS Formatting
ReadS [Formatting]
(Int -> ReadS Formatting)
-> ReadS [Formatting]
-> ReadPrec Formatting
-> ReadPrec [Formatting]
-> Read Formatting
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Formatting]
$creadListPrec :: ReadPrec [Formatting]
readPrec :: ReadPrec Formatting
$creadPrec :: ReadPrec Formatting
readList :: ReadS [Formatting]
$creadList :: ReadS [Formatting]
readsPrec :: Int -> ReadS Formatting
$creadsPrec :: Int -> ReadS Formatting
Read, Formatting -> Formatting -> Bool
(Formatting -> Formatting -> Bool)
-> (Formatting -> Formatting -> Bool) -> Eq Formatting
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Formatting -> Formatting -> Bool
$c/= :: Formatting -> Formatting -> Bool
== :: Formatting -> Formatting -> Bool
$c== :: Formatting -> Formatting -> Bool
Eq, Eq Formatting
Eq Formatting =>
(Formatting -> Formatting -> Ordering)
-> (Formatting -> Formatting -> Bool)
-> (Formatting -> Formatting -> Bool)
-> (Formatting -> Formatting -> Bool)
-> (Formatting -> Formatting -> Bool)
-> (Formatting -> Formatting -> Formatting)
-> (Formatting -> Formatting -> Formatting)
-> Ord Formatting
Formatting -> Formatting -> Bool
Formatting -> Formatting -> Ordering
Formatting -> Formatting -> Formatting
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 :: Formatting -> Formatting -> Formatting
$cmin :: Formatting -> Formatting -> Formatting
max :: Formatting -> Formatting -> Formatting
$cmax :: Formatting -> Formatting -> Formatting
>= :: Formatting -> Formatting -> Bool
$c>= :: Formatting -> Formatting -> Bool
> :: Formatting -> Formatting -> Bool
$c> :: Formatting -> Formatting -> Bool
<= :: Formatting -> Formatting -> Bool
$c<= :: Formatting -> Formatting -> Bool
< :: Formatting -> Formatting -> Bool
$c< :: Formatting -> Formatting -> Bool
compare :: Formatting -> Formatting -> Ordering
$ccompare :: Formatting -> Formatting -> Ordering
$cp1Ord :: Eq Formatting
Ord, Typeable, Typeable Formatting
Constr
DataType
Typeable Formatting =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Formatting -> c Formatting)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Formatting)
-> (Formatting -> Constr)
-> (Formatting -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Formatting))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Formatting))
-> ((forall b. Data b => b -> b) -> Formatting -> Formatting)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Formatting -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Formatting -> r)
-> (forall u. (forall d. Data d => d -> u) -> Formatting -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Formatting -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Formatting -> m Formatting)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formatting -> m Formatting)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Formatting -> m Formatting)
-> Data Formatting
Formatting -> Constr
Formatting -> DataType
(forall b. Data b => b -> b) -> Formatting -> Formatting
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatting -> c Formatting
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatting
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) -> Formatting -> u
forall u. (forall d. Data d => d -> u) -> Formatting -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formatting -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formatting -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formatting -> m Formatting
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formatting -> m Formatting
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatting
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatting -> c Formatting
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formatting)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatting)
$cFormatting :: Constr
$tFormatting :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Formatting -> m Formatting
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formatting -> m Formatting
gmapMp :: (forall d. Data d => d -> m d) -> Formatting -> m Formatting
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Formatting -> m Formatting
gmapM :: (forall d. Data d => d -> m d) -> Formatting -> m Formatting
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Formatting -> m Formatting
gmapQi :: Int -> (forall d. Data d => d -> u) -> Formatting -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Formatting -> u
gmapQ :: (forall d. Data d => d -> u) -> Formatting -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Formatting -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formatting -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Formatting -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formatting -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Formatting -> r
gmapT :: (forall b. Data b => b -> b) -> Formatting -> Formatting
$cgmapT :: (forall b. Data b => b -> b) -> Formatting -> Formatting
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatting)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Formatting)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Formatting)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Formatting)
dataTypeOf :: Formatting -> DataType
$cdataTypeOf :: Formatting -> DataType
toConstr :: Formatting -> Constr
$ctoConstr :: Formatting -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatting
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Formatting
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatting -> c Formatting
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Formatting -> c Formatting
$cp1Data :: Typeable Formatting
Data, (forall x. Formatting -> Rep Formatting x)
-> (forall x. Rep Formatting x -> Formatting) -> Generic Formatting
forall x. Rep Formatting x -> Formatting
forall x. Formatting -> Rep Formatting x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Formatting x -> Formatting
$cfrom :: forall x. Formatting -> Rep Formatting x
Generic )

-- custom instance to make debugging output less busy
instance Show Formatting where
  show :: Formatting -> [Char]
show x :: Formatting
x
    | Formatting
x Formatting -> Formatting -> Bool
forall a. Eq a => a -> a -> Bool
== Formatting
emptyFormatting = "emptyFormatting"
    | Bool
otherwise            = "emptyFormatting{"
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate ", "
           [ [Char]
k [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ " = " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Formatting -> [Char]
f Formatting
x |
             (k :: [Char]
k, f :: Formatting -> [Char]
f) <- [("prefix", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
prefix)
                       ,("suffix", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
suffix)
                       ,("fontFamily", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
fontFamily)
                       ,("fontStyle", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
fontStyle)
                       ,("fontVariant", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
fontVariant)
                       ,("fontWeight", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
fontWeight)
                       ,("textDecoration", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
textDecoration)
                       ,("verticalAlign", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
verticalAlign)
                       ,("textCase", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
textCase)
                       ,("display", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
display)
                       ,("quotes", Quote -> [Char]
forall a. Show a => a -> [Char]
show (Quote -> [Char]) -> (Formatting -> Quote) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Quote
quotes)
                       ,("stripPeriods", Bool -> [Char]
forall a. Show a => a -> [Char]
show (Bool -> [Char]) -> (Formatting -> Bool) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Bool
stripPeriods)
                       ,("noCase", Bool -> [Char]
forall a. Show a => a -> [Char]
show (Bool -> [Char]) -> (Formatting -> Bool) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Bool
noCase)
                       ,("noDecor", Bool -> [Char]
forall a. Show a => a -> [Char]
show (Bool -> [Char]) -> (Formatting -> Bool) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Bool
noDecor)
                       ,("hyperlink", Text -> [Char]
forall a. Show a => a -> [Char]
show (Text -> [Char]) -> (Formatting -> Text) -> Formatting -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatting -> Text
hyperlink)],
             Formatting -> [Char]
f Formatting
x [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
/= Formatting -> [Char]
f Formatting
emptyFormatting ]
        [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ "}"

rmTitleCase :: Formatting -> Formatting
rmTitleCase :: Formatting -> Formatting
rmTitleCase f :: Formatting
f = Formatting
f{ textCase :: Text
textCase = if Formatting -> Text
textCase Formatting
f Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "title" then "" else Formatting -> Text
textCase Formatting
f  }

rmTitleCase' :: Output -> Output
rmTitleCase' :: Output -> Output
rmTitleCase' o :: Output
o =
  case Output
o of
       OStr s :: Text
s f :: Formatting
f    -> Text -> Formatting -> Output
OStr Text
s (Formatting -> Formatting
rmTitleCase Formatting
f)
       Output os :: [Output]
os f :: Formatting
f -> [Output] -> Formatting -> Output
Output [Output]
os (Formatting -> Formatting
rmTitleCase Formatting
f)
       _           -> Output
o

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

emptyFormatting :: Formatting
emptyFormatting :: Formatting
emptyFormatting
    = Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Quote
-> Bool
-> Bool
-> Bool
-> Text
-> Formatting
Formatting "" "" "" "" "" "" "" "" "" "" Quote
NoQuote Bool
False Bool
False Bool
False ""

mergeFM :: Formatting -> Formatting -> Formatting
mergeFM :: Formatting -> Formatting -> Formatting
mergeFM (Formatting aa :: Text
aa ab :: Text
ab ac :: Text
ac ad :: Text
ad ae :: Text
ae af :: Text
af ag :: Text
ag ah :: Text
ah ai :: Text
ai aj :: Text
aj ak :: Quote
ak al :: Bool
al am :: Bool
am an :: Bool
an ahl :: Text
ahl)
        (Formatting ba :: Text
ba bb :: Text
bb bc :: Text
bc bd :: Text
bd be :: Text
be bf :: Text
bf bg :: Text
bg bh :: Text
bh bi :: Text
bi bj :: Text
bj bk :: Quote
bk bl :: Bool
bl bm :: Bool
bm bn :: Bool
bn bhl :: Text
bhl) =
                   Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Text
-> Quote
-> Bool
-> Bool
-> Bool
-> Text
-> Formatting
Formatting (Text
ba Text -> Text -> Text
`orIfEmpty` Text
aa)
                              (Text
bb Text -> Text -> Text
`orIfEmpty` Text
ab)
                              (Text
bc Text -> Text -> Text
`orIfEmpty` Text
ac)
                              (Text
bd Text -> Text -> Text
`orIfEmpty` Text
ad)
                              (Text
be Text -> Text -> Text
`orIfEmpty` Text
ae)
                              (Text
bf Text -> Text -> Text
`orIfEmpty` Text
af)
                              (Text
bg Text -> Text -> Text
`orIfEmpty` Text
ag)
                              (Text
bh Text -> Text -> Text
`orIfEmpty` Text
ah)
                              (Text
bi Text -> Text -> Text
`orIfEmpty` Text
ai)
                              (Text
bj Text -> Text -> Text
`orIfEmpty` Text
aj)
                              (if Quote
bk Quote -> Quote -> Bool
forall a. Eq a => a -> a -> Bool
== Quote
NoQuote then Quote
ak else Quote
bk)
                              (Bool
bl Bool -> Bool -> Bool
|| Bool
al)
                              (Bool
bm Bool -> Bool -> Bool
|| Bool
am)
                              (Bool
bn Bool -> Bool -> Bool
|| Bool
an)
                              (Text
bhl Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
ahl)
 where orIfEmpty :: Text -> Text -> Text
       orIfEmpty :: Text -> Text -> Text
orIfEmpty "" fallback :: Text
fallback = Text
fallback
       orIfEmpty t :: Text
t  _ = Text
t

data CSInfo
    = CSInfo
      { CSInfo -> Text
csiTitle      :: Text
      , CSInfo -> CSAuthor
csiAuthor     :: CSAuthor
      , CSInfo -> [CSCategory]
csiCategories :: [CSCategory]
      , CSInfo -> Text
csiId         :: Text
      , CSInfo -> Text
csiUpdated    :: Text
      } deriving ( Int -> CSInfo -> ShowS
[CSInfo] -> ShowS
CSInfo -> [Char]
(Int -> CSInfo -> ShowS)
-> (CSInfo -> [Char]) -> ([CSInfo] -> ShowS) -> Show CSInfo
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [CSInfo] -> ShowS
$cshowList :: [CSInfo] -> ShowS
show :: CSInfo -> [Char]
$cshow :: CSInfo -> [Char]
showsPrec :: Int -> CSInfo -> ShowS
$cshowsPrec :: Int -> CSInfo -> ShowS
Show, ReadPrec [CSInfo]
ReadPrec CSInfo
Int -> ReadS CSInfo
ReadS [CSInfo]
(Int -> ReadS CSInfo)
-> ReadS [CSInfo]
-> ReadPrec CSInfo
-> ReadPrec [CSInfo]
-> Read CSInfo
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [CSInfo]
$creadListPrec :: ReadPrec [CSInfo]
readPrec :: ReadPrec CSInfo
$creadPrec :: ReadPrec CSInfo
readList :: ReadS [CSInfo]
$creadList :: ReadS [CSInfo]
readsPrec :: Int -> ReadS CSInfo
$creadsPrec :: Int -> ReadS CSInfo
Read, Typeable, Typeable CSInfo
Constr
DataType
Typeable CSInfo =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CSInfo -> c CSInfo)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CSInfo)
-> (CSInfo -> Constr)
-> (CSInfo -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CSInfo))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSInfo))
-> ((forall b. Data b => b -> b) -> CSInfo -> CSInfo)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CSInfo -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CSInfo -> r)
-> (forall u. (forall d. Data d => d -> u) -> CSInfo -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CSInfo -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CSInfo -> m CSInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CSInfo -> m CSInfo)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CSInfo -> m CSInfo)
-> Data CSInfo
CSInfo -> Constr
CSInfo -> DataType
(forall b. Data b => b -> b) -> CSInfo -> CSInfo
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSInfo -> c CSInfo
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSInfo
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) -> CSInfo -> u
forall u. (forall d. Data d => d -> u) -> CSInfo -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSInfo -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSInfo -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSInfo
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSInfo -> c CSInfo
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CSInfo)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSInfo)
$cCSInfo :: Constr
$tCSInfo :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
gmapMp :: (forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
gmapM :: (forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CSInfo -> m CSInfo
gmapQi :: Int -> (forall d. Data d => d -> u) -> CSInfo -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CSInfo -> u
gmapQ :: (forall d. Data d => d -> u) -> CSInfo -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CSInfo -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSInfo -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> CSInfo -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSInfo -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> CSInfo -> r
gmapT :: (forall b. Data b => b -> b) -> CSInfo -> CSInfo
$cgmapT :: (forall b. Data b => b -> b) -> CSInfo -> CSInfo
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSInfo)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CSInfo)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CSInfo)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CSInfo)
dataTypeOf :: CSInfo -> DataType
$cdataTypeOf :: CSInfo -> DataType
toConstr :: CSInfo -> Constr
$ctoConstr :: CSInfo -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSInfo
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CSInfo
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSInfo -> c CSInfo
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CSInfo -> c CSInfo
$cp1Data :: Typeable CSInfo
Data, (forall x. CSInfo -> Rep CSInfo x)
-> (forall x. Rep CSInfo x -> CSInfo) -> Generic CSInfo
forall x. Rep CSInfo x -> CSInfo
forall x. CSInfo -> Rep CSInfo x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CSInfo x -> CSInfo
$cfrom :: forall x. CSInfo -> Rep CSInfo x
Generic )

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

data CiteprocError
   = NoOutput
   | ReferenceNotFound Text
   deriving ( CiteprocError -> CiteprocError -> Bool
(CiteprocError -> CiteprocError -> Bool)
-> (CiteprocError -> CiteprocError -> Bool) -> Eq CiteprocError
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CiteprocError -> CiteprocError -> Bool
$c/= :: CiteprocError -> CiteprocError -> Bool
== :: CiteprocError -> CiteprocError -> Bool
$c== :: CiteprocError -> CiteprocError -> Bool
Eq, Eq CiteprocError
Eq CiteprocError =>
(CiteprocError -> CiteprocError -> Ordering)
-> (CiteprocError -> CiteprocError -> Bool)
-> (CiteprocError -> CiteprocError -> Bool)
-> (CiteprocError -> CiteprocError -> Bool)
-> (CiteprocError -> CiteprocError -> Bool)
-> (CiteprocError -> CiteprocError -> CiteprocError)
-> (CiteprocError -> CiteprocError -> CiteprocError)
-> Ord CiteprocError
CiteprocError -> CiteprocError -> Bool
CiteprocError -> CiteprocError -> Ordering
CiteprocError -> CiteprocError -> CiteprocError
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 :: CiteprocError -> CiteprocError -> CiteprocError
$cmin :: CiteprocError -> CiteprocError -> CiteprocError
max :: CiteprocError -> CiteprocError -> CiteprocError
$cmax :: CiteprocError -> CiteprocError -> CiteprocError
>= :: CiteprocError -> CiteprocError -> Bool
$c>= :: CiteprocError -> CiteprocError -> Bool
> :: CiteprocError -> CiteprocError -> Bool
$c> :: CiteprocError -> CiteprocError -> Bool
<= :: CiteprocError -> CiteprocError -> Bool
$c<= :: CiteprocError -> CiteprocError -> Bool
< :: CiteprocError -> CiteprocError -> Bool
$c< :: CiteprocError -> CiteprocError -> Bool
compare :: CiteprocError -> CiteprocError -> Ordering
$ccompare :: CiteprocError -> CiteprocError -> Ordering
$cp1Ord :: Eq CiteprocError
Ord, Int -> CiteprocError -> ShowS
[CiteprocError] -> ShowS
CiteprocError -> [Char]
(Int -> CiteprocError -> ShowS)
-> (CiteprocError -> [Char])
-> ([CiteprocError] -> ShowS)
-> Show CiteprocError
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [CiteprocError] -> ShowS
$cshowList :: [CiteprocError] -> ShowS
show :: CiteprocError -> [Char]
$cshow :: CiteprocError -> [Char]
showsPrec :: Int -> CiteprocError -> ShowS
$cshowsPrec :: Int -> CiteprocError -> ShowS
Show, Typeable, Typeable CiteprocError
Constr
DataType
Typeable CiteprocError =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CiteprocError -> c CiteprocError)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CiteprocError)
-> (CiteprocError -> Constr)
-> (CiteprocError -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CiteprocError))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CiteprocError))
-> ((forall b. Data b => b -> b) -> CiteprocError -> CiteprocError)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CiteprocError -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CiteprocError -> r)
-> (forall u. (forall d. Data d => d -> u) -> CiteprocError -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CiteprocError -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError)
-> Data CiteprocError
CiteprocError -> Constr
CiteprocError -> DataType
(forall b. Data b => b -> b) -> CiteprocError -> CiteprocError
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteprocError -> c CiteprocError
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteprocError
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) -> CiteprocError -> u
forall u. (forall d. Data d => d -> u) -> CiteprocError -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CiteprocError -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CiteprocError -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteprocError
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteprocError -> c CiteprocError
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CiteprocError)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CiteprocError)
$cReferenceNotFound :: Constr
$cNoOutput :: Constr
$tCiteprocError :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
gmapMp :: (forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
gmapM :: (forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CiteprocError -> m CiteprocError
gmapQi :: Int -> (forall d. Data d => d -> u) -> CiteprocError -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CiteprocError -> u
gmapQ :: (forall d. Data d => d -> u) -> CiteprocError -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CiteprocError -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CiteprocError -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CiteprocError -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CiteprocError -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CiteprocError -> r
gmapT :: (forall b. Data b => b -> b) -> CiteprocError -> CiteprocError
$cgmapT :: (forall b. Data b => b -> b) -> CiteprocError -> CiteprocError
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CiteprocError)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CiteprocError)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CiteprocError)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CiteprocError)
dataTypeOf :: CiteprocError -> DataType
$cdataTypeOf :: CiteprocError -> DataType
toConstr :: CiteprocError -> Constr
$ctoConstr :: CiteprocError -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteprocError
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteprocError
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteprocError -> c CiteprocError
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteprocError -> c CiteprocError
$cp1Data :: Typeable CiteprocError
Data, (forall x. CiteprocError -> Rep CiteprocError x)
-> (forall x. Rep CiteprocError x -> CiteprocError)
-> Generic CiteprocError
forall x. Rep CiteprocError x -> CiteprocError
forall x. CiteprocError -> Rep CiteprocError x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CiteprocError x -> CiteprocError
$cfrom :: forall x. CiteprocError -> Rep CiteprocError x
Generic )

-- | The 'Output' generated by the evaluation of a style. Must be
-- further processed for disambiguation and collapsing.
data Output
    = ONull
    | OSpace
    | OPan    [Inline]
    | OStatus [Inline]
    | ODel     Text                                   -- ^ A delimiter string.
    | OStr     Text           Formatting            -- ^ A simple 'String'
    | OErr     CiteprocError                            -- ^ Warning message
    | OLabel   Text           Formatting            -- ^ A label used for roles
    | ONum     Int            Formatting            -- ^ A number (used to count contributors)
    | OCitNum  Int            Formatting            -- ^ The citation number
    | OCitLabel Text          Formatting            -- ^ The citation label
    | ODate   [Output]                                  -- ^ A (possibly) ranged date
    | OYear    Text    Text   Formatting            -- ^ The year and the citeId
    | OYearSuf Text    Text   [Output]   Formatting -- ^ The year suffix, the citeId and a holder for collision data
    | OName    Agent    [Output] [[Output]]  Formatting -- ^ A (family) name with the list of given names.
    | OContrib Text    Text   [Output] [Output] [[Output]] -- ^ The citation key, the role (author, editor, etc.), the contributor(s),
                                                        -- the output needed for year suf. disambiguation, and everything used for
                                                        -- name disambiguation.
    | OLoc    [Output]        Formatting            -- ^ The citation's locator
    | Output  [Output]        Formatting            -- ^ Some nested 'Output'
      deriving ( Output -> Output -> Bool
(Output -> Output -> Bool)
-> (Output -> Output -> Bool) -> Eq Output
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Output -> Output -> Bool
$c/= :: Output -> Output -> Bool
== :: Output -> Output -> Bool
$c== :: Output -> Output -> Bool
Eq, Eq Output
Eq Output =>
(Output -> Output -> Ordering)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Bool)
-> (Output -> Output -> Output)
-> (Output -> Output -> Output)
-> Ord Output
Output -> Output -> Bool
Output -> Output -> Ordering
Output -> Output -> Output
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 :: Output -> Output -> Output
$cmin :: Output -> Output -> Output
max :: Output -> Output -> Output
$cmax :: Output -> Output -> Output
>= :: Output -> Output -> Bool
$c>= :: Output -> Output -> Bool
> :: Output -> Output -> Bool
$c> :: Output -> Output -> Bool
<= :: Output -> Output -> Bool
$c<= :: Output -> Output -> Bool
< :: Output -> Output -> Bool
$c< :: Output -> Output -> Bool
compare :: Output -> Output -> Ordering
$ccompare :: Output -> Output -> Ordering
$cp1Ord :: Eq Output
Ord, Int -> Output -> ShowS
[Output] -> ShowS
Output -> [Char]
(Int -> Output -> ShowS)
-> (Output -> [Char]) -> ([Output] -> ShowS) -> Show Output
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Output] -> ShowS
$cshowList :: [Output] -> ShowS
show :: Output -> [Char]
$cshow :: Output -> [Char]
showsPrec :: Int -> Output -> ShowS
$cshowsPrec :: Int -> Output -> ShowS
Show, Typeable, Typeable Output
Constr
DataType
Typeable Output =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Output -> c Output)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Output)
-> (Output -> Constr)
-> (Output -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Output))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Output))
-> ((forall b. Data b => b -> b) -> Output -> Output)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Output -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Output -> r)
-> (forall u. (forall d. Data d => d -> u) -> Output -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Output -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Output -> m Output)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Output -> m Output)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Output -> m Output)
-> Data Output
Output -> Constr
Output -> DataType
(forall b. Data b => b -> b) -> Output -> Output
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Output -> c Output
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Output
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) -> Output -> u
forall u. (forall d. Data d => d -> u) -> Output -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Output -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Output -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Output -> m Output
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Output -> m Output
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Output
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Output -> c Output
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Output)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Output)
$cOutput :: Constr
$cOLoc :: Constr
$cOContrib :: Constr
$cOName :: Constr
$cOYearSuf :: Constr
$cOYear :: Constr
$cODate :: Constr
$cOCitLabel :: Constr
$cOCitNum :: Constr
$cONum :: Constr
$cOLabel :: Constr
$cOErr :: Constr
$cOStr :: Constr
$cODel :: Constr
$cOStatus :: Constr
$cOPan :: Constr
$cOSpace :: Constr
$cONull :: Constr
$tOutput :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Output -> m Output
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Output -> m Output
gmapMp :: (forall d. Data d => d -> m d) -> Output -> m Output
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Output -> m Output
gmapM :: (forall d. Data d => d -> m d) -> Output -> m Output
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Output -> m Output
gmapQi :: Int -> (forall d. Data d => d -> u) -> Output -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Output -> u
gmapQ :: (forall d. Data d => d -> u) -> Output -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Output -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Output -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Output -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Output -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Output -> r
gmapT :: (forall b. Data b => b -> b) -> Output -> Output
$cgmapT :: (forall b. Data b => b -> b) -> Output -> Output
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Output)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Output)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Output)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Output)
dataTypeOf :: Output -> DataType
$cdataTypeOf :: Output -> DataType
toConstr :: Output -> Constr
$ctoConstr :: Output -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Output
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Output
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Output -> c Output
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Output -> c Output
$cp1Data :: Typeable Output
Data, (forall x. Output -> Rep Output x)
-> (forall x. Rep Output x -> Output) -> Generic Output
forall x. Rep Output x -> Output
forall x. Output -> Rep Output x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Output x -> Output
$cfrom :: forall x. Output -> Rep Output x
Generic )

type Citations = [[Cite]]
data Cite
    = Cite
      { Cite -> Text
citeId         :: Text
      , Cite -> Formatted
citePrefix     :: Formatted
      , Cite -> Formatted
citeSuffix     :: Formatted
      , Cite -> Text
citeLabel      :: Text
      , Cite -> Text
citeLocator    :: Text
      , Cite -> Text
citeNoteNumber :: Text
      , Cite -> Text
citePosition   :: Text
      , Cite -> Bool
nearNote       :: Bool
      , Cite -> Bool
authorInText   :: Bool
      , Cite -> Bool
suppressAuthor :: Bool
      , Cite -> Int
citeHash       :: Int
      } deriving ( Int -> Cite -> ShowS
[Cite] -> ShowS
Cite -> [Char]
(Int -> Cite -> ShowS)
-> (Cite -> [Char]) -> ([Cite] -> ShowS) -> Show Cite
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [Cite] -> ShowS
$cshowList :: [Cite] -> ShowS
show :: Cite -> [Char]
$cshow :: Cite -> [Char]
showsPrec :: Int -> Cite -> ShowS
$cshowsPrec :: Int -> Cite -> ShowS
Show, Cite -> Cite -> Bool
(Cite -> Cite -> Bool) -> (Cite -> Cite -> Bool) -> Eq Cite
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Cite -> Cite -> Bool
$c/= :: Cite -> Cite -> Bool
== :: Cite -> Cite -> Bool
$c== :: Cite -> Cite -> Bool
Eq, Typeable, Typeable Cite
Constr
DataType
Typeable Cite =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Cite -> c Cite)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Cite)
-> (Cite -> Constr)
-> (Cite -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Cite))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cite))
-> ((forall b. Data b => b -> b) -> Cite -> Cite)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r)
-> (forall u. (forall d. Data d => d -> u) -> Cite -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Cite -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Cite -> m Cite)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cite -> m Cite)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Cite -> m Cite)
-> Data Cite
Cite -> Constr
Cite -> DataType
(forall b. Data b => b -> b) -> Cite -> Cite
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cite -> c Cite
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cite
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) -> Cite -> u
forall u. (forall d. Data d => d -> u) -> Cite -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cite -> m Cite
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cite -> m Cite
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cite
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cite -> c Cite
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cite)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cite)
$cCite :: Constr
$tCite :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Cite -> m Cite
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cite -> m Cite
gmapMp :: (forall d. Data d => d -> m d) -> Cite -> m Cite
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Cite -> m Cite
gmapM :: (forall d. Data d => d -> m d) -> Cite -> m Cite
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Cite -> m Cite
gmapQi :: Int -> (forall d. Data d => d -> u) -> Cite -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Cite -> u
gmapQ :: (forall d. Data d => d -> u) -> Cite -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Cite -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Cite -> r
gmapT :: (forall b. Data b => b -> b) -> Cite -> Cite
$cgmapT :: (forall b. Data b => b -> b) -> Cite -> Cite
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cite)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Cite)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Cite)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Cite)
dataTypeOf :: Cite -> DataType
$cdataTypeOf :: Cite -> DataType
toConstr :: Cite -> Constr
$ctoConstr :: Cite -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cite
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Cite
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cite -> c Cite
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Cite -> c Cite
$cp1Data :: Typeable Cite
Data, (forall x. Cite -> Rep Cite x)
-> (forall x. Rep Cite x -> Cite) -> Generic Cite
forall x. Rep Cite x -> Cite
forall x. Cite -> Rep Cite x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Cite x -> Cite
$cfrom :: forall x. Cite -> Rep Cite x
Generic )

instance FromJSON Cite where
  parseJSON :: Value -> Parser Cite
parseJSON (Object v :: Object
v) = Text
-> Formatted
-> Formatted
-> Text
-> Text
-> Text
-> Text
-> Bool
-> Bool
-> Bool
-> Int
-> Cite
Cite (Text
 -> Formatted
 -> Formatted
 -> Text
 -> Text
 -> Text
 -> Text
 -> Bool
 -> Bool
 -> Bool
 -> Int
 -> Cite)
-> Parser Text
-> Parser
     (Formatted
      -> Formatted
      -> Text
      -> Text
      -> Text
      -> Text
      -> Bool
      -> Bool
      -> Bool
      -> Int
      -> Cite)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
              Object
v Object -> Text -> Parser Text
.#: "id" Parser
  (Formatted
   -> Formatted
   -> Text
   -> Text
   -> Text
   -> Text
   -> Bool
   -> Bool
   -> Bool
   -> Int
   -> Cite)
-> Parser Formatted
-> Parser
     (Formatted
      -> Text
      -> Text
      -> Text
      -> Text
      -> Bool
      -> Bool
      -> Bool
      -> Int
      -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "prefix" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty Parser
  (Formatted
   -> Text
   -> Text
   -> Text
   -> Text
   -> Bool
   -> Bool
   -> Bool
   -> Int
   -> Cite)
-> Parser Formatted
-> Parser
     (Text
      -> Text -> Text -> Text -> Bool -> Bool -> Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "suffix" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty Parser
  (Text
   -> Text -> Text -> Text -> Bool -> Bool -> Bool -> Int -> Cite)
-> Parser Text
-> Parser
     (Text -> Text -> Text -> Bool -> Bool -> Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Text)
.#? "label" Parser (Maybe Text) -> Text -> Parser Text
forall a. Parser (Maybe a) -> a -> Parser a
.!= "page" Parser
  (Text -> Text -> Text -> Bool -> Bool -> Bool -> Int -> Cite)
-> Parser Text
-> Parser (Text -> Text -> Bool -> Bool -> Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Text)
.#? "locator"  Parser (Maybe Text) -> Text -> Parser Text
forall a. Parser (Maybe a) -> a -> Parser a
.!= "" Parser (Text -> Text -> Bool -> Bool -> Bool -> Int -> Cite)
-> Parser Text
-> Parser (Text -> Bool -> Bool -> Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Text)
.#? "note-number" Parser (Maybe Text) -> Text -> Parser Text
forall a. Parser (Maybe a) -> a -> Parser a
.!= "" Parser (Text -> Bool -> Bool -> Bool -> Int -> Cite)
-> Parser Text -> Parser (Bool -> Bool -> Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Text)
.#? "position" Parser (Maybe Text) -> Text -> Parser Text
forall a. Parser (Maybe a) -> a -> Parser a
.!= "" Parser (Bool -> Bool -> Bool -> Int -> Cite)
-> Parser Bool -> Parser (Bool -> Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              (Object
v Object -> Text -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "near-note" Parser (Maybe Value)
-> (Maybe Value -> Parser (Maybe Bool)) -> Parser (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Value -> Parser Bool) -> Maybe Value -> Parser (Maybe Bool)
forall (m :: * -> *) b a.
Monad m =>
(b -> m a) -> Maybe b -> m (Maybe a)
mb Value -> Parser Bool
parseBool) Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False Parser (Bool -> Bool -> Int -> Cite)
-> Parser Bool -> Parser (Bool -> Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              (Object
v Object -> Text -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "author-in-text" Parser (Maybe Value)
-> (Maybe Value -> Parser (Maybe Bool)) -> Parser (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Value -> Parser Bool) -> Maybe Value -> Parser (Maybe Bool)
forall (m :: * -> *) b a.
Monad m =>
(b -> m a) -> Maybe b -> m (Maybe a)
mb Value -> Parser Bool
parseBool) Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False Parser (Bool -> Int -> Cite) -> Parser Bool -> Parser (Int -> Cite)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              (Object
v Object -> Text -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "suppress-author" Parser (Maybe Value)
-> (Maybe Value -> Parser (Maybe Bool)) -> Parser (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Value -> Parser Bool) -> Maybe Value -> Parser (Maybe Bool)
forall (m :: * -> *) b a.
Monad m =>
(b -> m a) -> Maybe b -> m (Maybe a)
mb Value -> Parser Bool
parseBool) Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False Parser (Int -> Cite) -> Parser Int -> Parser Cite
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Int)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "cite-hash" Parser (Maybe Int) -> Int -> Parser Int
forall a. Parser (Maybe a) -> a -> Parser a
.!= 0
  parseJSON _ = [Char] -> Parser Cite
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail "Could not parse Cite"

instance OVERLAPS
         FromJSON [[Cite]] where
  parseJSON :: Value -> Parser [[Cite]]
parseJSON (Array v :: Array
v) = (Value -> Parser [Cite]) -> [Value] -> Parser [[Cite]]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> Parser [Cite]
forall a. FromJSON a => Value -> Parser a
parseJSON ([Value] -> Parser [[Cite]]) -> [Value] -> Parser [[Cite]]
forall a b. (a -> b) -> a -> b
$ Array -> [Value]
forall a. Vector a -> [a]
V.toList Array
v
  parseJSON _         = [[Cite]] -> Parser [[Cite]]
forall (m :: * -> *) a. Monad m => a -> m a
return []

emptyCite :: Cite
emptyCite :: Cite
emptyCite  = Text
-> Formatted
-> Formatted
-> Text
-> Text
-> Text
-> Text
-> Bool
-> Bool
-> Bool
-> Int
-> Cite
Cite "" Formatted
forall a. Monoid a => a
mempty Formatted
forall a. Monoid a => a
mempty "" "" "" "" Bool
False Bool
False Bool
False 0

-- | A citation group: the first list has a single member when the
-- citation group starts with an "author-in-text" cite, the
-- 'Formatting' to be applied, the 'Delimiter' between individual
-- citations and the list of evaluated citations.
data CitationGroup = CG [(Cite, Output)] Formatting Delimiter [(Cite, Output)] deriving ( Int -> CitationGroup -> ShowS
[CitationGroup] -> ShowS
CitationGroup -> [Char]
(Int -> CitationGroup -> ShowS)
-> (CitationGroup -> [Char])
-> ([CitationGroup] -> ShowS)
-> Show CitationGroup
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [CitationGroup] -> ShowS
$cshowList :: [CitationGroup] -> ShowS
show :: CitationGroup -> [Char]
$cshow :: CitationGroup -> [Char]
showsPrec :: Int -> CitationGroup -> ShowS
$cshowsPrec :: Int -> CitationGroup -> ShowS
Show, CitationGroup -> CitationGroup -> Bool
(CitationGroup -> CitationGroup -> Bool)
-> (CitationGroup -> CitationGroup -> Bool) -> Eq CitationGroup
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CitationGroup -> CitationGroup -> Bool
$c/= :: CitationGroup -> CitationGroup -> Bool
== :: CitationGroup -> CitationGroup -> Bool
$c== :: CitationGroup -> CitationGroup -> Bool
Eq, Typeable, Typeable CitationGroup
Constr
DataType
Typeable CitationGroup =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CitationGroup -> c CitationGroup)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CitationGroup)
-> (CitationGroup -> Constr)
-> (CitationGroup -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CitationGroup))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CitationGroup))
-> ((forall b. Data b => b -> b) -> CitationGroup -> CitationGroup)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationGroup -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CitationGroup -> r)
-> (forall u. (forall d. Data d => d -> u) -> CitationGroup -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CitationGroup -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup)
-> Data CitationGroup
CitationGroup -> Constr
CitationGroup -> DataType
(forall b. Data b => b -> b) -> CitationGroup -> CitationGroup
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CitationGroup -> c CitationGroup
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CitationGroup
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) -> CitationGroup -> u
forall u. (forall d. Data d => d -> u) -> CitationGroup -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CitationGroup -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CitationGroup -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CitationGroup
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CitationGroup -> c CitationGroup
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CitationGroup)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CitationGroup)
$cCG :: Constr
$tCitationGroup :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
gmapMp :: (forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
gmapM :: (forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CitationGroup -> m CitationGroup
gmapQi :: Int -> (forall d. Data d => d -> u) -> CitationGroup -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CitationGroup -> u
gmapQ :: (forall d. Data d => d -> u) -> CitationGroup -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CitationGroup -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CitationGroup -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CitationGroup -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CitationGroup -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CitationGroup -> r
gmapT :: (forall b. Data b => b -> b) -> CitationGroup -> CitationGroup
$cgmapT :: (forall b. Data b => b -> b) -> CitationGroup -> CitationGroup
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CitationGroup)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CitationGroup)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CitationGroup)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CitationGroup)
dataTypeOf :: CitationGroup -> DataType
$cdataTypeOf :: CitationGroup -> DataType
toConstr :: CitationGroup -> Constr
$ctoConstr :: CitationGroup -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CitationGroup
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CitationGroup
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CitationGroup -> c CitationGroup
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CitationGroup -> c CitationGroup
$cp1Data :: Typeable CitationGroup
Data, (forall x. CitationGroup -> Rep CitationGroup x)
-> (forall x. Rep CitationGroup x -> CitationGroup)
-> Generic CitationGroup
forall x. Rep CitationGroup x -> CitationGroup
forall x. CitationGroup -> Rep CitationGroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CitationGroup x -> CitationGroup
$cfrom :: forall x. CitationGroup -> Rep CitationGroup x
Generic )

data BiblioData
    = BD
      { BiblioData -> [Formatted]
citations    :: [Formatted]
      , BiblioData -> [Formatted]
bibliography :: [Formatted]
      , BiblioData -> [Text]
citationIds  :: [Text]
      } deriving ( Int -> BiblioData -> ShowS
[BiblioData] -> ShowS
BiblioData -> [Char]
(Int -> BiblioData -> ShowS)
-> (BiblioData -> [Char])
-> ([BiblioData] -> ShowS)
-> Show BiblioData
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [BiblioData] -> ShowS
$cshowList :: [BiblioData] -> ShowS
show :: BiblioData -> [Char]
$cshow :: BiblioData -> [Char]
showsPrec :: Int -> BiblioData -> ShowS
$cshowsPrec :: Int -> BiblioData -> ShowS
Show, Typeable, Typeable BiblioData
Constr
DataType
Typeable BiblioData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BiblioData -> c BiblioData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BiblioData)
-> (BiblioData -> Constr)
-> (BiblioData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BiblioData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BiblioData))
-> ((forall b. Data b => b -> b) -> BiblioData -> BiblioData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BiblioData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BiblioData -> r)
-> (forall u. (forall d. Data d => d -> u) -> BiblioData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BiblioData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BiblioData -> m BiblioData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BiblioData -> m BiblioData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BiblioData -> m BiblioData)
-> Data BiblioData
BiblioData -> Constr
BiblioData -> DataType
(forall b. Data b => b -> b) -> BiblioData -> BiblioData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BiblioData -> c BiblioData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BiblioData
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) -> BiblioData -> u
forall u. (forall d. Data d => d -> u) -> BiblioData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BiblioData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BiblioData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BiblioData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BiblioData -> c BiblioData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BiblioData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BiblioData)
$cBD :: Constr
$tBiblioData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
gmapMp :: (forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
gmapM :: (forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BiblioData -> m BiblioData
gmapQi :: Int -> (forall d. Data d => d -> u) -> BiblioData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BiblioData -> u
gmapQ :: (forall d. Data d => d -> u) -> BiblioData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BiblioData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BiblioData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BiblioData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BiblioData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BiblioData -> r
gmapT :: (forall b. Data b => b -> b) -> BiblioData -> BiblioData
$cgmapT :: (forall b. Data b => b -> b) -> BiblioData -> BiblioData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BiblioData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c BiblioData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BiblioData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BiblioData)
dataTypeOf :: BiblioData -> DataType
$cdataTypeOf :: BiblioData -> DataType
toConstr :: BiblioData -> Constr
$ctoConstr :: BiblioData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BiblioData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BiblioData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BiblioData -> c BiblioData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BiblioData -> c BiblioData
$cp1Data :: Typeable BiblioData
Data, (forall x. BiblioData -> Rep BiblioData x)
-> (forall x. Rep BiblioData x -> BiblioData) -> Generic BiblioData
forall x. Rep BiblioData x -> BiblioData
forall x. BiblioData -> Rep BiblioData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep BiblioData x -> BiblioData
$cfrom :: forall x. BiblioData -> Rep BiblioData x
Generic )

-- | A record with all the data to produce the 'Formatted' of a
-- citation: the citation key, the part of the formatted citation that
-- may be colliding with other citations, the form of the citation
-- when a year suffix is used for disambiguation , the data to
-- disambiguate it (all possible contributors and all possible given
-- names), and, after processing, the disambiguated citation and its
-- year, initially empty.
data CiteData
    = CD
      { CiteData -> Text
key        ::   Text
      , CiteData -> [Output]
collision  ::  [Output]
      , CiteData -> [Output]
disambYS   ::  [Output]
      , CiteData -> [[Output]]
disambData :: [[Output]]
      , CiteData -> [Output]
disambed   ::  [Output]
      , CiteData -> [Text]
sameAs     ::  [Text]
      , CiteData -> Text
citYear    ::   Text
      } deriving ( Int -> CiteData -> ShowS
[CiteData] -> ShowS
CiteData -> [Char]
(Int -> CiteData -> ShowS)
-> (CiteData -> [Char]) -> ([CiteData] -> ShowS) -> Show CiteData
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [CiteData] -> ShowS
$cshowList :: [CiteData] -> ShowS
show :: CiteData -> [Char]
$cshow :: CiteData -> [Char]
showsPrec :: Int -> CiteData -> ShowS
$cshowsPrec :: Int -> CiteData -> ShowS
Show, Typeable, Typeable CiteData
Constr
DataType
Typeable CiteData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CiteData -> c CiteData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CiteData)
-> (CiteData -> Constr)
-> (CiteData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CiteData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CiteData))
-> ((forall b. Data b => b -> b) -> CiteData -> CiteData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CiteData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CiteData -> r)
-> (forall u. (forall d. Data d => d -> u) -> CiteData -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> CiteData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> CiteData -> m CiteData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CiteData -> m CiteData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> CiteData -> m CiteData)
-> Data CiteData
CiteData -> Constr
CiteData -> DataType
(forall b. Data b => b -> b) -> CiteData -> CiteData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteData -> c CiteData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteData
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) -> CiteData -> u
forall u. (forall d. Data d => d -> u) -> CiteData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CiteData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CiteData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CiteData -> m CiteData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CiteData -> m CiteData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteData -> c CiteData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CiteData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CiteData)
$cCD :: Constr
$tCiteData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> CiteData -> m CiteData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CiteData -> m CiteData
gmapMp :: (forall d. Data d => d -> m d) -> CiteData -> m CiteData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> CiteData -> m CiteData
gmapM :: (forall d. Data d => d -> m d) -> CiteData -> m CiteData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> CiteData -> m CiteData
gmapQi :: Int -> (forall d. Data d => d -> u) -> CiteData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> CiteData -> u
gmapQ :: (forall d. Data d => d -> u) -> CiteData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CiteData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CiteData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CiteData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CiteData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CiteData -> r
gmapT :: (forall b. Data b => b -> b) -> CiteData -> CiteData
$cgmapT :: (forall b. Data b => b -> b) -> CiteData -> CiteData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CiteData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c CiteData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CiteData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CiteData)
dataTypeOf :: CiteData -> DataType
$cdataTypeOf :: CiteData -> DataType
toConstr :: CiteData -> Constr
$ctoConstr :: CiteData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CiteData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteData -> c CiteData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CiteData -> c CiteData
$cp1Data :: Typeable CiteData
Data, (forall x. CiteData -> Rep CiteData x)
-> (forall x. Rep CiteData x -> CiteData) -> Generic CiteData
forall x. Rep CiteData x -> CiteData
forall x. CiteData -> Rep CiteData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep CiteData x -> CiteData
$cfrom :: forall x. CiteData -> Rep CiteData x
Generic )

instance Eq CiteData where
    == :: CiteData -> CiteData -> Bool
(==) (CD ka :: Text
ka ca :: [Output]
ca _ _ _ _ _)
         (CD kb :: Text
kb cb :: [Output]
cb _ _ _ _ _) = Text
ka Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== Text
kb Bool -> Bool -> Bool
&& [Output]
ca [Output] -> [Output] -> Bool
forall a. Eq a => a -> a -> Bool
== [Output]
cb

data NameData
    = ND
      { NameData -> Agent
nameKey        ::  Agent
      , NameData -> [Output]
nameCollision  ::  [Output]
      , NameData -> [[Output]]
nameDisambData :: [[Output]]
      , NameData -> [Output]
nameDataSolved ::  [Output]
      } deriving ( Int -> NameData -> ShowS
[NameData] -> ShowS
NameData -> [Char]
(Int -> NameData -> ShowS)
-> (NameData -> [Char]) -> ([NameData] -> ShowS) -> Show NameData
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [NameData] -> ShowS
$cshowList :: [NameData] -> ShowS
show :: NameData -> [Char]
$cshow :: NameData -> [Char]
showsPrec :: Int -> NameData -> ShowS
$cshowsPrec :: Int -> NameData -> ShowS
Show, Typeable, Typeable NameData
Constr
DataType
Typeable NameData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NameData -> c NameData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NameData)
-> (NameData -> Constr)
-> (NameData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NameData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameData))
-> ((forall b. Data b => b -> b) -> NameData -> NameData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NameData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NameData -> r)
-> (forall u. (forall d. Data d => d -> u) -> NameData -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> NameData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NameData -> m NameData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameData -> m NameData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NameData -> m NameData)
-> Data NameData
NameData -> Constr
NameData -> DataType
(forall b. Data b => b -> b) -> NameData -> NameData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameData -> c NameData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameData
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) -> NameData -> u
forall u. (forall d. Data d => d -> u) -> NameData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameData -> m NameData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameData -> m NameData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameData -> c NameData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameData)
$cND :: Constr
$tNameData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> NameData -> m NameData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameData -> m NameData
gmapMp :: (forall d. Data d => d -> m d) -> NameData -> m NameData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NameData -> m NameData
gmapM :: (forall d. Data d => d -> m d) -> NameData -> m NameData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NameData -> m NameData
gmapQi :: Int -> (forall d. Data d => d -> u) -> NameData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NameData -> u
gmapQ :: (forall d. Data d => d -> u) -> NameData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NameData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NameData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NameData -> r
gmapT :: (forall b. Data b => b -> b) -> NameData -> NameData
$cgmapT :: (forall b. Data b => b -> b) -> NameData -> NameData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c NameData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c NameData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NameData)
dataTypeOf :: NameData -> DataType
$cdataTypeOf :: NameData -> DataType
toConstr :: NameData -> Constr
$ctoConstr :: NameData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NameData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameData -> c NameData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NameData -> c NameData
$cp1Data :: Typeable NameData
Data, (forall x. NameData -> Rep NameData x)
-> (forall x. Rep NameData x -> NameData) -> Generic NameData
forall x. Rep NameData x -> NameData
forall x. NameData -> Rep NameData x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NameData x -> NameData
$cfrom :: forall x. NameData -> Rep NameData x
Generic )

instance Eq NameData where
    == :: NameData -> NameData -> Bool
(==) (ND ka :: Agent
ka ca :: [Output]
ca _ _)
         (ND kb :: Agent
kb cb :: [Output]
cb _ _) = Agent
ka Agent -> Agent -> Bool
forall a. Eq a => a -> a -> Bool
== Agent
kb Bool -> Bool -> Bool
&& [Output]
ca [Output] -> [Output] -> Bool
forall a. Eq a => a -> a -> Bool
== [Output]
cb

isPunctuationInQuote :: Style -> Bool
isPunctuationInQuote :: Style -> Bool
isPunctuationInQuote sty :: Style
sty =
  case Style -> [Locale]
styleLocale Style
sty of
       (l :: Locale
l:_) -> ("punctuation-in-quote","true") Option -> [Option] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` Locale -> [Option]
localeOptions Locale
l
       _     -> Bool
False

object' :: [Pair] -> Aeson.Value
object' :: [Pair] -> Value
object' = [Pair] -> Value
object ([Pair] -> Value) -> ([Pair] -> [Pair]) -> [Pair] -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Pair -> Bool) -> [Pair] -> [Pair]
forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not (Bool -> Bool) -> (Pair -> Bool) -> Pair -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Pair -> Bool
forall a. (Eq a, IsString a) => (a, Value) -> Bool
isempty)
  where isempty :: (a, Value) -> Bool
isempty (_, Array v :: Array
v)                                    = Array -> Bool
forall a. Vector a -> Bool
V.null Array
v
        isempty (_, String t :: Text
t)                                   = Text -> Bool
T.null Text
t
        isempty ("first-reference-note-number", Aeson.Number n :: Scientific
n) = Scientific
n Scientific -> Scientific -> Bool
forall a. Eq a => a -> a -> Bool
== 0
        isempty ("citation-number", Aeson.Number n :: Scientific
n)             = Scientific
n Scientific -> Scientific -> Bool
forall a. Eq a => a -> a -> Bool
== 0
        isempty (_, _)                                          = Bool
False

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

emptyAgent :: Agent
emptyAgent :: Agent
emptyAgent = [Formatted]
-> Formatted
-> Formatted
-> Formatted
-> Formatted
-> Formatted
-> Bool
-> Bool
-> Agent
Agent [] Formatted
forall a. Monoid a => a
mempty Formatted
forall a. Monoid a => a
mempty Formatted
forall a. Monoid a => a
mempty Formatted
forall a. Monoid a => a
mempty Formatted
forall a. Monoid a => a
mempty Bool
False Bool
False

-- CSL JSON uses quotes to protect capitalization
removeQuoted :: Formatted -> Formatted
removeQuoted :: Formatted -> Formatted
removeQuoted (Formatted ils :: [Inline]
ils) = [Inline] -> Formatted
Formatted ([Inline] -> [Inline]
go [Inline]
ils)
  where go :: [Inline] -> [Inline]
go []                             = []
        go (Quoted DoubleQuote ils' :: [Inline]
ils' : xs :: [Inline]
xs) = [Inline]
ils' [Inline] -> [Inline] -> [Inline]
forall a. [a] -> [a] -> [a]
++ [Inline] -> [Inline]
go [Inline]
xs
        go (x :: Inline
x:xs :: [Inline]
xs)                         = Inline
x Inline -> [Inline] -> [Inline]
forall a. a -> [a] -> [a]
: [Inline] -> [Inline]
go [Inline]
xs

instance FromJSON Agent where
  parseJSON :: Value -> Parser Agent
parseJSON (Object v :: Object
v) = Agent -> Agent
nameTransform (Agent -> Agent) -> Parser Agent -> Parser Agent
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Formatted]
-> Formatted
-> Formatted
-> Formatted
-> Formatted
-> Formatted
-> Bool
-> Bool
-> Agent
Agent ([Formatted]
 -> Formatted
 -> Formatted
 -> Formatted
 -> Formatted
 -> Formatted
 -> Bool
 -> Bool
 -> Agent)
-> Parser [Formatted]
-> Parser
     (Formatted
      -> Formatted
      -> Formatted
      -> Formatted
      -> Formatted
      -> Bool
      -> Bool
      -> Agent)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
              (Object
v Object -> Text -> Parser [Formatted]
forall a. FromJSON a => Object -> Text -> Parser a
.: "given" Parser [Formatted] -> Parser [Formatted] -> Parser [Formatted]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> ((([Inline] -> Formatted) -> [[Inline]] -> [Formatted]
forall a b. (a -> b) -> [a] -> [b]
map [Inline] -> Formatted
Formatted ([[Inline]] -> [Formatted])
-> (Formatted -> [[Inline]]) -> Formatted -> [Formatted]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Bool) -> [Inline] -> [[Inline]]
forall a. (a -> Bool) -> [a] -> [[a]]
wordsBy Inline -> Bool
isSpace ([Inline] -> [[Inline]])
-> (Formatted -> [Inline]) -> Formatted -> [[Inline]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                                  [Inline] -> [Inline]
addSpaceAfterPeriod ([Inline] -> [Inline])
-> (Formatted -> [Inline]) -> Formatted -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Formatted -> [Inline]
unFormatted) (Formatted -> [Formatted])
-> Parser Formatted -> Parser [Formatted]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                  Object
v Object -> Text -> Parser Formatted
forall a. FromJSON a => Object -> Text -> Parser a
.: "given") Parser [Formatted] -> Parser [Formatted] -> Parser [Formatted]
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> [Formatted] -> Parser [Formatted]
forall (f :: * -> *) a. Applicative f => a -> f a
pure []) Parser
  (Formatted
   -> Formatted
   -> Formatted
   -> Formatted
   -> Formatted
   -> Bool
   -> Bool
   -> Agent)
-> Parser Formatted
-> Parser
     (Formatted
      -> Formatted -> Formatted -> Formatted -> Bool -> Bool -> Agent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:?  "dropping-particle" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty Parser
  (Formatted
   -> Formatted -> Formatted -> Formatted -> Bool -> Bool -> Agent)
-> Parser Formatted
-> Parser
     (Formatted -> Formatted -> Formatted -> Bool -> Bool -> Agent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "non-dropping-particle" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty Parser
  (Formatted -> Formatted -> Formatted -> Bool -> Bool -> Agent)
-> Parser Formatted
-> Parser (Formatted -> Formatted -> Bool -> Bool -> Agent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              (Formatted -> Formatted
removeQuoted (Formatted -> Formatted) -> Parser Formatted -> Parser Formatted
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "family" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty)) Parser (Formatted -> Formatted -> Bool -> Bool -> Agent)
-> Parser Formatted -> Parser (Formatted -> Bool -> Bool -> Agent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "suffix" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty Parser (Formatted -> Bool -> Bool -> Agent)
-> Parser Formatted -> Parser (Bool -> Bool -> Agent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              Object
v Object -> Text -> Parser (Maybe Formatted)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "literal" Parser (Maybe Formatted) -> Formatted -> Parser Formatted
forall a. Parser (Maybe a) -> a -> Parser a
.!= Formatted
forall a. Monoid a => a
mempty Parser (Bool -> Bool -> Agent)
-> Parser Bool -> Parser (Bool -> Agent)
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              (Object
v Object -> Text -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "comma-suffix" Parser (Maybe Value)
-> (Maybe Value -> Parser (Maybe Bool)) -> Parser (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Value -> Parser Bool) -> Maybe Value -> Parser (Maybe Bool)
forall (m :: * -> *) b a.
Monad m =>
(b -> m a) -> Maybe b -> m (Maybe a)
mb Value -> Parser Bool
parseBool) Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False Parser (Bool -> Agent) -> Parser Bool -> Parser Agent
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*>
              (Object
v Object -> Text -> Parser (Maybe Value)
forall a. FromJSON a => Object -> Text -> Parser (Maybe a)
.:? "parse-names" Parser (Maybe Value)
-> (Maybe Value -> Parser (Maybe Bool)) -> Parser (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (Value -> Parser Bool) -> Maybe Value -> Parser (Maybe Bool)
forall (m :: * -> *) b a.
Monad m =>
(b -> m a) -> Maybe b -> m (Maybe a)
mb Value -> Parser Bool
parseBool) Parser (Maybe Bool) -> Bool -> Parser Bool
forall a. Parser (Maybe a) -> a -> Parser a
.!= Bool
False)
  parseJSON _ = [Char] -> Parser Agent
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail "Could not parse Agent"

instance ToYaml Agent where
  toYaml :: Agent -> YamlBuilder
toYaml ag :: Agent
ag = [[(Text, YamlBuilder)] -> [(Text, YamlBuilder)]] -> YamlBuilder
mapping' [ "family" Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= Agent -> Formatted
familyName Agent
ag
                       , case Agent -> [Formatted]
givenName Agent
ag of
                              []    -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a. a -> a
id
                              xs :: [Formatted]
xs    -> "given" Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= [Inline] -> Formatted
Formatted
                                                  ([Inline] -> [[Inline]] -> [Inline]
forall a. [a] -> [[a]] -> [a]
intercalate [Inline
Space]
                                                    ((Formatted -> [Inline]) -> [Formatted] -> [[Inline]]
forall a b. (a -> b) -> [a] -> [b]
map Formatted -> [Inline]
unFormatted [Formatted]
xs))
                       , "non-dropping-particle" Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= Agent -> Formatted
nonDroppingPart Agent
ag
                       , "dropping-particle" Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= Agent -> Formatted
droppingPart Agent
ag
                       , "suffix" Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= Agent -> Formatted
nameSuffix Agent
ag
                       , "literal" Text -> Formatted -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= Agent -> Formatted
literal Agent
ag
                       , "comma-suffix" Text -> Text -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= [Char] -> Text
T.pack (if Agent -> Bool
commaSuffix Agent
ag
                                                      then "true"
                                                      else "")
                       , "parse-names" Text -> Text -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
forall a.
AddYaml a =>
Text -> a -> [(Text, YamlBuilder)] -> [(Text, YamlBuilder)]
&= [Char] -> Text
T.pack (if Agent -> Bool
parseNames Agent
ag
                                                     then "true"
                                                     else "")
                       ]

-- See http://gsl-nagoya-u.net/http/pub/citeproc-doc.html#id28
nameTransform :: Agent -> Agent
nameTransform :: Agent -> Agent
nameTransform ag :: Agent
ag
  | Agent -> Bool
parseNames Agent
ag = Agent -> Agent
nonDroppingPartTransform (Agent -> Agent) -> (Agent -> Agent) -> Agent -> Agent
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    Agent -> Agent
droppingPartTransform (Agent -> Agent) -> (Agent -> Agent) -> Agent -> Agent
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
                    Agent -> Agent
suffixTransform (Agent -> Agent) -> Agent -> Agent
forall a b. (a -> b) -> a -> b
$ Agent
ag{ parseNames :: Bool
parseNames = Bool
False }
  | Bool
otherwise = Agent
ag

nonDroppingPartTransform :: Agent -> Agent
nonDroppingPartTransform :: Agent -> Agent
nonDroppingPartTransform ag :: Agent
ag
  | Agent -> Formatted
nonDroppingPart Agent
ag Formatted -> Formatted -> Bool
forall a. Eq a => a -> a -> Bool
== Formatted
forall a. Monoid a => a
mempty =
    case (Inline -> Bool) -> [Inline] -> ([Inline], [Inline])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break Inline -> Bool
startWithCapital'
         ((Char -> Bool) -> [Inline] -> [Inline]
splitStrWhen (\c :: Char
c -> Char -> Bool
isPunctuation Char
c Bool -> Bool -> Bool
|| Char -> Bool
isUpper Char
c) ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall a b. (a -> b) -> a -> b
$
          Formatted -> [Inline]
unFormatted (Formatted -> [Inline]) -> Formatted -> [Inline]
forall a b. (a -> b) -> a -> b
$ Agent -> Formatted
familyName Agent
ag) of
         ([], _)  -> Agent
ag
         (xs :: [Inline]
xs, ys :: [Inline]
ys)
           | [Inline] -> Maybe Char
lastInline [Inline]
xs Maybe Char -> [Maybe Char] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` (Char -> Maybe Char) -> [Char] -> [Maybe Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Maybe Char
forall a. a -> Maybe a
Just (" -'’" :: String) -> Agent
ag {
                          nonDroppingPart :: Formatted
nonDroppingPart = [Inline] -> Formatted
Formatted ([Inline] -> Formatted) -> [Inline] -> Formatted
forall a b. (a -> b) -> a -> b
$ [Inline] -> [Inline]
trimSpace [Inline]
xs,
                          familyName :: Formatted
familyName = [Inline] -> Formatted
Formatted [Inline]
ys }
           | Bool
otherwise -> Agent
ag
  | Bool
otherwise = Agent
ag

trimSpace :: [Inline] -> [Inline]
trimSpace :: [Inline] -> [Inline]
trimSpace = [Inline] -> [Inline]
forall a. [a] -> [a]
reverse ([Inline] -> [Inline])
-> ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Bool) -> [Inline] -> [Inline]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Inline -> Bool
isSpace ([Inline] -> [Inline])
-> ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Inline] -> [Inline]
forall a. [a] -> [a]
reverse ([Inline] -> [Inline])
-> ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Inline -> Bool) -> [Inline] -> [Inline]
forall a. (a -> Bool) -> [a] -> [a]
dropWhile Inline -> Bool
isSpace

isSpace :: Inline -> Bool
isSpace :: Inline -> Bool
isSpace Space     = Bool
True
isSpace SoftBreak = Bool
True
isSpace _         = Bool
False

droppingPartTransform :: Agent -> Agent
droppingPartTransform :: Agent -> Agent
droppingPartTransform ag :: Agent
ag
  | Agent -> Formatted
droppingPart Agent
ag Formatted -> Formatted -> Bool
forall a. Eq a => a -> a -> Bool
== Formatted
forall a. Monoid a => a
mempty =
    case (Formatted -> Bool) -> [Formatted] -> ([Formatted], [Formatted])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break Formatted -> Bool
startWithCapital ([Formatted] -> ([Formatted], [Formatted]))
-> [Formatted] -> ([Formatted], [Formatted])
forall a b. (a -> b) -> a -> b
$ [Formatted] -> [Formatted]
forall a. [a] -> [a]
reverse ([Formatted] -> [Formatted]) -> [Formatted] -> [Formatted]
forall a b. (a -> b) -> a -> b
$ Agent -> [Formatted]
givenName Agent
ag of
          ([],_)  -> Agent
ag
          (ys :: [Formatted]
ys,zs :: [Formatted]
zs) -> Agent
ag{ droppingPart :: Formatted
droppingPart = [Formatted] -> Formatted
forall a. Monoid a => [a] -> a
mconcat ([Formatted] -> Formatted) -> [Formatted] -> Formatted
forall a b. (a -> b) -> a -> b
$
                                         Formatted -> [Formatted] -> [Formatted]
forall a. a -> [a] -> [a]
intersperse ([Inline] -> Formatted
Formatted [Inline
Space]) ([Formatted] -> [Formatted]) -> [Formatted] -> [Formatted]
forall a b. (a -> b) -> a -> b
$
                                         [Formatted] -> [Formatted]
forall a. [a] -> [a]
reverse [Formatted]
ys
                       , givenName :: [Formatted]
givenName = [Formatted] -> [Formatted]
forall a. [a] -> [a]
reverse [Formatted]
zs }
  | Bool
otherwise = Agent
ag

startWithCapital' :: Inline -> Bool
startWithCapital' :: Inline -> Bool
startWithCapital' (Str (Text -> Maybe (Char, Text)
T.uncons -> Just (c :: Char
c,_))) = Char -> Bool
isUpper Char
c Bool -> Bool -> Bool
&& Char -> Bool
isLetter Char
c
startWithCapital' _           = Bool
False

startWithCapital :: Formatted -> Bool
startWithCapital :: Formatted -> Bool
startWithCapital (Formatted (x :: Inline
x:_)) = Inline -> Bool
startWithCapital' Inline
x
startWithCapital _                 = Bool
False

stripFinalComma :: Formatted -> (Text, Formatted)
stripFinalComma :: Formatted -> (Text, Formatted)
stripFinalComma (Formatted ils :: [Inline]
ils) =
  case [Inline] -> [Inline]
forall a. [a] -> [a]
reverse ([Inline] -> [Inline]) -> [Inline] -> [Inline]
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> [Inline] -> [Inline]
splitStrWhen Char -> Bool
isPunctuation [Inline]
ils of
       Str ",":xs :: [Inline]
xs         -> (",", [Inline] -> Formatted
Formatted ([Inline] -> Formatted) -> [Inline] -> Formatted
forall a b. (a -> b) -> a -> b
$ [Inline] -> [Inline]
forall a. [a] -> [a]
reverse [Inline]
xs)
       Str "!":Str ",":xs :: [Inline]
xs -> (",!", [Inline] -> Formatted
Formatted ([Inline] -> Formatted) -> [Inline] -> Formatted
forall a b. (a -> b) -> a -> b
$ [Inline] -> [Inline]
forall a. [a] -> [a]
reverse [Inline]
xs)
       _                  -> ("", [Inline] -> Formatted
Formatted [Inline]
ils)

suffixTransform :: Agent -> Agent
suffixTransform :: Agent -> Agent
suffixTransform ag :: Agent
ag
  | Agent -> Formatted
nameSuffix Agent
ag Formatted -> Formatted -> Bool
forall a. Eq a => a -> a -> Bool
== Formatted
forall a. Monoid a => a
mempty = (Agent, Bool) -> Agent
forall a b. (a, b) -> a
fst ((Agent, Bool) -> Agent) -> (Agent, Bool) -> Agent
forall a b. (a -> b) -> a -> b
$ ((Agent, Bool) -> Formatted -> (Agent, Bool))
-> (Agent, Bool) -> [Formatted] -> (Agent, Bool)
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (Agent, Bool) -> Formatted -> (Agent, Bool)
go
                              (Agent
ag{ givenName :: [Formatted]
givenName   = [Formatted]
forall a. Monoid a => a
mempty
                                 , nameSuffix :: Formatted
nameSuffix  = Formatted
forall a. Monoid a => a
mempty
                                 , commaSuffix :: Bool
commaSuffix = Bool
False }, Bool
False)
                              (Agent -> [Formatted]
givenName Agent
ag)
  | Bool
otherwise = Agent
ag
  where go :: (Agent, Bool) -> Formatted -> (Agent, Bool)
go (ag' :: Agent
ag', False) n :: Formatted
n =
               case Formatted -> (Text, Formatted)
stripFinalComma Formatted
n of
                    ("", _)   -> (Agent
ag'{ givenName :: [Formatted]
givenName = Agent -> [Formatted]
givenName Agent
ag' [Formatted] -> [Formatted] -> [Formatted]
forall a. [a] -> [a] -> [a]
++ [Formatted
n] }, Bool
False)
                    (",",n' :: Formatted
n')  -> (Agent
ag'{ givenName :: [Formatted]
givenName = Agent -> [Formatted]
givenName Agent
ag' [Formatted] -> [Formatted] -> [Formatted]
forall a. [a] -> [a] -> [a]
++ [Formatted
n'] }, Bool
True)
                    (",!",n' :: Formatted
n') -> (Agent
ag'{ givenName :: [Formatted]
givenName = Agent -> [Formatted]
givenName Agent
ag' [Formatted] -> [Formatted] -> [Formatted]
forall a. [a] -> [a] -> [a]
++ [Formatted
n']
                                     , commaSuffix :: Bool
commaSuffix = Bool
True }, Bool
True)
                    _         -> [Char] -> (Agent, Bool)
forall a. HasCallStack => [Char] -> a
error "stripFinalComma returned unexpected value"
        go (ag' :: Agent
ag', True) n :: Formatted
n = (Agent
ag'{ nameSuffix :: Formatted
nameSuffix = if Agent -> Formatted
nameSuffix Agent
ag' Formatted -> Formatted -> Bool
forall a. Eq a => a -> a -> Bool
== Formatted
forall a. Monoid a => a
mempty
                                                 then Formatted
n
                                                 else Agent -> Formatted
nameSuffix Agent
ag' Formatted -> Formatted -> Formatted
forall a. Semigroup a => a -> a -> a
<>
                                                      [Inline] -> Formatted
Formatted [Inline
Space] Formatted -> Formatted -> Formatted
forall a. Semigroup a => a -> a -> a
<> Formatted
n }, Bool
True)

instance ToJSON Agent where
  toJSON :: Agent -> Value
toJSON agent :: Agent
agent = [Pair] -> Value
object' ([Pair] -> Value) -> [Pair] -> Value
forall a b. (a -> b) -> a -> b
$ [
      "given" Text -> Formatted -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= [Inline] -> Formatted
Formatted ([Inline] -> [[Inline]] -> [Inline]
forall a. [a] -> [[a]] -> [a]
intercalate [Inline
Space] ([[Inline]] -> [Inline]) -> [[Inline]] -> [Inline]
forall a b. (a -> b) -> a -> b
$ (Formatted -> [Inline]) -> [Formatted] -> [[Inline]]
forall a b. (a -> b) -> [a] -> [b]
map Formatted -> [Inline]
unFormatted
                                                ([Formatted] -> [[Inline]]) -> [Formatted] -> [[Inline]]
forall a b. (a -> b) -> a -> b
$ Agent -> [Formatted]
givenName Agent
agent)
    , "dropping-particle" Text -> Formatted -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Agent -> Formatted
droppingPart Agent
agent
    , "non-dropping-particle" Text -> Formatted -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Agent -> Formatted
nonDroppingPart Agent
agent
    , "family" Text -> Formatted -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Agent -> Formatted
familyName Agent
agent
    , "suffix" Text -> Formatted -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Agent -> Formatted
nameSuffix Agent
agent
    , "literal" Text -> Formatted -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Agent -> Formatted
literal Agent
agent
    ] [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ ["comma-suffix" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Agent -> Bool
commaSuffix Agent
agent | Agent -> Formatted
nameSuffix Agent
agent Formatted -> Formatted -> Bool
forall a. Eq a => a -> a -> Bool
/= Formatted
forall a. Monoid a => a
mempty]
      [Pair] -> [Pair] -> [Pair]
forall a. [a] -> [a] -> [a]
++ ["parse-names" Text -> Bool -> Pair
forall kv v. (KeyValue kv, ToJSON v) => Text -> v -> kv
.= Bool
True | Agent -> Bool
parseNames Agent
agent ]

instance OVERLAPS
         FromJSON [Agent] where
  parseJSON :: Value -> Parser [Agent]
parseJSON (Array xs :: Array
xs) = (Value -> Parser Agent) -> [Value] -> Parser [Agent]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Value -> Parser Agent
forall a. FromJSON a => Value -> Parser a
parseJSON ([Value] -> Parser [Agent]) -> [Value] -> Parser [Agent]
forall a b. (a -> b) -> a -> b
$ Array -> [Value]
forall a. Vector a -> [a]
V.toList Array
xs
  parseJSON (Object v :: Object
v) = (Agent -> [Agent] -> [Agent]
forall a. a -> [a] -> [a]
:[]) (Agent -> [Agent]) -> Parser Agent -> Parser [Agent]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
`fmap` Value -> Parser Agent
forall a. FromJSON a => Value -> Parser a
parseJSON (Object -> Value
Object Object
v)
  parseJSON _          = [Char] -> Parser [Agent]
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail "Could not parse [Agent]"

-- instance ToJSON [Agent] where
-- toJSON xs  = Array (V.fromList $ map toJSON xs)