     }
   }
   
-  /// Evaluates the given transform closure when this `Result` instance is
-  /// `.failure`, passing the error as a parameter.
+  /// Evaluates the given closure when this `Result` instance is `.failure`,
+  /// passing the failure value as a parameter.
   ///
   /// Use the `mapError` method with a closure that returns a non-`Result`
   /// value.
   ///
   /// - Parameter transform: A closure that takes the failure value of the
   ///   instance.
-  /// - Returns: A new `Result` instance with the result of the transform, if
-  ///   it was applied.
+  /// - Returns: A `Result` instance with the result of evaluating the given
+  ///   closure as the new failure value if this instance is `.failure`.
   public func mapError<NewFailure>(
     _ transform: (Failure) -> NewFailure
   ) -> Result<Success, NewFailure> {

    }
  }
  
  /// Evaluates the given transform closure when this `Result` instance is
  /// `.failure`, passing the error as a parameter and flattening the result.
  ///
  /// - Parameter transform: A closure that takes the error value of the
  ///   instance.
  /// - Returns: A new `Result` instance, either from the transform or from
  ///   the previous success value.
  public func flatMapError<NewFailure>(
    _ transform: (Failure) -> Result<Success, NewFailure>
  ) -> Result<Success, NewFailure> {

}

extension Result where Failure == Swift.Error {
  /// Create an instance by evaluating a throwing closure, capturing the 
  /// returned value as a `.success` or any thrown error as `.failure`.
  ///
  /// - Parameter catching: A throwing closure to evaluate.
  @_transparent
  public init(catching body: () throws -> Success) {
    do {
      self = .success(try body())
    } catch {
      self = .failure(error)
    }
  }
}

extension Result: Equatable where Success: Equatable, Failure: Equatable { }

extension Result: Hashable where Success: Hashable, Failure: Hashable { }
