Implement when function

[bannzai]

I implement "when" method.
It corresponds to multiple value type.

Usage

• success pattern

        let task1 = Task<Float, String, NSError?> { fulfill, reject in fulfill("Success") }
        let task2 = Task<Float, Int, NSError?> { fulfill, reject in fulfill(1) }
        let task3 = Task<Float, Double, NSError?> { fulfill, reject in fulfill(1.1) }

        Task<Float, (String, Int, Double), NSError>.when((task1, task2, task3)).success { (string, int, double) -> Void in
            print(string) // -> Success
            print(int) // -> 1
            print(double) // -> 1.1
        }.failure { (error, isCancelled) -> Void in
            fatalError()
        }

*failure pattern

        let task1 = Task<Float, String, String> { fulfill, reject in fulfill("Success") }
        let task2 = Task<Float, Int, String> { fulfill, reject in fulfill(1) }
        let task3 = Task<Float, Double, String> { fulfill, reject in  reject("Rejected") }

        Task<Float, (String, Int, Double), String>.when((task1, task2, task3)).success { (string, int, double) -> Void in
            fatalError()
        }.failure { (error, isCancelled) -> Void in
            print(error) // -> Optional("Rejected")
        }

[inamiy]

Hi, thank you for pull request :)

Currently, there is already Task.all() class method to achieve similar functionality.
For type-strict version, you can find scratch code in

SwiftTask/SwiftTask/SwiftTask.swift

Lines 669 to 699 in 4bdab82

	public func zip<Progress2, Value2, Error2>(task2: Task<Progress2, Value2, Error2>) -> Task<(Progress?, Progress2?), (Value, Value2), (Error?, Error2?)>
	{
	return Task<(Progress?, Progress2?), (Value, Value2), (Error?, Error2?)> { machine, progress, fulfill, _reject, configure in
	let t1 = self.convert(progress: _toAny, value: _toAny, error: _toAny)
	let t2 = task2.convert(progress: _toAny, value: _toAny, error: _toAny)
	let zipTask = Task<Any, Any, Any>.all([t1, t2])
	configure.pause = { zipTask.pause() }
	configure.resume = { zipTask.resume() }
	configure.cancel = { zipTask.cancel() }
	t1.progress { _, p in
	if t2.value == nil && t2.errorInfo == nil {
	progress((p as? Progress, t2.progress as? Progress2))
	}
	}
	t2.progress { _, p in
	if t1.value == nil && t1.errorInfo == nil {
	progress((t1.progress as? Progress, p as? Progress2))
	}
	}
	zipTask.success { (valueTuple: [Any]) -> Void in
	fulfill((valueTuple[0] as! Value, valueTuple[1] as! Value2))
	}.failure { _, isCancelled -> Void in
	_reject((error: (t1.errorInfo?.error as? Error, t2.errorInfo?.error as? Error2), isCancelled: isCancelled))
	}
	}.name("\(self.name)-zip(\(task2.name))")
	}

(not merged yet) which was first discussed in #44 .

I personally think we can just keep using variadic Task.all() for API simplicity.
What do you think?