Monads and Maybes in elixir

possibly.ex

defprotocol Functor do
  def fmap(data, func)
end

defprotocol Applicative do
  def pure(data)
  def run(wrapped_func, data)
end

defprotocol Monad do
  def bind(ma, func)
end

defmodule Maybe do
  defstruct id: :nothing, value: nil

  def just(value) do
    %Maybe{id: :just, value: value}
  end

  def nothing(_value \\ nil) do
    %Maybe{id: :nothing}
  end
end

defimpl Monad, for: Maybe do
  import Maybe

  def bind(%Maybe{id: :nothing}, _func), do: nothing
  def bind(%Maybe{id: :just, value: val}, func) do
    func.(val)
  end
end

defimpl Applicative, for: Maybe do
  import Maybe
  import Functor

  def pure(f), do: just(f)

  def run(%Maybe{id: :nothing}, _), do: nothing
  def run(%Maybe{id: :just, value: f}, something) do
    fmap(something, f)
  end
end

defimpl Functor, for: Maybe do
  import Maybe

  def fmap(%Maybe{id: :just, value: value}, func) do
    just func.(value)
  end

  def fmap(%Maybe{id: :nothing}, _f) do
    nothing
  end
end

defimpl String.Chars, for: Maybe do
  def to_string(%Maybe{value: value}), do: "#{value}"
end

defmodule Possibly do
  import Maybe
  import Functor
  import Applicative
  import Integer
  import Monad

  def main do
    just(20)
    |> bind(&half/1) # => just 10
    |> bind(&half/1) # => just 5
    |> bind(&half/1) # => nothing
    |> bind(&half/1) # => nothing
  end

  def half(x) do
    if is_even(x) do
      just(round(x/2))
    else
      nothing
    end
  end
end


Possibly.main # => nil