       File.read!("invalid.txt")
       #=> raises File.Error
 
-  In general, a developer should use the former in case
-  he wants to react in the fie does not exist. The latter
-  should be used when the developer expects his software
-  to fail in case the file cannot be read (i.e. it is
-  literally an exception).
-
-  Finally, the functions in this module accept either
-  a char lists or a binary. When manipulating paths, a char
-  list is returned if one is given as argument. However,
-  when reading files, binaries are always returned.
+  In general, a developer should use the former in case he wants
+  to react in the fie does not exist. The latter should be used
+  when the developer expects his software to fail in case the
+  file cannot be read (i.e. it is literally an exception).
   """
 
   alias :file,     as: F

  end

  @doc """
  Copies the contents in `source` to `destination`.
  Similar to the command `cp -r` in Unix systems,
  this function behaves differently depending
  if `source` and `destination` are a file or a directory.

  If both are files, it simply copies `source` to
  `destination`. However, if `destination` is a directory,
  it copies the contents of `source` to `destination/source`
  recursively.

  If a file already exists in the destination,
  it invokes a callback which should return
  true if the existing file should be overriden,
  false otherwise. It defaults to return true.

  It returns `:ok` in case of success, returns
  `{ :error, reason }` otherwise.
  """
  def cp(source, destination, callback // fn(_, _) -> true end) do
    if dir?(source) do
      { :error, :eisdir }
    else
      output =
        if dir?(destination) do
          mkdir(destination)
          FN.join(destination, FN.basename(source))
        else
          destination
        end

      case do_cp_file(source, output, callback, []) do
        { :error, reason, _ } -> { :error, reason }
        _ -> :ok
      end
    end
  end


  end

  @doc """
  The same as `copy/3` but raises an `File.CopyError` if it fails.
  Returns the `bytes_copied` otherwise.
  """
  def copy!(source, destination, bytes_count // :infinity) do
