Passing anonymous function as plug option

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?

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.

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.

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.

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?

The ability to include extra arguments

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?

&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.

Understood, thank you!