Chris Martin

Some Applicative Functors

Types are great. Lifting them into some sort of applicative functor makes them even better. This post is an homage to our favorite applicatives, and to the semigroups with which they are instrinsically connected.

Lifted-but-why

LiftedButWhy is a boring functor that just has one value and no other structure or interesting properties.

data LiftedButWhy a =

-- A value that has been lifted
-- for some damned reason
LiftedButWhy a

deriving (Eq, Functor, Show)

… Okay, to be honest, this one is nobody’s favorite, but it is included here for completeness.

instance Applicative LiftedButWhy where

pure = LiftedButWhy

LiftedButWhy f <*> LiftedButWhy a =
LiftedButWhy (f a)

LiftedButWhy a >>= f = f a

instance Semigroup a =>
Semigroup (LiftedButWhy a) where

LiftedButWhy x <> LiftedButWhy y =
LiftedButWhy (x <> y)

instance Monoid a =>
Monoid (LiftedButWhy a) where

mempty = LiftedButWhy mempty

Or-not

OrNot is somehow slightly more interesting than LiftedButWhy, even though it may actually contain less. Instead of a value, there might not be a value.

When you combine stuff with (<*>) or (<>), all of the values need to be present. If any of them are absent, the whole expression evaluates to Nope.

data OrNot a =
ActuallyYes a -- Some normal value
| Nope        -- Chuck Testa
deriving (Eq, Functor, Show)

If you have a function f that might not actually be there, and a value a that might not actually be there, lifted application (<*>) gives you f a only if both of them are actually there.

instance Applicative OrNot where

pure = ActuallyYes

ActuallyYes f <*> ActuallyYes a =
ActuallyYes (f a)
_ <*> _ = Nope

ActuallyYes a >>= f = f a
Nope          >>= _ = Nope

If you have value a that may not actually be there, and another value a' that might not actually be there, the lifted semigroup operation (<>) gives you a <> a' only if both of them are actually there.

instance Semigroup a =>
Semigroup (OrNot a) where

ActuallyYes a <> ActuallyYes a' =
ActuallyYes (a <> a')
_ <> _ = Nope

instance Monoid a =>
Monoid (OrNot a) where

mempty = ActuallyYes mempty

Two

Two is two values. Yep. Just two values.

data Two a = Two
{ firstOfTwo  :: a -- One value
, secondOfTwo :: a -- Another value
} deriving (Eq, Functor, Show)

If you have two functions f and g and two values a and a', then you can apply them with (<*>) to get two results f a and g a'.

instance Applicative Two where

pure a = Two a a

Two f g <*> Two a a' = Two (f a) (g a')

instance Semigroup a =>
Semigroup (Two a) where

Two x y <> Two x' y' =
Two (x <> x') (y <> y')

instance Monoid a =>
Monoid (Two a) where

mempty = Two mempty mempty

Any-number-of

AnyNumberOf starts to get exciting. Any number of values you want. Zero … one … two … three … four … five … The possibilities are truly endless.

data AnyNumberOf a =

-- One value, and maybe even more after that!
OneAndMaybeMore a (AnyNumberOf a)

-- Oh. Well this is less fun.
| ActuallyNone

deriving (Eq, Functor, Show)

Here’s an alias for OneAndMaybeMore which provides some brevity:

(~~) :: a -> AnyNumberOf a -> AnyNumberOf a
(~~) = OneAndMaybeMore
infixr 5 ~~

You can use the applicative functor to apply any number of functions to any number of arguments.

instance Applicative AnyNumberOf where

pure a = OneAndMaybeMore a ActuallyNone

OneAndMaybeMore f fs <*> OneAndMaybeMore x xs =
OneAndMaybeMore (f x) (fs <*> xs)
_ <*> _ = ActuallyNone

Example:

((+ 1) ~~ (* 2) ~~       ActuallyNone)
<*> (  1  ~~    6  ~~ 37 ~~ ActuallyNone)
=  (  7  ~~   12  ~~       ActuallyNone)

This example demonstrates how when there are more arguments than functions, any excess arguments (in this case, the 37) are ignored.

The operation of combining some number of a with some other number of a is sometimes referred to as zipping.

instance Semigroup a =>
Semigroup (AnyNumberOf a) where

OneAndMaybeMore x xs <> OneAndMaybeMore y ys =
OneAndMaybeMore (x <> y) (xs <> ys)
_ <> _ = ActuallyNone

instance Monoid a =>
Monoid (AnyNumberOf a) where

mempty = mempty ~~ mempty

One-or-more

OneOrMore is more restrictive than AnyNumberOf, yet somehow actually more interesting, because it excludes that dull situation where there aren’t any values at all.

data OneOrMore a = OneOrMore

-- Definitely at least this one
{ theFirstOfMany :: a

-- And perhaps others
, possiblyMore :: AnyNumberOf a

} deriving (Eq, Functor, Show)

instance Applicative OneOrMore where

pure a = OneOrMore a ActuallyNone

OneOrMore f fs <*> OneOrMore x xs =
OneOrMore (f x) (fs <*> xs)

instance Semigroup a =>
Semigroup (OneOrMore a) where

OneOrMore a more <> OneOrMore a' more' =
OneOrMore a (more <> OneAndMaybeMore a' more')

instance Monoid a =>
Monoid (OneOrMore a) where

mempty = OneOrMore mempty ActuallyNone

Also-extra-thing

Also extraThing is a functor in which each value has an extraThing of some other type that tags along with it.

data (Also extraThing) a = Also

-- A value
{ withoutExtraThing :: a

-- An additional thing that tags along
, theExtraThing :: extraThing

} deriving (Eq, Functor, Show)

Dragging the extraThing along can be a bit of a burden. It prevents Also extraThing from being an applicative functor — unless the extraThing can pull its weight by bringing a monoid to the table.

instance Monoid extraThing =>
Applicative (Also extraThing) where

pure = (`Also` mempty)

(f `Also` extra1) <*> (a `Also` extra2) =
f a
`Also` (extra1 <> extra2)

instance (Semigroup extraThing, Semigroup a) =>
Semigroup ((Also extraThing) a) where

(a `Also` extra1) <> (a' `Also` extra2) =
(a <> a')
`Also` (extra1 <> extra2)

instance (Monoid extraThing, Monoid a) =>
Monoid ((Also extraThing) a) where

mempty = Also mempty mempty

OrInstead otherThing is a functor in which, instead of having a value, can actually just have some totally unrelated otherThing instead.

When you combine stuff with (<*>) or (<>), all of the values need to be present. If any of them are the otherThing instead, then the whole expression evaluates to the combination of the otherThings.

-- A normal value

-- Some totally unrelated other thing

deriving (Eq, Functor, Show)

The possibility of having an otherThing obstructs this functor’s ability to be applicative, much like the extra thing in Also extraThing does. In this case, since we do not need an empty value for the otherThing, it needs only a semigroup to be in compliance.

instance Semigroup otherThing =>

instance (Semigroup otherThing, Semigroup a) =>

instance (Semigroup otherThing, Monoid a) =>

OrInsteadFirst otherThing looks a lot like OrInstead otherThing, but it manages to always be an applicative functor — and even a monad too — by handling the otherThings a bit more hamfistedly.

When you combine stuff with (<*>) or (<>), all of the values need to be present. If any of them are the otherThing instead, then the whole expression evaluates to the first otherThing encountered, ignoring any additional otherThings that may subsequently pop up.

-- A normal value

-- Some totally unrelated other thing

deriving (Eq, Functor, Show)

NotInsteadFirst a  >>= f = f a

instance (Semigroup otherThing, Semigroup a) =>

instance (Semigroup otherThing, Monoid a) =>

Determined-by-parameter

DeterminedBy parameter is a value that… well, we’re not really sure what it is. We’ll find out once a parameter is provided.

The mechanism for deciding how the value is determined from the parameter is opaque; all you can do is test it with different parameters and see what results. There aren’t even Eq or Show instances, which is annoying.

data DeterminedBy parameter a =
Determination ((->) parameter a)
deriving Functor

instance Applicative (DeterminedBy parameter) where

pure a = Determination (\_ -> a)

Determination f <*> Determination a =
Determination (\x -> f x (a x))

Determination fa >>= ff =
Determination (\x ->
let Determination f = ff (fa x)
in  f x)

instance Semigroup a =>
Semigroup ((DeterminedBy parameter) a) where

Determination f <> Determination g =
Determination (\x -> f x <> g x)

instance Monoid a =>
Monoid ((DeterminedBy parameter) a) where

mempty = Determination (\_ -> mempty)

Footnotes

LiftedButWhy is Identity.

OrNot is Maybe, but with the monoid that is appropriate for its applicative.

Two doesn’t have an analogue in any standard library as far as I know.

AnyNumberOf is ZipList, with the appropriate semigroup added.

OneOrMore is like NonEmpty, but with instances that match ZipList.

Also is (,) — also known as the 2-tuple.

OrInstead is AccValidation from the validation package.