See FunLand.Applicative.apply_discard_left/2.

See FunLand.Applicative.apply_discard_right/2.

Something is Appliable if you can apply one of it (containing one or multiple functions) with another.

Appliable is mostly born out of the needs to apply a function that is already wrapped in a Mappable:

• If you had a bare function, you could use Mappable.map/2 to apply it over a Mappable.
• If however, you have a function already inside a Mappable, a new operation has to be defined to apply it over a Mappable (of the same kind).

This operation is called apply_with/2.

‘a function inside a Mappable’ is something that happens when you partially apply functions, which isn’t that common in Elixir because functions are not automatically curried.

Currying and Partial Application

As apply_with works only applies a single argument per function at a time, it works the best when used with curried functions. In Elixir, functions are no curried by default. Fortunately, there exists the Currying library, which transforms your normal functions into curried functions.

If you want to be able to use Applicative to its fullest potential, instead of calling fun.(b) in your implementation, use Currying.curry(fun).(b)

To be Appliable something also has to be Mappable. To make your data structure Appliable, use use Appliable in its module, and implement both Appliable’s apply_with/2 and Mappable’s map/2.

Fruit Salad Example

Say we have a bowl with a partiall-made fruit-salad. We have a second bowl, which contains some (peeled) bananas.

We would like to add these bananas to the fruit salad.

This would be easy if we had our partially-made fruit-salad, as we could just map the ‘combine a banana with some fruit salad’ operation over the bowl of bananas.

However, we don’t ‘just’ have the partially-made fruit-salad, as this would make a big mess of our kitchen countertop. In fact, it is very likely that this bowl-with partially-made fruit salad was the result of combining (mapping) earlier ingredients in bowls.

So, we need something similar to map, but instead of taking ‘just’ an operation, we use a bowl with that operation.

For the fruit salad bowl, we could define it as ‘take some fruit-salad from Bowl A, combine it with a banana in Bowl B. -> repeat until bananas and fruit-salad are fully combined’.

This is called apply_with. Note that, because the part that changes more often is the Appliable with the (partially-applied) function (in other words: The bowl with the partially-made fruit salad), the parameters of this functions are the reverse of Mappable.map.

In Other Environments

• In Haskell, Appliable.apply_with is known by the uninformative name ap, often written as <$>.
• In Category Theory, something that is Appliable is called an Apply.

Callback implementation for FunLand.Appliable.apply_with/2.

Callback implementation for FunLand.Chainable.chain/2.

This is called internally whenever a YourMonad.chain() operation fails.

For most monads, the default behaviour of crashing is great. For some, you might want to override it.

This should return the Module name of the Combinable that should be used as the logging part of this Writer monad.

This module’s empty value is used when a new instance of this Writer monad is made using wrap/0, and combine is used whenever the Writer’s apply_with/2 or chain/2

Callback implementation for FunLandic.Writer.log_combinable_module/0.

Free implementation new Mappable.map as FunLandic.IOListWriter is Applicative

Allows you to write multiple consecutive operations using this monad on new lines. This is called ‘monadic do-notation’.

For more info, see FunLand.Monad.monadic

Rules:

1. Every normal line returns a new instance of the monad.
2. You can write x <- some_expr_returning_a_monad_instance to bind x to whatever is inside the monad. You can then use x on any subsequent lines.
3. If you want to use one or multiple normal statements, use let something = some_statement or let something = do ...

The final line is of course expected to also return an instance of the monad. Use new at any time to new a value back into a monad if you need.

Inside the monadic context, the module of the monad that was defined is automatically imported. Any local calls to e.g. new, apply, chain or functions you’ve defined yourself in your monad module will thus be called on your module.