(FunctionClauseError) no function clause matching in anonymous fn/1

defmodule Sandbox do
  def currencies do
    [
      %{
        "USD" => %{
          asset: "USD",
          exchange_currencies: ["JPY"],
          priced_in: "KHR"
        }
      },
      %{
        "CVE" => %{
          asset: "CVE",
          exchange_currencies: ["JPY"],
          priced_in: "KHR"
        }
      },
      %{
        "CVE" => %{
          asset: "CVE",
          exchange_currencies: ["KHR", "JPY"],
          priced_in: "USD"
        }
      },
      %{
        "AUD" => %{
          asset: "AUD",
          exchange_currencies: ["JPY"],
          priced_in: "KHR"
        }
      },
      %{
        "AUD" => %{
          asset: "AUD",
          exchange_currencies: ["KHR", "USD", "JPY", "ZAR"],
          priced_in: "KRW"
        }
      },
      %{
        "AUD" => %{
          asset: "AUD",
          exchange_currencies: ["KHR", "JPY"],
          priced_in: "USD"
        }
      },
      %{
        "AUD" => %{
          asset: "AUD",
          exchange_currencies: ["KHR", "KRW", "LAK", "MGA", "XOF", "USD", "JPY", "AUD", "EUR"],
          priced_in: "ZAR"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["JPY"],
          priced_in: "KHR"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["KHR", "USD", "JPY", "ZAR"],
          priced_in: "KRW"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["JPY", "ZAR"],
          priced_in: "LAK"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["KHR", "USD", "ZAR"],
          priced_in: "MGA"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["KHR", "USD", "JPY", "ZAR"],
          priced_in: "XOF"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["KHR", "JPY"],
          priced_in: "USD"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["KHR", "KRW", "USD", "JPY", "ZAR"],
          priced_in: "AUD"
        }
      },
      %{
        "ZAR" => %{
          asset: "ZAR",
          exchange_currencies: ["LAK", "ZAR"],
          priced_in: "EUR"
        }
      },
      %{
        "MNT" => %{
          asset: "MNT",
          exchange_currencies: ["JPY"],
          priced_in: "KHR"
        }
      }
    ]
  end

  def foo do
    currencies = currencies()

    Enum.map(currencies, fn {_asset, record} -> record end)
  end

  def bar do
    data = %{"USD" => %{asset: "USD", exchange_currencies: ["JPY"], priced_in: "KHR"}}

    Enum.map(data, fn {_asset, record} -> record end)
  end
end
iex(1)> Sandbox.bar
[%{asset: "USD", exchange_currencies: ["JPY"], priced_in: "KHR"}]
iex(2)> Sandbox.foo
** (FunctionClauseError) no function clause matching in anonymous fn/1 in Sandbox.foo/0    
    
    The following arguments were given to anonymous fn/1 in Sandbox.foo/0:
    
        # 1
        %{"USD" => %{asset: "USD", exchange_currencies: ["JPY"], priced_in: "KHR"}}
    
    (arbit 0.1.0) lib/Sandbox.ex:122: anonymous fn/1 in Sandbox.foo/0
    (elixir 1.10.3) lib/enum.ex:1396: Enum."-map/2-lists^map/1-0-"/2

Why exactly does Sandbox.foo fail but Sandbox.bar succeed? How shouldSandbox.foo be corrected for it to succeed as well?

foo's calls Enum.map list of maps, but the anonymous function pattern matches on the argument as if it were a tuple. The tuple pattern doesn’t match the map, so it crashes.

You’ll need to remove the tuple pattern for this not to crash.

  def foo do
    currencies = currencies()

    Enum.map(currencies, fn map -> do_something_with(map) end)
  end
2 Likes
  def foo do
    currencies = currencies()

    Enum.map(currencies,
      fn record
      ->
        asset =
        Map.keys(record)
        |> List.first

        Map.get(record, asset)
        |> Map.get(:exchange_currencies)
     end)
  end
iex(1)> Sandbox.foo
[
  ["JPY"],
  ["JPY"],
  ["KHR", "JPY"],
  ["JPY"],
  ["KHR", "USD", "JPY", "ZAR"],
  ["KHR", "JPY"],
  ["KHR", "KRW", "LAK", "MGA", "XOF", "USD", "JPY", "AUD", "EUR"],
  ["JPY"],
  ["KHR", "USD", "JPY", "ZAR"],
  ["JPY", "ZAR"],
  ["KHR", "USD", "ZAR"],
  ["KHR", "USD", "JPY", "ZAR"],
  ["KHR", "JPY"],
  ["KHR", "KRW", "USD", "JPY", "ZAR"],
  ["LAK", "ZAR"],
  ["JPY"]
]

Thanks for the insight. As refactored, Sandbox.foo doesn’t seem to be efficient nor idiomatic. What’s a better approach?

currencies returns an unusual shape - a list of maps, each with exactly one key. I’d typically expect either a map of currency name -> some value, or a list of tuples ready for List.keyfind if the order is important.

BUT

I also see that the values in currencies don’t have unique keys ("AUD" appears more than once, for instance). What’s the intent of these separate records? That might suggest a better data structure.

3 Likes

It’s fairly idiomatic and relatively efficient, but you might be surprised by the behaviour.

Maps are not ordered so the one you get from List.first will be semi-random depending on how many keys are in the map. If this is ok (i.e. if the map only has one key) then that is not a problem.

2 Likes

Thanks for your input :slight_smile:

So here’s the workflow:

  1. Compile a list of currencies ( C ).
  2. For each currency in C create a record consisting of the following key/value pairs: currency name, exchange rate into some universal currency, its value in that universal currency. Aggregate these results into a new list (V).
  3. For each currency in V compile a list of currencies it can be exchanged into along with their exchange rates. (E)
  4. For each currency in E create a record with the following key/value pairs: its name, its exchange rate into the universal currency used in C, its value in terms of that universal currency. Aggregate these results into a new list F.
  5. Compare the value of each currency in V (initial_value) against the value of each of its corresponding exchange currencies in F (final_value). When final_value is greater than initial_value, add initial_value and final_value records to a new list R.

What data structure(s) would you recommend for this workflow?

Nothing special here. You could use atoms for currency names, but that makes things more complicated when interacting with other systems.

all_currencies = ["AUD", "CVE", "USD"]

I’ve bolded the key words that suggest the data structure, a list of maps:

currencies = [
    %{name: "USD", exchange_rate: 1.23, value: 0.87},
    %{name: "CVE", exchange_rate: 1.75, value: 0.75},
    %{name: "AUD", exchange_rate: 1.01, value: 0.99}
  ]

The numbers here are written as floats, but that may not be what you want. Consider the Decimal library for doing financial arithmetic.

“Record” could also be satisfied with a defstruct (or an Erlang record if you’re feeling exotic).

Looking up a record is spelled Enum.find(currencies, & &1.name == "USD"). If the code does this a lot, consider making a map out of currencies:

currencies_map = Map.new(currencies, fn v -> {v.name, v} end)
  exchange_rates = %{
    "AUD" => %{"USD" => 1.14, "CVN" => 1.2},
    # OR, if an exchange rate is more complicated than just a number
    "USD" => %{"CVN" => %{rate: 0.67, quote_id: 1234}, "AUD" => %{rate: 1.06, quote_id: 4567}}
  }

The benefit of using nested maps here is that looking up an exchange rate is spelled exchange_rates[source_currency][destination_currency].

If there is more than one exchange rate for a given currency pair, this approach will not work. Consider using lists for that case.

exchanged_values =
  exchange_rates
  |> Map.new(fn {src_currency, dest_currencies} ->
    {
      src_currency,
      Map.new(dest_currencies, fn {dest_currency, exchange_rate} ->
        # do something with src_currency, dst_currency, and exchange_rate
        # probably look things up in currencies
        result = %{
          name: dst_currency, # or "#{src_currency} -> #{dst_currency}"
          exchange_rate: ... # calculate this
          value: ... # and this
        }

        {dest_currency, result}
      end
    }
  end

This results in a new map of maps; exchanged_values[source_currency][dest_currency] is a map just like the ones in currencies.

That last part about adding initial and final values to the same list seems tricky; how do consumers of R know how to interpret the {name: ..., exchange_rate:..., value:...} results?

One option would be to have R contain tuples:

exchanged_values
|> Enum.flat_map(fn {src_currency, dest_currencies} ->
  dest_currencies
  |> Enum.map(fn {dest_currency, final_value} ->
    # get initial_value for dest_currency from currencies
    {initial_value, final_value}
  end)
  |> Enum.filter(fn {initial_value, final_value} ->
    # decide if record should be included or not
  end)
end)

This uses Enum.flat_map for two reasons:

  • we’re building a list, but a single key of the input may return many values
  • some keys in the input may return NO values
1 Like

Here’s a crude attempt: https://defuse.ca/b/ZqUSguft

It’s ugly, I know . . .

What improvements do you suggest?