     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 }

//    public typealias PulseChannelMap<S, T> = (Self.Pulse) -> Channel<S, T>

    /// Chains one channel to the next only if the result was successful
    @inlinable func successfully<Source2, Pulse2>(_ next: @escaping (Self.Pulse.Success) -> Channel<Source2, Pulse2>) -> Channel<Self.Source, Pulse2> where Self.Pulse : ResultType, Pulse2 : ResultType, Self.Pulse.Failure == Pulse2.Failure {
        return alternate(to: { next($0.value!).anySource() }, unless: { pulse in
            if let error = pulse.error {
                return errorChannel(source: (), error: error)
