Blog Post: Elixir for JavaScript developers: first impressions

maybe I’m missing the point, but

def reverse_sentence(sentence) do
  sentence |> String.split() |> Enum.reverse() |> Enum.join(" ")
end

and if reverse is the point and you do not want to use stdlib

defp reverse([]), do: []
defp reverse([word | rest]), do: reverse(rest) ++ [word]

Also, you should check you code, as it is not correct.
Elixir has the great ExUnit and mix test.

@Sebb your solution has a downside in that it’s going to be slow on larger inputs.
You’re appending to a list which becomes expensive on big lists

Sure, if you want speed use Enum.
But I do not think my solution would be slower, because of the Enum.at.
But memory usage will be bad with my solution.

This will be way better:

defp reverse2([], result), do: result
defp reverse2([word | rest], result) do
  reverse2(rest, [word | result])
end

Unfortunately that’s not true, but I like your dreams.

Enum was added to provide generic API for every Enumerable. If I’m not wrong some optimizations were even rejected on GitHub. Even if Enum would have every optimization there is still one extra call for Enumerable implementation. Since the post is for Elixir newbies we should avoid going this topic too long.

In mentioned post I have added a comment with both reduce and fast implementations. If we want to do it really fast we should only use pattern matching and recursion, for example:

defmodule Example do
  # function head with default arguments as described in article
  # `?\s` or `?\ ` returns a codepoint of space
  def sample(string, separator \\ ?\s, word \\ "", acc \\ "")

  # we simply pattern match if
  # current input, word (characters joined so far) and acc (words joined so far)
  # are empty which is true only if
  # the whole string is empty or contains only separator characters
  def sample("", _separator, "", ""), do: ""

  # when we reached end of input string
  # the only thing left is to join last word with our accumulator
  # Note: acc is common naming and short version of accumulator
  def sample("", separator, word, acc), do: <<word::binary, separator::utf8, acc::binary>>

  # trimming goes here
  # we simply pattern match checking if next 2 characters are our separator
  # in such case the function calls itself with only one separator
  def sample(<<separator::utf8, separator::utf8, rest::binary>>, separator, word, acc) do
    sample(<<separator::utf8, rest::binary>>, separator, word, acc)
  end

  # pattern matching for last separator after recent word (see clasule above)
  # in this case we do not want to have trailing separator
  # so we change our empty acc to the first word
  def sample(<<separator::utf8, rest::binary>>, separator, word, "") do
    sample(rest, separator, "", word)
  end

  # same as above, but with non empty acc
  # notice we reset the word after we set/add it to acc
  def sample(<<separator::utf8, rest::binary>>, separator, word, acc) do
    sample(rest, separator, "", <<word::binary, separator::utf8, acc::binary>>)
  end

  # this simple function clasule collects all characters that are not separator
  # and adds it to word parameter
  def sample(<<char::utf8, rest::binary>>, separator, word, acc) do
    sample(rest, separator, <<word::binary, char::utf8>>, acc)
  end
end

Edit: Oh, for those newbies confused with too many solutions I would recommend to give benchee a try. With just few lines we can determine which solutions is faster.

Nice article, but you might want to edit this:

Elixir, also known as Phoenix/LiveView, the most loved web framework

which is just not quite true. You probably meant something more like

Elixir, probably best known as the language behind Phoenix/LiveView, the most loved web framework in the StackOverflow 2022 survey …

It will at least be magnitudes faster than the version provided in the article and my recursive version. Hopefully also significantly faster than the tail-recursive reverse2 … or is it?

I’ll look into those with Benchee as you suggested.