 
 			case .Completed:
 				completed()
+
+			case .Cancelled:
+				cancelled()
 			}
 		}
 	}

		return left.unbox == right.unbox

	case (.Completed, .Completed):
		return true

	default:

/// Represents a signal event.
///
/// Signals must conform to the grammar:
/// `Next* (Error | Completed | Cancelled)?`
public enum Event<T, E: ErrorType> {
	/// A value provided by the signal.
	case Next(Box<T>)

	/// The signal terminated because of an error. No further events will be
	/// received.
	case Error(Box<E>)

	/// The signal successfully terminated. No further events will be received.
	case Completed

	/// Event production on the signal has been cancelled. No further events
	/// will be received.
	case Cancelled

	/// Whether this event indicates signal termination (from success or
	/// failure).
	public var isTerminating: Bool {
		switch self {
		case .Next:
			return false

		case .Error:
			return true

		case .Completed:
			return true

		case .Cancelled:
			return true
		}
	}

	/// Lifts the given function over the event's value.
	public func map<U>(f: T -> U) -> Event<U, E> {
		switch self {
		case let .Next(value):
			return Event<U, E>.Next(Box(f(value.unbox)))

		case let .Error(error):
			return Event<U, E>.Error(error)

		case .Completed:
			return .Completed

		case .Cancelled:
			return .Cancelled
		}
	}

	/// Creates a sink that can receive events of this type, then invoke the
	/// given handlers based on the kind of event received.
	public static func sink(next: T -> () = doNothing, error: E -> () = doNothing, completed: () -> () = doNothing, cancelled: () -> () = doNothing) -> SinkOf<Event> {
		return SinkOf { event in
			switch event {
			case let .Next(value):
