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

• Type

Undefined

undefined :: a

Fixities

infixr 0  $

infixl 1  &  <&>  >>=

infixr 1  =<<  <=<  >=>
               <<<  >>>

infixl 4  <$>  <$  $>
          <*>  *>  <*  <**>

infix  4  ==  /=
          <   >
          <=  >=

infixr 6  <>

infixr 9  .