anchor.diff:      | _ -> Assert.Fail "task should have errored"
   
   [<Test>]
  -let ``canceled task``() =
  -    let task = Task.TaskBuilderWithToken()
  +let ``canceled task``() =    
       let cts = new CancellationTokenSource()
       let t = 
  -        task {
  +        task' {
               cts.Token.ThrowIfCancellationRequested()
           }
       checkCancelledWithToken cts t
   
   [<Test>]
  -let ``canceled task 2``() =    
  -    let task = Task.TaskBuilderWithToken()
  -    let t = 
  -        task {
  +let ``canceled task 2``() =        
  +    let t = 
  +        task' {
               let! v = Task.Factory.StartNew(fun () -> 0)
               return ()
           }
       checkCancelled t
   
   [<Test>]
  -let ``return should return value``() =    
  -    let task = Task.TaskBuilderWithToken()
  -    let t = 
  -        task {            
  +let ``return should return value``() =        
  +    let t = 
  +        task' {            
               return 100
           }
       checkSuccess 100 t  
   
   [<Test>]
  -let ``return! should accept task parametrized by CancellationToken``() =
  -    let task = Task.TaskBuilderWithToken()
  +let ``return! should accept task parametrized by CancellationToken``() =    
       let t1 = 
  -        task {
  +        task' {
               let! v = Task.Factory.StartNew(fun () -> 100)
               return v
           }
   
       let t2 = 
  -        task {            
  +        task' {            
               return! t1
           }
       checkSuccess 100 t2    
   
   [<Test>]
  -let ``bind should chain two tasks``() =
  -    let task = Task.TaskBuilderWithToken()
  -    let t = 
  -        task {
  +let ``bind should chain two tasks``() =    
  +    let t = 
  +        task' {
               let! v1 = Task.Factory.StartNew(fun () -> 100)
               let! v2 = Task.Factory.StartNew(fun () -> v1 + 1)
               return v2
  
positive.code:     Assert.AreEqual(1, !i)
  
  let whileExpression (i: ref<int>) = 
      let task = Task.TaskBuilderWithToken(continuationOptions = TaskContinuationOptions.ExecuteSynchronously)    
      task {
          while !i > 0 do
              decr i
              do! Task.Factory.StartNew ignore
  
negative.code:     checkCancelled t
      Assert.AreEqual(10, !i)
  
  let tryFinallyExpression (i: ref<int>) =     
      task' {
          let! v1 = Task.Factory.StartNew(fun () -> 100)
          try
              let! v2 = Task.Factory.StartNew(fun () -> v1 + 1)
  