Documentation

Methods

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

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

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

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

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

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

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

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

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

toList :: Inc a -> [a] #

null :: Inc a -> Bool #

length :: Inc a -> Int #

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

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

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

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

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

Methods

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

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

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

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

Methods

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

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

Methods

showsPrec :: Int -> Inc var -> ShowS #

show :: Inc var -> String #

showList :: [Inc var] -> ShowS #

Methods

(==) :: Inc var -> Inc var -> Bool #

(/=) :: Inc var -> Inc var -> Bool #

Methods

fromString :: String -> Term' #

Methods

fromString :: String -> TermT' #

Methods

showsPrec :: Int -> Term' -> ShowS #

show :: Term' -> String #

showList :: [Term'] -> ShowS #

Methods

showsPrec :: Int -> TermT' -> ShowS #

show :: TermT' -> String #

showList :: [TermT'] -> ShowS #

Methods

fold :: Monoid m => FS t m -> m #

foldMap :: Monoid m => (a -> m) -> FS t a -> m #

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

foldr :: (a -> b -> b) -> b -> FS t a -> b #

foldr' :: (a -> b -> b) -> b -> FS t a -> b #

foldl :: (b -> a -> b) -> b -> FS t a -> b #

foldl' :: (b -> a -> b) -> b -> FS t a -> b #

foldr1 :: (a -> a -> a) -> FS t a -> a #

foldl1 :: (a -> a -> a) -> FS t a -> a #

toList :: FS t a -> [a] #

null :: FS t a -> Bool #

length :: FS t a -> Int #

elem :: Eq a => a -> FS t a -> Bool #

maximum :: Ord a => FS t a -> a #

minimum :: Ord a => FS t a -> a #

sum :: Num a => FS t a -> a #

product :: Num a => FS t a -> a #

Methods

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

sequenceA :: Applicative f => FS t (f a) -> f (FS t a) #

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

sequence :: Monad m => FS t (m a) -> m (FS t a) #

Methods

pure :: a -> FS t a #

(<*>) :: FS t (a -> b) -> FS t a -> FS t b #

liftA2 :: (a -> b -> c) -> FS t a -> FS t b -> FS t c #

(*>) :: FS t a -> FS t b -> FS t b #

(<*) :: FS t a -> FS t b -> FS t a #

Methods

fmap :: (a -> b) -> FS t a -> FS t b #

(<$) :: a -> FS t b -> FS t a #

Methods

(>>=) :: FS t a -> (a -> FS t b) -> FS t b #

(>>) :: FS t a -> FS t b -> FS t b #

return :: a -> FS t a #

Methods

(==) :: FS t a -> FS t a -> Bool #

(/=) :: FS t a -> FS t a -> Bool #

Methods

bifold :: Monoid m => Sum f g m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> Sum f g a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Sum f g a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Sum f g a b -> c #

Methods

bimap :: (a -> b) -> (c -> d) -> Sum f g a c -> Sum f g b d #

first :: (a -> b) -> Sum f g a c -> Sum f g b c #

second :: (b -> c) -> Sum f g a b -> Sum f g a c #

Methods

bitraverse :: Applicative f0 => (a -> f0 c) -> (b -> f0 d) -> Sum f g a b -> f0 (Sum f g c d) #

Methods

fold :: Monoid m => Sum f g scope m -> m #

foldMap :: Monoid m => (a -> m) -> Sum f g scope a -> m #

foldMap' :: Monoid m => (a -> m) -> Sum f g scope a -> m #

foldr :: (a -> b -> b) -> b -> Sum f g scope a -> b #

foldr' :: (a -> b -> b) -> b -> Sum f g scope a -> b #

foldl :: (b -> a -> b) -> b -> Sum f g scope a -> b #

foldl' :: (b -> a -> b) -> b -> Sum f g scope a -> b #

foldr1 :: (a -> a -> a) -> Sum f g scope a -> a #

foldl1 :: (a -> a -> a) -> Sum f g scope a -> a #

toList :: Sum f g scope a -> [a] #

null :: Sum f g scope a -> Bool #

length :: Sum f g scope a -> Int #

elem :: Eq a => a -> Sum f g scope a -> Bool #

maximum :: Ord a => Sum f g scope a -> a #

minimum :: Ord a => Sum f g scope a -> a #

sum :: Num a => Sum f g scope a -> a #

product :: Num a => Sum f g scope a -> a #

Methods

traverse :: Applicative f0 => (a -> f0 b) -> Sum f g scope a -> f0 (Sum f g scope b) #

sequenceA :: Applicative f0 => Sum f g scope (f0 a) -> f0 (Sum f g scope a) #

mapM :: Monad m => (a -> m b) -> Sum f g scope a -> m (Sum f g scope b) #

sequence :: Monad m => Sum f g scope (m a) -> m (Sum f g scope a) #

Methods

fmap :: (a -> b) -> Sum f g scope a -> Sum f g scope b #

(<$) :: a -> Sum f g scope b -> Sum f g scope a #

Methods

from :: Sum f g scope term -> Rep (Sum f g scope term) x #

to :: Rep (Sum f g scope term) x -> Sum f g scope term #

Methods

bifold :: Monoid m => Empty m m -> m #

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

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> Empty a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> Empty a b -> c #

Methods

bimap :: (a -> b) -> (c -> d) -> Empty a c -> Empty b d #

first :: (a -> b) -> Empty a c -> Empty b c #

second :: (b -> c) -> Empty a b -> Empty a c #

Methods

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

Methods

fold :: Monoid m => Empty scope m -> m #

foldMap :: Monoid m => (a -> m) -> Empty scope a -> m #

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

foldr :: (a -> b -> b) -> b -> Empty scope a -> b #

foldr' :: (a -> b -> b) -> b -> Empty scope a -> b #

foldl :: (b -> a -> b) -> b -> Empty scope a -> b #

foldl' :: (b -> a -> b) -> b -> Empty scope a -> b #

foldr1 :: (a -> a -> a) -> Empty scope a -> a #

foldl1 :: (a -> a -> a) -> Empty scope a -> a #

toList :: Empty scope a -> [a] #

null :: Empty scope a -> Bool #

length :: Empty scope a -> Int #

elem :: Eq a => a -> Empty scope a -> Bool #

maximum :: Ord a => Empty scope a -> a #

minimum :: Ord a => Empty scope a -> a #

sum :: Num a => Empty scope a -> a #

product :: Num a => Empty scope a -> a #

Methods

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

sequenceA :: Applicative f => Empty scope (f a) -> f (Empty scope a) #

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

sequence :: Monad m => Empty scope (m a) -> m (Empty scope a) #

Methods

fmap :: (a -> b) -> Empty scope a -> Empty scope b #

(<$) :: a -> Empty scope b -> Empty scope a #

Methods

fromString :: String -> TermT' #

Methods

showsPrec :: Int -> TermT' -> ShowS #

show :: TermT' -> String #

showList :: [TermT'] -> ShowS #

Methods

bifold :: Monoid m => AnnF ann term m m -> m #

bifoldMap :: Monoid m => (a -> m) -> (b -> m) -> AnnF ann term a b -> m #

bifoldr :: (a -> c -> c) -> (b -> c -> c) -> c -> AnnF ann term a b -> c #

bifoldl :: (c -> a -> c) -> (c -> b -> c) -> c -> AnnF ann term a b -> c #

Methods

bimap :: (a -> b) -> (c -> d) -> AnnF ann term a c -> AnnF ann term b d #

first :: (a -> b) -> AnnF ann term a c -> AnnF ann term b c #

second :: (b -> c) -> AnnF ann term a b -> AnnF ann term a c #

Methods

bitraverse :: Applicative f => (a -> f c) -> (b -> f d) -> AnnF ann term a b -> f (AnnF ann term c d) #

Methods

fmap :: (a -> b) -> AnnF ann term scope a -> AnnF ann term scope b #

(<$) :: a -> AnnF ann term scope b -> AnnF ann term scope a #

Methods

showsPrec :: Int -> AnnF ann term scope typedTerm -> ShowS #

show :: AnnF ann term scope typedTerm -> String #

showList :: [AnnF ann term scope typedTerm] -> ShowS #

Methods

(==) :: AnnF ann term scope typedTerm -> AnnF ann term scope typedTerm -> Bool #

(/=) :: AnnF ann term scope typedTerm -> AnnF ann term scope typedTerm -> Bool #