     init(error: Failure)
 
     /// Convert this type into a concrete result
-    var asResult: Result<Wrapped, Failure> { get }
+    var asResult: Result<Success, Failure> { get }
 
     /// Convert this type into a type-erased error result
-    var asErrorResult: ResultOf<Wrapped> { get }
+    var asErrorResult: ResultOf<Success> { get }
 }
 
 extension Result : ResultType {
-    public typealias Wrapped = Success
-
     public init(_ some: Success) {
         self = .success(some)
     }

/// A result tyoe that can accept any error type
public typealias ResultOf<T> = Result<T, Error>

public protocol ResultType : _WrapperType {
    associatedtype Failure : Error

    /// Returns the value for `.success` or nil if this is a `.failure`
    var value: Wrapped? { get }

    /// Returns the error for `.failure` or nil if this is a `.success`
    var error: Failure? { get }


extension Result : Choose2Type {

    @inlinable public var choose2: Choose2<Success, Failure> {
        switch self {
        case .success(let value): return .v1(value)
        case .failure(let error): return .v2(error)
