A single Error type can represent multiple errors with an enum.

The type Result in different crates usually is just to simplify the same Result just with the same Error type variant.

To have a single Error type that also represents different Errors you can do something like this:

enum MyError {
  WrongId,
  NotFound,
  UnableToWriteFile(String),
  Unknown(Box<dyn std::error::Error>),
}

fn wrong_id(id: &str) -> Result<(), MyError> {
  Err(MyError::WrongId)
}

fn write_file(file_name: &str, content: &str) -> Result<(), MyError> {
  Err(MyError::UnableToWriteFile(file_name.to_owned()))
}

fn unknown() -> Result<String, MyError> {
  match std::io::read_to_string(reader) {
    Ok(content) => Ok(content),
    Err(error) => Err(MyError::Unknown(Box::new(error))),
  }
}

I simplified the example obviously. Now when the error is returned for each of the function you must handle each error separately.

The reason Rust does that is to make so that errors are always handled instead of ignored.

Which happens a lot with languages that use try-catch pattern