anchor.diff:              notImpl "String.Split.fold"
   
           //
  -        let foldi (separator : char[]) (folder : int -> 'State -> string -> 'State) (state : 'State) (str : string) : 'State =
  +        [<CompiledName("FoldIndexed")>]
  +        let foldi (separator : char[]) (folder : 'State -> int -> substring -> 'State) (state : 'State) (str : string) : 'State =
               // Preconditions
               checkNonNull "separator" separator
               checkNonNull "str" str
               // TODO : What if separator is empty?
   
               notImpl "String.Split.foldi"
  -    *)
  -    (*
  -    - String.Split.filter
  -    - String.Split.choose
  -      - These functions should work like .Split(...) |> Array.iter (or Array.fold, etc.),
  -        except that they won't actually need to traverse the entire string first and split
  -        it into an array of substrings. Instead, they'll improve performance by allowing us
  -        to execute a function on each of the substrings in a single forward pass.
  -      - We might be able to further improve performance by not actually applying the given
  -        function to the substrings themselves, but instead to some struct representing the
  -        initial position and length of the substring; this may be enough information for some
  -        functions (e.g., to filter out strings less than 10 characters), but then we'd easily
  -        be able to create the substring from that information if necessary.
  -            - Perhaps create some type that has a field containing a Lazy<string> which could
  -              create the string value if the user wants it.
  -      - This could be implemented by using the regular vector type / functions from fsharplex.
  -    *)
  -
  +
  +
  +////
  +//module StringOperators =
  +//    //
  +//    type System.String with
  +//        // TODO : Re-implement the slice operator on strings so it returns a substring instead of a new string.
  +
  
positive.code:     member this.ToArray () : char[] =
          this.String.ToCharArray (this.Offset, this.Length)
  
  //
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module Substring =
      open OptimizedClosures
  
      //
      [<CompiledName("IsEmpty")>]
      let inline isEmpty (substring : Substring) : bool =
          substring.IsEmpty
  
      //
      [<CompiledName("ToString")>]
      let inline toString (substring : Substring) : string =
          substring.ToString ()
  
      //
      [<CompiledName("ToArray")>]
      let inline toArray (substring : Substring) : char[] =
          substring.ToArray ()
  
      //
      [<CompiledName("Iter")>]
      let iter action (substring : Substring) : unit =
          let len = substring.Length
          for i = 0 to len - 1 do
              action substring.[i]
  
      //
      [<CompiledName("IterIndexed")>]
      let iteri action (substring : Substring) : unit =
          // OPTIMIZATION : Immediately return if the substring is empty.
          let len = substring.Length
          if len > 0 then
  
negative.code: 
      //
      [<CompiledName("FoldIndexed")>]
      let foldi (folder : 'State -> int -> char -> 'State) state (substring : substring) : 'State =
          // OPTIMIZATION : Immediately return if the substring is empty.
          let len = substring.Length
          if len = 0 then state
  