Essentials is a small Prelude alternative. It was born out of the experience
of maintaining a number of libraries that don't use a prelude at all, preferring
instead to use tightly limited explicit imports. When we do this, we find that
although the standard prelude contains many things that most modules can live
without, there is a handful of items that most code truly needs.
There are plenty of good reasons to use names that conflict with things in the
standard prelude. For example, the standard prelude has a takeWhile function
that deals with lists; a streaming library might define a function of the same
name that deals with effectful streams. The standard prelude has a log
function that is an abbreviation for 'logarithm'; a logging library might define
a function of the same name that writes an event to a log file. Some names,
however, are more sacrosanct. It would be generally unwise and unappreciated to
define anything named pure or (>>=), for example. The guiding principle for
the Essentials module is that it includes things in the latter category.
Function
($) :: (a -> b) -> a -> b
(&) :: a -> (a -> b) -> b
($) and (&) are the same function, just flipped.
(&) has slightly higher operator precedence.
Category
id :: Category cat => cat a a
(>>>) :: Category cat => cat a b -> cat b c -> cat a c
(<<<), (.) :: Category cat => cat b c -> cat a b -> cat a c
Usually specialized as cat ~ (->):
id :: a -> a
(>>>) :: (a -> b) -> (b -> c) -> a -> c
(<<<), (.) :: (b -> c) -> (a -> b) -> a -> c
(>>>) and (<<<) are the same function, just flipped.
(.) is the same as (<<<), but with higher operator precedence.
Functor, Applicative, Monad
pure :: Applicative f => a -> f a
fmap, (<$>) :: Functor f => (a -> b) -> f a -> f b
(<&>) :: Functor f => f a -> (a -> b) -> f b
(<$>) is the same as fmap.
(<$>) and (<&>) are also the same function, just flipped.
(<$>) has higher operator precedence.
(<*>) :: Applicative f => f (a -> b) -> f a -> f b
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
(<*>) and (<**>) are the same function, just flipped.
(>>=) :: Monad m => m a -> (a -> m b) -> m b
(=<<) :: Monad m => (a -> m b) -> m a -> m b
(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
(>>=) is left associative; (=<<) is right associative.
These functions keep all effects but discard some values:
(<$) :: Functor f => a -> f b -> f a
(<*) :: Applicative f => f a -> f b -> f a
($>) :: Functor f => f a -> b -> f b
(*>) :: Applicative f => f a -> f b -> f b
void :: Functor f => f a -> f ()
Boole
data Bool = False | True
otherwise = True
Comparison
(==), (/=) :: Eq a => a -> a -> Bool
(<), (>), (<=), (>=) :: Ord a => a -> a -> Bool
Monoid
(<>) :: Semigroup a => a -> a -> a
mempty :: Monoid a => a
Traversal
traverse :: Traversable t => Applicative f =>
(a -> f b) -> t a -> f (t b)
traverse_ :: Foldable t => Applicative f =>
(a -> f b) -> t a -> f ()
Maybe
data Maybe a =
Nothing | Just a
maybe :: b -> (a -> b) -> Maybe a -> b
Void
data Void
absurd :: Void -> a
Identity
newtype Identity a =
Identity {runIdentity :: a}
Const
newtype Const a b =
Const {getConst :: a}
Type classes
Semigroup
Monoid
Eq
Ord
Enum
Bounded
Show
Constructor classes
Functor
Applicative
Monad
Foldable
Traversable
Type
Undefined
undefined :: a
Fixities
infixr 0 $
infixl 1 & <&> >>=
infixr 1 =<< <=< >=>
<<< >>>
infixl 4 <$> <$ $>
<*> *> <* <**>
infix 4 == /=
< >
<= >=
infixr 6 <>
infixr 9 .
