{-# LANGUAGE OverloadedStrings,QuasiQuotes
        ,ImplicitParams
        ,CPP
        ,TemplateHaskell
        ,ConstraintKinds
        ,FlexibleContexts
        ,FlexibleInstances
        ,StandaloneDeriving
        ,UndecidableInstances
        ,MultiParamTypeClasses
        ,FunctionalDependencies
        ,GeneralizedNewtypeDeriving #-}
module Text.LaTeX.Internal.FunctionTable where


import Control.Applicative
import Control.Lens hiding ((&))
import Control.Monad.Writer

import Data.Bifoldable
import Data.Bitraversable
import Data.List as L
import Data.List.NonEmpty as N hiding (repeat)
import Data.Maybe
import Data.Semigroup hiding ((<>))
#if MIN_VERSION_base(4,9,0)
import GHC.Stack
#else
import GHC.Stack
import GHC.SrcLoc
#endif
import Text.LaTeX
import Text.LaTeX.Packages.AMSMath
import Text.LaTeX.Base.Syntax
import Text.LaTeX.Base.Class

data LaTeXLI = LaTeXLI SrcLoc String 
    deriving (Int -> LaTeXLI -> ShowS
[LaTeXLI] -> ShowS
LaTeXLI -> String
(Int -> LaTeXLI -> ShowS)
-> (LaTeXLI -> String) -> ([LaTeXLI] -> ShowS) -> Show LaTeXLI
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> LaTeXLI -> ShowS
showsPrec :: Int -> LaTeXLI -> ShowS
$cshow :: LaTeXLI -> String
show :: LaTeXLI -> String
$cshowList :: [LaTeXLI] -> ShowS
showList :: [LaTeXLI] -> ShowS
Show,LaTeXLI -> LaTeXLI -> Bool
(LaTeXLI -> LaTeXLI -> Bool)
-> (LaTeXLI -> LaTeXLI -> Bool) -> Eq LaTeXLI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: LaTeXLI -> LaTeXLI -> Bool
== :: LaTeXLI -> LaTeXLI -> Bool
$c/= :: LaTeXLI -> LaTeXLI -> Bool
/= :: LaTeXLI -> LaTeXLI -> Bool
Eq)

data TableCells' a b = Cell b | Condition Cols (NonEmpty (a,TableCells' a b))
    deriving (Int -> TableCells' a b -> ShowS
[TableCells' a b] -> ShowS
TableCells' a b -> String
(Int -> TableCells' a b -> ShowS)
-> (TableCells' a b -> String)
-> ([TableCells' a b] -> ShowS)
-> Show (TableCells' a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show b, Show a) => Int -> TableCells' a b -> ShowS
forall a b. (Show b, Show a) => [TableCells' a b] -> ShowS
forall a b. (Show b, Show a) => TableCells' a b -> String
$cshowsPrec :: forall a b. (Show b, Show a) => Int -> TableCells' a b -> ShowS
showsPrec :: Int -> TableCells' a b -> ShowS
$cshow :: forall a b. (Show b, Show a) => TableCells' a b -> String
show :: TableCells' a b -> String
$cshowList :: forall a b. (Show b, Show a) => [TableCells' a b] -> ShowS
showList :: [TableCells' a b] -> ShowS
Show,TableCells' a b -> TableCells' a b -> Bool
(TableCells' a b -> TableCells' a b -> Bool)
-> (TableCells' a b -> TableCells' a b -> Bool)
-> Eq (TableCells' a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b.
(Eq b, Eq a) =>
TableCells' a b -> TableCells' a b -> Bool
$c== :: forall a b.
(Eq b, Eq a) =>
TableCells' a b -> TableCells' a b -> Bool
== :: TableCells' a b -> TableCells' a b -> Bool
$c/= :: forall a b.
(Eq b, Eq a) =>
TableCells' a b -> TableCells' a b -> Bool
/= :: TableCells' a b -> TableCells' a b -> Bool
Eq,(forall a b. (a -> b) -> TableCells' a a -> TableCells' a b)
-> (forall a b. a -> TableCells' a b -> TableCells' a a)
-> Functor (TableCells' a)
forall a b. a -> TableCells' a b -> TableCells' a a
forall a b. (a -> b) -> TableCells' a a -> TableCells' a b
forall a a b. a -> TableCells' a b -> TableCells' a a
forall a a b. (a -> b) -> TableCells' a a -> TableCells' a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a a b. (a -> b) -> TableCells' a a -> TableCells' a b
fmap :: forall a b. (a -> b) -> TableCells' a a -> TableCells' a b
$c<$ :: forall a a b. a -> TableCells' a b -> TableCells' a a
<$ :: forall a b. a -> TableCells' a b -> TableCells' a a
Functor,(forall m. Monoid m => TableCells' a m -> m)
-> (forall m a. Monoid m => (a -> m) -> TableCells' a a -> m)
-> (forall m a. Monoid m => (a -> m) -> TableCells' a a -> m)
-> (forall a b. (a -> b -> b) -> b -> TableCells' a a -> b)
-> (forall a b. (a -> b -> b) -> b -> TableCells' a a -> b)
-> (forall b a. (b -> a -> b) -> b -> TableCells' a a -> b)
-> (forall b a. (b -> a -> b) -> b -> TableCells' a a -> b)
-> (forall a. (a -> a -> a) -> TableCells' a a -> a)
-> (forall a. (a -> a -> a) -> TableCells' a a -> a)
-> (forall a. TableCells' a a -> [a])
-> (forall a. TableCells' a a -> Bool)
-> (forall a. TableCells' a a -> Int)
-> (forall a. Eq a => a -> TableCells' a a -> Bool)
-> (forall a. Ord a => TableCells' a a -> a)
-> (forall a. Ord a => TableCells' a a -> a)
-> (forall a. Num a => TableCells' a a -> a)
-> (forall a. Num a => TableCells' a a -> a)
-> Foldable (TableCells' a)
forall a. Eq a => a -> TableCells' a a -> Bool
forall a. Num a => TableCells' a a -> a
forall a. Ord a => TableCells' a a -> a
forall m. Monoid m => TableCells' a m -> m
forall a. TableCells' a a -> Bool
forall a. TableCells' a a -> Int
forall a. TableCells' a a -> [a]
forall a. (a -> a -> a) -> TableCells' a a -> a
forall a a. Eq a => a -> TableCells' a a -> Bool
forall a a. Num a => TableCells' a a -> a
forall a a. Ord a => TableCells' a a -> a
forall a m. Monoid m => TableCells' a m -> m
forall m a. Monoid m => (a -> m) -> TableCells' a a -> m
forall a a. TableCells' a a -> Bool
forall a a. TableCells' a a -> Int
forall a a. TableCells' a a -> [a]
forall b a. (b -> a -> b) -> b -> TableCells' a a -> b
forall a b. (a -> b -> b) -> b -> TableCells' a a -> b
forall a a. (a -> a -> a) -> TableCells' a a -> a
forall a m a. Monoid m => (a -> m) -> TableCells' a a -> m
forall a b a. (b -> a -> b) -> b -> TableCells' a a -> b
forall a a b. (a -> b -> b) -> b -> TableCells' a a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall a m. Monoid m => TableCells' a m -> m
fold :: forall m. Monoid m => TableCells' a m -> m
$cfoldMap :: forall a m a. Monoid m => (a -> m) -> TableCells' a a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> TableCells' a a -> m
$cfoldMap' :: forall a m a. Monoid m => (a -> m) -> TableCells' a a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> TableCells' a a -> m
$cfoldr :: forall a a b. (a -> b -> b) -> b -> TableCells' a a -> b
foldr :: forall a b. (a -> b -> b) -> b -> TableCells' a a -> b
$cfoldr' :: forall a a b. (a -> b -> b) -> b -> TableCells' a a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> TableCells' a a -> b
$cfoldl :: forall a b a. (b -> a -> b) -> b -> TableCells' a a -> b
foldl :: forall b a. (b -> a -> b) -> b -> TableCells' a a -> b
$cfoldl' :: forall a b a. (b -> a -> b) -> b -> TableCells' a a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> TableCells' a a -> b
$cfoldr1 :: forall a a. (a -> a -> a) -> TableCells' a a -> a
foldr1 :: forall a. (a -> a -> a) -> TableCells' a a -> a
$cfoldl1 :: forall a a. (a -> a -> a) -> TableCells' a a -> a
foldl1 :: forall a. (a -> a -> a) -> TableCells' a a -> a
$ctoList :: forall a a. TableCells' a a -> [a]
toList :: forall a. TableCells' a a -> [a]
$cnull :: forall a a. TableCells' a a -> Bool
null :: forall a. TableCells' a a -> Bool
$clength :: forall a a. TableCells' a a -> Int
length :: forall a. TableCells' a a -> Int
$celem :: forall a a. Eq a => a -> TableCells' a a -> Bool
elem :: forall a. Eq a => a -> TableCells' a a -> Bool
$cmaximum :: forall a a. Ord a => TableCells' a a -> a
maximum :: forall a. Ord a => TableCells' a a -> a
$cminimum :: forall a a. Ord a => TableCells' a a -> a
minimum :: forall a. Ord a => TableCells' a a -> a
$csum :: forall a a. Num a => TableCells' a a -> a
sum :: forall a. Num a => TableCells' a a -> a
$cproduct :: forall a a. Num a => TableCells' a a -> a
product :: forall a. Num a => TableCells' a a -> a
Foldable,Functor (TableCells' a)
Foldable (TableCells' a)
(Functor (TableCells' a), Foldable (TableCells' a)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> TableCells' a a -> f (TableCells' a b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    TableCells' a (f a) -> f (TableCells' a a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> TableCells' a a -> m (TableCells' a b))
-> (forall (m :: * -> *) a.
    Monad m =>
    TableCells' a (m a) -> m (TableCells' a a))
-> Traversable (TableCells' a)
forall a. Functor (TableCells' a)
forall a. Foldable (TableCells' a)
forall a (m :: * -> *) a.
Monad m =>
TableCells' a (m a) -> m (TableCells' a a)
forall a (f :: * -> *) a.
Applicative f =>
TableCells' a (f a) -> f (TableCells' a a)
forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TableCells' a a -> m (TableCells' a b)
forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TableCells' a a -> f (TableCells' a b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
TableCells' a (m a) -> m (TableCells' a a)
forall (f :: * -> *) a.
Applicative f =>
TableCells' a (f a) -> f (TableCells' a a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TableCells' a a -> m (TableCells' a b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TableCells' a a -> f (TableCells' a b)
$ctraverse :: forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TableCells' a a -> f (TableCells' a b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> TableCells' a a -> f (TableCells' a b)
$csequenceA :: forall a (f :: * -> *) a.
Applicative f =>
TableCells' a (f a) -> f (TableCells' a a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
TableCells' a (f a) -> f (TableCells' a a)
$cmapM :: forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TableCells' a a -> m (TableCells' a b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> TableCells' a a -> m (TableCells' a b)
$csequence :: forall a (m :: * -> *) a.
Monad m =>
TableCells' a (m a) -> m (TableCells' a a)
sequence :: forall (m :: * -> *) a.
Monad m =>
TableCells' a (m a) -> m (TableCells' a a)
Traversable)

data FunctionTable' a b = Table b (TableCells' a b)
    deriving (Int -> FunctionTable' a b -> ShowS
[FunctionTable' a b] -> ShowS
FunctionTable' a b -> String
(Int -> FunctionTable' a b -> ShowS)
-> (FunctionTable' a b -> String)
-> ([FunctionTable' a b] -> ShowS)
-> Show (FunctionTable' a b)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall a b. (Show b, Show a) => Int -> FunctionTable' a b -> ShowS
forall a b. (Show b, Show a) => [FunctionTable' a b] -> ShowS
forall a b. (Show b, Show a) => FunctionTable' a b -> String
$cshowsPrec :: forall a b. (Show b, Show a) => Int -> FunctionTable' a b -> ShowS
showsPrec :: Int -> FunctionTable' a b -> ShowS
$cshow :: forall a b. (Show b, Show a) => FunctionTable' a b -> String
show :: FunctionTable' a b -> String
$cshowList :: forall a b. (Show b, Show a) => [FunctionTable' a b] -> ShowS
showList :: [FunctionTable' a b] -> ShowS
Show,FunctionTable' a b -> FunctionTable' a b -> Bool
(FunctionTable' a b -> FunctionTable' a b -> Bool)
-> (FunctionTable' a b -> FunctionTable' a b -> Bool)
-> Eq (FunctionTable' a b)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall a b.
(Eq b, Eq a) =>
FunctionTable' a b -> FunctionTable' a b -> Bool
$c== :: forall a b.
(Eq b, Eq a) =>
FunctionTable' a b -> FunctionTable' a b -> Bool
== :: FunctionTable' a b -> FunctionTable' a b -> Bool
$c/= :: forall a b.
(Eq b, Eq a) =>
FunctionTable' a b -> FunctionTable' a b -> Bool
/= :: FunctionTable' a b -> FunctionTable' a b -> Bool
Eq,(forall a b. (a -> b) -> FunctionTable' a a -> FunctionTable' a b)
-> (forall a b. a -> FunctionTable' a b -> FunctionTable' a a)
-> Functor (FunctionTable' a)
forall a b. a -> FunctionTable' a b -> FunctionTable' a a
forall a b. (a -> b) -> FunctionTable' a a -> FunctionTable' a b
forall a a b. a -> FunctionTable' a b -> FunctionTable' a a
forall a a b. (a -> b) -> FunctionTable' a a -> FunctionTable' a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a a b. (a -> b) -> FunctionTable' a a -> FunctionTable' a b
fmap :: forall a b. (a -> b) -> FunctionTable' a a -> FunctionTable' a b
$c<$ :: forall a a b. a -> FunctionTable' a b -> FunctionTable' a a
<$ :: forall a b. a -> FunctionTable' a b -> FunctionTable' a a
Functor,Functor (FunctionTable' a)
Foldable (FunctionTable' a)
(Functor (FunctionTable' a), Foldable (FunctionTable' a)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> FunctionTable' a a -> f (FunctionTable' a b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    FunctionTable' a (f a) -> f (FunctionTable' a a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> FunctionTable' a a -> m (FunctionTable' a b))
-> (forall (m :: * -> *) a.
    Monad m =>
    FunctionTable' a (m a) -> m (FunctionTable' a a))
-> Traversable (FunctionTable' a)
forall a. Functor (FunctionTable' a)
forall a. Foldable (FunctionTable' a)
forall a (m :: * -> *) a.
Monad m =>
FunctionTable' a (m a) -> m (FunctionTable' a a)
forall a (f :: * -> *) a.
Applicative f =>
FunctionTable' a (f a) -> f (FunctionTable' a a)
forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunctionTable' a a -> m (FunctionTable' a b)
forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunctionTable' a a -> f (FunctionTable' a b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
FunctionTable' a (m a) -> m (FunctionTable' a a)
forall (f :: * -> *) a.
Applicative f =>
FunctionTable' a (f a) -> f (FunctionTable' a a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunctionTable' a a -> m (FunctionTable' a b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunctionTable' a a -> f (FunctionTable' a b)
$ctraverse :: forall a (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunctionTable' a a -> f (FunctionTable' a b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> FunctionTable' a a -> f (FunctionTable' a b)
$csequenceA :: forall a (f :: * -> *) a.
Applicative f =>
FunctionTable' a (f a) -> f (FunctionTable' a a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
FunctionTable' a (f a) -> f (FunctionTable' a a)
$cmapM :: forall a (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunctionTable' a a -> m (FunctionTable' a b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> FunctionTable' a a -> m (FunctionTable' a b)
$csequence :: forall a (m :: * -> *) a.
Monad m =>
FunctionTable' a (m a) -> m (FunctionTable' a a)
sequence :: forall (m :: * -> *) a.
Monad m =>
FunctionTable' a (m a) -> m (FunctionTable' a a)
Traversable,(forall m. Monoid m => FunctionTable' a m -> m)
-> (forall m a. Monoid m => (a -> m) -> FunctionTable' a a -> m)
-> (forall m a. Monoid m => (a -> m) -> FunctionTable' a a -> m)
-> (forall a b. (a -> b -> b) -> b -> FunctionTable' a a -> b)
-> (forall a b. (a -> b -> b) -> b -> FunctionTable' a a -> b)
-> (forall b a. (b -> a -> b) -> b -> FunctionTable' a a -> b)
-> (forall b a. (b -> a -> b) -> b -> FunctionTable' a a -> b)
-> (forall a. (a -> a -> a) -> FunctionTable' a a -> a)
-> (forall a. (a -> a -> a) -> FunctionTable' a a -> a)
-> (forall a. FunctionTable' a a -> [a])
-> (forall a. FunctionTable' a a -> Bool)
-> (forall a. FunctionTable' a a -> Int)
-> (forall a. Eq a => a -> FunctionTable' a a -> Bool)
-> (forall a. Ord a => FunctionTable' a a -> a)
-> (forall a. Ord a => FunctionTable' a a -> a)
-> (forall a. Num a => FunctionTable' a a -> a)
-> (forall a. Num a => FunctionTable' a a -> a)
-> Foldable (FunctionTable' a)
forall a. Eq a => a -> FunctionTable' a a -> Bool
forall a. Num a => FunctionTable' a a -> a
forall a. Ord a => FunctionTable' a a -> a
forall m. Monoid m => FunctionTable' a m -> m
forall a. FunctionTable' a a -> Bool
forall a. FunctionTable' a a -> Int
forall a. FunctionTable' a a -> [a]
forall a. (a -> a -> a) -> FunctionTable' a a -> a
forall a a. Eq a => a -> FunctionTable' a a -> Bool
forall a a. Num a => FunctionTable' a a -> a
forall a a. Ord a => FunctionTable' a a -> a
forall a m. Monoid m => FunctionTable' a m -> m
forall m a. Monoid m => (a -> m) -> FunctionTable' a a -> m
forall a a. FunctionTable' a a -> Bool
forall a a. FunctionTable' a a -> Int
forall a a. FunctionTable' a a -> [a]
forall b a. (b -> a -> b) -> b -> FunctionTable' a a -> b
forall a b. (a -> b -> b) -> b -> FunctionTable' a a -> b
forall a a. (a -> a -> a) -> FunctionTable' a a -> a
forall a m a. Monoid m => (a -> m) -> FunctionTable' a a -> m
forall a b a. (b -> a -> b) -> b -> FunctionTable' a a -> b
forall a a b. (a -> b -> b) -> b -> FunctionTable' a a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall a m. Monoid m => FunctionTable' a m -> m
fold :: forall m. Monoid m => FunctionTable' a m -> m
$cfoldMap :: forall a m a. Monoid m => (a -> m) -> FunctionTable' a a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> FunctionTable' a a -> m
$cfoldMap' :: forall a m a. Monoid m => (a -> m) -> FunctionTable' a a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> FunctionTable' a a -> m
$cfoldr :: forall a a b. (a -> b -> b) -> b -> FunctionTable' a a -> b
foldr :: forall a b. (a -> b -> b) -> b -> FunctionTable' a a -> b
$cfoldr' :: forall a a b. (a -> b -> b) -> b -> FunctionTable' a a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> FunctionTable' a a -> b
$cfoldl :: forall a b a. (b -> a -> b) -> b -> FunctionTable' a a -> b
foldl :: forall b a. (b -> a -> b) -> b -> FunctionTable' a a -> b
$cfoldl' :: forall a b a. (b -> a -> b) -> b -> FunctionTable' a a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> FunctionTable' a a -> b
$cfoldr1 :: forall a a. (a -> a -> a) -> FunctionTable' a a -> a
foldr1 :: forall a. (a -> a -> a) -> FunctionTable' a a -> a
$cfoldl1 :: forall a a. (a -> a -> a) -> FunctionTable' a a -> a
foldl1 :: forall a. (a -> a -> a) -> FunctionTable' a a -> a
$ctoList :: forall a a. FunctionTable' a a -> [a]
toList :: forall a. FunctionTable' a a -> [a]
$cnull :: forall a a. FunctionTable' a a -> Bool
null :: forall a. FunctionTable' a a -> Bool
$clength :: forall a a. FunctionTable' a a -> Int
length :: forall a. FunctionTable' a a -> Int
$celem :: forall a a. Eq a => a -> FunctionTable' a a -> Bool
elem :: forall a. Eq a => a -> FunctionTable' a a -> Bool
$cmaximum :: forall a a. Ord a => FunctionTable' a a -> a
maximum :: forall a. Ord a => FunctionTable' a a -> a
$cminimum :: forall a a. Ord a => FunctionTable' a a -> a
minimum :: forall a. Ord a => FunctionTable' a a -> a
$csum :: forall a a. Num a => FunctionTable' a a -> a
sum :: forall a. Num a => FunctionTable' a a -> a
$cproduct :: forall a a. Num a => FunctionTable' a a -> a
product :: forall a. Num a => FunctionTable' a a -> a
Foldable)

type TableCells a = TableCells' a a
type FunctionTable a = FunctionTable' a a

newtype Rows = Rows Int
    deriving (Int -> Rows -> ShowS
[Rows] -> ShowS
Rows -> String
(Int -> Rows -> ShowS)
-> (Rows -> String) -> ([Rows] -> ShowS) -> Show Rows
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Rows -> ShowS
showsPrec :: Int -> Rows -> ShowS
$cshow :: Rows -> String
show :: Rows -> String
$cshowList :: [Rows] -> ShowS
showList :: [Rows] -> ShowS
Show,Rows -> Rows -> Bool
(Rows -> Rows -> Bool) -> (Rows -> Rows -> Bool) -> Eq Rows
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Rows -> Rows -> Bool
== :: Rows -> Rows -> Bool
$c/= :: Rows -> Rows -> Bool
/= :: Rows -> Rows -> Bool
Eq,Eq Rows
Eq Rows =>
(Rows -> Rows -> Ordering)
-> (Rows -> Rows -> Bool)
-> (Rows -> Rows -> Bool)
-> (Rows -> Rows -> Bool)
-> (Rows -> Rows -> Bool)
-> (Rows -> Rows -> Rows)
-> (Rows -> Rows -> Rows)
-> Ord Rows
Rows -> Rows -> Bool
Rows -> Rows -> Ordering
Rows -> Rows -> Rows
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Rows -> Rows -> Ordering
compare :: Rows -> Rows -> Ordering
$c< :: Rows -> Rows -> Bool
< :: Rows -> Rows -> Bool
$c<= :: Rows -> Rows -> Bool
<= :: Rows -> Rows -> Bool
$c> :: Rows -> Rows -> Bool
> :: Rows -> Rows -> Bool
$c>= :: Rows -> Rows -> Bool
>= :: Rows -> Rows -> Bool
$cmax :: Rows -> Rows -> Rows
max :: Rows -> Rows -> Rows
$cmin :: Rows -> Rows -> Rows
min :: Rows -> Rows -> Rows
Ord,Integer -> Rows
Rows -> Rows
Rows -> Rows -> Rows
(Rows -> Rows -> Rows)
-> (Rows -> Rows -> Rows)
-> (Rows -> Rows -> Rows)
-> (Rows -> Rows)
-> (Rows -> Rows)
-> (Rows -> Rows)
-> (Integer -> Rows)
-> Num Rows
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Rows -> Rows -> Rows
+ :: Rows -> Rows -> Rows
$c- :: Rows -> Rows -> Rows
- :: Rows -> Rows -> Rows
$c* :: Rows -> Rows -> Rows
* :: Rows -> Rows -> Rows
$cnegate :: Rows -> Rows
negate :: Rows -> Rows
$cabs :: Rows -> Rows
abs :: Rows -> Rows
$csignum :: Rows -> Rows
signum :: Rows -> Rows
$cfromInteger :: Integer -> Rows
fromInteger :: Integer -> Rows
Num)
newtype Cols = Cols Int
    deriving (Int -> Cols -> ShowS
[Cols] -> ShowS
Cols -> String
(Int -> Cols -> ShowS)
-> (Cols -> String) -> ([Cols] -> ShowS) -> Show Cols
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Cols -> ShowS
showsPrec :: Int -> Cols -> ShowS
$cshow :: Cols -> String
show :: Cols -> String
$cshowList :: [Cols] -> ShowS
showList :: [Cols] -> ShowS
Show,Cols -> Cols -> Bool
(Cols -> Cols -> Bool) -> (Cols -> Cols -> Bool) -> Eq Cols
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Cols -> Cols -> Bool
== :: Cols -> Cols -> Bool
$c/= :: Cols -> Cols -> Bool
/= :: Cols -> Cols -> Bool
Eq,Eq Cols
Eq Cols =>
(Cols -> Cols -> Ordering)
-> (Cols -> Cols -> Bool)
-> (Cols -> Cols -> Bool)
-> (Cols -> Cols -> Bool)
-> (Cols -> Cols -> Bool)
-> (Cols -> Cols -> Cols)
-> (Cols -> Cols -> Cols)
-> Ord Cols
Cols -> Cols -> Bool
Cols -> Cols -> Ordering
Cols -> Cols -> Cols
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Cols -> Cols -> Ordering
compare :: Cols -> Cols -> Ordering
$c< :: Cols -> Cols -> Bool
< :: Cols -> Cols -> Bool
$c<= :: Cols -> Cols -> Bool
<= :: Cols -> Cols -> Bool
$c> :: Cols -> Cols -> Bool
> :: Cols -> Cols -> Bool
$c>= :: Cols -> Cols -> Bool
>= :: Cols -> Cols -> Bool
$cmax :: Cols -> Cols -> Cols
max :: Cols -> Cols -> Cols
$cmin :: Cols -> Cols -> Cols
min :: Cols -> Cols -> Cols
Ord,Integer -> Cols
Cols -> Cols
Cols -> Cols -> Cols
(Cols -> Cols -> Cols)
-> (Cols -> Cols -> Cols)
-> (Cols -> Cols -> Cols)
-> (Cols -> Cols)
-> (Cols -> Cols)
-> (Cols -> Cols)
-> (Integer -> Cols)
-> Num Cols
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: Cols -> Cols -> Cols
+ :: Cols -> Cols -> Cols
$c- :: Cols -> Cols -> Cols
- :: Cols -> Cols -> Cols
$c* :: Cols -> Cols -> Cols
* :: Cols -> Cols -> Cols
$cnegate :: Cols -> Cols
negate :: Cols -> Cols
$cabs :: Cols -> Cols
abs :: Cols -> Cols
$csignum :: Cols -> Cols
signum :: Cols -> Cols
$cfromInteger :: Integer -> Cols
fromInteger :: Integer -> Cols
Num)

data Row a = Row [Either Filler Heading] a
    deriving (Int -> Row a -> ShowS
[Row a] -> ShowS
Row a -> String
(Int -> Row a -> ShowS)
-> (Row a -> String) -> ([Row a] -> ShowS) -> Show (Row a)
forall a. Show a => Int -> Row a -> ShowS
forall a. Show a => [Row a] -> ShowS
forall a. Show a => Row a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Row a -> ShowS
showsPrec :: Int -> Row a -> ShowS
$cshow :: forall a. Show a => Row a -> String
show :: Row a -> String
$cshowList :: forall a. Show a => [Row a] -> ShowS
showList :: [Row a] -> ShowS
Show,Row a -> Row a -> Bool
(Row a -> Row a -> Bool) -> (Row a -> Row a -> Bool) -> Eq (Row a)
forall a. Eq a => Row a -> Row a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Row a -> Row a -> Bool
== :: Row a -> Row a -> Bool
$c/= :: forall a. Eq a => Row a -> Row a -> Bool
/= :: Row a -> Row a -> Bool
Eq,(forall a b. (a -> b) -> Row a -> Row b)
-> (forall a b. a -> Row b -> Row a) -> Functor Row
forall a b. a -> Row b -> Row a
forall a b. (a -> b) -> Row a -> Row b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a b. (a -> b) -> Row a -> Row b
fmap :: forall a b. (a -> b) -> Row a -> Row b
$c<$ :: forall a b. a -> Row b -> Row a
<$ :: forall a b. a -> Row b -> Row a
Functor,Functor Row
Foldable Row
(Functor Row, Foldable Row) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> Row a -> f (Row b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    Row (f a) -> f (Row a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> Row a -> m (Row b))
-> (forall (m :: * -> *) a. Monad m => Row (m a) -> m (Row a))
-> Traversable Row
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a. Monad m => Row (m a) -> m (Row a)
forall (f :: * -> *) a. Applicative f => Row (f a) -> f (Row a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Row a -> m (Row b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Row a -> f (Row b)
$ctraverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Row a -> f (Row b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Row a -> f (Row b)
$csequenceA :: forall (f :: * -> *) a. Applicative f => Row (f a) -> f (Row a)
sequenceA :: forall (f :: * -> *) a. Applicative f => Row (f a) -> f (Row a)
$cmapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Row a -> m (Row b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Row a -> m (Row b)
$csequence :: forall (m :: * -> *) a. Monad m => Row (m a) -> m (Row a)
sequence :: forall (m :: * -> *) a. Monad m => Row (m a) -> m (Row a)
Traversable,(forall m. Monoid m => Row m -> m)
-> (forall m a. Monoid m => (a -> m) -> Row a -> m)
-> (forall m a. Monoid m => (a -> m) -> Row a -> m)
-> (forall a b. (a -> b -> b) -> b -> Row a -> b)
-> (forall a b. (a -> b -> b) -> b -> Row a -> b)
-> (forall b a. (b -> a -> b) -> b -> Row a -> b)
-> (forall b a. (b -> a -> b) -> b -> Row a -> b)
-> (forall a. (a -> a -> a) -> Row a -> a)
-> (forall a. (a -> a -> a) -> Row a -> a)
-> (forall a. Row a -> [a])
-> (forall a. Row a -> Bool)
-> (forall a. Row a -> Int)
-> (forall a. Eq a => a -> Row a -> Bool)
-> (forall a. Ord a => Row a -> a)
-> (forall a. Ord a => Row a -> a)
-> (forall a. Num a => Row a -> a)
-> (forall a. Num a => Row a -> a)
-> Foldable Row
forall a. Eq a => a -> Row a -> Bool
forall a. Num a => Row a -> a
forall a. Ord a => Row a -> a
forall m. Monoid m => Row m -> m
forall a. Row a -> Bool
forall a. Row a -> Int
forall a. Row a -> [a]
forall a. (a -> a -> a) -> Row a -> a
forall m a. Monoid m => (a -> m) -> Row a -> m
forall b a. (b -> a -> b) -> b -> Row a -> b
forall a b. (a -> b -> b) -> b -> Row a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall m. Monoid m => Row m -> m
fold :: forall m. Monoid m => Row m -> m
$cfoldMap :: forall m a. Monoid m => (a -> m) -> Row a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Row a -> m
$cfoldMap' :: forall m a. Monoid m => (a -> m) -> Row a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> Row a -> m
$cfoldr :: forall a b. (a -> b -> b) -> b -> Row a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Row a -> b
$cfoldr' :: forall a b. (a -> b -> b) -> b -> Row a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Row a -> b
$cfoldl :: forall b a. (b -> a -> b) -> b -> Row a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Row a -> b
$cfoldl' :: forall b a. (b -> a -> b) -> b -> Row a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> Row a -> b
$cfoldr1 :: forall a. (a -> a -> a) -> Row a -> a
foldr1 :: forall a. (a -> a -> a) -> Row a -> a
$cfoldl1 :: forall a. (a -> a -> a) -> Row a -> a
foldl1 :: forall a. (a -> a -> a) -> Row a -> a
$ctoList :: forall a. Row a -> [a]
toList :: forall a. Row a -> [a]
$cnull :: forall a. Row a -> Bool
null :: forall a. Row a -> Bool
$clength :: forall a. Row a -> Int
length :: forall a. Row a -> Int
$celem :: forall a. Eq a => a -> Row a -> Bool
elem :: forall a. Eq a => a -> Row a -> Bool
$cmaximum :: forall a. Ord a => Row a -> a
maximum :: forall a. Ord a => Row a -> a
$cminimum :: forall a. Ord a => Row a -> a
minimum :: forall a. Ord a => Row a -> a
$csum :: forall a. Num a => Row a -> a
sum :: forall a. Num a => Row a -> a
$cproduct :: forall a. Num a => Row a -> a
product :: forall a. Num a => Row a -> a
Foldable)

data Filler = Filler 
        { Filler -> Cols
_fillerWidth :: Cols 
        , Filler -> Bool
_fillerIsLast :: Bool
        }
    deriving (Int -> Filler -> ShowS
[Filler] -> ShowS
Filler -> String
(Int -> Filler -> ShowS)
-> (Filler -> String) -> ([Filler] -> ShowS) -> Show Filler
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Filler -> ShowS
showsPrec :: Int -> Filler -> ShowS
$cshow :: Filler -> String
show :: Filler -> String
$cshowList :: [Filler] -> ShowS
showList :: [Filler] -> ShowS
Show,Filler -> Filler -> Bool
(Filler -> Filler -> Bool)
-> (Filler -> Filler -> Bool) -> Eq Filler
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Filler -> Filler -> Bool
== :: Filler -> Filler -> Bool
$c/= :: Filler -> Filler -> Bool
/= :: Filler -> Filler -> Bool
Eq)

data Heading = Heading 
        { Heading -> LaTeX
_title :: LaTeX 
        , Heading -> Rows
_headingHeight :: Rows 
        , Heading -> Cols
_headingWidth :: Cols 
        , Heading -> Bool
_headingIsLast :: Bool
        }
    deriving (Int -> Heading -> ShowS
[Heading] -> ShowS
Heading -> String
(Int -> Heading -> ShowS)
-> (Heading -> String) -> ([Heading] -> ShowS) -> Show Heading
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Heading -> ShowS
showsPrec :: Int -> Heading -> ShowS
$cshow :: Heading -> String
show :: Heading -> String
$cshowList :: [Heading] -> ShowS
showList :: [Heading] -> ShowS
Show,Heading -> Heading -> Bool
(Heading -> Heading -> Bool)
-> (Heading -> Heading -> Bool) -> Eq Heading
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Heading -> Heading -> Bool
== :: Heading -> Heading -> Bool
$c/= :: Heading -> Heading -> Bool
/= :: Heading -> Heading -> Bool
Eq)

makePrisms ''TableCells'
makeFields ''Heading
makeFields ''Filler

instance Bifunctor FunctionTable' where
    bimap :: forall a b c d.
(a -> b) -> (c -> d) -> FunctionTable' a c -> FunctionTable' b d
bimap = (a -> b) -> (c -> d) -> FunctionTable' a c -> FunctionTable' b d
forall (t :: * -> * -> *) a b c d.
Bitraversable t =>
(a -> b) -> (c -> d) -> t a c -> t b d
bimapDefault
instance Bifunctor TableCells' where
    bimap :: forall a b c d.
(a -> b) -> (c -> d) -> TableCells' a c -> TableCells' b d
bimap = (a -> b) -> (c -> d) -> TableCells' a c -> TableCells' b d
forall (t :: * -> * -> *) a b c d.
Bitraversable t =>
(a -> b) -> (c -> d) -> t a c -> t b d
bimapDefault
instance Bifoldable FunctionTable' where
    bifoldMap :: forall m a b.
Monoid m =>
(a -> m) -> (b -> m) -> FunctionTable' a b -> m
bifoldMap = (a -> m) -> (b -> m) -> FunctionTable' a b -> m
forall (t :: * -> * -> *) m a b.
(Bitraversable t, Monoid m) =>
(a -> m) -> (b -> m) -> t a b -> m
bifoldMapDefault
instance Bifoldable TableCells' where
    bifoldMap :: forall m a b.
Monoid m =>
(a -> m) -> (b -> m) -> TableCells' a b -> m
bifoldMap = (a -> m) -> (b -> m) -> TableCells' a b -> m
forall (t :: * -> * -> *) m a b.
(Bitraversable t, Monoid m) =>
(a -> m) -> (b -> m) -> t a b -> m
bifoldMapDefault
instance Bitraversable FunctionTable' where
    bitraverse :: forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c)
-> (b -> f d) -> FunctionTable' a b -> f (FunctionTable' c d)
bitraverse a -> f c
f b -> f d
g (Table b
h TableCells' a b
t) = (d -> TableCells' c d -> FunctionTable' c d)
-> f d -> f (TableCells' c d) -> f (FunctionTable' c d)
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 d -> TableCells' c d -> FunctionTable' c d
forall a b. b -> TableCells' a b -> FunctionTable' a b
Table (b -> f d
g b
h) ((a -> f c) -> (b -> f d) -> TableCells' a b -> f (TableCells' c d)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> TableCells' a b -> f (TableCells' c d)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bitraverse a -> f c
f b -> f d
g TableCells' a b
t)
instance Bitraversable TableCells' where
    bitraverse :: forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> TableCells' a b -> f (TableCells' c d)
bitraverse a -> f c
_ b -> f d
g (Cell b
x) = d -> TableCells' c d
forall a b. b -> TableCells' a b
Cell (d -> TableCells' c d) -> f d -> f (TableCells' c d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> b -> f d
g b
x
    bitraverse a -> f c
f b -> f d
g (Condition Cols
w NonEmpty (a, TableCells' a b)
ts) = Cols -> NonEmpty (c, TableCells' c d) -> TableCells' c d
forall a b.
Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
Condition Cols
w (NonEmpty (c, TableCells' c d) -> TableCells' c d)
-> f (NonEmpty (c, TableCells' c d)) -> f (TableCells' c d)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, TableCells' a b) -> f (c, TableCells' c d))
-> NonEmpty (a, TableCells' a b)
-> f (NonEmpty (c, TableCells' c d))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmpty a -> f (NonEmpty b)
traverse ((a -> f c)
-> (TableCells' a b -> f (TableCells' c d))
-> (a, TableCells' a b)
-> f (c, TableCells' c d)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> (a, b) -> f (c, d)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bitraverse a -> f c
f ((TableCells' a b -> f (TableCells' c d))
 -> (a, TableCells' a b) -> f (c, TableCells' c d))
-> (TableCells' a b -> f (TableCells' c d))
-> (a, TableCells' a b)
-> f (c, TableCells' c d)
forall a b. (a -> b) -> a -> b
$ (a -> f c) -> (b -> f d) -> TableCells' a b -> f (TableCells' c d)
forall (f :: * -> *) a c b d.
Applicative f =>
(a -> f c) -> (b -> f d) -> TableCells' a b -> f (TableCells' c d)
forall (t :: * -> * -> *) (f :: * -> *) a c b d.
(Bitraversable t, Applicative f) =>
(a -> f c) -> (b -> f d) -> t a b -> f (t c d)
bitraverse a -> f c
f b -> f d
g) NonEmpty (a, TableCells' a b)
ts

type Pre = (?loc :: CallStack)

subtables :: Traversal' (TableCells' a b) (a,TableCells' a b)
subtables :: forall a b (f :: * -> *).
Applicative f =>
((a, TableCells' a b) -> f (a, TableCells' a b))
-> TableCells' a b -> f (TableCells' a b)
subtables (a, TableCells' a b) -> f (a, TableCells' a b)
_f x :: TableCells' a b
x@(Cell b
_) = TableCells' a b -> f (TableCells' a b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TableCells' a b
x
subtables (a, TableCells' a b) -> f (a, TableCells' a b)
f (Condition Cols
k NonEmpty (a, TableCells' a b)
xs) = Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
forall a b.
Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
Condition Cols
k (NonEmpty (a, TableCells' a b) -> TableCells' a b)
-> f (NonEmpty (a, TableCells' a b)) -> f (TableCells' a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((a, TableCells' a b) -> f (a, TableCells' a b))
-> NonEmpty (a, TableCells' a b)
-> f (NonEmpty (a, TableCells' a b))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> NonEmpty a -> f (NonEmpty b)
traverse (a, TableCells' a b) -> f (a, TableCells' a b)
f NonEmpty (a, TableCells' a b)
xs

isubtables :: IndexedTraversal' Int (TableCells' a b) (a,TableCells' a b)
isubtables :: forall a b (p :: * -> * -> *) (f :: * -> *).
(Indexable Int p, Applicative f) =>
p (a, TableCells' a b) (f (a, TableCells' a b))
-> TableCells' a b -> f (TableCells' a b)
isubtables p (a, TableCells' a b) (f (a, TableCells' a b))
_f x :: TableCells' a b
x@(Cell b
_) = TableCells' a b -> f (TableCells' a b)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure TableCells' a b
x
isubtables p (a, TableCells' a b) (f (a, TableCells' a b))
f (Condition Cols
k NonEmpty (a, TableCells' a b)
xs) = Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
forall a b.
Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
Condition Cols
k (NonEmpty (a, TableCells' a b) -> TableCells' a b)
-> f (NonEmpty (a, TableCells' a b)) -> f (TableCells' a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> (a, TableCells' a b) -> f (a, TableCells' a b))
-> NonEmpty (a, TableCells' a b)
-> f (NonEmpty (a, TableCells' a b))
forall i (t :: * -> *) (f :: * -> *) a b.
(TraversableWithIndex i t, Applicative f) =>
(i -> a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(Int -> a -> f b) -> NonEmpty a -> f (NonEmpty b)
itraverse (p (a, TableCells' a b) (f (a, TableCells' a b))
-> Int -> (a, TableCells' a b) -> f (a, TableCells' a b)
forall a b. p a b -> Int -> a -> b
forall i (p :: * -> * -> *) a b.
Indexable i p =>
p a b -> i -> a -> b
indexed p (a, TableCells' a b) (f (a, TableCells' a b))
f) NonEmpty (a, TableCells' a b)
xs

type M a = WriterT [(a,TableCells a)] Maybe

makeTable :: Pre
          => String 
          -> M LaTeXLI () 
          -> FunctionTable LaTeXLI
makeTable :: Pre => String -> M LaTeXLI () -> FunctionTable LaTeXLI
makeTable String
x M LaTeXLI ()
t = LaTeXLI -> TableCells' LaTeXLI LaTeXLI -> FunctionTable LaTeXLI
forall a b. b -> TableCells' a b -> FunctionTable' a b
Table (SrcLoc -> String -> LaTeXLI
LaTeXLI ((String, SrcLoc) -> SrcLoc
forall a b. (a, b) -> b
snd ((String, SrcLoc) -> SrcLoc) -> (String, SrcLoc) -> SrcLoc
forall a b. (a -> b) -> a -> b
$ [(String, SrcLoc)] -> (String, SrcLoc)
forall a. HasCallStack => [a] -> a
L.head ([(String, SrcLoc)] -> (String, SrcLoc))
-> [(String, SrcLoc)] -> (String, SrcLoc)
forall a b. (a -> b) -> a -> b
$ CallStack -> [(String, SrcLoc)]
getCallStack Pre
CallStack
?loc) String
x) 
            (TableCells' LaTeXLI LaTeXLI -> FunctionTable LaTeXLI)
-> TableCells' LaTeXLI LaTeXLI -> FunctionTable LaTeXLI
forall a b. (a -> b) -> a -> b
$ Cols
-> NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
-> TableCells' LaTeXLI LaTeXLI
forall a b.
Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
Condition (Int -> Cols
Cols Int
1) 
            (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
 -> TableCells' LaTeXLI LaTeXLI)
-> NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
-> TableCells' LaTeXLI LaTeXLI
forall a b. (a -> b) -> a -> b
$ Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
-> NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
 -> NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
-> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
-> NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
forall a b. (a -> b) -> a -> b
$ [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
-> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
 -> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)))
-> Maybe [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
-> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< M LaTeXLI () -> Maybe [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
forall (m :: * -> *) w a. Monad m => WriterT w m a -> m w
execWriterT M LaTeXLI ()
t

cell :: Pre => String -> String -> M LaTeXLI ()
-- cell l x = tell [(math $ TeXRaw $ fromString l,Cell $ math $ TeXRaw $ fromString x)]
cell :: Pre => String -> String -> M LaTeXLI ()
cell String
l String
x = [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)] -> M LaTeXLI ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [(SrcLoc -> String -> LaTeXLI
LaTeXLI ((String, SrcLoc) -> SrcLoc
forall a b. (a, b) -> b
snd ((String, SrcLoc) -> SrcLoc) -> (String, SrcLoc) -> SrcLoc
forall a b. (a -> b) -> a -> b
$ [(String, SrcLoc)] -> (String, SrcLoc)
forall a. HasCallStack => [a] -> a
L.head ([(String, SrcLoc)] -> (String, SrcLoc))
-> [(String, SrcLoc)] -> (String, SrcLoc)
forall a b. (a -> b) -> a -> b
$ CallStack -> [(String, SrcLoc)]
getCallStack Pre
CallStack
?loc) String
l
                 ,LaTeXLI -> TableCells' LaTeXLI LaTeXLI
forall a b. b -> TableCells' a b
Cell (LaTeXLI -> TableCells' LaTeXLI LaTeXLI)
-> LaTeXLI -> TableCells' LaTeXLI LaTeXLI
forall a b. (a -> b) -> a -> b
$ SrcLoc -> String -> LaTeXLI
LaTeXLI ((String, SrcLoc) -> SrcLoc
forall a b. (a, b) -> b
snd ((String, SrcLoc) -> SrcLoc) -> (String, SrcLoc) -> SrcLoc
forall a b. (a -> b) -> a -> b
$ [(String, SrcLoc)] -> (String, SrcLoc)
forall a. HasCallStack => [a] -> a
L.head ([(String, SrcLoc)] -> (String, SrcLoc))
-> [(String, SrcLoc)] -> (String, SrcLoc)
forall a b. (a -> b) -> a -> b
$ CallStack -> [(String, SrcLoc)]
getCallStack Pre
CallStack
?loc) String
x)]

branch :: Pre => String -> M LaTeXLI () -> M LaTeXLI ()
branch :: Pre => String -> M LaTeXLI () -> M LaTeXLI ()
branch String
l M LaTeXLI ()
t = do
    NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
xs <- Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
-> WriterT
     [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
     Maybe
     (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
forall (m :: * -> *) a.
Monad m =>
m a -> WriterT [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)] m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
 -> WriterT
      [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
      Maybe
      (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)))
-> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
-> WriterT
     [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
     Maybe
     (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
forall a b. (a -> b) -> a -> b
$ [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
-> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
forall a. [a] -> Maybe (NonEmpty a)
nonEmpty ([(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
 -> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)))
-> Maybe [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
-> Maybe (NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< M LaTeXLI () -> Maybe [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)]
forall (m :: * -> *) w a. Monad m => WriterT w m a -> m w
execWriterT M LaTeXLI ()
t
    [(LaTeXLI, TableCells' LaTeXLI LaTeXLI)] -> M LaTeXLI ()
forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [(SrcLoc -> String -> LaTeXLI
LaTeXLI ((String, SrcLoc) -> SrcLoc
forall a b. (a, b) -> b
snd ((String, SrcLoc) -> SrcLoc) -> (String, SrcLoc) -> SrcLoc
forall a b. (a -> b) -> a -> b
$ [(String, SrcLoc)] -> (String, SrcLoc)
forall a. HasCallStack => [a] -> a
L.head ([(String, SrcLoc)] -> (String, SrcLoc))
-> [(String, SrcLoc)] -> (String, SrcLoc)
forall a b. (a -> b) -> a -> b
$ CallStack -> [(String, SrcLoc)]
getCallStack Pre
CallStack
?loc) String
l,Cols
-> NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
-> TableCells' LaTeXLI LaTeXLI
forall a b.
Cols -> NonEmpty (a, TableCells' a b) -> TableCells' a b
Condition (Int -> Cols
Cols Int
1) NonEmpty (LaTeXLI, TableCells' LaTeXLI LaTeXLI)
xs)]

depth :: TableCells' a b -> Int
depth :: forall a a. TableCells' a a -> Int
depth (Cell b
_) = Int
0
depth (Condition (Cols Int
w) NonEmpty (a, TableCells' a b)
xs) = Int
w Int -> Int -> Int
forall a. Num a => a -> a -> a
+ NonEmpty Int -> Int
forall a. Ord a => NonEmpty a -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum (TableCells' a b -> Int
forall a a. TableCells' a a -> Int
depth(TableCells' a b -> Int)
-> ((a, TableCells' a b) -> TableCells' a b)
-> (a, TableCells' a b)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a, TableCells' a b) -> TableCells' a b
forall a b. (a, b) -> b
snd ((a, TableCells' a b) -> Int)
-> NonEmpty (a, TableCells' a b) -> NonEmpty Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (a, TableCells' a b)
xs)

witdth :: TableCells' a b -> Int
witdth :: forall a a. TableCells' a a -> Int
witdth (Cell b
_) = Int
1
witdth (Condition Cols
_ NonEmpty (a, TableCells' a b)
xs) = NonEmpty Int -> Int
forall a. Num a => NonEmpty a -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum (TableCells' a b -> Int
forall a a. TableCells' a a -> Int
witdth(TableCells' a b -> Int)
-> ((a, TableCells' a b) -> TableCells' a b)
-> (a, TableCells' a b)
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(a, TableCells' a b) -> TableCells' a b
forall a b. (a, b) -> b
snd ((a, TableCells' a b) -> Int)
-> NonEmpty (a, TableCells' a b) -> NonEmpty Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (a, TableCells' a b)
xs)

columnSpecOf :: TableCells' a b -> [TableSpec]
columnSpecOf :: forall a b. TableCells' a b -> [TableSpec]
columnSpecOf TableCells' a b
t = [TableSpec]
cols
    where
        d :: Int
d = TableCells' a b -> Int
forall a a. TableCells' a a -> Int
depth TableCells' a b
t
        cols :: [TableSpec]
cols = TableSpec
VerticalLine TableSpec -> [TableSpec] -> [TableSpec]
forall a. a -> [a] -> [a]
: TableSpec -> [TableSpec] -> [TableSpec]
forall a. a -> [a] -> [a]
L.intersperse TableSpec
VerticalLine (Int -> TableSpec -> [TableSpec]
forall a. Int -> a -> [a]
replicate Int
d TableSpec
LeftColumn) 
                [TableSpec] -> [TableSpec] -> [TableSpec]
forall a. [a] -> [a] -> [a]
++ [TableSpec
VerticalLine,TableSpec
VerticalLine,TableSpec
CenterColumn,TableSpec
VerticalLine,TableSpec
VerticalLine]

rowToLatex :: Render a => Cols -> Row a -> LaTeX
rowToLatex :: forall a. Render a => Cols -> Row a -> LaTeX
rowToLatex (Cols Int
size) (Row [Either Filler Heading]
hs a
x) = 
                           (LaTeX -> LaTeX -> LaTeX) -> LaTeX -> [LaTeX] -> LaTeX
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr LaTeX -> LaTeX -> LaTeX
forall l. LaTeXC l => l -> l -> l
(&) (a -> LaTeX
forall a l. (Render a, LaTeXC l) => a -> l
rendertex a
x) ((Either Filler Heading -> LaTeX)
-> [Either Filler Heading] -> [LaTeX]
forall a b. (a -> b) -> [a] -> [b]
L.map Either Filler Heading -> LaTeX
oneHeading [Either Filler Heading]
hs) 
                        LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> LaTeX
forall l. LaTeXC l => l
lnbk LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> Int -> Int -> LaTeX
forall l. LaTeXC l => Int -> Int -> l
cline (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1) Int
size
    where
        colSpec :: [TableSpec]
colSpec = [TableSpec
VerticalLine,TableSpec
LeftColumn,TableSpec
VerticalLine]
        oneHeading :: Either Filler Heading -> LaTeX
oneHeading (Left (Filler (Cols Int
c) Bool
_)) 
                = Int -> [TableSpec] -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> [TableSpec] -> l -> l
multicolumn Int
c [TableSpec]
colSpec LaTeX
""
        oneHeading (Right (Heading LaTeX
h (Rows Int
r) (Cols Int
c) Bool
isLast))
                | Bool
isLast    = Int -> [TableSpec] -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> [TableSpec] -> l -> l
multicolumn (Int
c Int -> Int -> Int
forall a. Num a => a -> a -> a
+ (Int
size Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
total) Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1) ([TableSpec]
colSpec [TableSpec] -> [TableSpec] -> [TableSpec]
forall a. [a] -> [a] -> [a]
++ [TableSpec
VerticalLine]) (Int -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> l -> l
multirow Int
r LaTeX
h)
                | Bool
otherwise = Int -> [TableSpec] -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> [TableSpec] -> l -> l
multicolumn Int
c [TableSpec]
colSpec (Int -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> l -> l
multirow Int
r LaTeX
h)
        canCut :: Either c Heading -> Bool
canCut Either c Heading
x = Getting Any (Either c Heading) Rows -> Either c Heading -> Bool
forall s a. Getting Any s a -> s -> Bool
has ((Heading -> Const Any Heading)
-> Either c Heading -> Const Any (Either c Heading)
forall c a b (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p a (f b) -> p (Either c a) (f (Either c b))
_Right((Heading -> Const Any Heading)
 -> Either c Heading -> Const Any (Either c Heading))
-> ((Rows -> Const Any Rows) -> Heading -> Const Any Heading)
-> Getting Any (Either c Heading) Rows
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Rows -> Const Any Rows) -> Heading -> Const Any Heading
Lens' Heading Rows
rows((Rows -> Const Any Rows) -> Heading -> Const Any Heading)
-> ((Rows -> Const Any Rows) -> Rows -> Const Any Rows)
-> (Rows -> Const Any Rows)
-> Heading
-> Const Any Heading
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Rows -> Bool)
-> (Rows -> Const Any Rows) -> Rows -> Const Any Rows
forall (p :: * -> * -> *) (f :: * -> *) a.
(Choice p, Applicative f) =>
(a -> Bool) -> Optic' p f a a
filtered (Rows -> Rows -> Bool
forall a. Ord a => a -> a -> Bool
<= Rows
1)) Either c Heading
x 
                    Bool -> Bool -> Bool
|| Getting Any (Either c Heading) Bool -> Either c Heading -> Bool
forall s a. Getting Any s a -> s -> Bool
has ((c -> Const Any c)
-> Either c Heading -> Const Any (Either c Heading)
forall a c b (p :: * -> * -> *) (f :: * -> *).
(Choice p, Applicative f) =>
p a (f b) -> p (Either a c) (f (Either b c))
_Left((c -> Const Any c)
 -> Either c Heading -> Const Any (Either c Heading))
-> ((Bool -> Const Any Bool) -> c -> Const Any c)
-> Getting Any (Either c Heading) Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Bool -> Const Any Bool) -> c -> Const Any c
forall s a. HasIsLast s a => Lens' s a
Lens' c Bool
isLast((Bool -> Const Any Bool) -> c -> Const Any c)
-> ((Bool -> Const Any Bool) -> Bool -> Const Any Bool)
-> (Bool -> Const Any Bool)
-> c
-> Const Any c
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Bool -> Bool)
-> (Bool -> Const Any Bool) -> Bool -> Const Any Bool
forall (p :: * -> * -> *) (f :: * -> *) a.
(Choice p, Applicative f) =>
(a -> Bool) -> Optic' p f a a
filtered Bool -> Bool
forall a. a -> a
id) Either c Heading
x 
        b :: [Either Filler Heading]
b = (Either Filler Heading -> Bool)
-> [Either Filler Heading] -> [Either Filler Heading]
forall a. (a -> Bool) -> [a] -> [a]
L.dropWhile Either Filler Heading -> Bool
forall {c}. HasIsLast c Bool => Either c Heading -> Bool
canCut ([Either Filler Heading] -> [Either Filler Heading])
-> [Either Filler Heading] -> [Either Filler Heading]
forall a b. (a -> b) -> a -> b
$ [Either Filler Heading] -> [Either Filler Heading]
forall a. [a] -> [a]
L.reverse [Either Filler Heading]
hs
        Cols Int
n = [Cols] -> Cols
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Cols] -> Cols) -> [Cols] -> Cols
forall a b. (a -> b) -> a -> b
$ Getting Cols (Either Filler Heading) Cols
-> Either Filler Heading -> Cols
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Cols (Either Filler Heading) Cols
forall s a. HasWidth s a => Lens' s a
Lens' (Either Filler Heading) Cols
width (Either Filler Heading -> Cols)
-> [Either Filler Heading] -> [Cols]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either Filler Heading]
b
        Cols Int
total = [Cols] -> Cols
forall a. Num a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum ([Cols] -> Cols) -> [Cols] -> Cols
forall a b. (a -> b) -> a -> b
$ Getting Cols (Either Filler Heading) Cols
-> Either Filler Heading -> Cols
forall s (m :: * -> *) a. MonadReader s m => Getting a s a -> m a
view Getting Cols (Either Filler Heading) Cols
forall s a. HasWidth s a => Lens' s a
Lens' (Either Filler Heading) Cols
width (Either Filler Heading -> Cols)
-> [Either Filler Heading] -> [Cols]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Either Filler Heading]
hs

instance (HasWidth a c,HasWidth b c) => HasWidth (Either a b) c where
    width :: Lens' (Either a b) c
width c -> f c
f (Left a
x) = a -> Either a b
forall a b. a -> Either a b
Left (a -> Either a b) -> f a -> f (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (c -> f c) -> a -> f a
forall s a. HasWidth s a => Lens' s a
Lens' a c
width c -> f c
f a
x
    width c -> f c
f (Right b
x) = b -> Either a b
forall a b. b -> Either a b
Right (b -> Either a b) -> f b -> f (Either a b)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (c -> f c) -> b -> f b
forall s a. HasWidth s a => Lens' s a
Lens' b c
width c -> f c
f b
x
instance HasWidth Cols Cols where
    width :: Lens' Cols Cols
width Cols -> f Cols
f Cols
x = Cols -> f Cols
f Cols
x

texFunctionTable :: (Render a,Render b) 
                 => FunctionTable' a b 
                 -> LaTeX
texFunctionTable :: forall a b. (Render a, Render b) => FunctionTable' a b -> LaTeX
texFunctionTable (Table b
x TableCells' a b
t) = Maybe Pos -> [TableSpec] -> LaTeX -> LaTeX
forall l. LaTeXC l => Maybe Pos -> [TableSpec] -> l -> l
tabular Maybe Pos
forall a. Maybe a
Nothing (TableCells' a b -> [TableSpec]
forall a b. TableCells' a b -> [TableSpec]
columnSpecOf TableCells' a b
t) (LaTeX -> LaTeX) -> LaTeX -> LaTeX
forall a b. (a -> b) -> a -> b
$ 
        LaTeX
forall l. LaTeXC l => l
hline LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> 
        Cols -> Row b -> LaTeX
forall a. Render a => Cols -> Row a -> LaTeX
rowToLatex Cols
sz ([Either Filler Heading] -> b -> Row b
forall a. [Either Filler Heading] -> a -> Row a
Row [Either Filler Heading]
forall {a}. [Either a Heading]
cond b
x) LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<>
        LaTeX
forall l. LaTeXC l => l
hline LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> 
        LaTeX
forall l. LaTeXC l => l
hline LaTeX -> LaTeX -> LaTeX
forall a. Semigroup a => a -> a -> a
<> 
        ((Row b -> LaTeX) -> NonEmpty (Row b) -> LaTeX
forall m a. Monoid m => (a -> m) -> NonEmpty a -> m
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap (Cols -> Row b -> LaTeX
forall a. Render a => Cols -> Row a -> LaTeX
rowToLatex Cols
sz) (NonEmpty (Row b) -> LaTeX)
-> (TableCells' a b -> NonEmpty (Row b))
-> TableCells' a b
-> LaTeX
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TableCells' a b -> NonEmpty (Row b)
forall a b. Render a => TableCells' a b -> NonEmpty (Row b)
texFunctionTableRows) TableCells' a b
t
    where
        cond :: [Either a Heading]
cond | Cols
sz Cols -> Cols -> Bool
forall a. Ord a => a -> a -> Bool
<= Cols
1   = []
             | Bool
otherwise = [Heading -> Either a Heading
forall a b. b -> Either a b
Right (Heading -> Either a Heading) -> Heading -> Either a Heading
forall a b. (a -> b) -> a -> b
$ LaTeX -> Rows -> Cols -> Bool -> Heading
Heading LaTeX
"" Rows
1 Cols
1 Bool
True]
        sz :: Cols
sz = Int -> Cols
Cols (Int -> Cols) -> Int -> Cols
forall a b. (a -> b) -> a -> b
$ TableCells' a b -> Int
forall a a. TableCells' a a -> Int
depth TableCells' a b
t Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1

-- \multirow{number rows}{width}{text}
multirow :: LaTeXC l => Int -> l -> l 
multirow :: forall l. LaTeXC l => Int -> l -> l
multirow Int
n = (LaTeX -> LaTeX) -> l -> l
forall l. LaTeXC l => (LaTeX -> LaTeX) -> l -> l
liftL ((LaTeX -> LaTeX) -> l -> l) -> (LaTeX -> LaTeX) -> l -> l
forall a b. (a -> b) -> a -> b
$ \LaTeX
l -> String -> [TeXArg] -> LaTeX
TeXComm String
"multirow"
      [ LaTeX -> TeXArg
FixArg (LaTeX -> TeXArg) -> LaTeX -> TeXArg
forall a b. (a -> b) -> a -> b
$ Int -> LaTeX
forall a l. (Render a, LaTeXC l) => a -> l
rendertex Int
n
      , LaTeX -> TeXArg
FixArg (LaTeX -> TeXArg) -> (Text -> LaTeX) -> Text -> TeXArg
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> LaTeX
TeXRaw (Text -> TeXArg) -> Text -> TeXArg
forall a b. (a -> b) -> a -> b
$ Text
"*"
      , LaTeX -> TeXArg
FixArg LaTeX
l
      ]

rows :: Lens' Heading Rows
rows :: Lens' Heading Rows
rows Rows -> f Rows
f (Heading LaTeX
l Rows
r Cols
c Bool
b) = (\Rows
r' -> LaTeX -> Rows -> Cols -> Bool -> Heading
Heading LaTeX
l Rows
r' Cols
c Bool
b) (Rows -> Heading) -> f Rows -> f Heading
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Rows -> f Rows
f Rows
r

cols :: Lens' Heading Cols
cols :: Lens' Heading Cols
cols Cols -> f Cols
f (Heading LaTeX
l Rows
r Cols
c Bool
b) = (\Cols
c' -> LaTeX -> Rows -> Cols -> Bool -> Heading
Heading LaTeX
l Rows
r Cols
c' Bool
b) (Cols -> Heading) -> f Cols -> f Heading
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Cols -> f Cols
f Cols
c

condition :: Rows -> Cols -> LaTeX -> NonEmpty LaTeX
condition :: Rows -> Cols -> LaTeX -> NonEmpty LaTeX
condition (Rows Int
n) (Cols Int
m) LaTeX
t = LaTeX
first LaTeX -> [LaTeX] -> NonEmpty LaTeX
forall a. a -> [a] -> NonEmpty a
:| [LaTeX]
rest 
    where
        first :: LaTeX
first = Int -> [TableSpec] -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> [TableSpec] -> l -> l
multicolumn Int
m [TableSpec
VerticalLine,TableSpec
CenterColumn,TableSpec
VerticalLine] (Int -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> l -> l
multirow Int
n LaTeX
t)
        rest :: [LaTeX]
rest  = Int -> LaTeX -> [LaTeX]
forall a. Int -> a -> [a]
replicate (Int
nInt -> Int -> Int
forall a. Num a => a -> a -> a
-Int
1) (Int -> [TableSpec] -> LaTeX -> LaTeX
forall l. LaTeXC l => Int -> [TableSpec] -> l -> l
multicolumn Int
m [TableSpec
VerticalLine,TableSpec
LeftColumn,TableSpec
VerticalLine] LaTeX
"")

makeLast :: Heading -> Heading
makeLast :: Heading -> Heading
makeLast (Heading LaTeX
a Rows
b Cols
c Bool
_) = LaTeX -> Rows -> Cols -> Bool -> Heading
Heading LaTeX
a Rows
b Cols
c Bool
True

addHeading :: Heading -> Row a -> Row a
addHeading :: forall a. Heading -> Row a -> Row a
addHeading Heading
h (Row [] a
x) = [Either Filler Heading] -> a -> Row a
forall a. [Either Filler Heading] -> a -> Row a
Row [Heading -> Either Filler Heading
forall a b. b -> Either a b
Right (Heading -> Either Filler Heading)
-> Heading -> Either Filler Heading
forall a b. (a -> b) -> a -> b
$ Heading -> Heading
makeLast Heading
h] a
x
addHeading Heading
h (Row [Either Filler Heading]
hs a
x) = [Either Filler Heading] -> a -> Row a
forall a. [Either Filler Heading] -> a -> Row a
Row (Heading -> Either Filler Heading
forall a b. b -> Either a b
Right Heading
hEither Filler Heading
-> [Either Filler Heading] -> [Either Filler Heading]
forall a. a -> [a] -> [a]
:[Either Filler Heading]
hs) a
x

addMargin :: Cols -> Row a -> Row a
addMargin :: forall a. Cols -> Row a -> Row a
addMargin Cols
n (Row [Either Filler Heading]
hs a
x) = [Either Filler Heading] -> a -> Row a
forall a. [Either Filler Heading] -> a -> Row a
Row (Filler -> Either Filler Heading
forall a b. a -> Either a b
Left (Cols -> Bool -> Filler
Filler Cols
n Bool
False)Either Filler Heading
-> [Either Filler Heading] -> [Either Filler Heading]
forall a. a -> [a] -> [a]
:[Either Filler Heading]
hs) a
x

addLastMargin :: Cols -> Row a -> Row a
addLastMargin :: forall a. Cols -> Row a -> Row a
addLastMargin Cols
n (Row [Either Filler Heading]
hs a
x) = [Either Filler Heading] -> a -> Row a
forall a. [Either Filler Heading] -> a -> Row a
Row (Filler -> Either Filler Heading
forall a b. a -> Either a b
Left (Cols -> Bool -> Filler
Filler Cols
n Bool
True)Either Filler Heading
-> [Either Filler Heading] -> [Either Filler Heading]
forall a. a -> [a] -> [a]
:[Either Filler Heading]
hs) a
x

mapNonEmpty :: (a -> b)
            -> ([a] -> [b])
            -> NonEmpty a
            -> NonEmpty b
mapNonEmpty :: forall a b. (a -> b) -> ([a] -> [b]) -> NonEmpty a -> NonEmpty b
mapNonEmpty a -> b
f [a] -> [b]
g (a
x :| [a]
xs) = a -> b
f a
x b -> [b] -> NonEmpty b
forall a. a -> [a] -> NonEmpty a
:| [a] -> [b]
g [a]
xs

texFunctionTableRows :: Render a 
                     => TableCells' a b
                     -> NonEmpty (Row b)
texFunctionTableRows :: forall a b. Render a => TableCells' a b -> NonEmpty (Row b)
texFunctionTableRows (Cell b
x) = Row b -> NonEmpty (Row b)
forall a. a -> NonEmpty a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Row b -> NonEmpty (Row b)) -> Row b -> NonEmpty (Row b)
forall a b. (a -> b) -> a -> b
$ [Either Filler Heading] -> b -> Row b
forall a. [Either Filler Heading] -> a -> Row a
Row [] b
x
texFunctionTableRows (Condition Cols
w NonEmpty (a, TableCells' a b)
ts) 
        = NonEmpty (NonEmpty (Row b)) -> NonEmpty (Row b)
forall a. Semigroup a => NonEmpty a -> a
sconcat (NonEmpty (NonEmpty (Row b)) -> NonEmpty (Row b))
-> NonEmpty (NonEmpty (Row b)) -> NonEmpty (Row b)
forall a b. (a -> b) -> a -> b
$ (a -> TableCells' a b -> NonEmpty (Row b))
-> (a, TableCells' a b) -> NonEmpty (Row b)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry a -> TableCells' a b -> NonEmpty (Row b)
forall {a} {p} {a}.
(Render a, Render p) =>
p -> TableCells' a a -> NonEmpty (Row a)
heading ((a, TableCells' a b) -> NonEmpty (Row b))
-> NonEmpty (a, TableCells' a b) -> NonEmpty (NonEmpty (Row b))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> NonEmpty (a, TableCells' a b)
ts
    where
        heading :: p -> TableCells' a a -> NonEmpty (Row a)
heading p
h TableCells' a a
t = (Row a -> Row a)
-> ([Row a] -> [Row a]) -> NonEmpty (Row a) -> NonEmpty (Row a)
forall a b. (a -> b) -> ([a] -> [b]) -> NonEmpty a -> NonEmpty b
mapNonEmpty 
                (Heading -> Row a -> Row a
forall a. Heading -> Row a -> Row a
addHeading Heading
h') 
                ((([Row a], Row a) -> Identity ([Row a], Row a))
-> [Row a] -> Identity [Row a]
forall s t a b. Snoc s t a b => Prism s t (s, a) (t, b)
Prism [Row a] [Row a] ([Row a], Row a) ([Row a], Row a)
_Snoc ((([Row a], Row a) -> Identity ([Row a], Row a))
 -> [Row a] -> Identity [Row a])
-> (([Row a], Row a) -> ([Row a], Row a)) -> [Row a] -> [Row a]
forall s t a b. ASetter s t a b -> (a -> b) -> s -> t
%~ ([Row a] -> [Row a])
-> (Row a -> Row a) -> ([Row a], Row a) -> ([Row a], Row a)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap ((Row a -> Row a) -> [Row a] -> [Row a]
forall a b. (a -> b) -> [a] -> [b]
L.map ((Row a -> Row a) -> [Row a] -> [Row a])
-> (Row a -> Row a) -> [Row a] -> [Row a]
forall a b. (a -> b) -> a -> b
$ Cols -> Row a -> Row a
forall a. Cols -> Row a -> Row a
addMargin Cols
w) (Cols -> Row a -> Row a
forall a. Cols -> Row a -> Row a
addLastMargin Cols
w)) 
                NonEmpty (Row a)
r
            where
                h' :: Heading
h' = LaTeX -> Rows -> Cols -> Bool -> Heading
Heading (p -> LaTeX
forall a l. (Render a, LaTeXC l) => a -> l
rendertex p
h) (Int -> Rows
Rows Int
n) Cols
w Bool
False
                r :: NonEmpty (Row a)
r = TableCells' a a -> NonEmpty (Row a)
forall a b. Render a => TableCells' a b -> NonEmpty (Row b)
texFunctionTableRows TableCells' a a
t
                n :: Int
n = NonEmpty (Row a) -> Int
forall a. NonEmpty a -> Int
N.length NonEmpty (Row a)
r

instance Render LaTeXLI where
    render :: LaTeXLI -> Text
render (LaTeXLI SrcLoc
_ String
l) = LaTeX -> Text
forall a. Render a => a -> Text
render (LaTeX -> Text) -> LaTeX -> Text
forall a b. (a -> b) -> a -> b
$ LaTeX -> LaTeX
forall l. LaTeXC l => l -> l
math (LaTeX -> LaTeX) -> LaTeX -> LaTeX
forall a b. (a -> b) -> a -> b
$ Text -> LaTeX
TeXRaw (Text -> LaTeX) -> Text -> LaTeX
forall a b. (a -> b) -> a -> b
$ String -> Text
forall a. IsString a => String -> a
fromString String
l

instance (Render a,Render b) => Render (FunctionTable' a b) where
    render :: FunctionTable' a b -> Text
render = LaTeX -> Text
forall a. Render a => a -> Text
render (LaTeX -> Text)
-> (FunctionTable' a b -> LaTeX) -> FunctionTable' a b -> Text
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FunctionTable' a b -> LaTeX
forall a b. (Render a, Render b) => FunctionTable' a b -> LaTeX
texFunctionTable