Anonymous functions equality comparison

Function.info can do that.

you sound like you know what you’re doing, but i feel like asking what you’re trying to accomplish anyway

Thank you!

At this point, I’m trying to understand how it works precisely so that I take into account all that is important when I transpile anonymous functions to JS (I work on Hologram: Hologram - full stack isomorphic Elixir web framework)

Initially, I thought that I would need this information for comparisons and decoding back JS to Elixir, but it looks like it won’t be required since it seems that each anonymous function “instance” is treated as a separate entity (so two anonymous functions will never be equal).

I’m trying to confirm this, so please let me know if you think that’s not the case.

Two anonymous functions are equal if they were created from the same definition (same fn ... statement) in the same module (same checksum), and have the exact same environment variables.

Funs defined in the shell satisfy the first two as long as their arity is the same, but differ in the latter as they’re interpreted by the shell which drags in a ton of stuff to their environment. If you want consistent results please try this with compiled modules instead.

By “environment variables” do you mean the variables captured in the closure of this anonymous function?

Using the following compiled code:

defmodule MyModule do
 def fun_1 do
   fn x -> x end
 end

 def fun_2 do
   fn x -> x end
 end

 def compare_1 do
   ((fn x -> x end) == (fn x -> x end)) |> IO.inspect()
 end

 def compare_2 do
   (fn x -> x end) |> Function.info() |> IO.inspect()
   (fn x -> x end) |> Function.info() |> IO.inspect()
   :ok
 end
end

iex -S mix:

iex> MyModule.fun_1() |> Function.info()
[
  pid: #PID<0.252.0>,
  module: MyModule,
  new_index: 0,
  new_uniq: <<93, 38, 53, 241, 226, 42, 107, 201, 80, 47, 228, 61, 192, 123,
    202, 1>>,
  index: 0,
  uniq: 48837039,
  name: :"-fun_1/0-fun-0-",
  arity: 1,
  env: [],
  type: :local
]

iex> MyModule.fun_2() |> Function.info()
[
  pid: #PID<0.252.0>,
  module: MyModule,
  new_index: 1,
  new_uniq: <<93, 38, 53, 241, 226, 42, 107, 201, 80, 47, 228, 61, 192, 123,
    202, 1>>,
  index: 1,
  uniq: 48837039,
  name: :"-fun_2/0-fun-0-",
  arity: 1,
  env: [],
  type: :local
]

iex> MyModule.compare_1()
false

iex> MyModule.compare_2()
[
  pid: #PID<0.251.0>,
  module: MyModule,
  new_index: 2,
  new_uniq: <<122, 234, 246, 244, 241, 108, 55, 10, 70, 250, 99, 174, 106, 44,
    101, 226>>,
  index: 2,
  uniq: 64444343,
  name: :"-compare_2/0-fun-0-",
  arity: 1,
  env: [],
  type: :local
]
[
  pid: #PID<0.251.0>,
  module: MyModule,
  new_index: 3,
  new_uniq: <<122, 234, 246, 244, 241, 108, 55, 10, 70, 250, 99, 174, 106, 44,
    101, 226>>,
  index: 3,
  uniq: 64444343,
  name: :"-compare_2/0-fun-1-",
  arity: 1,
  env: [],
  type: :local
]
:ok

Looks like the functions will always differ at least in new_index or index (?)

Yes.

Yes, because you’re consistently comparing different definitions. Different fn ... end statements yield different funs. If you were to compare the result of fun_1 to the result of another invocation of fun_1, they would compare equal.

I think I understand, thank you!

There is no way to have semantic equality for anonymous functions. However, if you want to compare functions you’ve defined in your project, it can be achieved by metaprogramming.

Plus, there is always a space for fetching debug_info from beam files, transpiling AST, performing context checks, checking captured variables, etc. But that’s a lot of job to do