{-# LANGUAGE TupleSections #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE OverloadedStrings #-}
{-
Copyright (C) 2009 John MacFarlane <jgm@berkeley.edu>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-}

{- | Functions for parsing a LaTeX formula to a Haskell representation.
-}

module Text.TeXMath.Readers.TeX (readTeX)
where

import Data.List (intercalate, intersperse, find)
import Control.Monad
import Data.Char (isDigit, isAscii, isLetter)
import qualified Data.Map as M
import qualified Data.Text as T
import Data.Text (Text)
import Data.Maybe (catMaybes, fromJust, mapMaybe)
import Text.Parsec hiding (label)
import Text.Parsec.Error
import Text.Parsec.Text
import Text.TeXMath.Types
import Data.Functor (($>))
import qualified Text.TeXMath.Shared as S
import Text.TeXMath.Readers.TeX.Macros (applyMacros, parseMacroDefinitions)
import Text.TeXMath.Unicode.ToTeX (getSymbolType)
import Text.TeXMath.Unicode.ToUnicode (toUnicode)
import Text.TeXMath.Shared (getSpaceChars)
import Data.Generics (everywhere, mkT)
import Text.TeXMath.Readers.TeX.Commands ( styleOps, textOps, enclosures,
                                           operators, symbols, siUnitMap )

type TP = Parser

-- The parser

expr1 :: TP Exp
expr1 :: TP Exp
expr1 = [TP Exp] -> TP Exp
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice
          [ TP Exp
inbraces
          , TP Exp
variable
          , TP Exp
number
          , TP Exp
unicode
          , TP Exp
operator
          , TP Exp
bareSubSup
          , TP Exp
enclosure
          , TP Exp
hyperref
          , TP Exp
command
          ] TP Exp -> ParsecT Text () Identity () -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
ignorable

-- | Parse a formula, returning a list of 'Exp'.
readTeX :: Text -> Either Text [Exp]
readTeX :: Text -> Either Text [Exp]
readTeX inp :: Text
inp =
  let (ms :: [Macro]
ms, rest :: Text
rest) = Text -> ([Macro], Text)
parseMacroDefinitions Text
inp in
  (ParseError -> Either Text [Exp])
-> ([Exp] -> Either Text [Exp])
-> Either ParseError [Exp]
-> Either Text [Exp]
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Text -> Either Text [Exp]
forall a b. a -> Either a b
Left (Text -> Either Text [Exp])
-> (ParseError -> Text) -> ParseError -> Either Text [Exp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> ParseError -> Text
showParseError Text
inp) ([Exp] -> Either Text [Exp]
forall a b. b -> Either a b
Right ([Exp] -> Either Text [Exp])
-> ([Exp] -> [Exp]) -> [Exp] -> Either Text [Exp]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (forall a. Data a => a -> a) -> forall a. Data a => a -> a
everywhere ((Exp -> Exp) -> a -> a
forall a b. (Typeable a, Typeable b) => (b -> b) -> a -> a
mkT Exp -> Exp
fixBins))
    (Either ParseError [Exp] -> Either Text [Exp])
-> Either ParseError [Exp] -> Either Text [Exp]
forall a b. (a -> b) -> a -> b
$ Parsec Text () [Exp]
-> SourceName -> Text -> Either ParseError [Exp]
forall s t a.
Stream s Identity t =>
Parsec s () a -> SourceName -> s -> Either ParseError a
parse Parsec Text () [Exp]
formula "formula" (Text -> Either ParseError [Exp])
-> Text -> Either ParseError [Exp]
forall a b. (a -> b) -> a -> b
$ [Macro] -> Text -> Text
applyMacros [Macro]
ms Text
rest

-- | Convert Bin after nothing, Open, Pun, or Op to Op (#176).
fixBins :: Exp -> Exp
fixBins :: Exp -> Exp
fixBins e :: Exp
e =
  case Exp
e of
    EGrouped es :: [Exp]
es -> [Exp] -> Exp
EGrouped (Bool -> [Exp] -> [Exp]
fixBinList Bool
True [Exp]
es)
    EDelimited op :: Text
op cl :: Text
cl des :: [InEDelimited]
des -> Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
op Text
cl (Bool -> [InEDelimited] -> [InEDelimited]
forall a. Bool -> [Either a Exp] -> [Either a Exp]
fixBinListDel Bool
True [InEDelimited]
des)
    _ -> Exp
e
 where
  fixBinList :: Bool -> [Exp] -> [Exp]
fixBinList atBeginning :: Bool
atBeginning xs :: [Exp]
xs =
    case [Exp]
xs of
      ESymbol Bin t :: Text
t : rest :: [Exp]
rest
        | Bool
atBeginning
        -> TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Op Text
t Exp -> [Exp] -> [Exp]
forall a. a -> [a] -> [a]
: Bool -> [Exp] -> [Exp]
fixBinList Bool
False [Exp]
rest
      ESymbol Bin t :: Text
t : rest :: [Exp]
rest@(ESymbol ty :: TeXSymbolType
ty _ : _)
        | TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Open Bool -> Bool -> Bool
|| TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Pun Bool -> Bool -> Bool
|| TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Op
        -> TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Op Text
t Exp -> [Exp] -> [Exp]
forall a. a -> [a] -> [a]
: Bool -> [Exp] -> [Exp]
fixBinList Bool
False [Exp]
rest
      x :: Exp
x:rest :: [Exp]
rest -> Exp
x Exp -> [Exp] -> [Exp]
forall a. a -> [a] -> [a]
: Bool -> [Exp] -> [Exp]
fixBinList Bool
False [Exp]
rest
      [] -> []

  fixBinListDel :: Bool -> [Either a Exp] -> [Either a Exp]
fixBinListDel atBeginning :: Bool
atBeginning xs :: [Either a Exp]
xs =
    case [Either a Exp]
xs of
      Left x :: a
x : rest :: [Either a Exp]
rest
        ->  a -> Either a Exp
forall a b. a -> Either a b
Left a
x Either a Exp -> [Either a Exp] -> [Either a Exp]
forall a. a -> [a] -> [a]
: Bool -> [Either a Exp] -> [Either a Exp]
fixBinListDel Bool
True [Either a Exp]
rest
      Right (ESymbol Bin t :: Text
t) : rest :: [Either a Exp]
rest
        | Bool
atBeginning
        -> Exp -> Either a Exp
forall a b. b -> Either a b
Right (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Op Text
t) Either a Exp -> [Either a Exp] -> [Either a Exp]
forall a. a -> [a] -> [a]
: Bool -> [Either a Exp] -> [Either a Exp]
fixBinListDel Bool
False [Either a Exp]
rest
      Right (ESymbol Bin t :: Text
t) : rest :: [Either a Exp]
rest@(Right (ESymbol ty :: TeXSymbolType
ty _):_)
        | TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Open Bool -> Bool -> Bool
|| TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Pun Bool -> Bool -> Bool
|| TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Op
        -> Exp -> Either a Exp
forall a b. b -> Either a b
Right (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Op Text
t) Either a Exp -> [Either a Exp] -> [Either a Exp]
forall a. a -> [a] -> [a]
: Bool -> [Either a Exp] -> [Either a Exp]
fixBinListDel Bool
False [Either a Exp]
rest
      x :: Either a Exp
x:rest :: [Either a Exp]
rest -> Either a Exp
x Either a Exp -> [Either a Exp] -> [Either a Exp]
forall a. a -> [a] -> [a]
: Bool -> [Either a Exp] -> [Either a Exp]
fixBinListDel Bool
False [Either a Exp]
rest
      [] -> []

showParseError :: Text -> ParseError -> Text
showParseError :: Text -> ParseError -> Text
showParseError inp :: Text
inp pe :: ParseError
pe =
  Text
snippet Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "\n" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
caretline Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
    SourceName -> Text
T.pack (SourceName
-> SourceName
-> SourceName
-> SourceName
-> SourceName
-> [Message]
-> SourceName
showErrorMessages "or" "unknown" "expecting" "unexpected" "eof"
            (ParseError -> [Message]
errorMessages ParseError
pe))
  where errln :: Line
errln = SourcePos -> Line
sourceLine (ParseError -> SourcePos
errorPos ParseError
pe)
        errcol :: Line
errcol = SourcePos -> Line
sourceColumn (ParseError -> SourcePos
errorPos ParseError
pe)
        snipoffset :: Line
snipoffset = Line -> Line -> Line
forall a. Ord a => a -> a -> a
max 0 (Line
errcol Line -> Line -> Line
forall a. Num a => a -> a -> a
- 20)
        inplns :: [Text]
inplns = Text -> [Text]
T.lines Text
inp
        ln :: Text
ln = if [Text] -> Line
forall (t :: * -> *) a. Foldable t => t a -> Line
length [Text]
inplns Line -> Line -> Bool
forall a. Ord a => a -> a -> Bool
>= Line
errln
                then [Text]
inplns [Text] -> Line -> Text
forall a. [a] -> Line -> a
!! (Line
errln Line -> Line -> Line
forall a. Num a => a -> a -> a
- 1)
                else ""  -- should not happen
        snippet :: Text
snippet = Line -> Text -> Text
T.take 40 (Text -> Text) -> Text -> Text
forall a b. (a -> b) -> a -> b
$ Line -> Text -> Text
T.drop Line
snipoffset Text
ln
        caretline :: Text
caretline = Line -> Text -> Text
T.replicate (Line
errcol Line -> Line -> Line
forall a. Num a => a -> a -> a
- Line
snipoffset Line -> Line -> Line
forall a. Num a => a -> a -> a
- 1) " " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "^"

anyCtrlSeq :: TP Text
anyCtrlSeq :: TP Text
anyCtrlSeq = TP Text -> TP Text
forall a. TP a -> TP a
lexeme (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ do
  Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '\\'
  SourceName
res <- Line
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
Line -> ParsecT s u m a -> ParsecT s u m [a]
count 1 ((Char -> Bool) -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (Bool -> Bool
not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isLetter)) ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ((Char -> Bool) -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy Char -> Bool
isLetter)
  Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> TP Text) -> Text -> TP Text
forall a b. (a -> b) -> a -> b
$ SourceName -> Text
T.pack (SourceName -> Text) -> SourceName -> Text
forall a b. (a -> b) -> a -> b
$ '\\' Char -> SourceName -> SourceName
forall a. a -> [a] -> [a]
: SourceName
res

ctrlseq :: String -> TP String
ctrlseq :: SourceName -> ParsecT Text () Identity SourceName
ctrlseq s :: SourceName
s = ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a. TP a -> TP a
lexeme (ParsecT Text () Identity SourceName
 -> ParsecT Text () Identity SourceName)
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a b. (a -> b) -> a -> b
$ ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity SourceName
 -> ParsecT Text () Identity SourceName)
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a b. (a -> b) -> a -> b
$ do
  SourceName
result <- SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string ('\\'Char -> SourceName -> SourceName
forall a. a -> [a] -> [a]
:SourceName
s)
  case SourceName
s of
       [c :: Char
c] | Bool -> Bool
not (Char -> Bool
isLetter Char
c) -> () -> ParsecT Text () Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
       _ -> (do SourcePos
pos <- ParsecT Text () Identity SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
                ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
                SourcePos -> ParsecT Text () Identity ()
forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
setPosition SourcePos
pos
                ParsecT Text () Identity ()
forall (m :: * -> *) a. MonadPlus m => m a
mzero ParsecT Text () Identity ()
-> SourceName -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> ("non-letter after \\" SourceName -> SourceName -> SourceName
forall a. [a] -> [a] -> [a]
++ SourceName
s))
            ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> () -> ParsecT Text () Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  SourceName -> ParsecT Text () Identity SourceName
forall (m :: * -> *) a. Monad m => a -> m a
return SourceName
result

ignorable :: TP ()
ignorable :: ParsecT Text () Identity ()
ignorable = ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (ParsecT Text () Identity () -> ParsecT Text () Identity ())
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$
        ParsecT Text () Identity ()
comment
    ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text () Identity ()
label
    ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text () Identity ()
tag
    ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> () ()
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
ctrlseq "nonumber"
    ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
space ParsecT Text () Identity ()
-> SourceName -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> "whitespace")

comment :: TP ()
comment :: ParsecT Text () Identity ()
comment = Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '%' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf "\n") ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
newline

label :: TP ()
label :: ParsecT Text () Identity ()
label = SourceName -> ParsecT Text () Identity SourceName
ctrlseq "label" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a. TP a -> TP a
braces (ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf "}"))

tag :: TP ()
tag :: ParsecT Text () Identity ()
tag = SourceName -> ParsecT Text () Identity SourceName
ctrlseq "tag" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '*') ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a. TP a -> TP a
braces (ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf "}"))

unGrouped :: Exp -> [Exp]
unGrouped :: Exp -> [Exp]
unGrouped (EGrouped xs :: [Exp]
xs) = [Exp]
xs
unGrouped x :: Exp
x = [Exp
x]

formula :: TP [Exp]
formula :: Parsec Text () [Exp]
formula = Exp -> [Exp]
unGrouped (Exp -> [Exp]) -> TP Exp -> Parsec Text () [Exp]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ParsecT Text () Identity ()
ignorable ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP Exp -> TP Exp
manyExp TP Exp
expr TP Exp -> ParsecT Text () Identity () -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) t u.
(Stream s m t, Show t) =>
ParsecT s u m ()
eof)

expr :: TP Exp
expr :: TP Exp
expr = do
  ParsecT Text () Identity SourceName -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "displaystyle" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> SourceName -> ParsecT Text () Identity SourceName
ctrlseq "textstyle" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
            SourceName -> ParsecT Text () Identity SourceName
ctrlseq "scriptstyle" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> SourceName -> ParsecT Text () Identity SourceName
ctrlseq "scriptscriptstyle")
  (a :: Exp
a, convertible :: Bool
convertible) <- ParsecT Text () Identity (Exp, Bool)
-> ParsecT Text () Identity (Exp, Bool)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity (Exp, Bool)
-> ParsecT Text () Identity (Exp, Bool)
forall a. TP a -> TP a
braces ParsecT Text () Identity (Exp, Bool)
operatorname) -- needed because macros add {}
                 ParsecT Text () Identity (Exp, Bool)
-> ParsecT Text () Identity (Exp, Bool)
-> ParsecT Text () Identity (Exp, Bool)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text () Identity (Exp, Bool)
operatorname
                 ParsecT Text () Identity (Exp, Bool)
-> ParsecT Text () Identity (Exp, Bool)
-> ParsecT Text () Identity (Exp, Bool)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ((,Bool
False) (Exp -> (Exp, Bool))
-> TP Exp -> ParsecT Text () Identity (Exp, Bool)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
expr1)
  Maybe Bool
limits <- TP (Maybe Bool)
limitsIndicator
  Maybe Bool -> Bool -> Exp -> TP Exp
subSup Maybe Bool
limits Bool
convertible Exp
a TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Maybe Bool -> Bool -> Exp -> TP Exp
superOrSubscripted Maybe Bool
limits Bool
convertible Exp
a TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
a

hyperref :: TP Exp
hyperref :: TP Exp
hyperref = do
  SourceName -> ParsecT Text () Identity SourceName
ctrlseq "hyperref"  -- we just ignore hyperref, see #186
  TP Exp -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional TP Exp
inbrackets
  TP Exp
inbraces

command :: TP Exp
command :: TP Exp
command = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
  Text
c <- TP Text
anyCtrlSeq
  Bool -> ParsecT Text () Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> ParsecT Text () Identity ())
-> Bool -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= "\\end" -- handled in environment
       Bool -> Bool -> Bool
&& Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
/= "\\operatorname" -- handled in expr
  [TP Exp] -> TP Exp
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice
    [ Text -> TP Exp
text Text
c
    , Text -> TP Exp
styled Text
c
    , Text -> TP Exp
root Text
c
    , Text -> TP Exp
xspace Text
c
    , Text -> TP Exp
mathop Text
c
    , Text -> TP Exp
phantom Text
c
    , Text -> TP Exp
boxed Text
c
    , Text -> TP Exp
binary Text
c
    , Text -> TP Exp
genfrac Text
c
    , Text -> TP Exp
substack Text
c
    , Text -> TP Exp
environment Text
c
    , Text -> TP Exp
ensuremath Text
c
    , Text -> TP Exp
scaled Text
c
    , Text -> TP Exp
negated Text
c
    , Text -> TP Exp
siunitx Text
c
    , Text -> TP Exp
arrow Text
c
    , Text -> TP Exp
tSymbol Text
c
    ] TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> SourceName -> TP Exp
forall s (m :: * -> *) t u a.
Stream s m t =>
SourceName -> ParsecT s u m a
unexpected ("control sequence " SourceName -> SourceName -> SourceName
forall a. Semigroup a => a -> a -> a
<> Text -> SourceName
T.unpack Text
c)


-- | Parser for \operatorname command.
-- Returns a tuple of EMathOperator name and Bool depending on the flavor
-- of the command:
--
--     - True for convertible operator (\operator*)
--
--     - False otherwise
operatorname :: TP (Exp, Bool)
operatorname :: ParsecT Text () Identity (Exp, Bool)
operatorname = do
    SourceName -> ParsecT Text () Identity SourceName
ctrlseq "operatorname"
    -- these are slightly different but we won't worry about that here...
    Bool
convertible <- (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '*' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity ()
-> ParsecT Text () Identity Bool -> ParsecT Text () Identity Bool
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> ParsecT Text () Identity Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
True) ParsecT Text () Identity Bool
-> ParsecT Text () Identity Bool -> ParsecT Text () Identity Bool
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Bool -> ParsecT Text () Identity Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
    Maybe Text
op <- Exp -> Maybe Text
expToOperatorName (Exp -> Maybe Text)
-> TP Exp -> ParsecT Text () Identity (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken
    ParsecT Text () Identity (Exp, Bool)
-> (Text -> ParsecT Text () Identity (Exp, Bool))
-> Maybe Text
-> ParsecT Text () Identity (Exp, Bool)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ParsecT Text () Identity (Exp, Bool)
forall (m :: * -> *) a. MonadPlus m => m a
mzero (\s :: Text
s -> (Exp, Bool) -> ParsecT Text () Identity (Exp, Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Exp
EMathOperator Text
s, Bool
convertible)) Maybe Text
op

-- | Converts identifiers, symbols and numbers to a flat string.
-- Returns Nothing if the expression contains anything else.
expToOperatorName :: Exp -> Maybe Text
expToOperatorName :: Exp -> Maybe Text
expToOperatorName e :: Exp
e = case Exp
e of
            EGrouped xs :: [Exp]
xs -> [Text] -> Text
T.concat ([Text] -> Text) -> Maybe [Text] -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Exp -> Maybe Text) -> [Exp] -> Maybe [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM Exp -> Maybe Text
fl [Exp]
xs
            _ -> Exp -> Maybe Text
fl Exp
e
    where fl :: Exp -> Maybe Text
fl f :: Exp
f = case Exp
f of
                    EIdentifier s :: Text
s -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
s
                    -- handle special characters
                    ESymbol _ "\x2212" -> Text -> Maybe Text
forall a. a -> Maybe a
Just "-"
                    ESymbol _ "\x2032" -> Text -> Maybe Text
forall a. a -> Maybe a
Just "'"
                    ESymbol _ "\x2033" -> Text -> Maybe Text
forall a. a -> Maybe a
Just "''"
                    ESymbol _ "\x2034" -> Text -> Maybe Text
forall a. a -> Maybe a
Just "'''"
                    ESymbol _ "\x2057" -> Text -> Maybe Text
forall a. a -> Maybe a
Just "''''"
                    ESymbol _ "\x02B9" -> Text -> Maybe Text
forall a. a -> Maybe a
Just "'"
                    ESymbol _ s :: Text
s -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
s
                    ENumber s :: Text
s -> Text -> Maybe Text
forall a. a -> Maybe a
Just Text
s
                    EStyled sty :: TextType
sty xs :: [Exp]
xs -> [Text] -> Text
T.concat ([Text] -> Text) -> Maybe [Text] -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Maybe Text] -> Maybe [Text]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ((Exp -> Maybe Text) -> [Exp] -> [Maybe Text]
forall a b. (a -> b) -> [a] -> [b]
map (TextType -> Exp -> Maybe Text
toStr TextType
sty) [Exp]
xs)
                    _ -> Maybe Text
forall a. Maybe a
Nothing
          toStr :: TextType -> Exp -> Maybe Text
toStr sty :: TextType
sty (EIdentifier s :: Text
s)     = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Text
toUnicode TextType
sty Text
s
          toStr _   (EText sty' :: TextType
sty' s :: Text
s)      = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Text
toUnicode TextType
sty' Text
s
          toStr sty :: TextType
sty (ENumber s :: Text
s)         = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Text
toUnicode TextType
sty Text
s
          toStr sty :: TextType
sty (EMathOperator s :: Text
s)   = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Text
toUnicode TextType
sty Text
s
          toStr sty :: TextType
sty (ESymbol _ s :: Text
s)       = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Text
toUnicode TextType
sty Text
s
          toStr _   (ESpace n :: Rational
n)          = Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Text -> Maybe Text
forall a b. (a -> b) -> a -> b
$ Rational -> Text
getSpaceChars Rational
n
          toStr _   (EStyled sty' :: TextType
sty' exps :: [Exp]
exps) = [Text] -> Text
T.concat ([Text] -> Text) -> Maybe [Text] -> Maybe Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                                            [Maybe Text] -> Maybe [Text]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence ((Exp -> Maybe Text) -> [Exp] -> [Maybe Text]
forall a b. (a -> b) -> [a] -> [b]
map (TextType -> Exp -> Maybe Text
toStr TextType
sty') [Exp]
exps)
          toStr _   _                   = Maybe Text
forall a. Maybe a
Nothing

bareSubSup :: TP Exp
bareSubSup :: TP Exp
bareSubSup = Maybe Bool -> Bool -> Exp -> TP Exp
subSup Maybe Bool
forall a. Maybe a
Nothing Bool
False (Text -> Exp
EIdentifier "")
  TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Maybe Bool -> Bool -> Exp -> TP Exp
superOrSubscripted Maybe Bool
forall a. Maybe a
Nothing Bool
False (Text -> Exp
EIdentifier "")

limitsIndicator :: TP (Maybe Bool)
limitsIndicator :: TP (Maybe Bool)
limitsIndicator =
   (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "limits" ParsecT Text () Identity SourceName
-> TP (Maybe Bool) -> TP (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe Bool -> TP (Maybe Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
True))
  TP (Maybe Bool) -> TP (Maybe Bool) -> TP (Maybe Bool)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "nolimits" ParsecT Text () Identity SourceName
-> TP (Maybe Bool) -> TP (Maybe Bool)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Maybe Bool -> TP (Maybe Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return (Bool -> Maybe Bool
forall a. a -> Maybe a
Just Bool
False))
  TP (Maybe Bool) -> TP (Maybe Bool) -> TP (Maybe Bool)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Maybe Bool -> TP (Maybe Bool)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Bool
forall a. Maybe a
Nothing

binomCmd :: TP Text
binomCmd :: TP Text
binomCmd = [Text] -> TP Text
oneOfCommands (Map Text (Exp -> Exp -> Exp) -> [Text]
forall k a. Map k a -> [k]
M.keys Map Text (Exp -> Exp -> Exp)
binomCmds)

binomCmds :: M.Map Text (Exp -> Exp -> Exp)
binomCmds :: Map Text (Exp -> Exp -> Exp)
binomCmds = [(Text, Exp -> Exp -> Exp)] -> Map Text (Exp -> Exp -> Exp)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
            [ ("\\choose", \x :: Exp
x y :: Exp
y ->
                Text -> Text -> [InEDelimited] -> Exp
EDelimited "(" ")" [Exp -> InEDelimited
forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NoLineFrac Exp
x Exp
y)])
            , ("\\brack", \x :: Exp
x y :: Exp
y ->
                Text -> Text -> [InEDelimited] -> Exp
EDelimited "[" "]" [Exp -> InEDelimited
forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NoLineFrac Exp
x Exp
y)])
            , ("\\brace", \x :: Exp
x y :: Exp
y ->
                Text -> Text -> [InEDelimited] -> Exp
EDelimited "{" "}" [Exp -> InEDelimited
forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NoLineFrac Exp
x Exp
y)])
            , ("\\bangle", \x :: Exp
x y :: Exp
y ->
                Text -> Text -> [InEDelimited] -> Exp
EDelimited "\x27E8" "\x27E9" [Exp -> InEDelimited
forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NoLineFrac Exp
x Exp
y)])
            ]

genfrac :: Text -> TP Exp
genfrac :: Text -> TP Exp
genfrac "\\genfrac" = do
  let opener :: ParsecT Text u Identity Text
opener = Text
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "" (ParsecT Text u Identity Text -> ParsecT Text u Identity Text)
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall a b. (a -> b) -> a -> b
$
                Char -> Text
T.singleton (Char -> Text)
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '\\' ParsecT Text u Identity Char
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT Text u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar) ParsecT Text u Identity Char
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar)
  let closer :: ParsecT Text u Identity Text
closer = Text
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "" (ParsecT Text u Identity Text -> ParsecT Text u Identity Text)
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall a b. (a -> b) -> a -> b
$
                Char -> Text
T.singleton (Char -> Text)
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '\\' ParsecT Text u Identity Char
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT Text u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar) ParsecT Text u Identity Char
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar)
  Text
openDelim <- TP Text -> TP Text
forall a. TP a -> TP a
braces TP Text
forall u. ParsecT Text u Identity Text
opener TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text
forall u. ParsecT Text u Identity Text
opener
  Text
closeDelim <- TP Text -> TP Text
forall a. TP a -> TP a
braces TP Text
forall u. ParsecT Text u Identity Text
closer TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text
forall u. ParsecT Text u Identity Text
closer
  Bool
bar <- Bool
False Bool
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a. TP a -> TP a
braces (SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "0pt")) ParsecT Text () Identity Bool
-> ParsecT Text () Identity Bool -> ParsecT Text () Identity Bool
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Bool
True Bool -> TP Exp -> ParsecT Text () Identity Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ TP Exp
texToken
  Bool
displayStyle <- Bool
True Bool
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a. TP a -> TP a
braces (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '0')) ParsecT Text () Identity Bool
-> ParsecT Text () Identity Bool -> ParsecT Text () Identity Bool
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Bool
False Bool -> TP Exp -> ParsecT Text () Identity Bool
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ TP Exp
texToken
  Exp
x <- TP Exp
texToken
  Exp
y <- TP Exp
texToken
  let fracType :: FractionType
fracType = case (Bool
bar, Bool
displayStyle) of
                      (False, _)   -> FractionType
NoLineFrac
                      (True, True) -> FractionType
DisplayFrac
                      _            -> FractionType
NormalFrac
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
openDelim Text
closeDelim
                      [Exp -> InEDelimited
forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
fracType Exp
x Exp
y)]
genfrac _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

substack :: Text -> TP Exp
substack :: Text -> TP Exp
substack "\\substack" = do
  [Exp]
formulas <- Parsec Text () [Exp] -> Parsec Text () [Exp]
forall a. TP a -> TP a
braces (Parsec Text () [Exp] -> Parsec Text () [Exp])
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall a b. (a -> b) -> a -> b
$ ParsecT Text () Identity ()
ignorable ParsecT Text () Identity ()
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (TP Exp -> TP Exp
manyExp TP Exp
expr) TP Exp -> ParsecT Text () Identity Char -> Parsec Text () [Exp]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
`sepEndBy` ParsecT Text () Identity Char
endLine
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray [Alignment
AlignCenter] ([ArrayLine] -> Exp) -> [ArrayLine] -> Exp
forall a b. (a -> b) -> a -> b
$ (Exp -> ArrayLine) -> [Exp] -> [ArrayLine]
forall a b. (a -> b) -> [a] -> [b]
map (\x :: Exp
x -> [[Exp
x]]) [Exp]
formulas
substack _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

asGroup :: [Exp] -> Exp
asGroup :: [Exp] -> Exp
asGroup [x :: Exp
x] = Exp
x
asGroup xs :: [Exp]
xs = [Exp] -> Exp
EGrouped [Exp]
xs

-- variant of many that is sensitive to \choose and other such commands
manyExp' :: Bool -> TP Exp -> TP Exp
manyExp' :: Bool -> TP Exp -> TP Exp
manyExp' requireNonempty :: Bool
requireNonempty p :: TP Exp
p = do
  [Exp]
initial <- if Bool
requireNonempty
                then TP Exp -> Parsec Text () [Exp]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (TP Text -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy TP Text
binomCmd ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TP Exp
p)
                else TP Exp -> Parsec Text () [Exp]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (TP Text -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy TP Text
binomCmd ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TP Exp
p)
  let withCmd :: Text -> TP Exp
      withCmd :: Text -> TP Exp
withCmd cmd :: Text
cmd =
         case Text -> Map Text (Exp -> Exp -> Exp) -> Maybe (Exp -> Exp -> Exp)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
cmd Map Text (Exp -> Exp -> Exp)
binomCmds of
              Just f :: Exp -> Exp -> Exp
f  -> Exp -> Exp -> Exp
f (Exp -> Exp -> Exp)
-> TP Exp -> ParsecT Text () Identity (Exp -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ([Exp] -> Exp
asGroup ([Exp] -> Exp) -> Parsec Text () [Exp] -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Exp] -> Parsec Text () [Exp]
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Exp]
initial)
                           ParsecT Text () Identity (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> ([Exp] -> Exp
asGroup ([Exp] -> Exp) -> Parsec Text () [Exp] -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp -> Parsec Text () [Exp]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many TP Exp
p)
              Nothing -> SourceName -> TP Exp
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail (SourceName -> TP Exp) -> SourceName -> TP Exp
forall a b. (a -> b) -> a -> b
$ "Unknown command " SourceName -> SourceName -> SourceName
forall a. Semigroup a => a -> a -> a
<> Text -> SourceName
T.unpack Text
cmd
  (TP Text
binomCmd TP Text -> (Text -> TP Exp) -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Text -> TP Exp
withCmd) TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return ([Exp] -> Exp
asGroup [Exp]
initial)

manyExp :: TP Exp -> TP Exp
manyExp :: TP Exp -> TP Exp
manyExp = Bool -> TP Exp -> TP Exp
manyExp' Bool
False

many1Exp :: TP Exp -> TP Exp
many1Exp :: TP Exp -> TP Exp
many1Exp = Bool -> TP Exp -> TP Exp
manyExp' Bool
True

inbraces :: TP Exp
inbraces :: TP Exp
inbraces = TP Exp -> TP Exp
forall a. TP a -> TP a
braces (TP Exp -> TP Exp
manyExp TP Exp
expr)

texToken :: TP Exp
texToken :: TP Exp
texToken = TP Exp
texSymbol TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
inbraces TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
texChar

-- Remove superfluous EGrouped if present.
deGroup :: Exp -> Exp
deGroup :: Exp -> Exp
deGroup (EGrouped [x :: Exp
x]) = Exp
x
deGroup x :: Exp
x = Exp
x

texChar :: TP Exp
texChar :: TP Exp
texChar =
  do
    Char
c <- SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf "\n\t\r \\{}" ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
    Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ (if Char -> Bool
isDigit Char
c then Text -> Exp
ENumber else Text -> Exp
EIdentifier) (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Char -> Text
T.singleton Char
c

inbrackets :: TP Exp
inbrackets :: TP Exp
inbrackets = (TP Exp -> TP Exp
forall a. TP a -> TP a
brackets (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TP Exp -> TP Exp
manyExp (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ']') ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TP Exp
expr)

number :: TP Exp
number :: TP Exp
number = TP Exp -> TP Exp
forall a. TP a -> TP a
lexeme (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Exp
ENumber (Text -> Exp) -> TP Text -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try TP Text
forall u. ParsecT Text u Identity Text
decimalNumber
  where decimalNumber :: ParsecT Text u Identity Text
decimalNumber = do
          SourceName
xs <- ParsecT Text u Identity Char -> ParsecT Text u Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT Text u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit
          SourceName
ys <- SourceName
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option [] (ParsecT Text u Identity SourceName
 -> ParsecT Text u Identity SourceName)
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall a b. (a -> b) -> a -> b
$ ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '.' ParsecT Text u Identity Char
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (('.'Char -> SourceName -> SourceName
forall a. a -> [a] -> [a]
:) (SourceName -> SourceName)
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text u Identity Char -> ParsecT Text u Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT Text u Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit))
          case SourceName
xs SourceName -> SourceName -> SourceName
forall a. [a] -> [a] -> [a]
++ SourceName
ys of
               []  -> ParsecT Text u Identity Text
forall (m :: * -> *) a. MonadPlus m => m a
mzero
               zs :: SourceName
zs  -> Text -> ParsecT Text u Identity Text
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> ParsecT Text u Identity Text)
-> Text -> ParsecT Text u Identity Text
forall a b. (a -> b) -> a -> b
$ SourceName -> Text
T.pack SourceName
zs

enclosure :: TP Exp
enclosure :: TP Exp
enclosure = TP Exp
delimited TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
delimitedImplicit TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
basicEnclosure

basicEnclosure :: TP Exp
basicEnclosure :: TP Exp
basicEnclosure = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
  Text
possibleEncl <- TP Text -> TP Text
forall a. TP a -> TP a
lexeme (TP Text
anyCtrlSeq TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Line -> ParsecT Text () Identity Char -> TP Text
countChar 1 (SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf "()[]|"))
  case Text -> Map Text Exp -> Maybe Exp
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
possibleEncl Map Text Exp
enclosures of
       Just x :: Exp
x  -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
x
       Nothing -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

fence :: String -> TP Text
fence :: SourceName -> TP Text
fence cmd :: SourceName
cmd = do
  SourceName -> ParsecT Text () Identity SourceName
symbol SourceName
cmd
  let nullDelim :: TP Exp
nullDelim = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Open "" Exp -> ParsecT Text () Identity SourceName -> TP Exp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
symbol ".")
      angleDelim :: TP Exp
angleDelim = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [TP Exp] -> TP Exp
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice
        [ TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Open "\x27E8" Exp -> ParsecT Text () Identity SourceName -> TP Exp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
symbol "<"
        , TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Close "\x27E9" Exp -> ParsecT Text () Identity SourceName -> TP Exp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
symbol ">"
        ]
  Exp
enc <- TP Exp
basicEnclosure TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
nullDelim TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
angleDelim
  case Exp
enc of
       ESymbol Open x :: Text
x  -> Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
x
       ESymbol Close x :: Text
x -> Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
x
       _ -> TP Text
forall (m :: * -> *) a. MonadPlus m => m a
mzero

middle :: TP Text
middle :: TP Text
middle = SourceName -> TP Text
fence "\\middle"

right :: TP Text
right :: TP Text
right = SourceName -> TP Text
fence "\\right"

delimited :: TP Exp
delimited :: TP Exp
delimited = do
  Text
openc <- TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ SourceName -> TP Text
fence "\\left"
  [InEDelimited]
contents <- [[InEDelimited]] -> [InEDelimited]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[InEDelimited]] -> [InEDelimited])
-> ParsecT Text () Identity [[InEDelimited]]
-> ParsecT Text () Identity [InEDelimited]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
              ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [[InEDelimited]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity [InEDelimited]
 -> ParsecT Text () Identity [InEDelimited])
-> ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
forall a b. (a -> b) -> a -> b
$ ((InEDelimited -> [InEDelimited] -> [InEDelimited]
forall a. a -> [a] -> [a]
:[]) (InEDelimited -> [InEDelimited])
-> (Text -> InEDelimited) -> Text -> [InEDelimited]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> InEDelimited
forall a b. a -> Either a b
Left  (Text -> [InEDelimited])
-> TP Text -> ParsecT Text () Identity [InEDelimited]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Text
middle)
                      ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ((Exp -> InEDelimited) -> [Exp] -> [InEDelimited]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> InEDelimited
forall a b. b -> Either a b
Right ([Exp] -> [InEDelimited])
-> (Exp -> [Exp]) -> Exp -> [InEDelimited]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp -> [Exp]
unGrouped (Exp -> [InEDelimited])
-> TP Exp -> ParsecT Text () Identity [InEDelimited]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                             TP Exp -> TP Exp
many1Exp (TP Text -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy TP Text
right ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP Exp
expr)))
  Text
closec <- TP Text
right TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return ""
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
openc Text
closec [InEDelimited]
contents

delimitedImplicit :: TP Exp
delimitedImplicit :: TP Exp
delimitedImplicit = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
  Char
openc <- ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a. TP a -> TP a
lexeme (ParsecT Text () Identity Char -> ParsecT Text () Identity Char)
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a b. (a -> b) -> a -> b
$ SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf "()[]|"
  Char
closec <- case Char
openc of
                 '(' -> Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return ')'
                 '[' -> Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return ']'
                 '|' -> Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return '|'
                 _   -> ParsecT Text () Identity Char
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  let closer :: ParsecT Text () Identity Char
closer = ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a. TP a -> TP a
lexeme (ParsecT Text () Identity Char -> ParsecT Text () Identity Char)
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
closec
  [InEDelimited]
contents <- [[InEDelimited]] -> [InEDelimited]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([[InEDelimited]] -> [InEDelimited])
-> ParsecT Text () Identity [[InEDelimited]]
-> ParsecT Text () Identity [InEDelimited]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
              ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [[InEDelimited]]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity [InEDelimited]
 -> ParsecT Text () Identity [InEDelimited])
-> ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
forall a b. (a -> b) -> a -> b
$ ((InEDelimited -> [InEDelimited] -> [InEDelimited]
forall a. a -> [a] -> [a]
:[]) (InEDelimited -> [InEDelimited])
-> (Text -> InEDelimited) -> Text -> [InEDelimited]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> InEDelimited
forall a b. a -> Either a b
Left  (Text -> [InEDelimited])
-> TP Text -> ParsecT Text () Identity [InEDelimited]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Text
middle)
                      ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
-> ParsecT Text () Identity [InEDelimited]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ((Exp -> InEDelimited) -> [Exp] -> [InEDelimited]
forall a b. (a -> b) -> [a] -> [b]
map Exp -> InEDelimited
forall a b. b -> Either a b
Right ([Exp] -> [InEDelimited])
-> (Exp -> [Exp]) -> Exp -> [InEDelimited]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp -> [Exp]
unGrouped (Exp -> [InEDelimited])
-> TP Exp -> ParsecT Text () Identity [InEDelimited]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                             TP Exp -> TP Exp
many1Exp (ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy ParsecT Text () Identity Char
closer ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP Exp
expr)))
  Char
_ <- ParsecT Text () Identity Char
closer
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited (Char -> Text
T.singleton Char
openc) (Char -> Text
T.singleton Char
closec) [InEDelimited]
contents

scaled :: Text -> TP Exp
scaled :: Text -> TP Exp
scaled cmd :: Text
cmd = do
  case Text -> Maybe Rational
S.getScalerValue Text
cmd of
       Just r :: Rational
r  -> Rational -> Exp -> Exp
EScaled Rational
r (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (TP Exp
basicEnclosure TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
operator)
       Nothing -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

endLine :: TP Char
endLine :: ParsecT Text () Identity Char
endLine = ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity Char -> ParsecT Text () Identity Char)
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a b. (a -> b) -> a -> b
$ do
  SourceName -> ParsecT Text () Identity SourceName
symbol "\\\\"
  TP Exp -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional TP Exp
inbrackets  -- can contain e.g. [1.0in] for a line height, not yet supported
  Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return '\n'

-- Within environments provided by AMSmath, spaces are not allowed between
-- the double-backslash command and its optional argument.
endLineAMS :: TP Char
endLineAMS :: ParsecT Text () Identity Char
endLineAMS = ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a. TP a -> TP a
lexeme (ParsecT Text () Identity Char -> ParsecT Text () Identity Char)
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a b. (a -> b) -> a -> b
$ ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity Char -> ParsecT Text () Identity Char)
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a b. (a -> b) -> a -> b
$ do
  SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "\\\\"
  ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany ParsecT Text () Identity ()
comment
  TP Exp -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional TP Exp
inbrackets  -- can contain e.g. [1.0in] for a line height, not yet supported
  Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return '\n'

arrayLine :: TP ArrayLine
arrayLine :: TP ArrayLine
arrayLine = ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "end" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return '\n') ParsecT Text () Identity () -> TP ArrayLine -> TP ArrayLine
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  Parsec Text () [Exp]
-> ParsecT Text () Identity SourceName -> TP ArrayLine
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy1 (Exp -> [Exp]
unGrouped (Exp -> [Exp]) -> TP Exp -> Parsec Text () [Exp]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
    TP Exp -> TP Exp
manyExp (ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity ()
ignorable' ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy ParsecT Text () Identity Char
endLine) ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*>
               TP Exp
expr TP Exp -> ParsecT Text () Identity () -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<*
               ParsecT Text () Identity ()
ignorable')) (SourceName -> ParsecT Text () Identity SourceName
symbol "&")
  where ignorable' :: ParsecT Text () Identity ()
ignorable' = ParsecT Text () Identity ()
ignorable ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
                     ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "hline" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT Text () Identity ()
ignorable'))
  -- we don't represent the line, but it shouldn't crash parsing

arrayAlignments :: TP [Alignment]
arrayAlignments :: TP [Alignment]
arrayAlignments = TP [Alignment] -> TP [Alignment]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP [Alignment] -> TP [Alignment])
-> TP [Alignment] -> TP [Alignment]
forall a b. (a -> b) -> a -> b
$ do
  SourceName
as <- ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a. TP a -> TP a
braces (ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter ParsecT Text () Identity Char
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '|'))
  let letterToAlignment :: Char -> Alignment
letterToAlignment 'l' = Alignment
AlignLeft
      letterToAlignment 'c' = Alignment
AlignCenter
      letterToAlignment 'r' = Alignment
AlignRight
      letterToAlignment _   = Alignment
AlignCenter
  [Alignment] -> TP [Alignment]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Alignment] -> TP [Alignment]) -> [Alignment] -> TP [Alignment]
forall a b. (a -> b) -> a -> b
$ (Char -> Alignment) -> SourceName -> [Alignment]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Alignment
letterToAlignment (SourceName -> [Alignment]) -> SourceName -> [Alignment]
forall a b. (a -> b) -> a -> b
$ (Char -> Bool) -> SourceName -> SourceName
forall a. (a -> Bool) -> [a] -> [a]
filter (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= '|') SourceName
as

environment :: Text -> TP Exp
environment :: Text -> TP Exp
environment "\\begin" = do
  Text
name <- TP Text -> TP Text
forall a. TP a -> TP a
braces ([Text] -> TP Text
oneOfStrings (Map Text (TP Exp) -> [Text]
forall k a. Map k a -> [k]
M.keys Map Text (TP Exp)
environments) TP Text -> ParsecT Text () Identity () -> TP Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '*'))
  ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
  case Text -> Map Text (TP Exp) -> Maybe (TP Exp)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
name Map Text (TP Exp)
environments of
        Just env :: TP Exp
env -> do
          Exp
result <- TP Exp
env
          ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
          SourceName -> ParsecT Text () Identity SourceName
ctrlseq "end"
          TP Text -> TP Text
forall a. TP a -> TP a
braces (Text -> TP Text
textStr Text
name TP Text -> ParsecT Text () Identity () -> TP Text
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '*'))
          ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
          Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
result
        Nothing  -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero  -- should not happen
environment _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

environments :: M.Map Text (TP Exp)
environments :: Map Text (TP Exp)
environments = [(Text, TP Exp)] -> Map Text (TP Exp)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
  [ ("array", TP Exp
stdarray)
  , ("eqnarray", TP Exp
eqnarray)
  , ("align", TP Exp
align)
  , ("aligned", TP Exp
align)
  , ("alignat", TP Exp
inbraces TP Exp
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP Exp
align)
  , ("alignedat", TP Exp
inbraces TP Exp
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP Exp
align)
  , ("flalign", TP Exp
flalign)
  , ("flaligned", TP Exp
flalign)
  , ("cases", TP Exp
cases)
  , ("matrix", Text -> Text -> TP Exp
matrixWith "" "")
  , ("smallmatrix", Text -> Text -> TP Exp
matrixWith "" "")
  , ("pmatrix", Text -> Text -> TP Exp
matrixWith "(" ")")
  , ("bmatrix", Text -> Text -> TP Exp
matrixWith "[" "]")
  , ("Bmatrix", Text -> Text -> TP Exp
matrixWith "{" "}")
  , ("vmatrix", Text -> Text -> TP Exp
matrixWith "\x2223" "\x2223")
  , ("Vmatrix", Text -> Text -> TP Exp
matrixWith "\x2225" "\x2225")
  , ("split", TP Exp
align)
  , ("multline", TP Exp
gather)
  , ("gather", TP Exp
gather)
  , ("gathered", TP Exp
gather)
  , ("equation", TP Exp
equation)
  ]

alignsFromRows :: Alignment -> [ArrayLine] -> [Alignment]
alignsFromRows :: Alignment -> [ArrayLine] -> [Alignment]
alignsFromRows _ [] = []
alignsFromRows defaultAlignment :: Alignment
defaultAlignment (r :: ArrayLine
r:_) = Line -> Alignment -> [Alignment]
forall a. Line -> a -> [a]
replicate (ArrayLine -> Line
forall (t :: * -> *) a. Foldable t => t a -> Line
length ArrayLine
r) Alignment
defaultAlignment

matrixWith :: Text -> Text -> TP Exp
matrixWith :: Text -> Text -> TP Exp
matrixWith opendelim :: Text
opendelim closedelim :: Text
closedelim = do
  [ArrayLine]
lines' <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy1 TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLineAMS
  let aligns :: [Alignment]
aligns = Alignment -> [ArrayLine] -> [Alignment]
alignsFromRows Alignment
AlignCenter [ArrayLine]
lines'
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ if Text -> Bool
T.null Text
opendelim Bool -> Bool -> Bool
&& Text -> Bool
T.null Text
closedelim
              then [Alignment] -> [ArrayLine] -> Exp
EArray [Alignment]
aligns [ArrayLine]
lines'
              else Text -> Text -> [InEDelimited] -> Exp
EDelimited Text
opendelim Text
closedelim
                       [Exp -> InEDelimited
forall a b. b -> Either a b
Right (Exp -> InEDelimited) -> Exp -> InEDelimited
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray [Alignment]
aligns [ArrayLine]
lines']

stdarray :: TP Exp
stdarray :: TP Exp
stdarray = do
  [Alignment]
aligns <- TP [Alignment]
arrayAlignments
  [ArrayLine]
lines' <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy1 TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLine
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray [Alignment]
aligns [ArrayLine]
lines'

gather :: TP Exp
gather :: TP Exp
gather = do
  [ArrayLine]
rows <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLineAMS
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray (Alignment -> [ArrayLine] -> [Alignment]
alignsFromRows Alignment
AlignCenter [ArrayLine]
rows) [ArrayLine]
rows

equation :: TP Exp
equation :: TP Exp
equation = do
  ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "end" ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a. Monad m => a -> m a
return '\n')
  TP Exp -> TP Exp
manyExp (ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy ParsecT Text () Identity Char
endLine ParsecT Text () Identity () -> TP Exp -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TP Exp
expr)

eqnarray :: TP Exp
eqnarray :: TP Exp
eqnarray = do
  [ArrayLine]
rows <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy1 TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLine
  let n :: Line
n = [Line] -> Line
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum ([Line] -> Line) -> [Line] -> Line
forall a b. (a -> b) -> a -> b
$ (ArrayLine -> Line) -> [ArrayLine] -> [Line]
forall a b. (a -> b) -> [a] -> [b]
map ArrayLine -> Line
forall (t :: * -> *) a. Foldable t => t a -> Line
length [ArrayLine]
rows
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray (Line -> [Alignment] -> [Alignment]
forall a. Line -> [a] -> [a]
take Line
n ([Alignment] -> [Alignment]) -> [Alignment] -> [Alignment]
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [Alignment]
forall a. [a] -> [a]
cycle [Alignment
AlignRight, Alignment
AlignCenter, Alignment
AlignLeft]) [ArrayLine]
rows

align :: TP Exp
align :: TP Exp
align = do
  [ArrayLine]
rows <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy1 TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLineAMS
  let n :: Line
n = [Line] -> Line
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum ([Line] -> Line) -> [Line] -> Line
forall a b. (a -> b) -> a -> b
$ (ArrayLine -> Line) -> [ArrayLine] -> [Line]
forall a b. (a -> b) -> [a] -> [b]
map ArrayLine -> Line
forall (t :: * -> *) a. Foldable t => t a -> Line
length [ArrayLine]
rows
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray (Line -> [Alignment] -> [Alignment]
forall a. Line -> [a] -> [a]
take Line
n ([Alignment] -> [Alignment]) -> [Alignment] -> [Alignment]
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [Alignment]
forall a. [a] -> [a]
cycle [Alignment
AlignRight, Alignment
AlignLeft]) [ArrayLine]
rows

flalign :: TP Exp
flalign :: TP Exp
flalign = do
  [ArrayLine]
rows <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy1 TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLineAMS
  let n :: Line
n = [Line] -> Line
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum ([Line] -> Line) -> [Line] -> Line
forall a b. (a -> b) -> a -> b
$ (ArrayLine -> Line) -> [ArrayLine] -> [Line]
forall a b. (a -> b) -> [a] -> [b]
map ArrayLine -> Line
forall (t :: * -> *) a. Foldable t => t a -> Line
length [ArrayLine]
rows
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray (Line -> [Alignment] -> [Alignment]
forall a. Line -> [a] -> [a]
take Line
n ([Alignment] -> [Alignment]) -> [Alignment] -> [Alignment]
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [Alignment]
forall a. [a] -> [a]
cycle [Alignment
AlignLeft, Alignment
AlignRight]) [ArrayLine]
rows

cases :: TP Exp
cases :: TP Exp
cases = do
  [ArrayLine]
rs <- TP ArrayLine
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity [ArrayLine]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepEndBy1 TP ArrayLine
arrayLine ParsecT Text () Identity Char
endLineAMS
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited "{" "" [Exp -> InEDelimited
forall a b. b -> Either a b
Right (Exp -> InEDelimited) -> Exp -> InEDelimited
forall a b. (a -> b) -> a -> b
$ [Alignment] -> [ArrayLine] -> Exp
EArray (Alignment -> [ArrayLine] -> [Alignment]
alignsFromRows Alignment
AlignLeft [ArrayLine]
rs) [ArrayLine]
rs]

variable :: TP Exp
variable :: TP Exp
variable = do
  Char
v <- ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
  ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Exp
EIdentifier (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Char -> Text
T.singleton Char
v

isConvertible :: Exp -> Bool
isConvertible :: Exp -> Bool
isConvertible (EMathOperator x :: Text
x) = Text
x Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
convertibleOps
  where convertibleOps :: [Text]
convertibleOps = [ "lim","liminf","limsup","inf","sup"
                         , "min","max","Pr","det","gcd"
                         ]
isConvertible (ESymbol Rel _) = Bool
True
isConvertible (ESymbol Bin _) = Bool
True
isConvertible (ESymbol Op x :: Text
x) = Text
x Text -> [Text] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Text]
convertibleSyms
  where convertibleSyms :: [Text]
convertibleSyms = ["\x2211","\x220F","\x22C2",
           "\x22C3","\x22C0","\x22C1","\x2A05","\x2A06",
           "\x2210","\x2A01","\x2A02","\x2A00","\x2A04"]
isConvertible _ = Bool
False

-- check if sub/superscripts should always be under and over the expression
isUnderover :: Exp -> Bool
isUnderover :: Exp -> Bool
isUnderover (EOver _ _ (ESymbol TOver "\xFE37")) = Bool
True   -- \overbrace
isUnderover (EOver _ _ (ESymbol TOver "\x23B4")) = Bool
True   -- \overbracket
isUnderover (EOver _  _ (ESymbol TOver "\x23DE")) = Bool
True  -- \overbrace
isUnderover (EUnder _ _ (ESymbol TUnder "\xFE38")) = Bool
True  -- \underbrace
isUnderover (EUnder _ _ (ESymbol TUnder "\x23B5")) = Bool
True  -- \underbracket
isUnderover (EUnder _  _ (ESymbol TUnder "\x23DF")) = Bool
True  -- \underbrace
isUnderover _ = Bool
False

subSup :: Maybe Bool -> Bool -> Exp -> TP Exp
subSup :: Maybe Bool -> Bool -> Exp -> TP Exp
subSup limits :: Maybe Bool
limits convertible :: Bool
convertible a :: Exp
a = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
  let sub1 :: TP Exp
sub1 = SourceName -> ParsecT Text () Identity SourceName
symbol "_" ParsecT Text () Identity SourceName -> TP Exp -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TP Exp
expr1
  let sup1 :: TP Exp
sup1 = SourceName -> ParsecT Text () Identity SourceName
symbol "^" ParsecT Text () Identity SourceName -> TP Exp -> TP Exp
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> TP Exp
expr1
  (b :: Exp
b,c :: Exp
c) <- ParsecT Text () Identity (Exp, Exp)
-> ParsecT Text () Identity (Exp, Exp)
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do {Exp
m <- TP Exp
sub1; Exp
n <- TP Exp
sup1; (Exp, Exp) -> ParsecT Text () Identity (Exp, Exp)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp
m,Exp
n)})
       ParsecT Text () Identity (Exp, Exp)
-> ParsecT Text () Identity (Exp, Exp)
-> ParsecT Text () Identity (Exp, Exp)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (do {Exp
n <- TP Exp
sup1; Exp
m <- TP Exp
sub1; (Exp, Exp) -> ParsecT Text () Identity (Exp, Exp)
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp
m,Exp
n)})
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ case Maybe Bool
limits of
            Just True  -> Bool -> Exp -> Exp -> Exp -> Exp
EUnderover Bool
False Exp
a Exp
b Exp
c
            Nothing | Bool
convertible Bool -> Bool -> Bool
|| Exp -> Bool
isConvertible Exp
a -> Bool -> Exp -> Exp -> Exp -> Exp
EUnderover Bool
True Exp
a Exp
b Exp
c
                    | Exp -> Bool
isUnderover Exp
a -> Bool -> Exp -> Exp -> Exp -> Exp
EUnderover Bool
False Exp
a Exp
b Exp
c
            _          -> Exp -> Exp -> Exp -> Exp
ESubsup Exp
a Exp
b Exp
c

superOrSubscripted :: Maybe Bool -> Bool -> Exp -> TP Exp
superOrSubscripted :: Maybe Bool -> Bool -> Exp -> TP Exp
superOrSubscripted limits :: Maybe Bool
limits convertible :: Bool
convertible a :: Exp
a = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
  Char
c <- SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf "^_"
  ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
  Exp
b <- TP Exp
expr
  case Char
c of
       '^' -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ case Maybe Bool
limits of
                        Just True  -> Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
a Exp
b
                        Nothing
                          | Bool
convertible Bool -> Bool -> Bool
|| Exp -> Bool
isConvertible Exp
a -> Bool -> Exp -> Exp -> Exp
EOver Bool
True Exp
a Exp
b
                          | Exp -> Bool
isUnderover Exp
a -> Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
a Exp
b
                        _          -> Exp -> Exp -> Exp
ESuper Exp
a Exp
b
       '_' -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ case Maybe Bool
limits of
                        Just True  -> Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
a Exp
b
                        Nothing
                          | Bool
convertible Bool -> Bool -> Bool
|| Exp -> Bool
isConvertible Exp
a -> Bool -> Exp -> Exp -> Exp
EUnder Bool
True Exp
a Exp
b
                          | Exp -> Bool
isUnderover Exp
a -> Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
a Exp
b
                        _          -> Exp -> Exp -> Exp
ESub Exp
a Exp
b
       _   -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

unicode :: TP Exp
unicode :: TP Exp
unicode = TP Exp -> TP Exp
forall a. TP a -> TP a
lexeme (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$
  do
    Char
c <- (Char -> Bool) -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (Bool -> Bool
not (Bool -> Bool) -> (Char -> Bool) -> Char -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Bool
isAscii)
    Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (TeXSymbolType -> Text -> Exp
ESymbol (Char -> TeXSymbolType
getSymbolType Char
c) (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Char -> Text
T.singleton Char
c)

ensuremath :: Text -> TP Exp
ensuremath :: Text -> TP Exp
ensuremath "\\ensuremath" = TP Exp
inbraces
ensuremath _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

phantom :: Text -> TP Exp
phantom :: Text -> TP Exp
phantom "\\phantom" = Exp -> Exp
EPhantom (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken
phantom _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

boxed :: Text -> TP Exp
boxed :: Text -> TP Exp
boxed "\\boxed" = Exp -> Exp
EBoxed (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken
boxed _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

text :: Text -> TP Exp
text :: Text -> TP Exp
text c :: Text
c = do
  Text -> Exp
op <- ParsecT Text () Identity (Text -> Exp)
-> ((Text -> Exp) -> ParsecT Text () Identity (Text -> Exp))
-> Maybe (Text -> Exp)
-> ParsecT Text () Identity (Text -> Exp)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe ParsecT Text () Identity (Text -> Exp)
forall (m :: * -> *) a. MonadPlus m => m a
mzero (Text -> Exp) -> ParsecT Text () Identity (Text -> Exp)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe (Text -> Exp) -> ParsecT Text () Identity (Text -> Exp))
-> Maybe (Text -> Exp) -> ParsecT Text () Identity (Text -> Exp)
forall a b. (a -> b) -> a -> b
$ Text -> Map Text (Text -> Exp) -> Maybe (Text -> Exp)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
c Map Text (Text -> Exp)
textOps
  Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '{'
  let chunk :: TP Exp
chunk = ((Text -> Exp
op (Text -> Exp) -> ([Text] -> Text) -> [Text] -> Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Text] -> Text
T.concat) ([Text] -> Exp) -> ParsecT Text () Identity [Text] -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Text -> ParsecT Text () Identity [Text]
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 TP Text
textual)
            TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '{' ParsecT Text () Identity Char -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ([Exp] -> Exp
asGroup ([Exp] -> Exp) -> Parsec Text () [Exp] -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp -> ParsecT Text () Identity Char -> Parsec Text () [Exp]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
manyTill TP Exp
chunk (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '}')))
            TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
innermath
  [Exp]
contents <- TP Exp -> ParsecT Text () Identity Char -> Parsec Text () [Exp]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
manyTill TP Exp
chunk (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '}')
  ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
  case [Exp]
contents of
       []   -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Text -> Exp
op "")
       [x :: Exp
x]  -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
x
       xs :: [Exp]
xs   -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return ([Exp] -> Exp
EGrouped [Exp]
xs)

innermath :: TP Exp
innermath :: TP Exp
innermath = [TP Exp] -> TP Exp
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice ([TP Exp] -> TP Exp) -> [TP Exp] -> TP Exp
forall a b. (a -> b) -> a -> b
$ ((SourceName, SourceName) -> TP Exp)
-> [(SourceName, SourceName)] -> [TP Exp]
forall a b. (a -> b) -> [a] -> [b]
map (SourceName, SourceName) -> TP Exp
innerMathWith
              [("$","$"),("$$","$$"),("\\(","\\)"),("\\[","\\]")]

innerMathWith :: (String, String) -> TP Exp
innerMathWith :: (SourceName, SourceName) -> TP Exp
innerMathWith (opener :: SourceName
opener, closer :: SourceName
closer) = do
  ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
opener)
  Exp
e <- TP Exp -> TP Exp
manyExp TP Exp
expr
  SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
closer
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
e

styled :: Text -> TP Exp
styled :: Text -> TP Exp
styled c :: Text
c = do
  case Text -> Map Text ([Exp] -> Exp) -> Maybe ([Exp] -> Exp)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
c Map Text ([Exp] -> Exp)
styleOps of
       Just f :: [Exp] -> Exp
f   -> do
         Exp
x <- TP Exp
texSymbol TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
inbraces TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
texChar
         Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ case Exp
x of
                       EGrouped xs :: [Exp]
xs -> [Exp] -> Exp
f [Exp]
xs
                       _           -> [Exp] -> Exp
f [Exp
x]
       Nothing  -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

-- note: sqrt can be unary, \sqrt{2}, or binary, \sqrt[3]{2}
root :: Text -> TP Exp
root :: Text -> TP Exp
root c :: Text
c = do
  Bool -> ParsecT Text () Identity ()
forall (f :: * -> *). Alternative f => Bool -> f ()
guard (Bool -> ParsecT Text () Identity ())
-> Bool -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "\\sqrt" Bool -> Bool -> Bool
|| Text
c Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "\\surd"
  (Exp -> Exp -> Exp
ERoot (Exp -> Exp -> Exp)
-> TP Exp -> ParsecT Text () Identity (Exp -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
inbrackets ParsecT Text () Identity (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TP Exp
texToken) TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Exp -> Exp
ESqrt (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken)

xspace :: Text -> TP Exp
xspace :: Text -> TP Exp
xspace "\\mspace" = do
  SourceName -> ParsecT Text () Identity SourceName
ctrlseq "mspace"
  TP Exp -> TP Exp
forall a. TP a -> TP a
braces (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
    SourceName
len <- ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit
    ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a. TP a -> TP a
lexeme (ParsecT Text () Identity SourceName
 -> ParsecT Text () Identity SourceName)
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a b. (a -> b) -> a -> b
$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "mu"
    case ReadS Integer
forall a. Read a => ReadS a
reads SourceName
len of
       ((Integer
n :: Integer,[]):_) -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Rational -> Exp
ESpace (Integer -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
nRational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18)
       _                     -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero
xspace "\\hspace" = do
  TP Exp -> TP Exp
forall a. TP a -> TP a
braces (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
    SourceName
len <- ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit
    Rational
scaleFactor <-
           1      Rational
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Rational
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "em")
      ParsecT Text () Identity Rational
-> ParsecT Text () Identity Rational
-> ParsecT Text () Identity Rational
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (1Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/12)  Rational
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Rational
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "pt")
      ParsecT Text () Identity Rational
-> ParsecT Text () Identity Rational
-> ParsecT Text () Identity Rational
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> 6       Rational
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Rational
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "in")
      ParsecT Text () Identity Rational
-> ParsecT Text () Identity Rational
-> ParsecT Text () Identity Rational
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (50Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/21) Rational
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity Rational
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ (SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "cm")
    case ReadS Integer
forall a. Read a => ReadS a
reads SourceName
len of
       ((Integer
n :: Integer,[]):_) -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Rational -> Exp
ESpace (Integer -> Rational
forall a b. (Integral a, Num b) => a -> b
fromIntegral Integer
n Rational -> Rational -> Rational
forall a. Num a => a -> a -> a
* Rational
scaleFactor)
       _                     -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero
xspace _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

mathop :: Text -> TP Exp
mathop :: Text -> TP Exp
mathop c :: Text
c =
  case Text
c of
    "\\mathop"    -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Op
    "\\mathrel"   -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Rel
    "\\mathbin"   -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Bin
    "\\mathord"   -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Ord
    "\\mathopen"  -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Open
    "\\mathclose" -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Close
    "\\mathpunct" -> TeXSymbolType -> TP Exp
mathopWith TeXSymbolType
Pun
    _              -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

mathopWith :: TeXSymbolType -> TP Exp
mathopWith :: TeXSymbolType -> TP Exp
mathopWith ty :: TeXSymbolType
ty = do
  Exp
e <- TP Exp
inbraces TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
expr1
  let es' :: [Exp]
es' = case Exp
e of
                 EGrouped xs :: [Exp]
xs -> [Exp]
xs
                 x :: Exp
x           -> [Exp
x]
  case [Exp]
es' of
     [ESymbol _ x :: Text
x]   -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
ty Text
x
     [EIdentifier x :: Text
x] -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
ty Text
x
     [EText TextNormal x :: Text
x] -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
ty Text
x
     [EText sty :: TextType
sty x :: Text
x] -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TextType -> [Exp] -> Exp
EStyled TextType
sty [TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
ty Text
x]
     xs :: [Exp]
xs | TeXSymbolType
ty TeXSymbolType -> TeXSymbolType -> Bool
forall a. Eq a => a -> a -> Bool
== TeXSymbolType
Op  -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Exp
EMathOperator (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$
                         [Text] -> Text
T.concat ([Text] -> Text) -> [Text] -> Text
forall a b. (a -> b) -> a -> b
$ (Exp -> Maybe Text) -> [Exp] -> [Text]
forall a b. (a -> Maybe b) -> [a] -> [b]
mapMaybe Exp -> Maybe Text
expToOperatorName [Exp]
xs
        | Bool
otherwise -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped [Exp]
xs

binary :: Text -> TP Exp
binary :: Text -> TP Exp
binary c :: Text
c = do
  case Text
c of
     "\\overset"  -> do
       Exp
a <- TP Exp
texToken
       Exp
b <- TP Exp
texToken
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
b Exp
a
     "\\stackrel" -> do
       Exp
a <- TP Exp
texToken
       Exp
b <- TP Exp
texToken
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
b Exp
a
     "\\underset" -> do
       Exp
a <- TP Exp
texToken
       Exp
b <- TP Exp
texToken
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
b Exp
a
     "\\frac"     -> FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NormalFrac (Exp -> Exp -> Exp)
-> TP Exp -> ParsecT Text () Identity (Exp -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken ParsecT Text () Identity (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TP Exp
texToken
     "\\tfrac"    -> FractionType -> Exp -> Exp -> Exp
EFraction FractionType
InlineFrac (Exp -> Exp -> Exp)
-> TP Exp -> ParsecT Text () Identity (Exp -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken ParsecT Text () Identity (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TP Exp
texToken
     "\\dfrac"    -> FractionType -> Exp -> Exp -> Exp
EFraction FractionType
DisplayFrac (Exp -> Exp -> Exp)
-> TP Exp -> ParsecT Text () Identity (Exp -> Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken ParsecT Text () Identity (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> TP Exp
texToken
     "\\binom"    -> do
       Exp
a <- TP Exp
texToken
       Exp
b <- TP Exp
texToken
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text -> [InEDelimited] -> Exp
EDelimited "(" ")" [Exp -> InEDelimited
forall a b. b -> Either a b
Right (FractionType -> Exp -> Exp -> Exp
EFraction FractionType
NoLineFrac Exp
a Exp
b)]
     _            -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

texSymbol :: TP Exp
texSymbol :: TP Exp
texSymbol = TP Exp
operator TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
            TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do Text
c <- TP Text
anyCtrlSeq
                    Text -> TP Exp
tSymbol Text
c TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Text -> TP Exp
negated Text
c)

negated :: Text -> TP Exp
negated :: Text -> TP Exp
negated "\\not" = do
  Exp
sym <- TP Exp
texSymbol TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
texChar
  case Exp
sym of
    ESymbol Rel x :: Text
x -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Rel (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text
toNeg Text
x
    EText tt :: TextType
tt x :: Text
x    -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ TextType -> Text -> Exp
EText TextType
tt (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text
toNeg Text
x
    ENumber x :: Text
x     -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Exp
ENumber (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text
toNeg Text
x
    EIdentifier x :: Text
x -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Text -> Exp
EIdentifier (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Text -> Text
toNeg Text
x
    _             -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero
negated _ = TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

toNeg :: Text -> Text
toNeg :: Text -> Text
toNeg x :: Text
x = case Text
x of
            "\x2203" -> "\x2204"
            "\x2208" -> "\x2209"
            "\x220B" -> "\x220C"
            "\x2223" -> "\x2224"
            "\x2225" -> "\x2226"
            "\x2243" -> "\x2244"
            "\x2245" -> "\x2246"
            "\x2248" -> "\x2249"
            "="      -> "\x2260"
            "\x2261" -> "\x2262"
            "<"      -> "\x226E"
            ">"      -> "\x226F"
            "\x2264" -> "\x2270"
            "\x2265" -> "\x2271"
            "\x2272" -> "\x2274"
            "\x2273" -> "\x2275"
            "\x227A" -> "\x2280"
            "\x227B" -> "\x2281"
            "\x2282" -> "\x2284"
            "\x2283" -> "\x2285"
            "\x2286" -> "\x2288"
            "\x2287" -> "\x2289"
            "\x227C" -> "\x22E0"
            "\x227D" -> "\x22E1"
            "\x2291" -> "\x22E2"
            "\x2292" -> "\x22E3"
            _        -> Text
x Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "\x0338"


oneOfCommands :: [Text] -> TP Text
oneOfCommands :: [Text] -> TP Text
oneOfCommands cmds :: [Text]
cmds = TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ do
  Text
cmd <- [Text] -> TP Text
oneOfStrings [Text]
cmds
  case Text -> SourceName
T.unpack Text
cmd of
    ['\\',c :: Char
c] | Bool -> Bool
not (Char -> Bool
isLetter Char
c) -> () -> ParsecT Text () Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    cmd' :: SourceName
cmd' -> (do SourcePos
pos <- ParsecT Text () Identity SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
                ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
                SourcePos -> ParsecT Text () Identity ()
forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
setPosition SourcePos
pos
                ParsecT Text () Identity ()
forall (m :: * -> *) a. MonadPlus m => m a
mzero ParsecT Text () Identity ()
-> SourceName -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> ("non-letter after " SourceName -> SourceName -> SourceName
forall a. Semigroup a => a -> a -> a
<> SourceName
cmd'))
         ParsecT Text () Identity ()
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> () -> ParsecT Text () Identity ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
  ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces
  Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
cmd

oneOfStrings' :: (Char -> Char -> Bool) -> [(String, Text)] -> TP Text
oneOfStrings' :: (Char -> Char -> Bool) -> [(SourceName, Text)] -> TP Text
oneOfStrings' _ [] = TP Text
forall (m :: * -> *) a. MonadPlus m => m a
mzero
oneOfStrings' matches :: Char -> Char -> Bool
matches strs :: [(SourceName, Text)]
strs = TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ do
    Char
c <- ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar
    let strs' :: [(SourceName, Text)]
strs' = [(SourceName
xs, Text
t) | ((x :: Char
x:xs :: SourceName
xs), t :: Text
t) <- [(SourceName, Text)]
strs, Char
x Char -> Char -> Bool
`matches` Char
c]
    case [(SourceName, Text)]
strs' of
      []  -> TP Text
forall (m :: * -> *) a. MonadPlus m => m a
mzero
      _   -> (Char -> Char -> Bool) -> [(SourceName, Text)] -> TP Text
oneOfStrings' Char -> Char -> Bool
matches [(SourceName, Text)]
strs'
             TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> case ((SourceName, Text) -> Bool)
-> [(SourceName, Text)] -> Maybe (SourceName, Text)
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Maybe a
find (SourceName -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (SourceName -> Bool)
-> ((SourceName, Text) -> SourceName) -> (SourceName, Text) -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (SourceName, Text) -> SourceName
forall a b. (a, b) -> a
fst) [(SourceName, Text)]
strs' of
                   Just (_, t :: Text
t) -> Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
t
                   Nothing     -> TP Text
forall (m :: * -> *) a. MonadPlus m => m a
mzero

-- | Parses one of a list of strings.  If the list contains
-- two strings one of which is a prefix of the other, the longer
-- string will be matched if possible.
oneOfStrings :: [Text] -> TP Text
oneOfStrings :: [Text] -> TP Text
oneOfStrings strs :: [Text]
strs = (Char -> Char -> Bool) -> [(SourceName, Text)] -> TP Text
oneOfStrings' Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
(==) [(SourceName, Text)]
strs' TP Text -> SourceName -> TP Text
forall (m :: * -> *) s u a.
Monad m =>
ParsecT s u m a -> SourceName -> ParsecT s u m a
<??> (SourceName -> [SourceName] -> SourceName
forall a. [a] -> [[a]] -> [a]
intercalate ", " ([SourceName] -> SourceName) -> [SourceName] -> SourceName
forall a b. (a -> b) -> a -> b
$ (Text -> SourceName) -> [Text] -> [SourceName]
forall a b. (a -> b) -> [a] -> [b]
map Text -> SourceName
forall a. Show a => a -> SourceName
show [Text]
strs)
  where
    strs' :: [(SourceName, Text)]
strs' = (Text -> (SourceName, Text)) -> [Text] -> [(SourceName, Text)]
forall a b. (a -> b) -> [a] -> [b]
map (\x :: Text
x -> (Text -> SourceName
T.unpack Text
x, Text
x)) [Text]
strs

-- | Like '(<?>)', but moves position back to the beginning of the parse
-- before reporting the error.
(<??>) :: Monad m => ParsecT s u m a -> String -> ParsecT s u m a
<??> :: ParsecT s u m a -> SourceName -> ParsecT s u m a
(<??>) p :: ParsecT s u m a
p expected :: SourceName
expected = do
  SourcePos
pos <- ParsecT s u m SourcePos
forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
getPosition
  ParsecT s u m a
p ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (SourcePos -> ParsecT s u m ()
forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
setPosition SourcePos
pos ParsecT s u m () -> ParsecT s u m a -> ParsecT s u m a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT s u m a
forall (m :: * -> *) a. MonadPlus m => m a
mzero ParsecT s u m a -> SourceName -> ParsecT s u m a
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> SourceName
expected)

infix 0 <??>

tSymbol :: Text -> TP Exp
tSymbol :: Text -> TP Exp
tSymbol sym :: Text
sym =
  case Text -> Map Text Exp -> Maybe Exp
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
sym Map Text Exp
symbols of
       Just acc :: Exp
acc@(ESymbol Accent _) ->
         (\t :: Exp
t -> Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
t Exp
acc) (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken
       Just acc :: Exp
acc@(ESymbol TUnder _) ->
         (\t :: Exp
t -> Bool -> Exp -> Exp -> Exp
EUnder Bool
False Exp
t Exp
acc) (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken
       Just acc :: Exp
acc@(ESymbol TOver _) ->
         (\t :: Exp
t -> Bool -> Exp -> Exp -> Exp
EOver Bool
False Exp
t Exp
acc) (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
texToken
       Just x :: Exp
x  -> Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return Exp
x
       Nothing
         | Text
sym Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "\\mod" -> do
             Exp
x <- Exp -> Exp
deGroup (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
expr
             Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped
               [Rational -> Exp
ESpace (8Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), Text -> Exp
EMathOperator "mod", Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), Exp
x]
         | Text
sym Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "\\bmod" -> do
             Exp
x <- Exp -> Exp
deGroup (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
expr
             Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped
               [Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), Text -> Exp
EMathOperator "mod", Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), Exp
x]
         | Text
sym Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "\\pmod" -> do
             Exp
x <- Exp -> Exp
deGroup (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
expr
             Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped
               [Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Open "(", Text -> Exp
EMathOperator "mod",
                Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), Exp
x, TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Close ")"]
         | Text
sym Text -> Text -> Bool
forall a. Eq a => a -> a -> Bool
== "\\pod"  -> do
             Exp
x <- Exp -> Exp
deGroup (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
expr
             Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped
               [Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18), TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Open "(", Exp
x, TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Close ")"]
         | Bool
otherwise -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

operator :: TP Exp
operator :: TP Exp
operator = do
  Text
sym <- TP Text -> TP Text
forall a. TP a -> TP a
lexeme ([Text] -> TP Text
oneOfStrings ([Text] -> TP Text) -> [Text] -> TP Text
forall a b. (a -> b) -> a -> b
$ Map Text Exp -> [Text]
forall k a. Map k a -> [k]
M.keys Map Text Exp
operators)
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Maybe Exp -> Exp
forall a. HasCallStack => Maybe a -> a
fromJust (Text -> Map Text Exp -> Maybe Exp
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
sym Map Text Exp
operators)

lexeme :: TP a -> TP a
lexeme :: TP a -> TP a
lexeme p :: TP a
p = TP a
p TP a -> ParsecT Text () Identity () -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
ignorable

braces :: TP a -> TP a
braces :: TP a -> TP a
braces p :: TP a
p = TP a -> TP a
forall a. TP a -> TP a
lexeme (TP a -> TP a) -> TP a -> TP a
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '{' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity () -> TP a -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP a
p TP a -> ParsecT Text () Identity () -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces TP a -> ParsecT Text () Identity Char -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '}'

brackets :: TP a -> TP a
brackets :: TP a -> TP a
brackets p :: TP a
p = TP a -> TP a
forall a. TP a -> TP a
lexeme (TP a -> TP a) -> TP a -> TP a
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '[' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity () -> TP a -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP a
p TP a -> ParsecT Text () Identity () -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces TP a -> ParsecT Text () Identity Char -> TP a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ']'

textStr :: Text -> TP Text
textStr :: Text -> TP Text
textStr t :: Text
t = SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string (Text -> SourceName
T.unpack Text
t) ParsecT Text () Identity SourceName -> Text -> TP Text
forall (f :: * -> *) a b. Functor f => f a -> b -> f b
$> Text
t

countChar :: Int -> TP Char -> TP Text
countChar :: Line -> ParsecT Text () Identity Char -> TP Text
countChar n :: Line
n = (SourceName -> Text)
-> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap SourceName -> Text
T.pack (ParsecT Text () Identity SourceName -> TP Text)
-> (ParsecT Text () Identity Char
    -> ParsecT Text () Identity SourceName)
-> ParsecT Text () Identity Char
-> TP Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Line
-> ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
Line -> ParsecT s u m a -> ParsecT s u m [a]
count Line
n

symbol :: String -> TP String
symbol :: SourceName -> ParsecT Text () Identity SourceName
symbol s :: SourceName
s = ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a. TP a -> TP a
lexeme (ParsecT Text () Identity SourceName
 -> ParsecT Text () Identity SourceName)
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a b. (a -> b) -> a -> b
$ ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity SourceName
 -> ParsecT Text () Identity SourceName)
-> ParsecT Text () Identity SourceName
-> ParsecT Text () Identity SourceName
forall a b. (a -> b) -> a -> b
$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string SourceName
s

-- text mode parsing

textual :: TP Text
textual :: TP Text
textual = TP Text
regular TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text
sps TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text
ligature TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text
textCommand
            TP Text -> SourceName -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> SourceName -> ParsecT s u m a
<?> "text"

sps :: TP Text
sps :: TP Text
sps = " " Text -> ParsecT Text () Identity () -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 (SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
oneOf " \t\n")

regular :: TP Text
regular :: TP Text
regular = SourceName -> Text
T.pack (SourceName -> Text)
-> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
-> ParsecT Text () Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 (SourceName -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m Char
noneOf "`'-~${}\\ \t")

ligature :: TP Text
ligature :: TP Text
ligature = TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\x2014" Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "---")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\x2013" Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "--")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Text -> TP Text
textStr "-")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\x201C" Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "``")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\x201D" Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "''")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\x2019" Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "'")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\x2018" Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "`")
       TP Text -> TP Text -> TP Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try ("\xA0"   Text -> ParsecT Text () Identity SourceName -> TP Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "~")

textCommand :: TP Text
textCommand :: TP Text
textCommand = do
  Text
cmd <- [Text] -> TP Text
oneOfCommands (Map Text (TP Text) -> [Text]
forall k a. Map k a -> [k]
M.keys Map Text (TP Text)
textCommands)
  ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity Char -> ParsecT Text () Identity ())
-> ParsecT Text () Identity Char -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '{' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity ()
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '}')
  case Text -> Map Text (TP Text) -> Maybe (TP Text)
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
cmd Map Text (TP Text)
textCommands of
       Nothing -> SourceName -> TP Text
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail (SourceName -> TP Text) -> SourceName -> TP Text
forall a b. (a -> b) -> a -> b
$ Text -> SourceName
T.unpack (Text -> SourceName) -> Text -> SourceName
forall a b. (a -> b) -> a -> b
$ "Unknown control sequence " Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
cmd
       Just c :: TP Text
c  -> TP Text
c

tok :: TP Char
tok :: ParsecT Text () Identity Char
tok = (ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT Text () Identity Char -> ParsecT Text () Identity Char)
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '{' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity ()
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity Char
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '}')
   ParsecT Text () Identity Char
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar

textCommands :: M.Map Text (TP Text)
textCommands :: Map Text (TP Text)
textCommands = [(Text, TP Text)] -> Map Text (TP Text)
forall k a. Ord k => [(k, a)] -> Map k a
M.fromList
  [ ("\\#", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "#")
  , ("\\$", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "$")
  , ("\\%", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "%")
  , ("\\&", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "&")
  , ("\\_", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "_")
  , ("\\{", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "{")
  , ("\\}", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "}")
  , ("\\ldots", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "\x2026")
  , ("\\textasciitilde", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "~")
  , ("\\textasciicircum", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "^")
  , ("\\textbackslash", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "\\")
  , ("\\char", TP Text
parseC)
  , ("\\aa", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "å")
  , ("\\AA", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "Å")
  , ("\\ss", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "ß")
  , ("\\o", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "ø")
  , ("\\O", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "Ø")
  , ("\\L", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "Ł")
  , ("\\l", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "ł")
  , ("\\ae", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "æ")
  , ("\\AE", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "Æ")
  , ("\\oe", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "œ")
  , ("\\OE", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return "Œ")
  , ("\\`", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "`" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
grave (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\'", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "'" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
acute (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\^", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "^" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
circ  (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\~", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "~" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
tilde (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\\"", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "\"" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
umlaut (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\.", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "." (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
dot (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\=", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "=" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
macron (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\c", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "c" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
cedilla (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\v", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "v" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
hacek (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\u", Text -> TP Text -> TP Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option "u" (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> Text
breve (Char -> Text) -> ParsecT Text () Identity Char -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text () Identity Char
tok)
  , ("\\ ", Text -> TP Text
forall (m :: * -> *) a. Monad m => a -> m a
return " ")
  ]

parseC :: TP Text
parseC :: TP Text
parseC = TP Text -> TP Text
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Text -> TP Text) -> TP Text -> TP Text
forall a b. (a -> b) -> a -> b
$ Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '`' ParsecT Text () Identity Char -> TP Text -> TP Text
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Line -> ParsecT Text () Identity Char -> TP Text
countChar 1 ParsecT Text () Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
anyChar

-- the functions below taken from pandoc:

grave :: Char -> Text
grave :: Char -> Text
grave 'A' = "À"
grave 'E' = "È"
grave 'I' = "Ì"
grave 'O' = "Ò"
grave 'U' = "Ù"
grave 'a' = "à"
grave 'e' = "è"
grave 'i' = "ì"
grave 'o' = "ò"
grave 'u' = "ù"
grave c :: Char
c   = Char -> Text
T.singleton Char
c

acute :: Char -> Text
acute :: Char -> Text
acute 'A' = "Á"
acute 'E' = "É"
acute 'I' = "Í"
acute 'O' = "Ó"
acute 'U' = "Ú"
acute 'Y' = "Ý"
acute 'a' = "á"
acute 'e' = "é"
acute 'i' = "í"
acute 'o' = "ó"
acute 'u' = "ú"
acute 'y' = "ý"
acute 'C' = "Ć"
acute 'c' = "ć"
acute 'L' = "Ĺ"
acute 'l' = "ĺ"
acute 'N' = "Ń"
acute 'n' = "ń"
acute 'R' = "Ŕ"
acute 'r' = "ŕ"
acute 'S' = "Ś"
acute 's' = "ś"
acute 'Z' = "Ź"
acute 'z' = "ź"
acute c :: Char
c   = Char -> Text
T.singleton Char
c

circ :: Char -> Text
circ :: Char -> Text
circ 'A' = "Â"
circ 'E' = "Ê"
circ 'I' = "Î"
circ 'O' = "Ô"
circ 'U' = "Û"
circ 'a' = "â"
circ 'e' = "ê"
circ 'i' = "î"
circ 'o' = "ô"
circ 'u' = "û"
circ 'C' = "Ĉ"
circ 'c' = "ĉ"
circ 'G' = "Ĝ"
circ 'g' = "ĝ"
circ 'H' = "Ĥ"
circ 'h' = "ĥ"
circ 'J' = "Ĵ"
circ 'j' = "ĵ"
circ 'S' = "Ŝ"
circ 's' = "ŝ"
circ 'W' = "Ŵ"
circ 'w' = "ŵ"
circ 'Y' = "Ŷ"
circ 'y' = "ŷ"
circ c :: Char
c   = Char -> Text
T.singleton Char
c

tilde :: Char -> Text
tilde :: Char -> Text
tilde 'A' = "Ã"
tilde 'a' = "ã"
tilde 'O' = "Õ"
tilde 'o' = "õ"
tilde 'I' = "Ĩ"
tilde 'i' = "ĩ"
tilde 'U' = "Ũ"
tilde 'u' = "ũ"
tilde 'N' = "Ñ"
tilde 'n' = "ñ"
tilde c :: Char
c   = Char -> Text
T.singleton Char
c

umlaut :: Char -> Text
umlaut :: Char -> Text
umlaut 'A' = "Ä"
umlaut 'E' = "Ë"
umlaut 'I' = "Ï"
umlaut 'O' = "Ö"
umlaut 'U' = "Ü"
umlaut 'a' = "ä"
umlaut 'e' = "ë"
umlaut 'i' = "ï"
umlaut 'o' = "ö"
umlaut 'u' = "ü"
umlaut c :: Char
c   = Char -> Text
T.singleton Char
c

dot :: Char -> Text
dot :: Char -> Text
dot 'C' = "Ċ"
dot 'c' = "ċ"
dot 'E' = "Ė"
dot 'e' = "ė"
dot 'G' = "Ġ"
dot 'g' = "ġ"
dot 'I' = "İ"
dot 'Z' = "Ż"
dot 'z' = "ż"
dot c :: Char
c   = Char -> Text
T.singleton Char
c

macron :: Char -> Text
macron :: Char -> Text
macron 'A' = "Ā"
macron 'E' = "Ē"
macron 'I' = "Ī"
macron 'O' = "Ō"
macron 'U' = "Ū"
macron 'a' = "ā"
macron 'e' = "ē"
macron 'i' = "ī"
macron 'o' = "ō"
macron 'u' = "ū"
macron c :: Char
c   = Char -> Text
T.singleton Char
c

cedilla :: Char -> Text
cedilla :: Char -> Text
cedilla 'c' = "ç"
cedilla 'C' = "Ç"
cedilla 's' = "ş"
cedilla 'S' = "Ş"
cedilla 't' = "ţ"
cedilla 'T' = "Ţ"
cedilla 'e' = "ȩ"
cedilla 'E' = "Ȩ"
cedilla 'h' = "ḩ"
cedilla 'H' = "Ḩ"
cedilla 'o' = "o̧"
cedilla 'O' = "O̧"
cedilla c :: Char
c   = Char -> Text
T.singleton Char
c

hacek :: Char -> Text
hacek :: Char -> Text
hacek 'A' = "Ǎ"
hacek 'a' = "ǎ"
hacek 'C' = "Č"
hacek 'c' = "č"
hacek 'D' = "Ď"
hacek 'd' = "ď"
hacek 'E' = "Ě"
hacek 'e' = "ě"
hacek 'G' = "Ǧ"
hacek 'g' = "ǧ"
hacek 'H' = "Ȟ"
hacek 'h' = "ȟ"
hacek 'I' = "Ǐ"
hacek 'i' = "ǐ"
hacek 'j' = "ǰ"
hacek 'K' = "Ǩ"
hacek 'k' = "ǩ"
hacek 'L' = "Ľ"
hacek 'l' = "ľ"
hacek 'N' = "Ň"
hacek 'n' = "ň"
hacek 'O' = "Ǒ"
hacek 'o' = "ǒ"
hacek 'R' = "Ř"
hacek 'r' = "ř"
hacek 'S' = "Š"
hacek 's' = "š"
hacek 'T' = "Ť"
hacek 't' = "ť"
hacek 'U' = "Ǔ"
hacek 'u' = "ǔ"
hacek 'Z' = "Ž"
hacek 'z' = "ž"
hacek c :: Char
c   = Char -> Text
T.singleton Char
c

breve :: Char -> Text
breve :: Char -> Text
breve 'A' = "Ă"
breve 'a' = "ă"
breve 'E' = "Ĕ"
breve 'e' = "ĕ"
breve 'G' = "Ğ"
breve 'g' = "ğ"
breve 'I' = "Ĭ"
breve 'i' = "ĭ"
breve 'O' = "Ŏ"
breve 'o' = "ŏ"
breve 'U' = "Ŭ"
breve 'u' = "ŭ"
breve c :: Char
c   = Char -> Text
T.singleton Char
c

-- siunitx

siunitx :: Text -> TP Exp
siunitx :: Text -> TP Exp
siunitx c :: Text
c = do
  case Text
c of
    "\\si"       -> TP Exp
dosi
    "\\unit"     -> TP Exp
dosi  -- v3 version of \si
    "\\SI"       -> TP Exp
doSI
    "\\qty"      -> TP Exp
doSI  -- v3 version of \SI
    "\\SIrange"  -> Bool -> TP Exp
doSIrange Bool
True
    "\\qtyrange" -> Bool -> TP Exp
doSIrange Bool
True -- v3 version of SIrange
    "\\numrange" -> Bool -> TP Exp
doSIrange Bool
False
    "\\numlist"  -> TP Exp
doSInumlist
  -- "\\SIlist"   -> doSIlist -- v3 version of SIlist
  -- "\\qtylist"  -> doSIlist -- v3 version of SIlist
    "\\num"      -> TP Exp
doSInum
    "\\ang"      -> TP Exp
doSIang
    _          -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero

-- converts e.g. \SIrange{100}{200}{\ms} to "100 ms--200 ms"
doSIrange :: Bool -> TP Exp
doSIrange :: Bool -> TP Exp
doSIrange includeUnits :: Bool
includeUnits = do
  ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity () -> ParsecT Text () Identity ())
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ TP Exp -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany TP Exp
inbrackets
  Maybe Exp
startvalue <- Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
doSInum
  Maybe Exp
startvalueprefix <- Maybe Exp
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Exp
forall a. Maybe a
Nothing (ParsecT Text () Identity (Maybe Exp)
 -> ParsecT Text () Identity (Maybe Exp))
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall a b. (a -> b) -> a -> b
$ Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp -> TP Exp
forall a. TP a -> TP a
brackets TP Exp
expr
  Maybe Exp
stopvalue <- Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
doSInum
  Maybe Exp
stopvalueprefix <- Maybe Exp
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Exp
forall a. Maybe a
Nothing (ParsecT Text () Identity (Maybe Exp)
 -> ParsecT Text () Identity (Maybe Exp))
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall a b. (a -> b) -> a -> b
$ Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp -> TP Exp
forall a. TP a -> TP a
brackets TP Exp
expr
  Maybe Exp
unit <- if Bool
includeUnits
             then Maybe Exp
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Exp
forall a. Maybe a
Nothing (ParsecT Text () Identity (Maybe Exp)
 -> ParsecT Text () Identity (Maybe Exp))
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall a b. (a -> b) -> a -> b
$ Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
dosi
             else Maybe Exp -> ParsecT Text () Identity (Maybe Exp)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Exp
forall a. Maybe a
Nothing
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped ([Exp] -> Exp) -> [Exp] -> Exp
forall a b. (a -> b) -> a -> b
$ [Maybe Exp] -> [Exp]
forall a. [Maybe a] -> [a]
catMaybes
           [Maybe Exp
startvalueprefix,
            Maybe Exp -> Maybe Exp
emptyOr160 Maybe Exp
startvalueprefix,
            Maybe Exp
startvalue,
            Maybe Exp -> Maybe Exp
emptyOr160 Maybe Exp
unit,
            Maybe Exp
unit,
            Exp -> Maybe Exp
forall a. a -> Maybe a
Just (TextType -> Text -> Exp
EText TextType
TextNormal "\8211"), -- An en-dash
            Maybe Exp
stopvalueprefix,
            Maybe Exp -> Maybe Exp
emptyOr160 Maybe Exp
stopvalueprefix,
            Maybe Exp
stopvalue,
            Maybe Exp -> Maybe Exp
emptyOr160 Maybe Exp
unit,
            Maybe Exp
unit]


doSInumlist :: TP Exp
doSInumlist :: TP Exp
doSInumlist = do
  ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity () -> ParsecT Text () Identity ())
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ TP Exp -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany TP Exp
inbrackets
  [Exp]
xs <- Parsec Text () [Exp] -> Parsec Text () [Exp]
forall a. TP a -> TP a
braces (TP Exp -> ParsecT Text () Identity Char -> Parsec Text () [Exp]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy TP Exp
siNum (ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity ()
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ';' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces))
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$
    case [Exp]
xs of
      []  -> [Exp] -> Exp
EGrouped []
      [x :: Exp
x] -> Exp
x
      _   -> [Exp] -> Exp
EGrouped ([Exp] -> Exp) -> [Exp] -> Exp
forall a b. (a -> b) -> a -> b
$
               Exp -> [Exp] -> [Exp]
forall a. a -> [a] -> [a]
intersperse (TextType -> Text -> Exp
EText TextType
TextNormal ", ") ([Exp] -> [Exp]
forall a. [a] -> [a]
init [Exp]
xs) [Exp] -> [Exp] -> [Exp]
forall a. [a] -> [a] -> [a]
++
               [TextType -> Text -> Exp
EText TextType
TextNormal ", & ", [Exp] -> Exp
forall a. [a] -> a
last [Exp]
xs]

dosi :: TP Exp
dosi :: TP Exp
dosi = TP Exp
siUnit TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp -> TP Exp
forall a. TP a -> TP a
braces (TP Exp -> TP Exp
manyExp (TP Exp
siUnit TP Exp -> TP Exp -> TP Exp
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> TP Exp
expr))

doSIang :: TP Exp
doSIang :: TP Exp
doSIang = do
  ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity () -> ParsecT Text () Identity ())
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ TP Exp -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany TP Exp
inbrackets
  [Exp]
ps <- Parsec Text () [Exp] -> Parsec Text () [Exp]
forall a. TP a -> TP a
braces (Parsec Text () [Exp] -> Parsec Text () [Exp])
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall a b. (a -> b) -> a -> b
$ TP Exp -> ParsecT Text () Identity Char -> Parsec Text () [Exp]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy TP Exp
siNum (ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces ParsecT Text () Identity ()
-> ParsecT Text () Identity Char -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> Char -> ParsecT Text () Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ';' ParsecT Text () Identity Char
-> ParsecT Text () Identity () -> ParsecT Text () Identity Char
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* ParsecT Text () Identity ()
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
spaces)
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped ([Exp] -> Exp) -> [Exp] -> Exp
forall a b. (a -> b) -> a -> b
$
    case [Exp]
ps [Exp] -> [Exp] -> [Exp]
forall a. [a] -> [a] -> [a]
++ Exp -> [Exp]
forall a. a -> [a]
repeat ([Exp] -> Exp
EGrouped []) of
      (d :: Exp
d:m :: Exp
m:s :: Exp
s:_) ->
        (if Exp
d Exp -> Exp -> Bool
forall a. Eq a => a -> a -> Bool
== [Exp] -> Exp
EGrouped [] then [] else [Exp
d, TextType -> Text -> Exp
EText TextType
TextNormal "\xb0"]) [Exp] -> [Exp] -> [Exp]
forall a. Semigroup a => a -> a -> a
<>
        (if Exp
m Exp -> Exp -> Bool
forall a. Eq a => a -> a -> Bool
== [Exp] -> Exp
EGrouped [] then [] else [Exp
m, TextType -> Text -> Exp
EText TextType
TextNormal "\x2032"]) [Exp] -> [Exp] -> [Exp]
forall a. Semigroup a => a -> a -> a
<>
        (if Exp
s Exp -> Exp -> Bool
forall a. Eq a => a -> a -> Bool
== [Exp] -> Exp
EGrouped [] then [] else [Exp
s, TextType -> Text -> Exp
EText TextType
TextNormal "\x2033"])
      _ -> []

-- converts e.g. \SI{1}[\$]{} to "$ 1" or \SI{1}{\euro} to "1 €"
doSI :: TP Exp
doSI :: TP Exp
doSI = do
  ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity () -> ParsecT Text () Identity ())
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ TP Exp -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany TP Exp
inbrackets
  Maybe Exp
value <- Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
doSInum
  Maybe Exp
valueprefix <- Maybe Exp
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Exp
forall a. Maybe a
Nothing (ParsecT Text () Identity (Maybe Exp)
 -> ParsecT Text () Identity (Maybe Exp))
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall a b. (a -> b) -> a -> b
$ do
                    Exp
x <- TP Exp
inbrackets
                    if Exp
x Exp -> Exp -> Bool
forall a. Eq a => a -> a -> Bool
== [Exp] -> Exp
EGrouped []
                       then Maybe Exp -> ParsecT Text () Identity (Maybe Exp)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Exp
forall a. Maybe a
Nothing
                       else Maybe Exp -> ParsecT Text () Identity (Maybe Exp)
forall (m :: * -> *) a. Monad m => a -> m a
return (Maybe Exp -> ParsecT Text () Identity (Maybe Exp))
-> Maybe Exp -> ParsecT Text () Identity (Maybe Exp)
forall a b. (a -> b) -> a -> b
$ Exp -> Maybe Exp
forall a. a -> Maybe a
Just Exp
x
  Maybe Exp
unit <- Maybe Exp
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Maybe Exp
forall a. Maybe a
Nothing (ParsecT Text () Identity (Maybe Exp)
 -> ParsecT Text () Identity (Maybe Exp))
-> ParsecT Text () Identity (Maybe Exp)
-> ParsecT Text () Identity (Maybe Exp)
forall a b. (a -> b) -> a -> b
$ Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Exp -> Maybe Exp)
-> TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Exp
dosi
  Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ [Exp] -> Exp
EGrouped ([Exp] -> Exp) -> [Exp] -> Exp
forall a b. (a -> b) -> a -> b
$ [Maybe Exp] -> [Exp]
forall a. [Maybe a] -> [a]
catMaybes
         [ Maybe Exp
valueprefix,
           Maybe Exp -> Maybe Exp
emptyOr160 Maybe Exp
valueprefix,
           Maybe Exp
value,
           Maybe Exp -> Maybe Exp
emptyOr160 Maybe Exp
unit,
           Maybe Exp
unit
         ]

emptyOr160 :: Maybe Exp -> Maybe Exp
emptyOr160 :: Maybe Exp -> Maybe Exp
emptyOr160 (Just _) = Exp -> Maybe Exp
forall a. a -> Maybe a
Just (Rational -> Exp
ESpace (4Rational -> Rational -> Rational
forall a. Fractional a => a -> a -> a
/18))
emptyOr160 Nothing  = Maybe Exp
forall a. Maybe a
Nothing


siUnit :: TP Exp
siUnit :: TP Exp
siUnit = TP Exp -> TP Exp
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ do
  Text
name <- (Char -> Bool) -> Text -> Text
T.dropWhile (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
=='\\') (Text -> Text) -> TP Text -> TP Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TP Text
anyCtrlSeq
  case Text
name of
    "square" -> do
       Exp
unit <- TP Exp
siUnit
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Exp -> Exp -> Exp
ESuper Exp
unit (Text -> Exp
ENumber "2")
    "cubic" -> do
       Exp
unit <- TP Exp
siUnit
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Exp -> Exp -> Exp
ESuper Exp
unit (Text -> Exp
ENumber "3")
    "raisetothe" -> do
       Exp
n <- TP Exp
expr
       Exp
unit <- TP Exp
siUnit
       Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ Exp -> Exp -> Exp
ESuper Exp
unit Exp
n
    _ ->
       case Text -> Map Text Exp -> Maybe Exp
forall k a. Ord k => k -> Map k a -> Maybe a
M.lookup Text
name Map Text Exp
siUnitMap of
            Just il :: Exp
il ->
              Exp -> TP Exp -> TP Exp
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Exp
il (TP Exp -> TP Exp) -> TP Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$
                [TP Exp] -> TP Exp
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice
                 [ (Exp -> Exp -> Exp
ESuper Exp
il (Text -> Exp
ENumber "2")) Exp -> ParsecT Text () Identity SourceName -> TP Exp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
ctrlseq "squared"
                 , (Exp -> Exp -> Exp
ESuper Exp
il (Text -> Exp
ENumber "3")) Exp -> ParsecT Text () Identity SourceName -> TP Exp
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ SourceName -> ParsecT Text () Identity SourceName
ctrlseq "cubed"
                 , (\n :: Exp
n -> Exp -> Exp -> Exp
ESuper Exp
il Exp
n) (Exp -> Exp) -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (SourceName -> ParsecT Text () Identity SourceName
ctrlseq "tothe" ParsecT Text () Identity SourceName -> TP Exp -> TP Exp
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> TP Exp
expr)
                 ]
            Nothing -> SourceName -> TP Exp
forall (m :: * -> *) a. MonadFail m => SourceName -> m a
fail "not an siunit unit command"

doSInum :: TP Exp
doSInum :: TP Exp
doSInum = do
  ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
optional (ParsecT Text () Identity () -> ParsecT Text () Identity ())
-> ParsecT Text () Identity () -> ParsecT Text () Identity ()
forall a b. (a -> b) -> a -> b
$ TP Exp -> ParsecT Text () Identity ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany TP Exp
inbrackets
  TP Exp -> TP Exp
forall a. TP a -> TP a
braces TP Exp
siNum

siNum :: TP Exp
siNum :: TP Exp
siNum = [Exp] -> Exp
asGroup ([Exp] -> Exp) -> (ArrayLine -> [Exp]) -> ArrayLine -> Exp
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ArrayLine -> [Exp]
forall a. Monoid a => [a] -> a
mconcat (ArrayLine -> Exp) -> TP ArrayLine -> TP Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parsec Text () [Exp] -> TP ArrayLine
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many Parsec Text () [Exp]
parseNumPart

parseNumPart :: TP [Exp]
parseNumPart :: Parsec Text () [Exp]
parseNumPart =
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parseDecimalNum Parsec Text () [Exp]
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parseComma Parsec Text () [Exp]
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parsePlusMinus Parsec Text () [Exp]
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parseI Parsec Text () [Exp]
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parseExp Parsec Text () [Exp]
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parseX Parsec Text () [Exp]
-> Parsec Text () [Exp] -> Parsec Text () [Exp]
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
  Parsec Text () [Exp]
forall u. ParsecT Text u Identity [Exp]
parseSpace
 where
  parseDecimalNum :: ParsecT Text u Identity [Exp]
parseDecimalNum = do
    Text
pref <- Text
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Text
forall a. Monoid a => a
mempty (ParsecT Text u Identity Text -> ParsecT Text u Identity Text)
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall a b. (a -> b) -> a -> b
$ (Text
forall a. Monoid a => a
mempty Text
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '+') ParsecT Text u Identity Text
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ("\x2212" Text
-> ParsecT Text u Identity Char -> ParsecT Text u Identity Text
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '-')
    Text
basenum <- (Text
pref Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>) (Text -> Text) -> (SourceName -> Text) -> SourceName -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SourceName -> Text
T.pack
                (SourceName -> Text)
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text u Identity Char -> ParsecT Text u Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ((Char -> Bool) -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (\c :: Char
c -> Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '.'))
    Text
uncertainty <- Text
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option Text
forall a. Monoid a => a
mempty (ParsecT Text u Identity Text -> ParsecT Text u Identity Text)
-> ParsecT Text u Identity Text -> ParsecT Text u Identity Text
forall a b. (a -> b) -> a -> b
$ SourceName -> Text
T.pack (SourceName -> Text)
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ParsecT Text u Identity SourceName
forall u. ParsecT Text u Identity SourceName
parseParens
    if Text -> Bool
T.null Text
uncertainty
       then [Exp] -> ParsecT Text u Identity [Exp]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text -> Exp
ENumber Text
basenum]
       else [Exp] -> ParsecT Text u Identity [Exp]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text -> Exp
ENumber (Text -> Exp) -> Text -> Exp
forall a b. (a -> b) -> a -> b
$ Text
basenum Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> "\xa0\xb1\xa0" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
             let (_,ys :: Text
ys) = (Char -> Bool) -> Text -> (Text, Text)
T.break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
=='.') Text
basenum
              in case (Text -> Line
T.length Text
ys Line -> Line -> Line
forall a. Num a => a -> a -> a
- 1, Text -> Line
T.length Text
uncertainty) of
                   (0,_) -> Text
uncertainty
                   (x :: Line
x,y :: Line
y)
                     | Line
x Line -> Line -> Bool
forall a. Ord a => a -> a -> Bool
> Line
y  -> "0." Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Line -> Text -> Text
T.replicate (Line
x Line -> Line -> Line
forall a. Num a => a -> a -> a
- Line
y) "0" Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                                      (Char -> Bool) -> Text -> Text
T.dropWhileEnd (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
=='0') Text
uncertainty
                     | Bool
otherwise -> Line -> Text -> Text
T.take (Line
y Line -> Line -> Line
forall a. Num a => a -> a -> a
- Line
x) Text
uncertainty Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<>
                                      case (Char -> Bool) -> Text -> Text
T.dropWhileEnd (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
=='0')
                                             (Line -> Text -> Text
T.drop (Line
y Line -> Line -> Line
forall a. Num a => a -> a -> a
- Line
x) Text
uncertainty) of
                                             t :: Text
t | Text -> Bool
T.null Text
t -> Text
forall a. Monoid a => a
mempty
                                               | Bool
otherwise -> "." Text -> Text -> Text
forall a. Semigroup a => a -> a -> a
<> Text
t]
  parseComma :: ParsecT Text u Identity [Exp]
parseComma = [Text -> Exp
ENumber "."] [Exp]
-> ParsecT Text u Identity Char -> ParsecT Text u Identity [Exp]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ','
  parsePlusMinus :: ParsecT Text u Identity [Exp]
parsePlusMinus = [TextType -> Text -> Exp
EText TextType
TextNormal "\xa0\xb1\xa0"] [Exp]
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity [Exp]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (SourceName -> ParsecT Text u Identity SourceName
forall s (m :: * -> *) u.
Stream s m Char =>
SourceName -> ParsecT s u m SourceName
string "+-")
  parseParens :: ParsecT Text u Identity SourceName
parseParens =
    Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '(' ParsecT Text u Identity Char
-> ParsecT Text u Identity SourceName
-> ParsecT Text u Identity SourceName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text u Identity Char -> ParsecT Text u Identity SourceName
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ((Char -> Bool) -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (\c :: Char
c -> Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
|| Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== '.')) ParsecT Text u Identity SourceName
-> ParsecT Text u Identity Char
-> ParsecT Text u Identity SourceName
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ')'
  parseI :: ParsecT Text u Identity [Exp]
parseI = [Text -> Exp
EIdentifier "i"] [Exp]
-> ParsecT Text u Identity Char -> ParsecT Text u Identity [Exp]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char 'i'
  parseX :: ParsecT Text u Identity [Exp]
parseX = [TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Rel "\xa0\xd7\xa0"] [Exp]
-> ParsecT Text u Identity Char -> ParsecT Text u Identity [Exp]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char 'x'
  parseExp :: ParsecT Text u Identity [Exp]
parseExp = do
    Exp
n <- [Exp] -> Exp
asGroup ([Exp] -> Exp)
-> ParsecT Text u Identity [Exp] -> ParsecT Text u Identity Exp
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char 'e' ParsecT Text u Identity Char
-> ParsecT Text u Identity [Exp] -> ParsecT Text u Identity [Exp]
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
*> ParsecT Text u Identity [Exp]
forall u. ParsecT Text u Identity [Exp]
parseDecimalNum)
    [Exp] -> ParsecT Text u Identity [Exp]
forall (m :: * -> *) a. Monad m => a -> m a
return ([Exp] -> ParsecT Text u Identity [Exp])
-> [Exp] -> ParsecT Text u Identity [Exp]
forall a b. (a -> b) -> a -> b
$ [TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Rel "\xa0\xd7\xa0", Exp -> Exp -> Exp
ESuper (Text -> Exp
ENumber "10") Exp
n ]
  parseSpace :: ParsecT Text u Identity [Exp]
parseSpace = [Exp]
forall a. Monoid a => a
mempty [Exp]
-> ParsecT Text u Identity () -> ParsecT Text u Identity [Exp]
forall (f :: * -> *) a b. Functor f => a -> f b -> f a
<$ ParsecT Text u Identity Char -> ParsecT Text u Identity ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 (Char -> ParsecT Text u Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char ' ')

arrow :: Text -> TP Exp
arrow :: Text -> TP Exp
arrow c :: Text
c = case Text
c of
  "\\xleftarrow"   -> Text -> TP Exp
underoverarrow "\x2190"
  "\\xrightarrow"  -> Text -> TP Exp
underoverarrow "\x2192"
  _                -> TP Exp
forall (m :: * -> *) a. MonadPlus m => m a
mzero
 where
  underoverarrow :: Text -> TP Exp
underoverarrow s :: Text
s = do
    Maybe Exp
munder <- TP Exp -> ParsecT Text () Identity (Maybe Exp)
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m (Maybe a)
optionMaybe TP Exp
inbrackets
    Exp
over <- TP Exp
texToken
    Exp -> TP Exp
forall (m :: * -> *) a. Monad m => a -> m a
return (Exp -> TP Exp) -> Exp -> TP Exp
forall a b. (a -> b) -> a -> b
$ case Maybe Exp
munder of
      Nothing    -> Bool -> Exp -> Exp -> Exp
EOver Bool
False (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Op Text
s) Exp
over
      Just under :: Exp
under -> Bool -> Exp -> Exp -> Exp -> Exp
EUnderover Bool
False (TeXSymbolType -> Text -> Exp
ESymbol TeXSymbolType
Op Text
s) Exp
under Exp
over