     XCTAssert(d3.error as? TestError == TestError(error))
   }
 
-  func testApply1()
-  {
-    let value = Int(arc4random() & 0x7fff + 10000)
-    let error = arc4random() & 0x3fff_ffff
-
-    // good operand, good transform
-    let o1 = Deferred(value: value)
-    let t1 = Deferred { i throws -> Double in Double(value*i) }
-    let r1 = o1.apply(t1)
-    XCTAssert(r1.value == Double(value*value))
-    XCTAssert(r1.error == nil)
-
-    // bad operand, transform not applied
-    let o2 = Deferred<Int> { throw TestError(error) }
-    let t2 = Deferred { (i:Int) throws -> Float in XCTFail(); return Float(i) }
-    let r2 = o2.apply(t2)
-    XCTAssert(r2.value == nil)
-    XCTAssert(r2.error as? TestError == TestError(error))
-
-    // good operand, transform throws
-    let o3 = Deferred(value: error)
-    let t3 = Deferred { (i:UInt32) throws -> AnyObject in throw TestError(i) }
-    let r3 = o3.apply(t3)
-    XCTAssert(r3.value == nil)
-    XCTAssert(r3.error as? TestError == TestError(error))
-  }
-
-  func testApply2()
-  {
-    // a silly example curried function.
+  func testApply()
+  {
+    // a simple curried function.
     func curriedSum(a: Int)(_ b: Int) -> Int
     {
       return a+b

    usleep(1000)
    XCTAssert(d2.cancel() == true)

    try! tbd.determine(numericCast(arc4random() & 0x3fff_ffff))

    waitForExpectationsWithTimeout(1.0, handler: nil)

    let value2 = Int(arc4random() & 0x3fff_ffff)
    let deferred = Deferred(value: value1).apply(qos: QOS_CLASS_USER_INITIATED, Deferred(value: curriedSum(value2)))
    XCTAssert(deferred.value == value1+value2)

    // a 2-tuple is the same as two parameters
    let transform = Deferred(value: powf)
    let v1 = Deferred(value: 3.0)
    let v2 = Deferred(value: 4.1)

    let args = combine(v1.map(Float.init), v2.map(Float.init))
    let result = args.apply(transform)

    XCTAssert(result.value == pow(3.0, 4.1))
  }

  func testApply1()
  {
    let transform = TBD<(Int) -> Double>()
    let operand = TBD<Int>()
