What are Monads?

OvermindDL1 · October 4, 2017, 4:11pm

Not a clue, at work, I can rarely watch video’s in general thus I tend to need text. ^.^;

Lol, all good.

I was curious about implementing the monad pattern in elixir so I went ahead and did so in a new playground

Monad definition:

OvermindDL1/ex_core/blob/master/lib/ex_core/monad.ex#L2-L26


      
          defprotocol_ex ExCore.Monad, as: monad do
            require ExCore.StreamDataGenerator
          
            def wrap(value, monad)
            def flat_map(monad, fun) when is_function(fun, 1)
          
            deftest neutrality do
              generator = ExCore.StreamDataGenerator.generator(Any, [])
              ident_wrap = &wrap(&1, nil)
              StreamData.check_all(generator, [initial_seed: :os.timestamp()], fn v ->
                wrap(v, nil) === flat_map(wrap(v, nil), ident_wrap) && {:ok, v} || {:error, v}
              end)
            end
          
            deftest succession_ordering do
              generator = ExCore.StreamDataGenerator.generator(ExCore.Monad, __MODULE__, [])
              f = fn x -> wrap({x, 1}, nil) end
              g = fn {x, 1} -> wrap(x, nil) end
              StreamData.check_all(generator, [initial_seed: :os.timestamp()], fn v ->
                if flat_map(flat_map(wrap(v, nil), f), g) === flat_map(wrap(v, nil), fn x -> flat_map(f.(x), g) end) do

This file has been truncated. show original

Monad implementations for list/map/okerrortuples:

github.com

OvermindDL1/ex_core/blob/master/lib/ex_core/monad/implementations.ex#L5-142


      
          import ProtocolEx
          
          ## List
          
          defimpl_ex EmptyList, [], for: ExCore.Monad do
            @priority 65535
          
            defmacro wrap(value, monad_type) do
              quote generated: true do
                _ = unquote(monad_type)
                [unquote(value)]
              end
            end
          
            defmacro flat_map(empty_list, fun) do

And the tests (it already has it’s own built-in tests via deftest but here are explicit ones too to show usage):

github.com

OvermindDL1/ex_core/blob/master/test/ex_core/monad_test.exs#L6-L49


      
          test "List" do
            assert [42] == Monad.wrap(42, [])
            assert [1, 1, 2, 2, 3, 3] = Monad.flat_map([1,2,3], &[&1, &1])
            assert [1, 2, 3, 6] =
              [1, 2, 3, 4]
              |> Monad.flat_map(fn x when rem(x, 2) === 1 -> [x]; _ -> [] end)
              |> Monad.flat_map(&[&1, &1 * 2])
          end
          
          test "Map" do
            assert %{a: 42} = Monad.wrap({:a, 42}, %{})
            assert %{:a => 1, :b => 2, 1 => :a, 2 => :b} =
              Monad.flat_map(%{a: 1, b: 2}, fn {key, value} -> %{key => value, value => key} end)
            assert %{:b => 4, 4 => :b} =
              %{a: 1, b: 2}
              |> Monad.flat_map(fn {_key, 1} -> %{}; {key, value} -> %{key => value * 2} end)
              |> Monad.flat_map(fn {key, value} -> %{key => value, value => key} end)
          
            # But not structs
            assert_raise(ProtocolEx.UnimplementedProtocolEx, fn -> Monad.wrap({:a, 42}, %ArgumentError{}) end)

This file has been truncated. show original