anchor.diff:          ///
           /// <returns>The concatenated string.</returns>
           /// <exception cref="T:System.ArgumentException">Thrown when <c>count</c> is negative.</exception>
  +        /// 
  +        /// <example id="replicate-example-1">
  +        /// <code lang="fsharp">
  +        /// "Do it!" |> String.replicate 3   // evaluates "Do it!Do it!Do it!"
  +        /// </code>
  +        /// </example>
           [<CompiledName("Replicate")>]
           val replicate: count:int -> str: string -> string
  -
  -        /// <summary>Returns the length of the string.</summary>
  -        ///
  -        /// <param name="str">The input string.</param>
  -        ///
  -        /// <returns>The number of characters in the string.</returns>
  -        [<CompiledName("Length")>]
  -        val length: str:string -> int
  -
  +        
  +
  
positive.code:         /// <param name="str">The input string.</param>
          ///
          /// <returns>The resulting string.</returns>
          [<CompiledName("Filter")>]
          val filter: predicate:(char -> bool) -> str:string -> string
  
          /// <summary>Builds a new string whose characters are the results of applying the function <c>mapping</c>
          /// to each index from <c>0</c> to <c>count-1</c> and concatenating the resulting
  
negative.code:         ///
          /// <returns>The constructed string.</returns>
          /// <exception cref="T:System.ArgumentException">Thrown when <c>count</c> is negative.</exception>
          /// 
          /// <example id="init-example-1"> Enumerate digits ASCII codes
          /// <code lang="fsharp">
          /// String.init 10 (fun i -> int '0' + i |> sprintf "%d ")  // evaluates "48 49 50 51 52 53 54 55 56 57 "
          /// </code>
          /// </example>
          [<CompiledName("Initialize")>]
          val init: count:int -> initializer:(int -> string) -> string
  
          /// <summary>Applies the function <c>action</c> to each character in the string.</summary>
          ///
          /// <param name="action">The function to be applied to each character of the string.</param>
          /// <param name="str">The input string.</param>
          /// 
          /// <example id="iter-example-1"> Printing the ASCII code for each characater in the string
          /// <code lang="fsharp">
          /// let input = "Hello"
          /// input |> String.iter (fun c -> printfn "%c %d" c (int c))
          /// // evaluates unit
          /// // prints:
          /// H 72
          /// e 101
          /// l 108
          /// l 108
          /// o 111
          /// </code>
          /// </example>
          [<CompiledName("Iterate")>]
          val iter: action:(char -> unit) -> str:string -> unit
  
          /// <summary>Applies the function <c>action</c> to the index of each character in the string and the
          /// character itself.</summary>
          ///
          /// <param name="action">The function to apply to each character and index of the string.</param>
          /// <param name="str">The input string.</param>
          /// 
          /// <example id="iteri-example-1"> Numbering the characters and printing the associated ASCII code 
          /// for each characater in the input string
          /// <code lang="fsharp">
          /// let input = "Hello"
          /// input |> String.iteri (fun i c -> printfn "%d. %c %d" (i + 1) c (int c))
          /// // evaluates unit
          /// // prints:
          /// 1. H 72
          /// 2. e 101
          /// 3. l 108
          /// 4. l 108
          /// 5. o 111
          /// </code>
          /// </example>
          [<CompiledName("IterateIndexed")>]
          val iteri: action:(int -> char -> unit) -> str:string -> unit
  
          /// <summary>Returns the length of the string.</summary>
          ///
          /// <param name="str">The input string.</param>
          ///
          /// <returns>The number of characters in the string.</returns>
          /// 
          /// <example id="length-example-1"> Getting the length of different strings
          /// <code lang="fsharp">
          /// String.length null   // evaluates 0
          /// String.length ""     // evaluates 0
          /// String.length "123"  // evaluates 3
          /// </code>
          /// </example>
          [<CompiledName("Length")>]
          val length: str:string -> int
  
          /// <summary>Builds a new string whose characters are the results of applying the function <c>mapping</c>
          /// to each of the characters of the input string.</summary>
          ///
          /// <param name="mapping">The function to apply to the characters of the string.</param>
          /// <param name="str">The input string.</param>
          ///
          /// <returns>The resulting string.</returns>
          /// 
          /// <example id="map-example-1"> Changing case to upper for all characters in the input string
          /// <code lang="fsharp">
          /// open System
          /// let input = "Hello there!"
          /// input |> String.map Char.ToUpper  // evaluates "HELLO THERE!"
          /// </code>
          /// </example>
          [<CompiledName("Map")>]
          val map: mapping:(char -> char) -> str:string -> string
  
          /// <summary>Builds a new string whose characters are the results of applying the function <c>mapping</c>
          /// to each character and index of the input string.</summary>
          ///
          /// <param name="mapping">The function to apply to each character and index of the string.</param>
          /// <param name="str">The input string.</param>
          ///
          /// <returns>The resulting string.</returns>
          /// 
          /// <example id="mapi-example-1"> Alternating case for all characters in the input string
          /// <code lang="fsharp">
          /// open System
          /// 
          /// let alternateCase indx chr =
          ///     if 0 = indx % 2 
          ///         then Char.ToUpper chr 
          ///         else Char.ToLower chr
          /// let input = "Hello there!"
          /// input |> String.mapi alternateCase  // evaluates "HeLlO ThErE!"
          /// </code>
          /// </example>
          [<CompiledName("MapIndexed")>]
          val mapi: mapping:(int -> char -> char) -> str:string -> string
  
          /// <summary>Returns a string by concatenating <c>count</c> instances of <c>str</c>.</summary>
          ///
  