latex-function-tables-0.1.0.0: Function table specifications in latex

Safe HaskellNone
LanguageHaskell2010

Text.LaTeX.Internal.FunctionTable

Documentation

data TableCells' a b Source #

Constructors

Cell b 
Condition Cols (NonEmpty (a, TableCells' a b)) 

Instances

Bifunctor TableCells' Source # 

Methods

bimap :: (a -> b) -> (c -> d) -> TableCells' a c -> TableCells' b d #

first :: (a -> b) -> TableCells' a c -> TableCells' b c #

second :: (b -> c) -> TableCells' a b -> TableCells' a c #

Bitraversable TableCells' Source # 

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> TableCells' a b -> f (TableCells' c d) #

Bifoldable TableCells' Source # 

Methods

bifold :: Monoid m => TableCells' m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> TableCells' a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> TableCells' a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> TableCells' a b -> c #

Functor (TableCells' a) Source # 

Methods

fmap :: (a -> b) -> TableCells' a a -> TableCells' a b #

(<$) :: a -> TableCells' a b -> TableCells' a a #

Foldable (TableCells' a) Source # 

Methods

fold :: Monoid m => TableCells' a m -> m #

foldMap :: Monoid m => (a -> m) -> TableCells' a a -> m #

foldr :: (a -> b -> b) -> b -> TableCells' a a -> b #

foldr' :: (a -> b -> b) -> b -> TableCells' a a -> b #

foldl :: (b -> a -> b) -> b -> TableCells' a a -> b #

foldl' :: (b -> a -> b) -> b -> TableCells' a a -> b #

foldr1 :: (a -> a -> a) -> TableCells' a a -> a #

foldl1 :: (a -> a -> a) -> TableCells' a a -> a #

toList :: TableCells' a a -> [a] #

null :: TableCells' a a -> Bool #

length :: TableCells' a a -> Int #

elem :: Eq a => a -> TableCells' a a -> Bool #

maximum :: Ord a => TableCells' a a -> a #

minimum :: Ord a => TableCells' a a -> a #

sum :: Num a => TableCells' a a -> a #

product :: Num a => TableCells' a a -> a #

Traversable (TableCells' a) Source # 

Methods

traverse :: Applicative f => (a -> f b) -> TableCells' a a -> f (TableCells' a b) #

sequenceA :: Applicative f => TableCells' a (f a) -> f (TableCells' a a) #

mapM :: Monad m => (a -> m b) -> TableCells' a a -> m (TableCells' a b) #

sequence :: Monad m => TableCells' a (m a) -> m (TableCells' a a) #

(Eq a, Eq b) => Eq (TableCells' a b) Source # 

Methods

(==) :: TableCells' a b -> TableCells' a b -> Bool #

(/=) :: TableCells' a b -> TableCells' a b -> Bool #

(Show a, Show b) => Show (TableCells' a b) Source # 

Methods

showsPrec :: Int -> TableCells' a b -> ShowS #

show :: TableCells' a b -> String #

showList :: [TableCells' a b] -> ShowS #

data FunctionTable' a b Source #

Constructors

Table b (TableCells' a b) 

Instances

Bifunctor FunctionTable' Source # 

Methods

bimap :: (a -> b) -> (c -> d) -> FunctionTable' a c -> FunctionTable' b d #

first :: (a -> b) -> FunctionTable' a c -> FunctionTable' b c #

second :: (b -> c) -> FunctionTable' a b -> FunctionTable' a c #

Bitraversable FunctionTable' Source # 

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> FunctionTable' a b -> f (FunctionTable' c d) #

Bifoldable FunctionTable' Source # 

Methods

bifold :: Monoid m => FunctionTable' m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> FunctionTable' a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> FunctionTable' a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> FunctionTable' a b -> c #

Functor (FunctionTable' a) Source # 

Methods

fmap :: (a -> b) -> FunctionTable' a a -> FunctionTable' a b #

(<$) :: a -> FunctionTable' a b -> FunctionTable' a a #

Foldable (FunctionTable' a) Source # 

Methods

fold :: Monoid m => FunctionTable' a m -> m #

foldMap :: Monoid m => (a -> m) -> FunctionTable' a a -> m #

foldr :: (a -> b -> b) -> b -> FunctionTable' a a -> b #

foldr' :: (a -> b -> b) -> b -> FunctionTable' a a -> b #

foldl :: (b -> a -> b) -> b -> FunctionTable' a a -> b #

foldl' :: (b -> a -> b) -> b -> FunctionTable' a a -> b #

foldr1 :: (a -> a -> a) -> FunctionTable' a a -> a #

foldl1 :: (a -> a -> a) -> FunctionTable' a a -> a #

toList :: FunctionTable' a a -> [a] #

null :: FunctionTable' a a -> Bool #

length :: FunctionTable' a a -> Int #

elem :: Eq a => a -> FunctionTable' a a -> Bool #

maximum :: Ord a => FunctionTable' a a -> a #

minimum :: Ord a => FunctionTable' a a -> a #

sum :: Num a => FunctionTable' a a -> a #

product :: Num a => FunctionTable' a a -> a #

Traversable (FunctionTable' a) Source # 

Methods

traverse :: Applicative f => (a -> f b) -> FunctionTable' a a -> f (FunctionTable' a b) #

sequenceA :: Applicative f => FunctionTable' a (f a) -> f (FunctionTable' a a) #

mapM :: Monad m => (a -> m b) -> FunctionTable' a a -> m (FunctionTable' a b) #

sequence :: Monad m => FunctionTable' a (m a) -> m (FunctionTable' a a) #

(Eq a, Eq b) => Eq (FunctionTable' a b) Source # 
(Show a, Show b) => Show (FunctionTable' a b) Source # 
(Render a, Render b) => Render (FunctionTable' a b) Source # 

Methods

render :: FunctionTable' a b -> Text #

newtype Rows Source #

Constructors

Rows Int 

Instances

Eq Rows Source # 

Methods

(==) :: Rows -> Rows -> Bool #

(/=) :: Rows -> Rows -> Bool #

Num Rows Source # 

Methods

(+) :: Rows -> Rows -> Rows #

(-) :: Rows -> Rows -> Rows #

(*) :: Rows -> Rows -> Rows #

negate :: Rows -> Rows #

abs :: Rows -> Rows #

signum :: Rows -> Rows #

fromInteger :: Integer -> Rows #

Ord Rows Source # 

Methods

compare :: Rows -> Rows -> Ordering #

(<) :: Rows -> Rows -> Bool #

(<=) :: Rows -> Rows -> Bool #

(>) :: Rows -> Rows -> Bool #

(>=) :: Rows -> Rows -> Bool #

max :: Rows -> Rows -> Rows #

min :: Rows -> Rows -> Rows #

Show Rows Source # 

Methods

showsPrec :: Int -> Rows -> ShowS #

show :: Rows -> String #

showList :: [Rows] -> ShowS #

HasHeight Heading Rows Source # 

newtype Cols Source #

Constructors

Cols Int 

data Row a Source #

Constructors

Row [Either Filler Heading] a 

Instances

Functor Row Source # 

Methods

fmap :: (a -> b) -> Row a -> Row b #

(<$) :: a -> Row b -> Row a #

Foldable Row Source # 

Methods

fold :: Monoid m => Row m -> m #

foldMap :: Monoid m => (a -> m) -> Row a -> m #

foldr :: (a -> b -> b) -> b -> Row a -> b #

foldr' :: (a -> b -> b) -> b -> Row a -> b #

foldl :: (b -> a -> b) -> b -> Row a -> b #

foldl' :: (b -> a -> b) -> b -> Row a -> b #

foldr1 :: (a -> a -> a) -> Row a -> a #

foldl1 :: (a -> a -> a) -> Row a -> a #

toList :: Row a -> [a] #

null :: Row a -> Bool #

length :: Row a -> Int #

elem :: Eq a => a -> Row a -> Bool #

maximum :: Ord a => Row a -> a #

minimum :: Ord a => Row a -> a #

sum :: Num a => Row a -> a #

product :: Num a => Row a -> a #

Traversable Row Source # 

Methods

traverse :: Applicative f => (a -> f b) -> Row a -> f (Row b) #

sequenceA :: Applicative f => Row (f a) -> f (Row a) #

mapM :: Monad m => (a -> m b) -> Row a -> m (Row b) #

sequence :: Monad m => Row (m a) -> m (Row a) #

Eq a => Eq (Row a) Source # 

Methods

(==) :: Row a -> Row a -> Bool #

(/=) :: Row a -> Row a -> Bool #

Show a => Show (Row a) Source # 

Methods

showsPrec :: Int -> Row a -> ShowS #

show :: Row a -> String #

showList :: [Row a] -> ShowS #

_Condition :: forall a b a. Prism (TableCells' a b) (TableCells' a b) (Cols, NonEmpty (a, TableCells' a b)) (Cols, NonEmpty (a, TableCells' a b)) Source #

_Cell :: forall a b. Prism' (TableCells' a b) b Source #

class HasHeight s a | s -> a where