Update for revised proposal.

Author: jshier

stdlib/public/core/Result.swift

@@ -13,35 +13,35 @@
 /// A value that represents either a success or failure, capturing associated
 /// values in both cases.
 @_frozen
-public enum Result<Value, Error: Swift.Error> {
-  /// A success, storing a `Value`.
-  case value(Value)
+public enum Result<Success, Failure: Error> {
+  /// A success, storing a `Success` value.
+  case success(Success)
 
-  /// A failure, storing an `Error`.
-  case error(Error)
+  /// A failure, storing a `Failure` value.
+  case failure(Failure)
 
   /// Evaluates the given transform closure when this `Result` instance is
-  /// `.value`, passing the value as a parameter.
+  /// `.success`, passing the value as a parameter.
   ///
   /// Use the `map` method with a closure that returns a non-`Result` value.
   ///
   /// - Parameter transform: A closure that takes the successful value of the
   ///   instance.
   /// - Returns: A new `Result` instance with the result of the transform, if
   ///   it was applied.
-  public func map<NewValue>(
-    _ transform: (Value) -> NewValue
-  ) -> Result<NewValue, Error> {
+  public func map<NewSuccess>(
+    _ transform: (Success) -> NewSuccess
+  ) -> Result<NewSuccess, Failure> {
     switch self {
-    case let .value(value):
-      return .value(transform(value))
-    case let .error(error):
-      return .error(error)
+    case let .success(success):
+      return .success(transform(success))
+    case let .failure(failure):
+      return .failure(failure)
     }
   }
 
   /// Evaluates the given transform closure when this `Result` instance is
-  /// `.error`, passing the error as a parameter.
+  /// `.failure`, passing the error as a parameter.
   ///
   /// Use the `mapError` method with a closure that returns a non-`Result`
   /// value.
@@ -50,82 +50,82 @@ public enum Result<Value, Error: Swift.Error> {
   ///   instance.
   /// - Returns: A new `Result` instance with the result of the transform, if
   ///   it was applied.
-  public func mapError<NewError>(
-    _ transform: (Error) -> NewError
-  ) -> Result<Value, NewError> {
+  public func mapError<NewFailure>(
+    _ transform: (Failure) -> NewFailure
+  ) -> Result<Success, NewFailure> {
     switch self {
-    case let .value(value):
-      return .value(value)
-    case let .error(error):
-      return .error(transform(error))
+    case let .success(success):
+      return .success(success)
+    case let .failure(failure):
+      return .failure(transform(failure))
     }
   }
 
   /// Evaluates the given transform closure when this `Result` instance is
-  /// `.value`, passing the value as a parameter and flattening the result.
+  /// `.success`, passing the value as a parameter and flattening the result.
   ///
   /// - Parameter transform: A closure that takes the successful value of the
   ///   instance.
   /// - Returns: A new `Result` instance, either from the transform or from
   ///   the previous error value.
-  public func flatMap<NewValue>(
-    _ transform: (Value) -> Result<NewValue, Error>
-  ) -> Result<NewValue, Error> {
+  public func flatMap<NewSuccess>(
+    _ transform: (Success) -> Result<NewSuccess, Failure>
+  ) -> Result<NewSuccess, Failure> {
     switch self {
-    case let .value(value):
-      return transform(value)
-    case let .error(error):
-      return .error(error)
+    case let .success(success):
+      return transform(success)
+    case let .failure(failure):
+      return .failure(failure)
     }
   }
 
   /// Evaluates the given transform closure when this `Result` instance is
-  /// `.error`, passing the error as a parameter and flattening the result.
+  /// `.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<NewError>(
-    _ transform: (Error) -> Result<Value, NewError>
-  ) -> Result<Value, NewError> {
+  public func flatMapError<NewFailure>(
+    _ transform: (Failure) -> Result<Success, NewFailure>
+  ) -> Result<Success, NewFailure> {
     switch self {
-    case let .value(value):
-      return .value(value)
-    case let .error(error):
-      return transform(error)
+    case let .success(success):
+      return .success(success)
+    case let .failure(failure):
+      return transform(failure)
     }
   }
 
-  /// Unwraps the `Result` into a throwing expression.
+  /// Attempts to get the `success` value as a throwing expression.
   ///
   /// - Returns: The success value, if the instance is a success.
-  /// - Throws:  The error value, if the instance is a failure.
-  public func unwrapped() throws -> Value {
+  /// - Throws:  The failure value, if the instance is a failure.
+  public func get() throws -> Success {
     switch self {
-    case let .value(value):
-      return value
-    case let .error(error):
-      throw error
+    case let .success(success):
+      return success
+    case let .failure(failure):
+      throw failure
     }
   }
 }
 
-extension Result where Error == Swift.Error {
+extension Result where Failure == Swift.Error {
   /// Create an instance by capturing the output of a throwing closure.
   ///
   /// - Parameter catching: A throwing closure to evaluate.
   @_transparent
-  public init(catching body: () throws -> Value) {
+  public init(catching body: () throws -> Success) {
     do {
       let value = try body()
-      self = .value(value)
+      self = .success(value)
     } catch {
-      self = .error(error)
+      self = .failure(error)
     }
   }
 }
 
-extension Result : Equatable where Value : Equatable, Error : Equatable { }
+extension Result : Equatable where Success : Equatable, Failure : Equatable { }
 
-extension Result : Hashable where Value : Hashable, Error : Hashable { }
+extension Result : Hashable where Success : Hashable, Failure : Hashable { }

test/stdlib/Result.swift

@@ -14,42 +14,42 @@ fileprivate enum Err: Error, Equatable {
 fileprivate let string = "string"
 
 fileprivate extension Result {
-  var value: Value? {
+  var success: Success? {
     switch self {
-    case let .value(value):
-      return value
-    case .error:
+    case let .success(success):
+      return success
+    case .failure:
       return nil
     }
   }
 
-  var error: Error? {
+  var failure: Failure? {
     switch self {
-    case .value:
+    case .success:
       return nil
-    case let .error(error):
-      return error
+    case let .failure(failure):
+      return failure
     }
   }
 }
 
 ResultTests.test("Construction") {
-  let result1: Result<String, Err> = .value(string)
-  let result2: Result<String, Err> = .error(.err)
+  let result1: Result<String, Err> = .success(string)
+  let result2: Result<String, Err> = .failure(.err)
   let string1: String? = {
     switch result1 {
-      case let .value(string): 
+      case let .success(string): 
         return string
-      case .error: 
+      case .failure: 
         expectUnreachable()
         return nil
     }
   }()
   let error: Err? = {
     switch result2 {
-      case let .error(error): 
-        return error
-      case .value: 
+      case let .failure(failure): 
+        return failure
+      case .success: 
         expectUnreachable()
         return nil
     }
@@ -71,28 +71,28 @@ ResultTests.test("Throwing Initialization and Unwrapping") {
   let result1 = Result { try throwing() }
   let result2 = Result { try notThrowing() }
 
-  expectEqual(result1.error as? Err, Err.err)
-  expectEqual(result2.value, string)
+  expectEqual(result1.failure as? Err, Err.err)
+  expectEqual(result2.success, string)
 
   do {
-    _ = try result1.unwrapped()
+    _ = try result1.get()
   } catch let error as Err {
     expectEqual(error, Err.err)
   } catch {
     expectUnreachable()
   }
 
   do {
-    let unwrapped = try result2.unwrapped()
+    let unwrapped = try result2.get()
     expectEqual(unwrapped, string)
   } catch {
     expectUnreachable()
   }
 
   // Test unwrapping strongly typed error.
-  let result3 = Result<String, Err>.error(Err.err)
+  let result3 = Result<String, Err>.failure(Err.err)
   do {
-    _ = try result3.unwrapped()
+    _ = try result3.get()
   } catch let error as Err {
     expectEqual(error, Err.err)
   } catch {
@@ -118,53 +118,53 @@ ResultTests.test("Functional Transforms") {
   }
 
   func resultValueTransform(_ int: Int) -> Result<Int, Err> {
-    return .value(transformDouble(int))
+    return .success(transformDouble(int))
   }
 
   func resultErrorTransform(_ err: Err) -> Result<Int, Err> {
-    return .error(transformError(err))
+    return .failure(transformError(err))
   }
 
-  let result1: Result<Int, Err> = .value(1)
+  let result1: Result<Int, Err> = .success(1)
   let newResult1 = result1.map(transformDouble)
 
-  expectEqual(newResult1, .value(2))
+  expectEqual(newResult1, .success(2))
 
-  let result2: Result<Int, Err> = .error(.err)
+  let result2: Result<Int, Err> = .failure(.err)
   let newResult2 = result2.mapError(transformError)
 
-  expectEqual(newResult2, .error(.derr))
+  expectEqual(newResult2, .failure(.derr))
 
-  let result3: Result<Int, Err> = .value(1)
+  let result3: Result<Int, Err> = .success(1)
   let newResult3 = result3.flatMap(resultValueTransform)
 
-  expectEqual(newResult3, .value(2))
+  expectEqual(newResult3, .success(2))
 
-  let result4: Result<Int, Err> = .error(.derr)
+  let result4: Result<Int, Err> = .failure(.derr)
   let newResult4 = result4.flatMapError(resultErrorTransform)
 
-  expectEqual(newResult4, .error(.err))
+  expectEqual(newResult4, .failure(.err))
 }
 
 ResultTests.test("Equatable") {
-  let result1: Result<Int, Err> = .value(1)
-  let result2: Result<Int, Err> = .error(.err)
-
-  expectEqual(result1, .value(1))
-  expectNotEqual(result1, .value(2))
-  expectNotEqual(result1, .error(.err))
-  expectNotEqual(result1, .error(.derr))
-
-  expectNotEqual(result2, .value(1))
-  expectNotEqual(result2, .value(2))
-  expectEqual(result2, .error(.err))
-  expectNotEqual(result2, .error(.derr))
+  let result1: Result<Int, Err> = .success(1)
+  let result2: Result<Int, Err> = .failure(.err)
+
+  expectEqual(result1, .success(1))
+  expectNotEqual(result1, .success(2))
+  expectNotEqual(result1, .failure(.err))
+  expectNotEqual(result1, .failure(.derr))
+
+  expectNotEqual(result2, .success(1))
+  expectNotEqual(result2, .success(2))
+  expectEqual(result2, .failure(.err))
+  expectNotEqual(result2, .failure(.derr))
 }
 
 ResultTests.test("Hashable") {
-  let result1: Result<Int, Err> = .value(1)
-  let result2: Result<Int, Err> = .value(2)
-  let result3: Result<Int, Err> = .error(.err)
+  let result1: Result<Int, Err> = .success(1)
+  let result2: Result<Int, Err> = .success(2)
+  let result3: Result<Int, Err> = .failure(.err)
   checkHashable([result1, result2, result3], equalityOracle: { $0 == $1 })
 }