     /// Chains one channel to the next only if the first result element of the pulse tuple was successful
     @inlinable func then<Source2, Pulse2, R: ResultType, Tuple>(_ next: Channel<Source2, Pulse2>) -> Channel<Self.Source, (Pulse2, Self.Pulse)> where Self.Pulse == (R, Tuple), Pulse2 : ResultType, R.Failure == Pulse2.Failure {
         return alternate(to: { _ in next }, unless: { pulse in
-            if let error = pulse.0.error {
+            if let error = pulse.0.resultError {
                 return errorChannel(source: next.source, error: error)
             } else {
                 return .none // continue on to the next channel

    associatedtype Failure : Error

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

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

    /// Must be able to initialize with an error
    init(error: Failure)

        self = .failure(error)
    }

    @inlinable public var resultValue: Success? {
        switch self {
        case .success(let x): return .some(x)
        case .failure: return .none
        }
    }

    @inlinable public var resultError: Failure? {
        switch self {
        case .success: return .none
        case .failure(let x): return .some(x)
