So I wrote the following simple Elixir script that uses benchee. I did not give it much thought to be honest. Let me know what you think.

TLDR; Performance for both approaches indeed seem to be equivalent.

Script

defmodule Test do
  @numbers Range.to_list(1..1000)

  def work(input, fun) do
    Enum.map(input, fun)
  end

  for number <- @numbers do
    def do_work_generated(unquote(number)), do: unquote(number)
  end

  def do_work_guards(number) when number in @numbers, do: number
end

Mix.install([:benchee, :benchee_markdown])
list_of_random_numbers = fn -> Enum.map(1..500_000, fn _ -> :rand.uniform(1000) end) end

inputs =
  list_of_random_numbers
  |> Stream.repeatedly()
  |> Stream.take(5)
  |> Stream.with_index()
  |> Stream.map(fn {numbers, idx} -> {"Batch #{idx + 1}", numbers} end)

Benchee.run(
  %{
    "Generated Functions" => fn input -> Test.work(input, &Test.do_work_generated/1) end,
    "Guards" => fn input -> Test.work(input, &Test.do_work_guards/1) end
  },
  memory_time: 60,
  inputs: inputs,
  formatters: [
    {Benchee.Formatters.Markdown, file: "BENCHMARK.md"},
    Benchee.Formatters.Console
  ]
)

Output

Configuration

Benchmark suite executing with the following configuration:

Statistics

Input: Batch 1

Run Time

Run Time Comparison

Memory Usage

Input: Batch 2

Run Time

Run Time Comparison

Memory Usage

Input: Batch 3

Run Time

Run Time Comparison

Memory Usage

Input: Batch 4

Run Time

Run Time Comparison

Memory Usage

Input: Batch 5

Run Time

Run Time Comparison

Memory Usage

in/2 doesn’t compile to an Enum.member?/2 call when used in a guard:

https://hexdocs.pm/elixir/Kernel.html#in/2-guards

You can use GitHub - michalmuskala/decompile to take a look how things will look at lower levels.

This exact test case has nothing to do for “guards vs generated functions”

when x in 1..100 gets compiled into when x > 1 and x < 100, so it is just faster.

So, to answer the original question “Performance Question: guards vs. generated functions: which is faster?”: none is faster, both are a different tools used for different tasks. The task you’ve brought up in the original post is made up and is actually solved not by x in y guard or generated clauses, but just by x >= left and x <= right

Yeah it looks like the compiler is able to optimize better if facts are known at compile time.

But here’s something interesting: I have adapted the code a bit because eventually, I’m gonna be working with strings. And if we add binary pattern matching to the mix, performance seems to be different.

Side note: Reading the documentation of Kernel.in/2 I read the following:

However, this construct will be inefficient for large lists. In such cases, it is best to stop using guards and use a more appropriate data structure, such as MapSet.

I therefore added a test using MapSets (which, afaict, is equivalent to @al2o3cr’s test using is_map_key).

TLDR;

In this case, guards seem to make the race, being twice as fast as generated functions and 2.5x faster than MapSets

Test

defmodule Test do
  @chars Range.to_list(1000..1)
  @chars_map_set MapSet.new(1000..1)

  def work(input, fun) do
    Enum.map(input, fun)
  end

  for char <- @chars do
    def do_work_generated(<<unquote(char)::utf8>>), do: unquote(char)

    def do_work_generated(<<unquote(char)::utf8, rest::binary>>) do
      do_work_generated(rest)
    end
  end

  def do_work_guards(<<char::utf8>>) when char in @chars, do: char

  def do_work_guards(<<char::utf8, rest::binary>>) when char in @chars do
    do_work_guards(rest)
  end

  def do_work_mapset(<<char::utf8>>) do
    if MapSet.member?(@chars_map_set, char) do
      char
    else
      :error
    end
  end

  def do_work_mapset(<<char::utf8, rest::binary>>) do
    if MapSet.member?(@chars_map_set, char) do
      do_work_mapset(rest)
    else
      :error
    end
  end
end

Mix.install([:benchee, :benchee_markdown])

list_of_random_strings = fn ->
  Enum.map(1..500_000, fn _ ->
    for _ <- 1..10,
        into: "",
        do: <<Enum.random(Range.to_list(?0..?9) ++ Range.to_list(?A..?z))>>
  end)
end

inputs =
  list_of_random_strings
  |> Stream.repeatedly()
  |> Stream.take(5)
  |> Stream.with_index()
  |> Stream.map(fn {strings, idx} -> {"Batch #{idx + 1}", strings} end)

Benchee.run(
  %{
    "Generated Functions" => fn input -> Test.work(input, &Test.do_work_generated/1) end,
    "Guards" => fn input -> Test.work(input, &Test.do_work_guards/1) end,
    "MapSet" => fn input -> Test.work(input, &Test.do_work_mapset/1) end
  },
  memory_time: 60,
  inputs: inputs,
  parallel: 10,
  formatters: [
    {Benchee.Formatters.Markdown, file: "BENCHMARK_STRINGS.md"},
    Benchee.Formatters.Console
  ]
)

Output

Statistics

Statistics

Input: Batch 1

Run Time

Run Time Comparison

Memory Usage

Input: Batch 2

Run Time

Run Time Comparison

Memory Usage

Input: Batch 3

Run Time

Run Time Comparison

Memory Usage

Input: Batch 4

Run Time

Run Time Comparison

Memory Usage

Input: Batch 5

Run Time

Run Time Comparison

Memory Usage