{-# LANGUAGE DeriveDataTypeable, DeriveGeneric #-}

-- | LaTeX syntax description in the definition of the 'LaTeX' datatype.
--   If you want to add new commands or environments not defined in
--   the library, import this module and use 'LaTeX' data constructors.
module Text.LaTeX.Base.Syntax
 ( -- * @LaTeX@ datatype
   Measure (..)
 , MathType (..)
 , LaTeX (..)
 , TeXArg (..)
 , (<>), between
   -- * Escaping reserved characters
 , protectString
 , protectText
   -- * Syntax analysis
 , matchCommand
 , lookForCommand
 , matchEnv
 , lookForEnv
 , texmap
 , texmapM
   -- ** Utils
 , getBody
 , getPreamble
   ) where

import Data.Text (Text,pack)
import qualified Data.Text
import qualified Data.Semigroup as Semigroup
import Data.String
import Control.Monad (replicateM)
import Data.Functor.Identity (runIdentity)
import Data.Data (Data)
import Data.Typeable
import Test.QuickCheck
import Data.Hashable
import GHC.Generics (Generic)
import Control.Applicative (liftA2)

-- | Measure units defined in LaTeX. Use 'CustomMeasure' to use commands like 'textwidth'.
--   For instance:
--
-- > rule Nothing (CustomMeasure linewidth) (Pt 2)
--
-- This will create a black box (see 'rule') as wide as the text and two points tall.
--
data Measure =
   Pt Double -- ^ A point is 1/72.27 inch, that means about 0.0138 inch or 0.3515 mm.
 | Mm Double -- ^ Millimeter.
 | Cm Double -- ^ Centimeter.
 | In Double -- ^ Inch.
 | Ex Double -- ^ The height of an \"x\" in the current font.
 | Em Double -- ^ The width of an \"M\" in the current font.
 | CustomMeasure LaTeX -- ^ You can introduce a 'LaTeX' expression as a measure.
   deriving (Typeable Measure
Typeable Measure =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Measure -> c Measure)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Measure)
-> (Measure -> Constr)
-> (Measure -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Measure))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Measure))
-> ((forall b. Data b => b -> b) -> Measure -> Measure)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Measure -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Measure -> r)
-> (forall u. (forall d. Data d => d -> u) -> Measure -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Measure -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Measure -> m Measure)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Measure -> m Measure)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Measure -> m Measure)
-> Data Measure
Measure -> Constr
Measure -> DataType
(forall b. Data b => b -> b) -> Measure -> Measure
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) -> Measure -> u
forall u. (forall d. Data d => d -> u) -> Measure -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Measure
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Measure -> c Measure
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Measure)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Measure)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Measure -> c Measure
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Measure -> c Measure
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Measure
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Measure
$ctoConstr :: Measure -> Constr
toConstr :: Measure -> Constr
$cdataTypeOf :: Measure -> DataType
dataTypeOf :: Measure -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Measure)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Measure)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Measure)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Measure)
$cgmapT :: (forall b. Data b => b -> b) -> Measure -> Measure
gmapT :: (forall b. Data b => b -> b) -> Measure -> Measure
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Measure -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Measure -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Measure -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Measure -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
Data, Measure -> Measure -> Bool
(Measure -> Measure -> Bool)
-> (Measure -> Measure -> Bool) -> Eq Measure
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Measure -> Measure -> Bool
== :: Measure -> Measure -> Bool
$c/= :: Measure -> Measure -> Bool
/= :: Measure -> Measure -> Bool
Eq, (forall x. Measure -> Rep Measure x)
-> (forall x. Rep Measure x -> Measure) -> Generic Measure
forall x. Rep Measure x -> Measure
forall x. Measure -> Rep Measure x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Measure -> Rep Measure x
from :: forall x. Measure -> Rep Measure x
$cto :: forall x. Rep Measure x -> Measure
to :: forall x. Rep Measure x -> Measure
Generic, Int -> Measure -> ShowS
[Measure] -> ShowS
Measure -> [Char]
(Int -> Measure -> ShowS)
-> (Measure -> [Char]) -> ([Measure] -> ShowS) -> Show Measure
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Measure -> ShowS
showsPrec :: Int -> Measure -> ShowS
$cshow :: Measure -> [Char]
show :: Measure -> [Char]
$cshowList :: [Measure] -> ShowS
showList :: [Measure] -> ShowS
Show, Typeable)

-- | Different types of syntax for mathematical expressions.
data MathType = Parentheses | Square | Dollar | DoubleDollar
  deriving (Typeable MathType
Typeable MathType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MathType -> c MathType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MathType)
-> (MathType -> Constr)
-> (MathType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MathType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType))
-> ((forall b. Data b => b -> b) -> MathType -> MathType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> MathType -> r)
-> (forall u. (forall d. Data d => d -> u) -> MathType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MathType -> m MathType)
-> Data MathType
MathType -> Constr
MathType -> DataType
(forall b. Data b => b -> b) -> MathType -> MathType
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) -> MathType -> u
forall u. (forall d. Data d => d -> u) -> MathType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MathType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MathType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MathType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MathType -> c MathType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MathType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MathType -> c MathType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MathType -> c MathType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MathType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MathType
$ctoConstr :: MathType -> Constr
toConstr :: MathType -> Constr
$cdataTypeOf :: MathType -> DataType
dataTypeOf :: MathType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MathType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MathType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MathType)
$cgmapT :: (forall b. Data b => b -> b) -> MathType -> MathType
gmapT :: (forall b. Data b => b -> b) -> MathType -> MathType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MathType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> MathType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MathType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> MathType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MathType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MathType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MathType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MathType -> m MathType
Data, MathType -> MathType -> Bool
(MathType -> MathType -> Bool)
-> (MathType -> MathType -> Bool) -> Eq MathType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MathType -> MathType -> Bool
== :: MathType -> MathType -> Bool
$c/= :: MathType -> MathType -> Bool
/= :: MathType -> MathType -> Bool
Eq, (forall x. MathType -> Rep MathType x)
-> (forall x. Rep MathType x -> MathType) -> Generic MathType
forall x. Rep MathType x -> MathType
forall x. MathType -> Rep MathType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MathType -> Rep MathType x
from :: forall x. MathType -> Rep MathType x
$cto :: forall x. Rep MathType x -> MathType
to :: forall x. Rep MathType x -> MathType
Generic, Int -> MathType -> ShowS
[MathType] -> ShowS
MathType -> [Char]
(Int -> MathType -> ShowS)
-> (MathType -> [Char]) -> ([MathType] -> ShowS) -> Show MathType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MathType -> ShowS
showsPrec :: Int -> MathType -> ShowS
$cshow :: MathType -> [Char]
show :: MathType -> [Char]
$cshowList :: [MathType] -> ShowS
showList :: [MathType] -> ShowS
Show, Typeable)

-- | Type of @LaTeX@ blocks.
data LaTeX =
   TeXRaw Text -- ^ Raw text.
 | TeXComm String [TeXArg] -- ^ Constructor for commands.
                           -- First argument is the name of the command.
                           -- Second, its arguments.
 | TeXCommS String -- ^ Constructor for commands with no arguments.
                   --   When rendering, no space or @{}@ will be added at
                   --   the end.
 | TeXEnv String [TeXArg] LaTeX -- ^ Constructor for environments.
                                -- First argument is the name of the environment.
                                -- Second, its arguments.
                                -- Third, its content.
 | TeXMath MathType LaTeX -- ^ Mathematical expressions.
 | TeXLineBreak (Maybe Measure) Bool -- ^ Line break command.
 | TeXBraces LaTeX -- ^ A expression between braces.
 | TeXComment Text -- ^ Comments.
 | TeXSeq LaTeX LaTeX -- ^ Sequencing of 'LaTeX' expressions.
                      -- Use '<>' preferably.
 | TeXEmpty -- ^ An empty block.
            -- /Neutral element/ of '<>'.
   deriving (Typeable LaTeX
Typeable LaTeX =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LaTeX -> c LaTeX)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LaTeX)
-> (LaTeX -> Constr)
-> (LaTeX -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LaTeX))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LaTeX))
-> ((forall b. Data b => b -> b) -> LaTeX -> LaTeX)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r)
-> (forall u. (forall d. Data d => d -> u) -> LaTeX -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> LaTeX -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LaTeX -> m LaTeX)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LaTeX -> m LaTeX)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LaTeX -> m LaTeX)
-> Data LaTeX
LaTeX -> Constr
LaTeX -> DataType
(forall b. Data b => b -> b) -> LaTeX -> LaTeX
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) -> LaTeX -> u
forall u. (forall d. Data d => d -> u) -> LaTeX -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LaTeX
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LaTeX -> c LaTeX
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LaTeX)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LaTeX)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LaTeX -> c LaTeX
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LaTeX -> c LaTeX
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LaTeX
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LaTeX
$ctoConstr :: LaTeX -> Constr
toConstr :: LaTeX -> Constr
$cdataTypeOf :: LaTeX -> DataType
dataTypeOf :: LaTeX -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LaTeX)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LaTeX)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LaTeX)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c LaTeX)
$cgmapT :: (forall b. Data b => b -> b) -> LaTeX -> LaTeX
gmapT :: (forall b. Data b => b -> b) -> LaTeX -> LaTeX
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> LaTeX -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LaTeX -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> LaTeX -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LaTeX -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LaTeX -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LaTeX -> m LaTeX
Data, LaTeX -> LaTeX -> Bool
(LaTeX -> LaTeX -> Bool) -> (LaTeX -> LaTeX -> Bool) -> Eq LaTeX
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LaTeX -> LaTeX -> Bool
== :: LaTeX -> LaTeX -> Bool
$c/= :: LaTeX -> LaTeX -> Bool
/= :: LaTeX -> LaTeX -> Bool
Eq, (forall x. LaTeX -> Rep LaTeX x)
-> (forall x. Rep LaTeX x -> LaTeX) -> Generic LaTeX
forall x. Rep LaTeX x -> LaTeX
forall x. LaTeX -> Rep LaTeX x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. LaTeX -> Rep LaTeX x
from :: forall x. LaTeX -> Rep LaTeX x
$cto :: forall x. Rep LaTeX x -> LaTeX
to :: forall x. Rep LaTeX x -> LaTeX
Generic, Int -> LaTeX -> ShowS
[LaTeX] -> ShowS
LaTeX -> [Char]
(Int -> LaTeX -> ShowS)
-> (LaTeX -> [Char]) -> ([LaTeX] -> ShowS) -> Show LaTeX
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LaTeX -> ShowS
showsPrec :: Int -> LaTeX -> ShowS
$cshow :: LaTeX -> [Char]
show :: LaTeX -> [Char]
$cshowList :: [LaTeX] -> ShowS
showList :: [LaTeX] -> ShowS
Show, Typeable)

-- | An argument for a 'LaTeX' command or environment.
data TeXArg =
   FixArg LaTeX    -- ^ Fixed argument.
 | OptArg LaTeX    -- ^ Optional argument.
 | MOptArg [LaTeX] -- ^ Multiple optional argument.
 | SymArg LaTeX    -- ^ An argument enclosed between @\<@ and @\>@.
 | MSymArg [LaTeX] -- ^ Version of 'SymArg' with multiple options.
 | ParArg LaTeX    -- ^ An argument enclosed between @(@ and @)@.
 | MParArg [LaTeX] -- ^ Version of 'ParArg' with multiple options.
   deriving (Typeable TeXArg
Typeable TeXArg =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> TeXArg -> c TeXArg)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TeXArg)
-> (TeXArg -> Constr)
-> (TeXArg -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TeXArg))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TeXArg))
-> ((forall b. Data b => b -> b) -> TeXArg -> TeXArg)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> TeXArg -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> TeXArg -> r)
-> (forall u. (forall d. Data d => d -> u) -> TeXArg -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TeXArg -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TeXArg -> m TeXArg)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TeXArg -> m TeXArg)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TeXArg -> m TeXArg)
-> Data TeXArg
TeXArg -> Constr
TeXArg -> DataType
(forall b. Data b => b -> b) -> TeXArg -> TeXArg
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) -> TeXArg -> u
forall u. (forall d. Data d => d -> u) -> TeXArg -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TeXArg -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TeXArg -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeXArg
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeXArg -> c TeXArg
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TeXArg)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TeXArg)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeXArg -> c TeXArg
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TeXArg -> c TeXArg
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeXArg
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TeXArg
$ctoConstr :: TeXArg -> Constr
toConstr :: TeXArg -> Constr
$cdataTypeOf :: TeXArg -> DataType
dataTypeOf :: TeXArg -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TeXArg)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TeXArg)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TeXArg)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TeXArg)
$cgmapT :: (forall b. Data b => b -> b) -> TeXArg -> TeXArg
gmapT :: (forall b. Data b => b -> b) -> TeXArg -> TeXArg
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TeXArg -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TeXArg -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TeXArg -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TeXArg -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TeXArg -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> TeXArg -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TeXArg -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TeXArg -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TeXArg -> m TeXArg
Data, TeXArg -> TeXArg -> Bool
(TeXArg -> TeXArg -> Bool)
-> (TeXArg -> TeXArg -> Bool) -> Eq TeXArg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TeXArg -> TeXArg -> Bool
== :: TeXArg -> TeXArg -> Bool
$c/= :: TeXArg -> TeXArg -> Bool
/= :: TeXArg -> TeXArg -> Bool
Eq, (forall x. TeXArg -> Rep TeXArg x)
-> (forall x. Rep TeXArg x -> TeXArg) -> Generic TeXArg
forall x. Rep TeXArg x -> TeXArg
forall x. TeXArg -> Rep TeXArg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. TeXArg -> Rep TeXArg x
from :: forall x. TeXArg -> Rep TeXArg x
$cto :: forall x. Rep TeXArg x -> TeXArg
to :: forall x. Rep TeXArg x -> TeXArg
Generic, Int -> TeXArg -> ShowS
[TeXArg] -> ShowS
TeXArg -> [Char]
(Int -> TeXArg -> ShowS)
-> (TeXArg -> [Char]) -> ([TeXArg] -> ShowS) -> Show TeXArg
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> TeXArg -> ShowS
showsPrec :: Int -> TeXArg -> ShowS
$cshow :: TeXArg -> [Char]
show :: TeXArg -> [Char]
$cshowList :: [TeXArg] -> ShowS
showList :: [TeXArg] -> ShowS
Show, Typeable)

-- Monoid instance for 'LaTeX'.

instance Monoid LaTeX where
  mempty :: LaTeX
mempty = LaTeX
TeXEmpty

-- | Appending is strict in both arguments (except when the first argument is 'TeXEmpty').
instance Semigroup.Semigroup LaTeX where
  LaTeX
TeXEmpty <> :: LaTeX -> LaTeX -> LaTeX
<> LaTeX
x = LaTeX
x
  LaTeX
x <> LaTeX
TeXEmpty = LaTeX
x
  -- This equation is to make 'mappend' associative.
  TeXSeq LaTeX
x LaTeX
y <> LaTeX
z = LaTeX -> LaTeX -> LaTeX
TeXSeq LaTeX
x (LaTeX -> LaTeX) -> LaTeX -> LaTeX
forall a b. (a -> b) -> a -> b
$ LaTeX
y LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> LaTeX
z
  LaTeX
x <> LaTeX
y = LaTeX -> LaTeX -> LaTeX
TeXSeq LaTeX
x LaTeX
y

-- | Calling 'between' @c l1 l2@ puts @c@ between @l1@ and @l2@ and
--   appends them.
--
-- > between c l1 l2 = l1 <> c <> l2
between :: Monoid m => m -> m -> m -> m
between :: forall m. Monoid m => m -> m -> m -> m
between m
c m
l1 m
l2 = m
l1 m -> m -> m
forall a. Semigroup a => a -> a -> a
<> m
c m -> m -> m
forall a. Semigroup a => a -> a -> a
<> m
l2

-- | Method 'fromString' escapes LaTeX reserved characters using 'protectString'.
instance IsString LaTeX where
 fromString :: [Char] -> LaTeX
fromString = Text -> LaTeX
TeXRaw (Text -> LaTeX) -> ([Char] -> Text) -> [Char] -> LaTeX
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
forall a. IsString a => [Char] -> a
fromString ([Char] -> Text) -> ShowS -> [Char] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ShowS
protectString

-- | Escape LaTeX reserved characters in a 'String'.
protectString :: String -> String
protectString :: ShowS
protectString = [[Char]] -> [Char]
forall a. Monoid a => [a] -> a
mconcat ([[Char]] -> [Char]) -> ([Char] -> [[Char]]) -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> [Char]) -> [Char] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> [Char]
protectChar

-- | Escape LaTeX reserved characters in a 'Text'.
protectText :: Text -> Text
protectText :: Text -> Text
protectText = (Char -> Text) -> Text -> Text
Data.Text.concatMap ([Char] -> Text
forall a. IsString a => [Char] -> a
fromString ([Char] -> Text) -> (Char -> [Char]) -> Char -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> [Char]
protectChar)

protectChar :: Char -> String
protectChar :: Char -> [Char]
protectChar Char
'#'  = [Char]
"\\#"
protectChar Char
'$'  = [Char]
"\\$"
protectChar Char
'%'  = [Char]
"\\%"
protectChar Char
'^'  = [Char]
"\\^{}"
protectChar Char
'&'  = [Char]
"\\&"
protectChar Char
'{'  = [Char]
"\\{"
protectChar Char
'}'  = [Char]
"\\}"
protectChar Char
'~'  = [Char]
"\\~{}"
protectChar Char
'\\' = [Char]
"\\textbackslash{}"
protectChar Char
'_'  = [Char]
"\\_{}"
protectChar Char
x = [Char
x]

-- Syntax analysis

-- | Look into a 'LaTeX' syntax tree to find any call to the command with
--   the given name. It returns a list of arguments with which this command
--   is called.
--
-- > lookForCommand = (fmap snd .) . matchCommand . (==)
--
--   If the returned list is empty, the command was not found. However,
--   if the list contains empty lists, those are callings to the command
--   with no arguments.
--
--   For example
--
-- > lookForCommand "author" l
--
--   would look for the argument passed to the @\\author@ command in @l@.
lookForCommand :: String -- ^ Name of the command.
               -> LaTeX  -- ^ LaTeX syntax tree.
               -> [[TeXArg]] -- ^ List of arguments passed to the command.
lookForCommand :: [Char] -> LaTeX -> [[TeXArg]]
lookForCommand = ((([Char], [TeXArg]) -> [TeXArg])
-> [([Char], [TeXArg])] -> [[TeXArg]]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char], [TeXArg]) -> [TeXArg]
forall a b. (a, b) -> b
snd ([([Char], [TeXArg])] -> [[TeXArg]])
-> (LaTeX -> [([Char], [TeXArg])]) -> LaTeX -> [[TeXArg]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LaTeX -> [([Char], [TeXArg])]) -> LaTeX -> [[TeXArg]])
-> ([Char] -> LaTeX -> [([Char], [TeXArg])])
-> [Char]
-> LaTeX
-> [[TeXArg]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])])
-> ([Char] -> [Char] -> Bool)
-> [Char]
-> LaTeX
-> [([Char], [TeXArg])]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
(==)

-- | Traverse a 'LaTeX' syntax tree and returns the commands (see 'TeXComm' and
--   'TeXCommS') that matches the condition and their arguments in each call.
matchCommand :: (String -> Bool) -> LaTeX -> [(String,[TeXArg])]
matchCommand :: ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f (TeXComm [Char]
str [TeXArg]
as) =
  let xs :: [([Char], [TeXArg])]
xs = (TeXArg -> [([Char], [TeXArg])])
-> [TeXArg] -> [([Char], [TeXArg])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> TeXArg -> [([Char], [TeXArg])]
matchCommandArg [Char] -> Bool
f) [TeXArg]
as
  in  if [Char] -> Bool
f [Char]
str then ([Char]
str,[TeXArg]
as) ([Char], [TeXArg]) -> [([Char], [TeXArg])] -> [([Char], [TeXArg])]
forall a. a -> [a] -> [a]
: [([Char], [TeXArg])]
xs else [([Char], [TeXArg])]
xs
matchCommand [Char] -> Bool
f (TeXCommS [Char]
str) = [([Char]
str, []) | [Char] -> Bool
f [Char]
str]
matchCommand [Char] -> Bool
f (TeXEnv [Char]
_ [TeXArg]
as LaTeX
l) =
  let xs :: [([Char], [TeXArg])]
xs = (TeXArg -> [([Char], [TeXArg])])
-> [TeXArg] -> [([Char], [TeXArg])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> TeXArg -> [([Char], [TeXArg])]
matchCommandArg [Char] -> Bool
f) [TeXArg]
as
  in  [([Char], [TeXArg])]
xs [([Char], [TeXArg])]
-> [([Char], [TeXArg])] -> [([Char], [TeXArg])]
forall a. [a] -> [a] -> [a]
++ ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommand [Char] -> Bool
f (TeXMath MathType
_ LaTeX
l) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommand [Char] -> Bool
f (TeXBraces LaTeX
l) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommand [Char] -> Bool
f (TeXSeq LaTeX
l1 LaTeX
l2) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l1 [([Char], [TeXArg])]
-> [([Char], [TeXArg])] -> [([Char], [TeXArg])]
forall a. [a] -> [a] -> [a]
++ ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l2
matchCommand [Char] -> Bool
_ LaTeX
_ = []

matchCommandArg :: (String -> Bool) -> TeXArg -> [(String,[TeXArg])]
matchCommandArg :: ([Char] -> Bool) -> TeXArg -> [([Char], [TeXArg])]
matchCommandArg [Char] -> Bool
f (OptArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommandArg [Char] -> Bool
f (FixArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommandArg [Char] -> Bool
f (MOptArg [LaTeX]
ls) = (LaTeX -> [([Char], [TeXArg])]) -> [LaTeX] -> [([Char], [TeXArg])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f) [LaTeX]
ls
matchCommandArg [Char] -> Bool
f (SymArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommandArg [Char] -> Bool
f (MSymArg [LaTeX]
ls) = (LaTeX -> [([Char], [TeXArg])]) -> [LaTeX] -> [([Char], [TeXArg])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f) [LaTeX]
ls
matchCommandArg [Char] -> Bool
f (ParArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f LaTeX
l
matchCommandArg [Char] -> Bool
f (MParArg [LaTeX]
ls) = (LaTeX -> [([Char], [TeXArg])]) -> [LaTeX] -> [([Char], [TeXArg])]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg])]
matchCommand [Char] -> Bool
f) [LaTeX]
ls

-- | Similar to 'lookForCommand', but applied to environments.
--   It returns a list with arguments passed and content of the
--   environment in each call.
--
-- > lookForEnv = (fmap (\(_,as,l) -> (as,l)) .) . matchEnv . (==)
--
lookForEnv :: String -> LaTeX -> [([TeXArg],LaTeX)]
lookForEnv :: [Char] -> LaTeX -> [([TeXArg], LaTeX)]
lookForEnv = ((([Char], [TeXArg], LaTeX) -> ([TeXArg], LaTeX))
-> [([Char], [TeXArg], LaTeX)] -> [([TeXArg], LaTeX)]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\([Char]
_,[TeXArg]
as,LaTeX
l) -> ([TeXArg]
as,LaTeX
l)) ([([Char], [TeXArg], LaTeX)] -> [([TeXArg], LaTeX)])
-> (LaTeX -> [([Char], [TeXArg], LaTeX)])
-> LaTeX
-> [([TeXArg], LaTeX)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.) ((LaTeX -> [([Char], [TeXArg], LaTeX)])
 -> LaTeX -> [([TeXArg], LaTeX)])
-> ([Char] -> LaTeX -> [([Char], [TeXArg], LaTeX)])
-> [Char]
-> LaTeX
-> [([TeXArg], LaTeX)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)])
-> ([Char] -> [Char] -> Bool)
-> [Char]
-> LaTeX
-> [([Char], [TeXArg], LaTeX)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
(==)

-- | Traverse a 'LaTeX' syntax tree and returns the environments (see
--   'TeXEnv') that matches the condition, their arguments and their content
--   in each call.
matchEnv :: (String -> Bool) -> LaTeX -> [(String,[TeXArg],LaTeX)]
matchEnv :: ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f (TeXComm [Char]
_ [TeXArg]
as) = (TeXArg -> [([Char], [TeXArg], LaTeX)])
-> [TeXArg] -> [([Char], [TeXArg], LaTeX)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> TeXArg -> [([Char], [TeXArg], LaTeX)]
matchEnvArg [Char] -> Bool
f) [TeXArg]
as
matchEnv [Char] -> Bool
f (TeXEnv [Char]
str [TeXArg]
as LaTeX
l) =
  let xs :: [([Char], [TeXArg], LaTeX)]
xs = (TeXArg -> [([Char], [TeXArg], LaTeX)])
-> [TeXArg] -> [([Char], [TeXArg], LaTeX)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> TeXArg -> [([Char], [TeXArg], LaTeX)]
matchEnvArg [Char] -> Bool
f) [TeXArg]
as
      ys :: [([Char], [TeXArg], LaTeX)]
ys = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
      zs :: [([Char], [TeXArg], LaTeX)]
zs = [([Char], [TeXArg], LaTeX)]
xs [([Char], [TeXArg], LaTeX)]
-> [([Char], [TeXArg], LaTeX)] -> [([Char], [TeXArg], LaTeX)]
forall a. [a] -> [a] -> [a]
++ [([Char], [TeXArg], LaTeX)]
ys
  in  if [Char] -> Bool
f [Char]
str then ([Char]
str,[TeXArg]
as,LaTeX
l) ([Char], [TeXArg], LaTeX)
-> [([Char], [TeXArg], LaTeX)] -> [([Char], [TeXArg], LaTeX)]
forall a. a -> [a] -> [a]
: [([Char], [TeXArg], LaTeX)]
zs else [([Char], [TeXArg], LaTeX)]
zs
matchEnv [Char] -> Bool
f (TeXMath MathType
_ LaTeX
l) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
matchEnv [Char] -> Bool
f (TeXBraces LaTeX
l) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
matchEnv [Char] -> Bool
f (TeXSeq LaTeX
l1 LaTeX
l2) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l1 [([Char], [TeXArg], LaTeX)]
-> [([Char], [TeXArg], LaTeX)] -> [([Char], [TeXArg], LaTeX)]
forall a. [a] -> [a] -> [a]
++ ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l2
matchEnv [Char] -> Bool
_ LaTeX
_ = []

matchEnvArg :: (String -> Bool) -> TeXArg -> [(String,[TeXArg],LaTeX)]
matchEnvArg :: ([Char] -> Bool) -> TeXArg -> [([Char], [TeXArg], LaTeX)]
matchEnvArg [Char] -> Bool
f (OptArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
matchEnvArg [Char] -> Bool
f (FixArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
matchEnvArg [Char] -> Bool
f (MOptArg [LaTeX]
ls) = (LaTeX -> [([Char], [TeXArg], LaTeX)])
-> [LaTeX] -> [([Char], [TeXArg], LaTeX)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f) [LaTeX]
ls
matchEnvArg [Char] -> Bool
f (SymArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
matchEnvArg [Char] -> Bool
f (MSymArg [LaTeX]
ls) = (LaTeX -> [([Char], [TeXArg], LaTeX)])
-> [LaTeX] -> [([Char], [TeXArg], LaTeX)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f) [LaTeX]
ls
matchEnvArg [Char] -> Bool
f (ParArg  LaTeX
l ) = ([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f LaTeX
l
matchEnvArg [Char] -> Bool
f (MParArg [LaTeX]
ls) = (LaTeX -> [([Char], [TeXArg], LaTeX)])
-> [LaTeX] -> [([Char], [TeXArg], LaTeX)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (([Char] -> Bool) -> LaTeX -> [([Char], [TeXArg], LaTeX)]
matchEnv [Char] -> Bool
f) [LaTeX]
ls

-- | The function 'texmap' looks for subexpressions that match a given
--   condition and applies a function to them.
--
-- > texmap c f = runIdentity . texmapM c (pure . f)
texmap :: (LaTeX -> Bool) -- ^ Condition.
       -> (LaTeX -> LaTeX) -- ^ Function to apply when the condition matches.
       ->  LaTeX -> LaTeX
texmap :: (LaTeX -> Bool) -> (LaTeX -> LaTeX) -> LaTeX -> LaTeX
texmap LaTeX -> Bool
c LaTeX -> LaTeX
f = Identity LaTeX -> LaTeX
forall a. Identity a -> a
runIdentity (Identity LaTeX -> LaTeX)
-> (LaTeX -> Identity LaTeX) -> LaTeX -> LaTeX
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (LaTeX -> Bool)
-> (LaTeX -> Identity LaTeX) -> LaTeX -> Identity LaTeX
forall (m :: * -> *).
(Applicative m, Monad m) =>
(LaTeX -> Bool) -> (LaTeX -> m LaTeX) -> LaTeX -> m LaTeX
texmapM LaTeX -> Bool
c (LaTeX -> Identity LaTeX
forall a. a -> Identity a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (LaTeX -> Identity LaTeX)
-> (LaTeX -> LaTeX) -> LaTeX -> Identity LaTeX
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LaTeX -> LaTeX
f)

-- | Version of 'texmap' where the function returns values in a 'Monad'.
texmapM :: (Applicative m, Monad m)
        => (LaTeX -> Bool) -- ^ Condition.
        -> (LaTeX -> m LaTeX) -- ^ Function to apply when the condition matches.
        ->  LaTeX -> m LaTeX
texmapM :: forall (m :: * -> *).
(Applicative m, Monad m) =>
(LaTeX -> Bool) -> (LaTeX -> m LaTeX) -> LaTeX -> m LaTeX
texmapM LaTeX -> Bool
c LaTeX -> m LaTeX
f = LaTeX -> m LaTeX
go
  where
   go :: LaTeX -> m LaTeX
go l :: LaTeX
l@(TeXComm [Char]
str [TeXArg]
as)  = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else [Char] -> [TeXArg] -> LaTeX
TeXComm [Char]
str ([TeXArg] -> LaTeX) -> m [TeXArg] -> m LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TeXArg -> m TeXArg) -> [TeXArg] -> m [TeXArg]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM TeXArg -> m TeXArg
go' [TeXArg]
as
   go l :: LaTeX
l@(TeXEnv [Char]
str [TeXArg]
as LaTeX
b) = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else [Char] -> [TeXArg] -> LaTeX -> LaTeX
TeXEnv [Char]
str ([TeXArg] -> LaTeX -> LaTeX) -> m [TeXArg] -> m (LaTeX -> LaTeX)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TeXArg -> m TeXArg) -> [TeXArg] -> m [TeXArg]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM TeXArg -> m TeXArg
go' [TeXArg]
as m (LaTeX -> LaTeX) -> m LaTeX -> m LaTeX
forall a b. m (a -> b) -> m a -> m b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> LaTeX -> m LaTeX
go LaTeX
b
   go l :: LaTeX
l@(TeXMath MathType
t LaTeX
b)     = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else MathType -> LaTeX -> LaTeX
TeXMath MathType
t (LaTeX -> LaTeX) -> m LaTeX -> m LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LaTeX -> m LaTeX
go LaTeX
b
   go l :: LaTeX
l@(TeXBraces LaTeX
b)     = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else LaTeX -> LaTeX
TeXBraces (LaTeX -> LaTeX) -> m LaTeX -> m LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LaTeX -> m LaTeX
go LaTeX
b
   go l :: LaTeX
l@(TeXSeq LaTeX
l1 LaTeX
l2)    = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else (LaTeX -> LaTeX -> LaTeX) -> m LaTeX -> m LaTeX -> m LaTeX
forall a b c. (a -> b -> c) -> m a -> m b -> m c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 LaTeX -> LaTeX -> LaTeX
TeXSeq (LaTeX -> m LaTeX
go LaTeX
l1) (LaTeX -> m LaTeX
go LaTeX
l2)
   go LaTeX
l = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else LaTeX -> m LaTeX
forall a. a -> m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure LaTeX
l
   --
   go' :: TeXArg -> m TeXArg
go' (FixArg  LaTeX
l ) = LaTeX -> TeXArg
FixArg  (LaTeX -> TeXArg) -> m LaTeX -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LaTeX -> m LaTeX
go LaTeX
l
   go' (OptArg  LaTeX
l ) = LaTeX -> TeXArg
OptArg  (LaTeX -> TeXArg) -> m LaTeX -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LaTeX -> m LaTeX
go LaTeX
l
   go' (MOptArg [LaTeX]
ls) = [LaTeX] -> TeXArg
MOptArg ([LaTeX] -> TeXArg) -> m [LaTeX] -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LaTeX -> m LaTeX) -> [LaTeX] -> m [LaTeX]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM LaTeX -> m LaTeX
go [LaTeX]
ls
   go' (SymArg  LaTeX
l ) = LaTeX -> TeXArg
SymArg  (LaTeX -> TeXArg) -> m LaTeX -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LaTeX -> m LaTeX
go LaTeX
l
   go' (MSymArg [LaTeX]
ls) = [LaTeX] -> TeXArg
MSymArg ([LaTeX] -> TeXArg) -> m [LaTeX] -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LaTeX -> m LaTeX) -> [LaTeX] -> m [LaTeX]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM LaTeX -> m LaTeX
go [LaTeX]
ls
   go' (ParArg  LaTeX
l ) = LaTeX -> TeXArg
ParArg  (LaTeX -> TeXArg) -> m LaTeX -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> LaTeX -> m LaTeX
go LaTeX
l
   go' (MParArg [LaTeX]
ls) = [LaTeX] -> TeXArg
MParArg ([LaTeX] -> TeXArg) -> m [LaTeX] -> m TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (LaTeX -> m LaTeX) -> [LaTeX] -> m [LaTeX]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b. Monad m => (a -> m b) -> [a] -> m [b]
mapM LaTeX -> m LaTeX
go [LaTeX]
ls

-- | Extract the content of the 'document' environment, if present.
getBody :: LaTeX -> Maybe LaTeX
getBody :: LaTeX -> Maybe LaTeX
getBody LaTeX
l =
  case [Char] -> LaTeX -> [([TeXArg], LaTeX)]
lookForEnv [Char]
"document" LaTeX
l of
    (([TeXArg]
_,LaTeX
b):[([TeXArg], LaTeX)]
_) -> LaTeX -> Maybe LaTeX
forall a. a -> Maybe a
Just LaTeX
b
    [([TeXArg], LaTeX)]
_ -> Maybe LaTeX
forall a. Maybe a
Nothing

-- | Extract the preamble of a 'LaTeX' document (everything before the 'document'
--   environment). It could be empty.
getPreamble :: LaTeX -> LaTeX
getPreamble :: LaTeX -> LaTeX
getPreamble (TeXEnv [Char]
"document" [TeXArg]
_ LaTeX
_) = LaTeX
forall a. Monoid a => a
mempty
getPreamble (TeXSeq LaTeX
l1 LaTeX
l2) = LaTeX -> LaTeX
getPreamble LaTeX
l1 LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> LaTeX -> LaTeX
getPreamble LaTeX
l2
getPreamble LaTeX
l = LaTeX
l

---------------------------------------
-- LaTeX Arbitrary instance

arbitraryChar :: Gen Char
arbitraryChar :: Gen Char
arbitraryChar = [Char] -> Gen Char
forall a. HasCallStack => [a] -> Gen a
elements ([Char] -> Gen Char) -> [Char] -> Gen Char
forall a b. (a -> b) -> a -> b
$
     [Char
'A'..Char
'Z']
  [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'a'..Char
'z']
  [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
"\n-+*/!\".,:;'@? "

-- | Utility for the instance of 'LaTeX' to 'Arbitrary'.
--   We generate a short sequence of characters and
--   escape reserved characters with 'protectText'.
arbitraryRaw :: Gen Text
arbitraryRaw :: Gen Text
arbitraryRaw = do
  Int
n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
20)
  Text -> Text
protectText (Text -> Text) -> ([Char] -> Text) -> [Char] -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Text
pack ([Char] -> Text) -> Gen [Char] -> Gen Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen Char -> Gen [Char]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
n Gen Char
arbitraryChar

-- | Generator for names of command and environments.
--   We use only alphabetical characters.
arbitraryName :: Gen String
arbitraryName :: Gen [Char]
arbitraryName = do
  Int
n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
10)
  Int -> Gen Char -> Gen [Char]
forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
n (Gen Char -> Gen [Char]) -> Gen Char -> Gen [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> Gen Char
forall a. HasCallStack => [a] -> Gen a
elements ([Char] -> Gen Char) -> [Char] -> Gen Char
forall a b. (a -> b) -> a -> b
$ [Char
'a' .. Char
'z'] [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char
'A' .. Char
'Z']

instance Arbitrary Measure where
  arbitrary :: Gen Measure
arbitrary = do
     Int
n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
5)
     let f :: Double -> Measure
f = [Double -> Measure
Pt,Double -> Measure
Mm,Double -> Measure
Cm,Double -> Measure
In,Double -> Measure
Ex,Double -> Measure
Em] [Double -> Measure] -> Int -> Double -> Measure
forall a. HasCallStack => [a] -> Int -> a
!! Int
n
     Double -> Measure
f (Double -> Measure) -> Gen Double -> Gen Measure
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Double
forall a. Arbitrary a => Gen a
arbitrary

instance Arbitrary LaTeX where
  arbitrary :: Gen LaTeX
arbitrary = Bool -> Gen LaTeX
arbitraryLaTeX Bool
False

arbitraryLaTeX :: Bool -> Gen LaTeX
arbitraryLaTeX :: Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar = do
  -- We give more chances to 'TeXRaw'.
  -- This results in arbitrary 'LaTeX' values
  -- not getting too large.
  Int
n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
16 :: Int)
  case Int
n of
    Int
0 -> if Bool
inDollar then Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar else LaTeX -> Gen LaTeX
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure LaTeX
TeXEmpty
    Int
1 -> do Int
m <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
5)
            [Char] -> [TeXArg] -> LaTeX
TeXComm ([Char] -> [TeXArg] -> LaTeX)
-> Gen [Char] -> Gen ([TeXArg] -> LaTeX)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [Char]
arbitraryName Gen ([TeXArg] -> LaTeX) -> Gen [TeXArg] -> Gen LaTeX
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen TeXArg -> Gen [TeXArg]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m Gen TeXArg
forall a. Arbitrary a => Gen a
arbitrary
    Int
2 -> [Char] -> LaTeX
TeXCommS ([Char] -> LaTeX) -> Gen [Char] -> Gen LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [Char]
arbitraryName
    Int
3 -> do Int
m <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
5)
            [Char] -> [TeXArg] -> LaTeX -> LaTeX
TeXEnv ([Char] -> [TeXArg] -> LaTeX -> LaTeX)
-> Gen [Char] -> Gen ([TeXArg] -> LaTeX -> LaTeX)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen [Char]
arbitraryName Gen ([TeXArg] -> LaTeX -> LaTeX)
-> Gen [TeXArg] -> Gen (LaTeX -> LaTeX)
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> Gen TeXArg -> Gen [TeXArg]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m Gen TeXArg
forall a. Arbitrary a => Gen a
arbitrary Gen (LaTeX -> LaTeX) -> Gen LaTeX -> Gen LaTeX
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
    Int
4 -> if Bool
inDollar
            then Bool -> Gen LaTeX
arbitraryLaTeX Bool
True
            else do Int
m <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
3)
                    let t :: MathType
t = [MathType
Parentheses,MathType
Square,MathType
Dollar,MathType
DoubleDollar] [MathType] -> Int -> MathType
forall a. HasCallStack => [a] -> Int -> a
!! Int
m
                    MathType -> LaTeX -> LaTeX
TeXMath (MathType -> LaTeX -> LaTeX)
-> Gen MathType -> Gen (LaTeX -> LaTeX)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MathType -> Gen MathType
forall a. a -> Gen a
forall (f :: * -> *) a. Applicative f => a -> f a
pure MathType
t Gen (LaTeX -> LaTeX) -> Gen LaTeX -> Gen LaTeX
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Gen LaTeX
arbitraryLaTeX (MathType
t MathType -> MathType -> Bool
forall a. Eq a => a -> a -> Bool
== MathType
Dollar Bool -> Bool -> Bool
|| MathType
t MathType -> MathType -> Bool
forall a. Eq a => a -> a -> Bool
== MathType
DoubleDollar)
    Int
5 -> Maybe Measure -> Bool -> LaTeX
TeXLineBreak (Maybe Measure -> Bool -> LaTeX)
-> Gen (Maybe Measure) -> Gen (Bool -> LaTeX)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen (Maybe Measure)
forall a. Arbitrary a => Gen a
arbitrary Gen (Bool -> LaTeX) -> Gen Bool -> Gen LaTeX
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Gen Bool
forall a. Arbitrary a => Gen a
arbitrary
    Int
6 -> LaTeX -> LaTeX
TeXBraces (LaTeX -> LaTeX) -> Gen LaTeX -> Gen LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar
    Int
7 -> Text -> LaTeX
TeXComment (Text -> LaTeX) -> Gen Text -> Gen LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Text
arbitraryRaw
    Int
8 -> LaTeX -> LaTeX -> LaTeX
TeXSeq (LaTeX -> LaTeX -> LaTeX) -> Gen LaTeX -> Gen (LaTeX -> LaTeX)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar Gen (LaTeX -> LaTeX) -> Gen LaTeX -> Gen LaTeX
forall a b. Gen (a -> b) -> Gen a -> Gen b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar
    Int
_ -> Text -> LaTeX
TeXRaw (Text -> LaTeX) -> Gen Text -> Gen LaTeX
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Text
arbitraryRaw

instance Arbitrary TeXArg where
  arbitrary :: Gen TeXArg
arbitrary = do
     Int
n <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
6 :: Int)
     case Int
n of
       Int
0 -> LaTeX -> TeXArg
OptArg (LaTeX -> TeXArg) -> Gen LaTeX -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
       Int
1 -> do Int
m <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
5)
               [LaTeX] -> TeXArg
MOptArg ([LaTeX] -> TeXArg) -> Gen [LaTeX] -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen LaTeX -> Gen [LaTeX]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
       Int
2 -> LaTeX -> TeXArg
SymArg (LaTeX -> TeXArg) -> Gen LaTeX -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
       Int
3 -> do Int
m <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
5)
               [LaTeX] -> TeXArg
MSymArg ([LaTeX] -> TeXArg) -> Gen [LaTeX] -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen LaTeX -> Gen [LaTeX]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
       Int
4 -> LaTeX -> TeXArg
ParArg (LaTeX -> TeXArg) -> Gen LaTeX -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
       Int
5 -> do Int
m <- (Int, Int) -> Gen Int
forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
5)
               [LaTeX] -> TeXArg
MParArg ([LaTeX] -> TeXArg) -> Gen [LaTeX] -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Gen LaTeX -> Gen [LaTeX]
forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary
       Int
_ -> LaTeX -> TeXArg
FixArg (LaTeX -> TeXArg) -> Gen LaTeX -> Gen TeXArg
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen LaTeX
forall a. Arbitrary a => Gen a
arbitrary


instance Hashable Measure
instance Hashable MathType
instance Hashable TeXArg
instance Hashable LaTeX