 
   @doc """
   Destructures two lists, assigning each term in the
-  right to the matching term in the left.
+  right one to the matching term in the left one.
 
   Unlike pattern matching via `=`, if the sizes of the left
   and right lists don't match, destructuring simply stops

  end

  @doc """
  `|>` is the pipe operator.

  This operator introduces the expression on the left as
  the first argument to the function call on the right.

  ## Examples

      iex> [1, [2], 3] |> List.flatten()
      [1, 2, 3]

  The example above is the same as calling `List.flatten([1, [2], 3])`,
  i.e. the argument on the left side of `|>` is introduced as the first
  argument of the function call on the right side.

  This pattern is mostly useful when there is a desire to execute
  a bunch of operations, resembling a pipeline:

      iex> [1, [2], 3] |> List.flatten |> Enum.map(fn x -> x * 2 end)
      [2, 4, 6]

  The example above will pass the list to `List.flatten/1`, then get
  the flattened list and pass to `Enum.map/2`, which will multiply
  each entry in the list per two.

  In other words, the expression above simply translates to:



  @doc """
  Provides a short-circuit operator that evaluates and returns the second
  expression only if the first one does not evaluate to `true` (i.e., it
  is either `nil` or `false`). Returns the first expression otherwise.

  Not allowed in guard clauses.

  ## Examples

