anchor.diff:                          Task.Factory.StartNew(fun () ->
                                                   let mutable i = s
                                                   while i < e && !nextRef do
  -                                                    iter.Index := i
                                                       iter.Func source.[i]
                                                       i <- i + 1 
                                                   ())
  
positive.code:             member self.SourceType = stream.SourceType
              member self.PreserveOrdering = true
              member self.Stream () = stream.Stream() |> Stream.mapi f 
              member self.Apply<'S> (collector : Collector<'R, 'S>) =
                  let collector = 
                      { new Collector<'T, 'S> with
                          member self.DegreeOfParallelism = collector.DegreeOfParallelism
                          member self.Iterator() =
                              let { Index = index; Func = iter } as iterator = collector.Iterator()
                              {   Index = iterator.Index; 
                                  Func = (fun value -> iter (f !index value));
                                  Cts = iterator.Cts } 
                          member self.Result = collector.Result }
                  stream.Apply collector }
  
      /// <summary>Transforms each element of the input parallel stream to a new stream and flattens its elements.</summary>
      /// <param name="f">A function to transform items from the input parallel stream.</param>
  
negative.code:             { new Collector<'T, 'R option> with
                  member self.DegreeOfParallelism = stream.DegreeOfParallelism
                  member self.Iterator() = 
                      {   Func = (fun value -> match chooser value with Some value' -> resultRef := Some value'; cts.Cancel() | None -> ());
                          Cts = cts }
                  member self.Result = 
                      !resultRef }
  