Passing anonymous function as plug option

Phoenix Forum Questions / Help
, ,
1

I can’t seem to pass an anonymous function as an option to a Plug. I am using plug_hmouse which from the documentation takes an option digest that is a function to be called on a string. The example is provided below:

plug PlugHMouse,
  ... # other options
  digest: fn string -> Base.encode16(string) end

However when I try this in my router.ex, I get the following error:

router.ex

plug PlugHMouse,
  validate: {"x-hub-signature", webhook_secret},
  hash_algo: :sha,
  split_digest: true,
  digest: fn string -> Base.encode16(string, :lower) end

error

== Compilation error in file lib/spellcanary_web/router.ex ==
** (ArgumentError) cannot escape #Function<0.85932033 in file:lib/spellcanary_web/router.ex>. The supported values are: lists, tuples, maps, atoms, numbers, bitstrings, PIDs and remote functions in the format &Mod.fun/arity
    (elixir) src/elixir_quote.erl:122: :elixir_quote.argument_error/1
    (elixir) src/elixir_quote.erl:259: :elixir_quote.do_quote/3
    (elixir) src/elixir_quote.erl:421: :elixir_quote.do_quote_splice/5
    (plug) lib/plug/builder.ex:312: Plug.Builder.init_module_plug/4
    (plug) lib/plug/builder.ex:286: anonymous fn/5 in Plug.Builder.compile/3
    (elixir) lib/enum.ex:1940: Enum."-reduce/3-lists^foldl/2-0-"/3
    (plug) lib/plug/builder.ex:284: Plug.Builder.compile/3
    lib/spellcanary_web/router.ex:17: (module)
    (stdlib) erl_eval.erl:680: :erl_eval.do_apply/6
    (elixir) lib/kernel/parallel_compiler.ex:208: anonymous fn/4 in Kernel.ParallelCompiler.spawn_workers/6

I don’t get this error when passing &Base.encode16/1 but I do get it when using an anonymous function or when defining a function in my router and passing that, eg.

def encode16lower(string) do
  Base.encode16(string, :lower)
end

...
plug PlugHMouse,
  validate: {"x-hub-signature", webhook_secret},
  hash_algo: :sha,
  split_digest: true,
  digest: &self().encode16lower/1

I need the anonymous function since I want to add an extra argument to the function I’m calling. How can I get around this error?

1 Like
2

Module attributes can not contain anonymous functions. They may only contain a very strict subset of values. Whereas &Mod.fun/arit is one of these.

&self().encode16lower/1

self() does not return a module name, but a PID. Probably you meant __MODULE__.encode16lower/1?

3 Likes
3

Thanks NobbZ, the __MODULE__ tip fixed the error! I didn’t realise that calling plug would create a module attribute. For anyone reading this thread in future, the docs on Module attributes actually have some info on this.

3 Likes
4

I don’t really understand this. Having this same issue, not sure how to go about solving it. I want to be able to dynamically define redirect behaviour. What do you mean about the module attributes?

I have this plug:

  @moduledoc """
  Redirects the path to one location or another depending on handler return value.
  """

  def init(default), do: default

  def call(conn, opts) do
    handler = Keyword.fetch!(opts, :handler)

    destination = handler.(conn)

    Phoenix.Controller.redirect(conn, to: destination)
  end

But I can’t use it like expected:

get "/work", Plugs.Redirect, handler: fn conn -> nil end

Because I get the error cannot escape #Function<0.92307874/1 in :elixir_compiler_158.__MODULE__/1>. The supported values are: lists, tuples, maps, atoms, numbers, bitstrings, PIDs and remote functions in the format &Mod.fun/arity. Not quite sure what this is telling me and how I can solve it. For such simple implementations I try to keep the definition as close to the usage as possible to facilitate understanding, but not sure how I can do that if I can’t use an anonymous function.

5

The issue is that Plug pre-compiles the stack of plugs, so the init function is called at compile time and its result is stored in the compiled module.

As the error message states, that place can’t store anonymous functions.

The “standard idiom” for this situation is to use a tuple to specify a function by name (you’ll see the term “MFA tuple” a lot). Something like:

# in the plug
  def call(conn, opts) do
    {mod, fun, args} = Keyword.fetch!(opts, :handler)

    destination = apply(mod, fun, [conn | args])

    Phoenix.Controller.redirect(conn, to: destination)
  end

# in the config
get "/work", Plugs.Redirect, handler: {SomeModule, some_fun, []}

# the function definition
defmodule SomeModule do
  def some_fun(conn) do
    ...etc...
  end
end

If some_fun expects more than one argument, you’d include it in the tuple’s third element.

1 Like
6

Why can’t it store anonymous functions? Also, is ther a reason to prefer an MFA tuple over referencing the named function directly as in &SomeModule.some_fun/1?

7

The ability to include extra arguments

8

Can’t you already do that with the &SomeModule.other_fun(&1, other_arg) syntax for a function that accepts 2 arguments? Or are you meaning something else?

9

&SomeModule.other_fun(&1, other_arg) is a shorthand for fn x -> SomeModule.other_fun(x, other_arg) end and will trigger precisely the same problems as any other anonymous function.

Despite the similar notation, &SomeModule.other_fun/1 is represented differently internally.

1 Like
10

Understood, thank you!