Data.UnBounded

Documentation

data Top a

`Top a` represents the type a, together with a Top element, i.e. an element that is greater than any other element. We can think of `Top a` being defined as:

>>> data Top a = ValT a | Top

Instances

Monad Top

Methods

(>>=) :: Top a -> (a -> Top b) -> Top b

(>>) :: Top a -> Top b -> Top b

return :: a -> Top a

fail :: String -> Top a

Functor Top

Methods

fmap :: (a -> b) -> Top a -> Top b

(<$) :: a -> Top b -> Top a

Applicative Top

Methods

pure :: a -> Top a

(<*>) :: Top (a -> b) -> Top a -> Top b

(*>) :: Top a -> Top b -> Top b

(<*) :: Top a -> Top b -> Top a

Foldable Top

Methods

fold :: Monoid m => Top m -> m

foldMap :: Monoid m => (a -> m) -> Top a -> m

foldr :: (a -> b -> b) -> b -> Top a -> b

foldr' :: (a -> b -> b) -> b -> Top a -> b

foldl :: (b -> a -> b) -> b -> Top a -> b

foldl' :: (b -> a -> b) -> b -> Top a -> b

foldr1 :: (a -> a -> a) -> Top a -> a

foldl1 :: (a -> a -> a) -> Top a -> a

toList :: Top a -> [a]

null :: Top a -> Bool

length :: Top a -> Int

elem :: Eq a => a -> Top a -> Bool

maximum :: Ord a => Top a -> a

minimum :: Ord a => Top a -> a

sum :: Num a => Top a -> a

product :: Num a => Top a -> a

Traversable Top

Methods

traverse :: Applicative f => (a -> f b) -> Top a -> f (Top b)

sequenceA :: Applicative f => Top (f a) -> f (Top a)

mapM :: Monad m => (a -> m b) -> Top a -> m (Top b)

sequence :: Monad m => Top (m a) -> m (Top a)

Eq a => Eq (Top a)

Methods

(==) :: Top a -> Top a -> Bool

(/=) :: Top a -> Top a -> Bool

Ord a => Ord (Top a)

Methods

compare :: Top a -> Top a -> Ordering

(<) :: Top a -> Top a -> Bool

(<=) :: Top a -> Top a -> Bool

(>) :: Top a -> Top a -> Bool

(>=) :: Top a -> Top a -> Bool

max :: Top a -> Top a -> Top a

min :: Top a -> Top a -> Top a

Show a => Show (Top a)

Methods

showsPrec :: Int -> Top a -> ShowS

show :: Top a -> String

showList :: [Top a] -> ShowS

topToMaybe :: Top a -> Maybe a

pattern ValT :: forall a. a -> Top a

pattern Top :: forall a. Top a

data Bottom a

`Bottom a` represents the type a, together with a Bottom element, i.e. an element that is smaller than any other element. We can think of `Bottom a` being defined as:

>>> data Bottom a = Bottom | ValB a

Instances

Monad Bottom

Methods

(>>=) :: Bottom a -> (a -> Bottom b) -> Bottom b

(>>) :: Bottom a -> Bottom b -> Bottom b

return :: a -> Bottom a

fail :: String -> Bottom a

Functor Bottom

Methods

fmap :: (a -> b) -> Bottom a -> Bottom b

(<$) :: a -> Bottom b -> Bottom a

Applicative Bottom

Methods

pure :: a -> Bottom a

(<*>) :: Bottom (a -> b) -> Bottom a -> Bottom b

(*>) :: Bottom a -> Bottom b -> Bottom b

(<*) :: Bottom a -> Bottom b -> Bottom a

Foldable Bottom

Methods

fold :: Monoid m => Bottom m -> m

foldMap :: Monoid m => (a -> m) -> Bottom a -> m

foldr :: (a -> b -> b) -> b -> Bottom a -> b

foldr' :: (a -> b -> b) -> b -> Bottom a -> b

foldl :: (b -> a -> b) -> b -> Bottom a -> b

foldl' :: (b -> a -> b) -> b -> Bottom a -> b

foldr1 :: (a -> a -> a) -> Bottom a -> a

foldl1 :: (a -> a -> a) -> Bottom a -> a

toList :: Bottom a -> [a]

null :: Bottom a -> Bool

length :: Bottom a -> Int

elem :: Eq a => a -> Bottom a -> Bool

maximum :: Ord a => Bottom a -> a

minimum :: Ord a => Bottom a -> a

sum :: Num a => Bottom a -> a

product :: Num a => Bottom a -> a

Traversable Bottom

Methods

traverse :: Applicative f => (a -> f b) -> Bottom a -> f (Bottom b)

sequenceA :: Applicative f => Bottom (f a) -> f (Bottom a)

mapM :: Monad m => (a -> m b) -> Bottom a -> m (Bottom b)

sequence :: Monad m => Bottom (m a) -> m (Bottom a)

Eq a => Eq (Bottom a)

Methods

(==) :: Bottom a -> Bottom a -> Bool

(/=) :: Bottom a -> Bottom a -> Bool

Ord a => Ord (Bottom a)

Methods

compare :: Bottom a -> Bottom a -> Ordering

(<) :: Bottom a -> Bottom a -> Bool

(<=) :: Bottom a -> Bottom a -> Bool

(>) :: Bottom a -> Bottom a -> Bool

(>=) :: Bottom a -> Bottom a -> Bool

max :: Bottom a -> Bottom a -> Bottom a

min :: Bottom a -> Bottom a -> Bottom a

Show a => Show (Bottom a)

Methods

showsPrec :: Int -> Bottom a -> ShowS

show :: Bottom a -> String

showList :: [Bottom a] -> ShowS

bottomToMaybe :: Bottom a -> Maybe a

pattern Bottom :: forall a. Bottom a

pattern ValB :: forall a. a -> Bottom a

data UnBounded a

`UnBounded a` represents the type a, together with an element MaxInfinity larger than any other element, and an element MinInfinity, smaller than any other element.

Constructors

MinInfinity

Val

Fields

• _unUnBounded :: a

MaxInfinity

Instances

Functor UnBounded

Methods

fmap :: (a -> b) -> UnBounded a -> UnBounded b

(<$) :: a -> UnBounded b -> UnBounded a

Foldable UnBounded

Methods

fold :: Monoid m => UnBounded m -> m

foldMap :: Monoid m => (a -> m) -> UnBounded a -> m

foldr :: (a -> b -> b) -> b -> UnBounded a -> b

foldr' :: (a -> b -> b) -> b -> UnBounded a -> b

foldl :: (b -> a -> b) -> b -> UnBounded a -> b

foldl' :: (b -> a -> b) -> b -> UnBounded a -> b

foldr1 :: (a -> a -> a) -> UnBounded a -> a

foldl1 :: (a -> a -> a) -> UnBounded a -> a

toList :: UnBounded a -> [a]

null :: UnBounded a -> Bool

length :: UnBounded a -> Int

elem :: Eq a => a -> UnBounded a -> Bool

maximum :: Ord a => UnBounded a -> a

minimum :: Ord a => UnBounded a -> a

sum :: Num a => UnBounded a -> a

product :: Num a => UnBounded a -> a

Traversable UnBounded

Methods

traverse :: Applicative f => (a -> f b) -> UnBounded a -> f (UnBounded b)

sequenceA :: Applicative f => UnBounded (f a) -> f (UnBounded a)

mapM :: Monad m => (a -> m b) -> UnBounded a -> m (UnBounded b)

sequence :: Monad m => UnBounded (m a) -> m (UnBounded a)

Eq a => Eq (UnBounded a)

Methods

(==) :: UnBounded a -> UnBounded a -> Bool

(/=) :: UnBounded a -> UnBounded a -> Bool

Fractional a => Fractional (UnBounded a)

Methods

(/) :: UnBounded a -> UnBounded a -> UnBounded a

recip :: UnBounded a -> UnBounded a

fromRational :: Rational -> UnBounded a

Num a => Num (UnBounded a)

Methods

(+) :: UnBounded a -> UnBounded a -> UnBounded a

(-) :: UnBounded a -> UnBounded a -> UnBounded a

(*) :: UnBounded a -> UnBounded a -> UnBounded a

negate :: UnBounded a -> UnBounded a

abs :: UnBounded a -> UnBounded a

signum :: UnBounded a -> UnBounded a

fromInteger :: Integer -> UnBounded a

Ord a => Ord (UnBounded a)

Methods

compare :: UnBounded a -> UnBounded a -> Ordering

(<) :: UnBounded a -> UnBounded a -> Bool

(<=) :: UnBounded a -> UnBounded a -> Bool

(>) :: UnBounded a -> UnBounded a -> Bool

(>=) :: UnBounded a -> UnBounded a -> Bool

max :: UnBounded a -> UnBounded a -> UnBounded a

min :: UnBounded a -> UnBounded a -> UnBounded a

Show a => Show (UnBounded a)

Methods

showsPrec :: Int -> UnBounded a -> ShowS

show :: UnBounded a -> String

showList :: [UnBounded a] -> ShowS

unUnBounded :: forall a a. Traversal (UnBounded a) (UnBounded a) a a

unBoundedToMaybe :: UnBounded a -> Maybe a