The point is that to me is like i’m using a switch statement, or a sort of case statement, and if the value that i pass match a case, i print the string, so what’s the difference to use a function like this or
use a switch in other languages?

Function clauses perform the control flow of switch statements (i.e. they allow branching on conditions) but they also bind values to variables at the same time. e.g. In the second line of:

handle_result = fn
  {:ok, result} -> IO.puts "handling the result..."
  {:error} -> IO.puts "an error is occurred"
end

a condition is checked (is the argument of the form {:ok, result}?), AND, if the condition is true, a value is bound to the variable ‘result’. A switch case does not assign values to variables but pattern matching does.

how can i use multiple bodies to compare if two values are equal or not equal with operators

You can use ‘when’ to add conditions to clauses:

fn 
  a,b when a > b -> ...
  a,b when a < b -> ...
  a,b -> 
end

last thing that i don’t get is, the argument of the function is implicit?

Not exactly. The arguments are pattern matched with each function clause. So for your example

fn a,b -> #  This is equivalent to fn a = arg1, b = arg2 ->
  a == b
end

Let me try to answer your questions:

Using multiple function heads is ‘sort of’ the same thing as a switch-case, but more powerful.
In languages like C and C++, you are only allowed to use int-like values in a switch case, as these can be optimized by the compiler to a direct jump at best, or a binary search at worst. Therefore, things like strings are not allowed.

In most imperative or object-oriented interpreted languages, however, this optimization does not happen. You are allowed to use any value in a switch statement, but this is treated as just syntactic sugar for an if ()... else if () ... else if ()...-chain.

In languages like Elixir that support pattern-matching, however, the case statement is a lot more powerful than a plain 'ol switch: The compiler will recognize what properties you are trying to ascertain of your data types, and underwater write the appropriate checks that only check what needs to be checked; redundant checks are not performed.
While this is of course marginally less fast than the ‘direct jump’ approach that C/C++ support, it is a lot faster than a simple if... else if-chain. And on the other hand, it makes for extremely readable code.

The compiler will take function with multiple heads (it does not matter if it is a named or anonymous function, it works the same way), and rewrite these multiple heads using a case-statement underwater. So yes, in this way, they are doing the same thing.

But from a code organization perspective, it usually is better to separate your functionality in many small named functions, because it makes it easier in the future to change only a small part.

In the case that a pattern is matched in a function head or in a case statement, only the variables that are part of that statement are available (also available are the ones before the function or case statement, but notably not the ones named in the other functin heads / case matches).

EDIT: @tyro was a little bit faster than me , but I hope you still find my background explanation helpful or at least entertaining .

Thank you guys! Now i understand everything! And Thank you for Your time