anchor.diff:              else
                   notImpl "String.Split.filter"
   
  -        //
  +        /// <summary></summary>
  +        /// <param name="separator"></param>
  +        /// <param name="chooser"></param>
  +        /// <param name="str"></param>
  +        /// <returns></returns>
           [<CompiledName("Choose")>]
  -        let choose (separator : char[], options : System.StringSplitOptions)
  -                (chooser : substring -> string option) (str : string) : string[] =
  +        let choose (separator : char[]) (chooser : substring -> string option) (str : string) : string[] =
               // Preconditions
               checkNonNull "str" str
   
  
positive.code:                 state <- folder.Invoke (state, str1.[i], str2.[i])
              state
  
      /// Applies the given function to pairs of characters drawn from matching indices
      /// in two strings, threading an accumulator argument through the computation.
      /// The two strings must have the same length, otherwise an ArgumentException is raised.
      /// If the input function is f and the characters are c0...cN and d0...dN then
      /// computes f c0 d0 (...(f cN dN s)).
      [<CompiledName("FoldBack2")>]
      let foldBack2 (folder : char -> char -> 'State -> 'State) (str1 : string) (str2 : string) (state : 'State) : 'State =
          // Preconditions
  
negative.code:             // Create a new string from the mapped characters.
              ofArray mappedChars
  
      /// <summary>
      /// Builds a new string whose characters are the results of applying the given function to the corresponding characters
      /// of the two strings pairwise, also passing the index of the characters.
      /// The two inputs strings must have the same length, otherwise <see cref="ArgumentException"/> is raised.
      /// </summary>
      /// <param name="mapping"></param>
      /// <param name="str1"></param>
      /// <param name="str2"></param>
      /// <returns></returns>
      [<CompiledName("MapIndexed2")>]
      let mapi2 (mapping : int -> char -> char -> char) (str1 : string) (str2 : string) : string =
         // Preconditions
  