Need help with a 'required' macro

saleyn

Is there a way to create a macro called required that could be used like this:

with required(var) <- Map.get(map, key) do
  var
else
  nil -> raise RuntimeError
end

I tried something like this, but it doesn’t work:

defmacro required(var) do
  quote do
    unquote(var) when not is_nil(var)
  end
end

4 comments

#macros #defmacro

0 655 4

2022-05-19 02:27:36 UTC

Showing Posts 1 to 4

Show Best Posts
Show All (oldest first)
Show All (newest first)

kip

ex_cldr Core Team

I don’t think a macro can return just the match part of a with (but happy to be wrong). Nevertheless, this looks more complex that the use case demands. Map.fetch!/2 does basically the same thing:

iex> Map.fetch!(%{a: "a"}, :a)
"a"
iex> Map.fetch!(%{a: "a"}, :b)
** (KeyError) key :b not found in: %{a: "a"}
    (stdlib 4.0) :maps.get(:b, %{a: "a"})

so you could simply:

with value <- Map.fetch!(map, key) do
  do_something()
end

Even in this case, its not very idiomatic since with’s value is to program “happy path” and therefore the with seems redundant in this example and the following would be the simplest:

var = Map.fetch!(%{a: "a"}, :a)

Post #1

saleyn

While Map.fetch!/2 is a viable option for simple cases, consider:

def some_fun(map) do
  with \
    {:ok, param1} <- wrap(map, :param1), 
    {:ok, param2} <- wrap(map, :param2),
    ...,
    {:ok, paramN} <- wrap(map, :paramN)
  do
    ...
  end
  ...
end

def wrap(map, param) do
  case Map.get(map, param) do
    nil -> {:error, :badarg}
    val -> {:ok, val}
  end
end

If we wanted to get rid of the wrapper, we could do:

def some_fun(map) do
  with \
    p1 when not is_nil(p1) <- Map.get(map, :param1), 
    p2 when not is_nil(p2) <- Map.get(map, :param2),
    ...,
    pN when not is_nil(pN) <- Map.get(map, :paramN)
  do
    ...
  else
    nil -> {:error, :badarg}
  end
  ...
end

But wouldn’t it be nice to be able to do:

def some_fun(map) do
  with \
    required(p1) <- Map.get(map, :param1), 
    required(p2) <- Map.get(map, :param2),
    ...,
    required(pN) <- Map.get(map, :paramN)
  do
    ...
  else
    nil -> {:error, :badarg}
  end
  ...
end

Maybe there is a way to come up with such a required/1 macro that would only add a single when guard to the AST?

Post #2

keep_zen

In the FP, there is a functor named Maybe.
I think Maybe can replace the with.
Like:

defmodule Fp do
   def maybe_of({:ok, v}), do: {:maybe, v}
   def maybe_of({:error, _}=v), do: v
   def maybe_of(v), do: {:maybe, v}
  
  def map({:error, v}, onError: handler) do
     (not v && handler.(v)) |> maybe_of()
  end
  def map({:maybe, v},fun) do
     (v && fun.(v) || v)
    |> maybe_of()
  end
 def map({:maby, v}, fun) do
    (v && fun.(v))
   |> maybe_of()
 end
end
Map.get(map, :field_name)
|> Fp.maybe_of()
|> Fp.map(step1)
|> Fp.map(step2)
|> Fp.map(onError: errorHanlder)

Post #3

kip

ex_cldr Core Team

Perhaps I’m missing something, but this is very similar (but not the same) to:

  with \
    {:ok, p1} <- Map.fetch(map, :param1), 
    {:ok, p2} <- Map.fetch(map, :param2),
    ...,
    {:ok, pn} <- Map.fetch(map, :paramN)
  do
    ...
  end

The difference being that if the key exists and its value is nil then it will still pass unlike your example. Normally when I see use cases like “required” its a data validation case and changesets become a good tool of choice.

Post #4

— All posts loaded —