anchor.diff:      /// <returns>The result sequence.</returns>
       ///
       /// <exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
  -    /// 
  +    ///
       /// <example-tbd></example-tbd>
       [<CompiledName("SkipWhile")>]
       val skipWhile: predicate:('T -> bool) -> source:seq<'T> -> seq<'T>
   
       /// <summary>Yields a sequence ordered by keys.</summary>
  -    /// 
  -    /// <remarks>This function returns a sequence that digests the whole initial sequence as soon as 
  -    /// that sequence is iterated. As a result this function should not be used with 
  -    /// large or infinite sequences.
  -    ///
  -    /// The function makes no assumption on the ordering of the original 
  -    /// sequence and uses a stable sort, that is the original order of equal elements is preserved.</remarks>
  -    ///
  -    /// <param name="source">The input sequence.</param>
  -    ///
  -    /// <returns>The result sequence.</returns>
  -    ///
  -    /// <exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
  -    /// 
  -    /// <example-tbd></example-tbd>
  -    [<CompiledName("Sort")>]
  -    val sort : source:seq<'T> -> seq<'T> when 'T : comparison
  -
  -    /// <summary>Yields a sequence ordered using the given comparison function.</summary>
       ///
       /// <remarks>This function returns a sequence that digests the whole initial sequence as soon as
       /// that sequence is iterated. As a result this function should not be used with
       /// large or infinite sequences.
       ///
  -    /// The function makes no assumption on the ordering of the original 
  +    /// The function makes no assumption on the ordering of the original
       /// sequence and uses a stable sort, that is the original order of equal elements is preserved.</remarks>
       ///
  +    /// <param name="source">The input sequence.</param>
  +    ///
  +    /// <returns>The result sequence.</returns>
  +    ///
  +    /// <exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
  +    ///
  +    /// <example-tbd></example-tbd>
  +    [<CompiledName("Sort")>]
  +    val sort : source:seq<'T> -> seq<'T> when 'T : comparison
  +
  +    /// <summary>Yields a sequence ordered using the given comparison function.</summary>
  +    ///
  +    /// <remarks>This function returns a sequence that digests the whole initial sequence as soon as
  +    /// that sequence is iterated. As a result this function should not be used with
  +    /// large or infinite sequences.
  +    ///
  +    /// The function makes no assumption on the ordering of the original
  +    /// sequence and uses a stable sort, that is the original order of equal elements is preserved.</remarks>
  +    ///
       /// <param name="comparer">The function to compare the collection elements.</param>
       /// <param name="source">The input sequence.</param>
       ///
       /// <returns>The result sequence.</returns>
  -    /// 
  +    ///
       /// <example-tbd></example-tbd>
       [<CompiledName("SortWith")>]
       val sortWith : comparer:('T -> 'T -> int) -> source:seq<'T> -> seq<'T>
   
       /// <summary>Applies a key-generating function to each element of a sequence and yield a sequence ordered
  -    /// by keys.  The keys are compared using generic comparison as implemented by <see cref="M:Microsoft.FSharp.Core.Operators.compare"/>.</summary> 
  -    /// 
  -    /// <remarks>This function returns a sequence that digests the whole initial sequence as soon as 
  -    /// that sequence is iterated. As a result this function should not be used with 
  -    /// large or infinite sequences. 
  -    ///
  -    /// The function makes no assumption on the ordering of the original 
  +    /// by keys.  The keys are compared using generic comparison as implemented by <see cref="M:Microsoft.FSharp.Core.Operators.compare"/>.</summary>
  +    ///
  +    /// <remarks>This function returns a sequence that digests the whole initial sequence as soon as
  +    /// that sequence is iterated. As a result this function should not be used with
  +    /// large or infinite sequences.
  +    ///
  +    /// The function makes no assumption on the ordering of the original
       /// sequence and uses a stable sort, that is the original order of equal elements is preserved.</remarks>
       ///
       /// <param name="projection">A function to transform items of the input sequence into comparable keys.</param>
  
positive.code:     ///
      /// <exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
      /// <exception cref="T:System.ArgumentException">Thrown when the index is negative or the input sequence does not contain enough elements.</exception>
      /// 
      /// <example-tbd></example-tbd>
      [<CompiledName("Item")>]
      val item: index:int -> source:seq<'T> -> 'T
  
  
negative.code:     /// <returns>The result sequence.</returns>
      ///
      /// <exception cref="T:System.ArgumentNullException">Thrown when the input sequence is null.</exception>
      ///
      /// <example-tbd></example-tbd>
      [<CompiledName("SortDescending")>]
      val inline sortDescending : source:seq<'T> -> seq<'T> when 'T : comparison
  
      /// <summary>Applies a key-generating function to each element of a sequence and yield a sequence ordered
      /// descending by keys.  The keys are compared using generic comparison as implemented by <see cref="M:Microsoft.FSharp.Core.Operators.compare"/>.</summary>
      ///
      /// <remarks>This function returns a sequence that digests the whole initial sequence as soon as
      /// that sequence is iterated. As a result this function should not be used with
      /// large or infinite sequences. The function makes no assumption on the ordering of the original
      /// sequence.
      ///
      /// This is a stable sort, that is the original order of equal elements is preserved.</remarks>
  