{-# LANGUAGE CPP, 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.Applicative
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)
#if !MIN_VERSION_base(4,11,0)
import Data.Monoid
#endif

-- | 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
Measure -> DataType
Measure -> Constr
(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)
gmapMo :: 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
gmapMp :: forall (m :: * -> *).
MonadPlus 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
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Measure -> m Measure
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Measure -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Measure -> u
gmapQ :: forall u. (forall d. Data d => d -> u) -> Measure -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Measure -> [u]
gmapQr :: 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
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Measure -> r
gmapT :: (forall b. Data b => b -> b) -> Measure -> Measure
$cgmapT :: (forall b. Data b => b -> b) -> Measure -> Measure
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Measure)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Measure)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Measure)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Measure)
dataTypeOf :: Measure -> DataType
$cdataTypeOf :: Measure -> DataType
toConstr :: Measure -> Constr
$ctoConstr :: Measure -> Constr
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Measure
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Measure
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Measure -> c Measure
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Measure -> c Measure
Data, Measure -> Measure -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Measure -> Measure -> Bool
$c/= :: Measure -> Measure -> Bool
== :: Measure -> Measure -> Bool
$c== :: Measure -> Measure -> Bool
Eq, 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
$cto :: forall x. Rep Measure x -> Measure
$cfrom :: forall x. Measure -> Rep Measure x
Generic, Int -> Measure -> ShowS
[Measure] -> ShowS
Measure -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Measure] -> ShowS
$cshowList :: [Measure] -> ShowS
show :: Measure -> String
$cshow :: Measure -> String
showsPrec :: Int -> Measure -> ShowS
$cshowsPrec :: Int -> Measure -> ShowS
Show, Typeable)

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

-- | Method 'fromString' escapes LaTeX reserved characters using 'protectString'.
instance IsString LaTeX where
 fromString :: String -> LaTeX
fromString = Text -> LaTeX
TeXRaw forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IsString a => String -> a
fromString 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 = forall a. Monoid a => [a] -> a
mconcat forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Char -> String
protectChar

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

protectChar :: Char -> String
protectChar :: Char -> String
protectChar Char
'#'  = String
"\\#"
protectChar Char
'$'  = String
"\\$"
protectChar Char
'%'  = String
"\\%"
protectChar Char
'^'  = String
"\\^{}"
protectChar Char
'&'  = String
"\\&"
protectChar Char
'{'  = String
"\\{"
protectChar Char
'}'  = String
"\\}"
protectChar Char
'~'  = String
"\\~{}"
protectChar Char
'\\' = String
"\\textbackslash{}"
protectChar Char
'_'  = String
"\\_{}"
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 :: String -> LaTeX -> [[TeXArg]]
lookForCommand = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a, b) -> b
snd forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f (TeXComm String
str [TeXArg]
as) =
  let xs :: [(String, [TeXArg])]
xs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> TeXArg -> [(String, [TeXArg])]
matchCommandArg String -> Bool
f) [TeXArg]
as
  in  if String -> Bool
f String
str then (String
str,[TeXArg]
as) forall a. a -> [a] -> [a]
: [(String, [TeXArg])]
xs else [(String, [TeXArg])]
xs
matchCommand String -> Bool
f (TeXCommS String
str) = [(String
str, []) | String -> Bool
f String
str]
matchCommand String -> Bool
f (TeXEnv String
_ [TeXArg]
as LaTeX
l) =
  let xs :: [(String, [TeXArg])]
xs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> TeXArg -> [(String, [TeXArg])]
matchCommandArg String -> Bool
f) [TeXArg]
as
  in  [(String, [TeXArg])]
xs forall a. [a] -> [a] -> [a]
++ (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommand String -> Bool
f (TeXMath MathType
_ LaTeX
l) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommand String -> Bool
f (TeXBraces LaTeX
l) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommand String -> Bool
f (TeXSeq LaTeX
l1 LaTeX
l2) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l1 forall a. [a] -> [a] -> [a]
++ (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l2
matchCommand String -> Bool
_ LaTeX
_ = []

matchCommandArg :: (String -> Bool) -> TeXArg -> [(String,[TeXArg])]
matchCommandArg :: (String -> Bool) -> TeXArg -> [(String, [TeXArg])]
matchCommandArg String -> Bool
f (OptArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommandArg String -> Bool
f (FixArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommandArg String -> Bool
f (MOptArg [LaTeX]
ls) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f) [LaTeX]
ls
matchCommandArg String -> Bool
f (SymArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommandArg String -> Bool
f (MSymArg [LaTeX]
ls) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f) [LaTeX]
ls
matchCommandArg String -> Bool
f (ParArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> Bool
f LaTeX
l
matchCommandArg String -> Bool
f (MParArg [LaTeX]
ls) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> LaTeX -> [(String, [TeXArg])]
matchCommand String -> 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 :: String -> LaTeX -> [([TeXArg], LaTeX)]
lookForEnv = (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(String
_,[TeXArg]
as,LaTeX
l) -> ([TeXArg]
as,LaTeX
l)) forall b c a. (b -> c) -> (a -> b) -> a -> c
.) forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f (TeXComm String
_ [TeXArg]
as) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> TeXArg -> [(String, [TeXArg], LaTeX)]
matchEnvArg String -> Bool
f) [TeXArg]
as
matchEnv String -> Bool
f (TeXEnv String
str [TeXArg]
as LaTeX
l) =
  let xs :: [(String, [TeXArg], LaTeX)]
xs = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> TeXArg -> [(String, [TeXArg], LaTeX)]
matchEnvArg String -> Bool
f) [TeXArg]
as
      ys :: [(String, [TeXArg], LaTeX)]
ys = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
      zs :: [(String, [TeXArg], LaTeX)]
zs = [(String, [TeXArg], LaTeX)]
xs forall a. [a] -> [a] -> [a]
++ [(String, [TeXArg], LaTeX)]
ys
  in  if String -> Bool
f String
str then (String
str,[TeXArg]
as,LaTeX
l) forall a. a -> [a] -> [a]
: [(String, [TeXArg], LaTeX)]
zs else [(String, [TeXArg], LaTeX)]
zs
matchEnv String -> Bool
f (TeXMath MathType
_ LaTeX
l) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
matchEnv String -> Bool
f (TeXBraces LaTeX
l) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
matchEnv String -> Bool
f (TeXSeq LaTeX
l1 LaTeX
l2) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l1 forall a. [a] -> [a] -> [a]
++ (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l2
matchEnv String -> Bool
_ LaTeX
_ = []

matchEnvArg :: (String -> Bool) -> TeXArg -> [(String,[TeXArg],LaTeX)]
matchEnvArg :: (String -> Bool) -> TeXArg -> [(String, [TeXArg], LaTeX)]
matchEnvArg String -> Bool
f (OptArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
matchEnvArg String -> Bool
f (FixArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
matchEnvArg String -> Bool
f (MOptArg [LaTeX]
ls) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f) [LaTeX]
ls
matchEnvArg String -> Bool
f (SymArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
matchEnvArg String -> Bool
f (MSymArg [LaTeX]
ls) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f) [LaTeX]
ls
matchEnvArg String -> Bool
f (ParArg  LaTeX
l ) = (String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> Bool
f LaTeX
l
matchEnvArg String -> Bool
f (MParArg [LaTeX]
ls) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ((String -> Bool) -> LaTeX -> [(String, [TeXArg], LaTeX)]
matchEnv String -> 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 = forall a. Identity a -> a
runIdentity forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *).
(Applicative m, Monad m) =>
(LaTeX -> Bool) -> (LaTeX -> m LaTeX) -> LaTeX -> m LaTeX
texmapM LaTeX -> Bool
c (forall (f :: * -> *) a. Applicative f => a -> f a
pure 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 String
str [TeXArg]
as)  = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else String -> [TeXArg] -> LaTeX
TeXComm String
str forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TeXArg -> m TeXArg
go' [TeXArg]
as
   go l :: LaTeX
l@(TeXEnv String
str [TeXArg]
as LaTeX
b) = if LaTeX -> Bool
c LaTeX
l then LaTeX -> m LaTeX
f LaTeX
l else String -> [TeXArg] -> LaTeX -> LaTeX
TeXEnv String
str forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM TeXArg -> m TeXArg
go' [TeXArg]
as 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 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 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 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 forall (f :: * -> *) a. Applicative f => a -> f a
pure LaTeX
l
   --
   go' :: TeXArg -> m TeXArg
go' (FixArg  LaTeX
l ) = LaTeX -> TeXArg
FixArg  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  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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM LaTeX -> m LaTeX
go [LaTeX]
ls
   go' (SymArg  LaTeX
l ) = LaTeX -> TeXArg
SymArg  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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM LaTeX -> m LaTeX
go [LaTeX]
ls
   go' (ParArg  LaTeX
l ) = LaTeX -> TeXArg
ParArg  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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t 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 String -> LaTeX -> [([TeXArg], LaTeX)]
lookForEnv String
"document" LaTeX
l of
    (([TeXArg]
_,LaTeX
b):[([TeXArg], LaTeX)]
_) -> forall a. a -> Maybe a
Just LaTeX
b
    [([TeXArg], 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 String
"document" [TeXArg]
_ LaTeX
_) = forall a. Monoid a => a
mempty
getPreamble (TeXSeq LaTeX
l1 LaTeX
l2) = LaTeX -> LaTeX
getPreamble LaTeX
l1 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 = forall a. [a] -> Gen a
elements forall a b. (a -> b) -> a -> b
$
     [Char
'A'..Char
'Z']
  forall a. [a] -> [a] -> [a]
++ [Char
'a'..Char
'z']
  forall a. [a] -> [a] -> [a]
++ String
"\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 <- forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
20)
  Text -> Text
protectText forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
pack forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 String
arbitraryName = do
  Int
n <- forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
10)
  forall (m :: * -> *) a. Applicative m => Int -> m a -> m [a]
replicateM Int
n forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Gen a
elements forall a b. (a -> b) -> a -> b
$ [Char
'a' .. Char
'z'] forall a. [a] -> [a] -> [a]
++ [Char
'A' .. Char
'Z']

instance Arbitrary Measure where
  arbitrary :: Gen Measure
arbitrary = do
     Int
n <- 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] forall a. [a] -> Int -> a
!! Int
n
     Double -> Measure
f forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 <- 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 forall (f :: * -> *) a. Applicative f => a -> f a
pure LaTeX
TeXEmpty
    Int
1 -> do Int
m <- forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
5)
            String -> [TeXArg] -> LaTeX
TeXComm forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
arbitraryName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m forall a. Arbitrary a => Gen a
arbitrary
    Int
2 -> String -> LaTeX
TeXCommS forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
arbitraryName
    Int
3 -> do Int
m <- forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
5)
            String -> [TeXArg] -> LaTeX -> LaTeX
TeXEnv forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen String
arbitraryName forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m forall a. Arbitrary a => Gen a
arbitrary forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary
    Int
4 -> if Bool
inDollar
            then Bool -> Gen LaTeX
arbitraryLaTeX Bool
True
            else do Int
m <- 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] forall a. [a] -> Int -> a
!! Int
m
                    MathType -> LaTeX -> LaTeX
TeXMath forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a. Applicative f => a -> f a
pure MathType
t forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Gen LaTeX
arbitraryLaTeX (MathType
t forall a. Eq a => a -> a -> Bool
== MathType
Dollar Bool -> Bool -> Bool
|| MathType
t forall a. Eq a => a -> a -> Bool
== MathType
DoubleDollar)
    Int
5 -> Maybe Measure -> Bool -> LaTeX
TeXLineBreak forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Arbitrary a => Gen a
arbitrary
    Int
6 -> LaTeX -> LaTeX
TeXBraces forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar
    Int
7 -> Text -> LaTeX
TeXComment forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Gen Text
arbitraryRaw
    Int
8 -> LaTeX -> LaTeX -> LaTeX
TeXSeq forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Bool -> Gen LaTeX
arbitraryLaTeX Bool
inDollar
    Int
_ -> Text -> LaTeX
TeXRaw 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 <- forall a. Random a => (a, a) -> Gen a
choose (Int
0,Int
6 :: Int)
     case Int
n of
       Int
0 -> LaTeX -> TeXArg
OptArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
       Int
1 -> do Int
m <- forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
5)
               [LaTeX] -> TeXArg
MOptArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m forall a. Arbitrary a => Gen a
arbitrary
       Int
2 -> LaTeX -> TeXArg
SymArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
       Int
3 -> do Int
m <- forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
5)
               [LaTeX] -> TeXArg
MSymArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m forall a. Arbitrary a => Gen a
arbitrary
       Int
4 -> LaTeX -> TeXArg
ParArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary
       Int
5 -> do Int
m <- forall a. Random a => (a, a) -> Gen a
choose (Int
1,Int
5)
               [LaTeX] -> TeXArg
MParArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Int -> Gen a -> Gen [a]
vectorOf Int
m forall a. Arbitrary a => Gen a
arbitrary
       Int
_ -> LaTeX -> TeXArg
FixArg forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Arbitrary a => Gen a
arbitrary


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