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

You need to use guard clauses. Here is an example:
http://elixirplayground.com?gist=58b573a1ae2de40bd468e78ccac38e96

Function #1 always matches 100, 99. So whenever you call PositivePrinter.print_positive_diference(100, 99) that is the function that will be called. No guard clauses here because they are not needed.
Functions #2 match only if the expression after the when clause evaluates to true.
Function #3 matches whatever as long it is called with 2 parameters.

The commented function will rise an error because we call it with one parameter but we haven’t define any function that it is called with one parameter. So none of our functions matches

Here is an example with maps:
http://elixirplayground.com?gist=c9060fb9b54bfd00053c6c50e75c2138

Functions at #1 match the map only if it has a key day with the appropriate value
Function at #2 matches the map if it has a key day with any value. At the same time it binds the value with the variable the_day so it can be used inside the function. Although the function head matches any value, we use a guard in it, so valid values are only :saturday and :sunday. This reads: match any map that has key :day with any value as long as the value is one of :saturday, :sunday

Function at #3 matches whatever value you throw at it. Even if today = 42