See FunLand.Applicative.apply_discard_left/2.

See FunLand.Applicative.apply_discard_right/2.

Callback implementation for FunLand.Appliable.apply_with/2.

Callback implementation for FunLand.Chainable.chain/2.

Callback implementation for FunLand.Semicombinable.combine/2.

Callback implementation for FunLand.Combinable.empty/0.

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.

Free implementation new Mappable.map as FunLand.Builtin.List 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.

A structure is Applicative if it is Appliable, as well as having the ability to create a new structure from any value, by newping it.

Being able to create new, apply and map means that we can create new structures with some values, transform them and (partially or fully) apply them to each other.

Therefore, we're able to re-use all new our old operations in a new, more complex context.

Fruit Salad Example

We've already seen that a fruit-salad bowl is Mappable and Appliable.

However, we'd like to know how we start out: When we have an apple, how do we end up with a bowl filled with an apple?

Bowl.new(my_apple) is the implementation that answers this question.

Together with apply and map, we can now take arbitrary ingredients, put them in bowls and mix and mash them together to our liking, without soiling the kitchen's countertop:

• new: We can take an apple, and put it in a bowl: we put the apple in a new bowl to return a bowl with an apple.
• apply: If we have a bowl with a partially-made fruit-salad, and we have a bowl with an apple, we can take the apple and the partially-made fruit salad to create a bowl with a fruit-with-apples-salad.
• map: We can take a bowl with any fruit or salad, and do some arbitrary operation with it, such as 'blending'. In this example, we end up with the same bowl, but now filled with blended fruit-salad.

In Other Environments

• In Haskell, Applicative.new is known by pure as well as return.
• In Category Theory, something that is Applicative is know as its more official name Applicative Functor.

Callback implementation for FunLand.Applicative.new/1.

A variant of reduce that accepts anything that is Combinable as second argument. This Combinable will determine what the empty value and the combining operation will be.

Pass in the combinable module name to start with empty as accumulator, or the combinable as struct to use that as starting accumulator.

Callback implementation for FunLand.Reducable.reduce/3.

Converts the reducable into a list, by building up a list from all elements, and in the end reversing it.

This is an automatic function implementation, made possible because FunLand.Builtin.List implements the FunLand.Reducable behaviour.

An Example of using traverse:

iex> FunLand.Traversable.traverse([1, 2, 3], FunLandic.Maybe, fn x -> FunLandic.Maybe.just(x) end)
FunLandic.Maybe.just([1, 2, 3])
iex> FunLand.Traversable.traverse([1, 2, 3], [], fn x -> [x,x] end)
[[1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3], [1, 2, 3],
[1, 2, 3]]