{-# LANGUAGE OverloadedStrings #-}

-- |
-- 
-- /For contributors: This module was automatically generated by HaTeX-meta./
-- /So, please, don't make any change here directly, because/
-- /this is intended to be generated automatically from/
-- "Text.LaTeX.Packages.AMSMath" /module via HaTeX-meta,/
-- /and therefore, changes must to be done in these places./

module Text.LaTeX.Packages.AMSMath.Monad
 ( -- * AMSMath package
   amsmath
   -- * AMSMath functions
 , math
   -- * Symbols and utilities
   -- ** Superscript and subscript
 , (^:) , (!:)
   -- ** Function symbols
   -- | Some symbols are preceded with /t/ to be distinguished from
   --   predefined Haskell entities (like 'sin' and 'cos').
 , tsin , arcsin
 , tcos , arccos
 , ttan , arctan
 , texp
 , tlog , ln
   -- ** Operator symbols
 , (=:) , (/=:)
 , (>:) , (>=:)
 , (<:) , (<=:)
 , in_ , ni , notin
   -- ** Greek alphabet
   -- | Functions of greek alphabet symbols.
   --
   --   Uppercase versions are suffixed with @u@.
   --   Variants are prefixed with @var@.
   --   The function 'pi_' is ended by an underscore symbol to
   --   distinguish it from the 'pi' Prelude function.
 , alpha    , beta       , gamma
 , gammau   , delta      , deltau
 , epsilon  , varepsilon , zeta
 , eta      , theta      , thetau
 , iota     , kappa      , lambda
 , lambdau  , mu         , nu
 , xi       , xiu        , pi_
 , varpi    , piu        , rho
 , varrho   , sigma      , varsigma
 , sigmau   , tau        , upsilon
 , upsilonu , phi        , varphi
 , phiu     , chi        , psi
 , psiu     , omega      , omegau
   -- ** Other symbols
 , to
 , forall
 , dagger, ddagger
   -- * Fonts
 , mathbf
 , mathrm
 , mathcal
 , mathsf
 , mathtt
 , mathit
   ) where

import Text.LaTeX.Base.Writer
import Text.LaTeX.Base.Render
import Text.LaTeX.Base.Types
import qualified Text.LaTeX.Packages.AMSMath as App
import Text.LaTeX.Packages.AMSMath()

{-|
AMSMath package.
 Example:

>  usepackage [] amsmath

-}
amsmath :: PackageName
amsmath = App.amsmath

-- | Inline mathematical expressions.

math ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
math a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.math a1)


(^:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(^:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.^:) a1 a2)


(!:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(!:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.!:) a1 a2)

-- | Sine function symbol.

tsin ::   (Monad m) => LaTeXT_ m
tsin = do textell ( App.tsin)

-- | Arcsine function symbol.

arcsin ::   (Monad m) => LaTeXT_ m
arcsin = do textell ( App.arcsin)

-- | Cosine function symbol.

tcos ::   (Monad m) => LaTeXT_ m
tcos = do textell ( App.tcos)

-- | Arccosine function symbol.

arccos ::   (Monad m) => LaTeXT_ m
arccos = do textell ( App.arccos)

-- | Tangent function symbol.

ttan ::   (Monad m) => LaTeXT_ m
ttan = do textell ( App.ttan)


arctan ::   (Monad m) => LaTeXT_ m
arctan = do textell ( App.arctan)

-- | Exponential function symbol.

texp ::   (Monad m) => LaTeXT_ m
texp = do textell ( App.texp)

-- | Logarithm function symbol.

tlog ::   (Monad m) => LaTeXT_ m
tlog = do textell ( App.tlog)

-- | Natural logarithm symbol.

ln ::   (Monad m) => LaTeXT_ m
ln = do textell ( App.ln)


(=:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(=:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.=:) a1 a2)


(/=:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(/=:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App./=:) a1 a2)


(>:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(>:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.>:) a1 a2)


(>=:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(>=:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.>=:) a1 a2)


(<:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(<:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.<:) a1 a2)


(<=:) ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
(<=:) a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( (App.<=:) a1 a2)


in_ ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
in_ a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( App.in_ a1 a2)


ni ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
ni a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( App.ni a1 a2)


notin ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m -> LaTeXT_ m
notin a1 a2
  = do a1 <- extractLaTeX_ a1
       a2 <- extractLaTeX_ a2
       textell ( App.notin a1 a2)


alpha ::   (Monad m) => LaTeXT_ m
alpha = do textell ( App.alpha)


beta ::   (Monad m) => LaTeXT_ m
beta = do textell ( App.beta)


gamma ::   (Monad m) => LaTeXT_ m
gamma = do textell ( App.gamma)


gammau ::   (Monad m) => LaTeXT_ m
gammau = do textell ( App.gammau)


delta ::   (Monad m) => LaTeXT_ m
delta = do textell ( App.delta)


deltau ::   (Monad m) => LaTeXT_ m
deltau = do textell ( App.deltau)


epsilon ::   (Monad m) => LaTeXT_ m
epsilon = do textell ( App.epsilon)


varepsilon ::   (Monad m) => LaTeXT_ m
varepsilon = do textell ( App.varepsilon)


zeta ::   (Monad m) => LaTeXT_ m
zeta = do textell ( App.zeta)


eta ::   (Monad m) => LaTeXT_ m
eta = do textell ( App.eta)


theta ::   (Monad m) => LaTeXT_ m
theta = do textell ( App.theta)


thetau ::   (Monad m) => LaTeXT_ m
thetau = do textell ( App.thetau)


iota ::   (Monad m) => LaTeXT_ m
iota = do textell ( App.iota)


kappa ::   (Monad m) => LaTeXT_ m
kappa = do textell ( App.kappa)


lambda ::   (Monad m) => LaTeXT_ m
lambda = do textell ( App.lambda)


lambdau ::   (Monad m) => LaTeXT_ m
lambdau = do textell ( App.lambdau)


mu ::   (Monad m) => LaTeXT_ m
mu = do textell ( App.mu)


nu ::   (Monad m) => LaTeXT_ m
nu = do textell ( App.nu)


xi ::   (Monad m) => LaTeXT_ m
xi = do textell ( App.xi)


xiu ::   (Monad m) => LaTeXT_ m
xiu = do textell ( App.xiu)


pi_ ::   (Monad m) => LaTeXT_ m
pi_ = do textell ( App.pi_)


varpi ::   (Monad m) => LaTeXT_ m
varpi = do textell ( App.varpi)


piu ::   (Monad m) => LaTeXT_ m
piu = do textell ( App.piu)


rho ::   (Monad m) => LaTeXT_ m
rho = do textell ( App.rho)


varrho ::   (Monad m) => LaTeXT_ m
varrho = do textell ( App.varrho)


sigma ::   (Monad m) => LaTeXT_ m
sigma = do textell ( App.sigma)


varsigma ::   (Monad m) => LaTeXT_ m
varsigma = do textell ( App.varsigma)


sigmau ::   (Monad m) => LaTeXT_ m
sigmau = do textell ( App.sigmau)


tau ::   (Monad m) => LaTeXT_ m
tau = do textell ( App.tau)


upsilon ::   (Monad m) => LaTeXT_ m
upsilon = do textell ( App.upsilon)


upsilonu ::   (Monad m) => LaTeXT_ m
upsilonu = do textell ( App.upsilonu)


phi ::   (Monad m) => LaTeXT_ m
phi = do textell ( App.phi)


varphi ::   (Monad m) => LaTeXT_ m
varphi = do textell ( App.varphi)


phiu ::   (Monad m) => LaTeXT_ m
phiu = do textell ( App.phiu)


chi ::   (Monad m) => LaTeXT_ m
chi = do textell ( App.chi)


psi ::   (Monad m) => LaTeXT_ m
psi = do textell ( App.psi)


psiu ::   (Monad m) => LaTeXT_ m
psiu = do textell ( App.psiu)


omega ::   (Monad m) => LaTeXT_ m
omega = do textell ( App.omega)


omegau ::   (Monad m) => LaTeXT_ m
omegau = do textell ( App.omegau)

-- | A right-arrow.

to ::   (Monad m) => LaTeXT_ m
to = do textell ( App.to)

-- | /For all/ symbol.

forall ::   (Monad m) => LaTeXT_ m
forall = do textell ( App.forall)

-- | Dagger symbol.

dagger ::   (Monad m) => LaTeXT_ m
dagger = do textell ( App.dagger)

-- | Double dagger symbol.

ddagger ::   (Monad m) => LaTeXT_ m
ddagger = do textell ( App.ddagger)


mathbf ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
mathbf a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.mathbf a1)


mathrm ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
mathrm a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.mathrm a1)


mathcal ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
mathcal a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.mathcal a1)


mathsf ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
mathsf a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.mathsf a1)


mathtt ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
mathtt a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.mathtt a1)


mathit ::   (Monad m) => LaTeXT_ m -> LaTeXT_ m
mathit a1
  = do a1 <- extractLaTeX_ a1
       textell ( App.mathit a1)