     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)
     }


    @inlinable public var asErrorResult: ResultOf<Success> {
        return self.mapError({ $0 })
    }

    @available(*, deprecated, renamed: "mapSuccess")
    public func map<U>(_ f: (Success) throws -> U) rethrows -> U? {
        guard case .success(let value) = self else { return nil }
        return try f(value)
    }

    public func mapSuccess<U>(_ f: (Success) throws -> U) rethrows -> U? {

}


public extension Result where Success : _WrapperType {
    /// Returns the unwrapped value flatMapped to itself (e.g., converts value of String?? into String?)
    @inlinable var flatValue: Success.Wrapped? {
        switch self {
        case .success(let x): return x.flatMap({ $0 })
        case .failure: return .none
        }
    }
}

public extension Result {
    /// Takes a Result<Result<X, E>, E> and flattens it to a Result<X, E>
    func flatten<T>() -> Result<T, Failure> where Success == Result<T, Failure> {
        switch self {
        case .failure(let x): return .failure(x)
        case .success(.failure(let x)): return .failure(x)
        case .success(.success(let x)): return .success(x)
        }
    }
}
