 //    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.Wrapped) -> Channel<Source2, Pulse2>) -> Channel<Self.Source, Pulse2> where Self.Pulse : ResultType, Pulse2 : ResultType, Self.Pulse.Failure == Pulse2.Failure {
+    @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)


    @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? {

    init(error: Failure)

    /// Convert this type into a concrete result
    var asResult: Result<Success, Failure> { get }

    /// Convert this type into a type-erased error result
    var asErrorResult: ResultOf<Success> { get }
}

extension Result : ResultType {
    public init(_ some: Success) {
        self = .success(some)
    }
