Testing functions that return other functions

  • I have a function (myfun/1) that takes in a list of characters, and depending on the characters in the list, returns a list of named functions (that are defined in the same module)–which will be applied at a later time.
Enum.reduce(com_chars, [], fn x, acc ->
  case x do
    "." -> [&to_lowercase/1 | acc]
    "^" -> [&to_uppercase/1 | acc]
    _ -> [:error | acc]
|> Enum.reverse()
  • when I test this function in ExUnit (after importing MyMod) with assert myfun([".", "^"]) == [&to_lowercase/1, &to_uppercase/1], the test fails for the following reasons:
    1. in the test, &to_lowercase/1 and &to_uppercase/1 are expanded to &MyMod.the_function/1
    2. myfun seems to return a list of lambdas and not the named functions: [#Function..., #Function...]
  • I can get around this if I use fully qualified names in myfun, however this does not work if I pass in a function with a set argument, like &get_slice(&1, "[0-5]"). In this case the function shows up as a lambda on both sides of the assert (and not the same lambda either).

My question is: how exactly should I be testing functions that return other functions?

I think perhaps instead of returning a real function you could return an atom that you later use apply with or even just pattern match and call the right function directly. If you need to have values included you could return a tuple of {:function_atom, [list, of, args]}.

1 Like

That’s a little unfortunate; to only be able to test at the cost of readability.

On the other hand, tuples like {module, function, arguments} are very idiomatic ways in Elixir (and Erlang) to pass around functions. They even have their own type (mfa, for module function arguments).


Function references aren’t compared by value or which function do they point at so you’re out of luck here.

I’d also recommend you don’t return direct function references but rather a structure that describes how to call the function later. A MFA would indeed be perfect as @lucaong said, and they can easily be compared with each other where the same module/function/arguments combo will compare equal to another identical combo.