How does implict return work in functions?

Not only does it have implicit return, there is no alternative, no return keyword in Elixir.

Functions in elixir (and erlang) always return some value. That value can be simply nil or :ok or whatever the output of the last statement executed in the function, but it will have a return value. If you only care about the side effects of calling the function, you may ignore its return value at the call site.

Note that if, case and cond all return the last value from their executed path as well.

The concept of referential transparency has some relevance here; though elixir doesn’t have strict referential transparency because of side effects, when there’s no explicit or implicit message passing to other processes or IO, I believe it does. Just thought worth mentioning, you asked “how does that work”, and depending on what sense you meant that in, there are a lot of answers, but it works great!

This is a consequence of Elixir (like Erlang) being expression-oriented, not statement oriented. Nearly everything in the language is an expression which evaluates to a value. This is in contrast with statement-oriented languages like C, Java, and others.

This has a few implications:

if and case can be used on the right hand side of = in Elixir, but not in C. Here’s an example:

a = if 1 == 2 do
      "huh"
    else
      "expected"
    end

In C that wouldn’t work since if returns nothing, you’d need to use the ternary expression to achieve a similar result. That choice of term is important. In every language (that I know of) expressions and statements are distinct.

To add on what the others have already said:

Expressions that have “nothing” to return usually return nil or sometimes :ok. An example is for instance if false do ... end (which returns nil because there is no else-block) and IO.puts/1 (which returns :ok).

Then it implicitly returns nil (which is actually a syntactic sugar for the atom :nil, same as true and false are syntactic sugar for :true and :false). Try this:

defmodule Nothing do
  def nothing()
  end
end

And then invoke Nothing.nothing() in iex. You’ll get nil.

Then You call it a method

It’s all about function composition. If it returns nothing, it is most likely a procedure, then it’s not possible to compose with it.

As simple as it is, a function should look like this, and pure function always returns the same output for the same input. You can compose with the powerful |>

Input → Output |> Input → Output |> Input → Output

And coming from Typescript, You will see it’s important to have clear input and output types. Functions are like interfaces.

This video helped me to switch from OOP to FP, because it’s better not to compare with what You already know. In fact, You need to unlearn