anchor.diff:          ///
           /// <returns>An asynchronous computation that executes <c>computation</c> and calls <c>catchHandler</c> if an
           /// exception is thrown.</returns>
  -        /// 
  +        ///
           /// <example-tbd></example-tbd>
           member inline TryWith : computation:Async<'T> * catchHandler:(exn -> Async<'T>) -> Async<'T>
   
  
positive.code:         /// <remarks>The computation will respond to cancellation while waiting for the completion
          /// of the operation. If a cancellation occurs, and <c>cancelAction</c> is specified, then it is 
          /// executed, and the computation continues to wait for the completion of the operation.
          /// 
          /// If <c>cancelAction</c> is not specified, then cancellation causes the computation
          /// to stop immediately, and subsequent invocations of the callback are ignored.</remarks>
          ///
  
negative.code:         /// <returns>A computation that returns an array of values from the sequence of input computations.</returns>
          ///
          /// <category index="1">Composing Async Computations</category>
          ///
          /// <example id="sequential-1">
          /// <code lang="fsharp">
          /// let primes = [ 2; 3; 5; 7; 10; 11 ]
          /// let computations =
          ///     [ for i in primes do
          ///             async {
          ///                 do! Async.Sleep(System.Random().Next(1000, 2000))
          ///
          ///                 if i % 2 > 0 then
          ///                     printfn $"{i}"
          ///                     return true
          ///                 else
          ///                     return false
          ///             }
          ///    ]
          ///
          /// let t =
          ///     Async.Sequential(computations)
          ///     |> Async.StartAsTask
          ///
          /// t.Wait()
          /// printfn $"%A{t.Result}" 
          /// </code>
          /// This will print "3", "5", "7", "11" with ~1-2 seconds between them except for pauses where even numbers would be and then
          /// prints [| false; true; true; true; false; true |].
          /// </example>
          static member Sequential : computations:seq<Async<'T>> -> Async<'T[]>
  
          /// <summary>
          /// Creates an asynchronous computation that executes all given asynchronous computations in parallel, 
          /// returning the result of the first succeeding computation (one whose result is 'Some x').
          /// If all child computations complete with None, the parent computation also returns None.
          /// </summary>
          ///
          /// <remarks>
          /// If any child computation raises an exception, then the overall computation will trigger an 
  