anchor.diff:      /// Active pattern that matches on flattened inner exceptions in an AggregateException
       let (|AggregateExn|_|) (e:exn) =
           match e with
  -        | :? AggregateException as ae -> ae.Flatten().InnerExceptions
  -                                         |> List.ofSeq
  -                                         |> Some
  -        | _                           -> None
  +        | :? AggregateException as ae ->
  +            ae.Flatten().InnerExceptions
  +            |> List.ofSeq
  +            |> Some
  +        | _ -> None
   
       /// Creates a task that executes a specified task.
       /// If this task completes successfully, then this function returns Choice1Of2 with the returned value.
       /// If this task raises an exception before it completes then return Choice2Of2 with the raised exception.
  -    let Catch (t:Task<'a>) =
  +    let Catch (t:Task<'a>) : Task<Choice<'a, exn>> =
           task {
               try let! r = t
                   return Choice1Of2 r
  
positive.code:         | Choice1Of2 a -> a
          | Choice2Of2 e -> invalidArg "choice" (sprintf "The choice value was Choice2Of2 '%A'" e)
      
      /// Wraps a function, encapsulates any exception thrown within to a Choice
      let inline protect f x = 
          try
  
negative.code:     /// Creates a task that executes all the given tasks.
      /// The paralelism is throttled, so that at most `throttle` tasks run at one time.
      let ParallelWithTrottle throttle (tasks : seq<unit -> Task<'a>>) : (Task<'a[]>) =
          ParallelWithTrottleCustom Choice.getOrRaise throttle tasks
  