Elixir - passing function parameter through

Question

Say I have a function, that's slightly verbose and is called with the same arguments each time, this function is also required a lot to do some setup before any other functions from that module can be called within its callback.

SomeMod.called_a_lot(‘xx’, fn(y) ->
  SomeMod.needs_called_a_lot_to_be_called_first(‘do_stuff’)
end)

I imagine that I can wrap it like so:

defp easier_to_call(func) do
  SomeMod.called_a_lot(‘xx’, fn(y) -> func(y) end
end

then use it like so:

easier_to_call(fn(y) ->
  SomeMod.needs_called_a_lot_to_be_called_first(‘do_stuff’)
end)

How does one actually do this in Elixir?

Your code looks fine; just change func(y) to func.(y) since it's an anonymous function. — Dogbert
– Dogbert, Commented May 9, 2017 at 19:09

cpjolicoeur · Accepted Answer · 2017-05-09 20:43:20Z

3

Your syntax is just a bit off for calling anonymous functions. You will need to use

func.(y)

instead of

func(y)

since it is an anonymous function.

See the Elixir Crash Course for a brief example.

answered May 9, 2017 at 20:43

cpjolicoeur

13.1k7 gold badges50 silver badges60 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Azolo · Accepted Answer · 2017-05-09 23:08:01Z

2

I don't really understand what exactly you're asking, but I feel like the capture operator (&) is what you're looking for.

An example use would be:

easier_func = &SomeMod.called_a_lot(‘xx’, &1)

easier_func.(fn(_y) ->
  SomeMod.needs_called_a_lot_to_be_called_first(‘do_stuff’)
end)

With &1 being the first parameter in the anonymous function.

If you need a multiple arity anonymous function then you can do:

easy_reduce = &Enum.reduce(&1, 0, &2)

easy_reduce.([1,2,3,4], fn(x, acc) -> acc + x end) # => 10

answered May 9, 2017 at 23:08

Azolo

4,3831 gold badge25 silver badges31 bronze badges

Comments

Alvin Lindstam · Accepted Answer · 2017-05-09 20:42:47Z

1

Dogbert's comment is correct. But since you don't modify the arguments, you could just pass the function on without wrapping it in an anonymous function:

defp easier_to_call(func) do
  SomeMod.called_a_lot(‘xx’, func)
end

answered May 9, 2017 at 20:42

Alvin Lindstam

3,16218 silver badges28 bronze badges

Comments

Aleksei Matiushkin · Accepted Answer · 2017-05-10 06:37:02Z

1

Just to show another approach: it might be achieved with macro, that calls the function to be called first and then calls the block:

defmodule Test do
  defmacro with_prepended(arg, do: block) do
    quote do
      IO.inspect(unquote(arg), label: "In function")
      prepended(unquote(arg))
      unquote(block)
    end
  end
end

defmodule Tester do
  require Test

  defp prepended(arg), do: IO.inspect(arg, label: "In prepended")

  def fun(arg) do
    Test.with_prepended(arg) do
      IO.puts "Actual code"
    end
  end
end

Tester.fun(42)

#⇒ In function: 42
#⇒ In prepended: 42
#⇒ Actual code

answered May 10, 2017 at 6:37

Aleksei Matiushkin

121k12 gold badges109 silver badges173 bronze badges

Collectives™ on Stack Overflow

Elixir - passing function parameter through

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related