anchor.diff:              for i = len - 1 downto 0 do
                   state <- folder.Invoke (substring.[i], state)
               state
  -
   
   
   /// Additional functional operators on strings.
  
positive.code:             for i = 0 to len - 1 do
                  action.Invoke (i, substring.[i])
  
      //
      [<CompiledName("IterBack")>]
      let iterBack action (substring : substring) : unit =
          let len = substring.Length
          for i = len - 1 downto 0 do
              action substring.[i]
  
      //
      [<CompiledName("Fold")>]
      let fold (folder : 'State -> char -> 'State) state (substring : substring) : 'State =
          // OPTIMIZATION : Immediately return if the substring is empty.
  
negative.code: 
          //
          [<CompiledName("Iter")>]
          let iter (separator : char[], options : System.StringSplitOptions) (action : substring -> unit) (str : string) : unit =
              // Preconditions
              //checkNonNull "separator" separator
              checkNonNull "str" str
  
              // The string-splitting functionality must be implemented specially for
              // the case where the separator array is null or empty.
              match separator with
              | null
              | [| |] ->
                  // System.Char.IsWhiteSpace
                  notImpl "String.Split.iter"
              | separator ->
                  /// A sorted copy of the separator array. Used to quickly determine if
                  /// a given character is a separator.
                  let sortedSeperators = Array.sort separator
  
                  //System.Array.BinarySearch
  
                  notImpl "String.Split.iter"
  
          //
          [<CompiledName("IterIndexed")>]
          let iteri (separator : char[], options : System.StringSplitOptions) (action : int -> substring -> unit) (str : string) : unit =
              // Preconditions
              checkNonNull "separator" separator
              checkNonNull "str" str
              // TODO : What if separator is empty?
  
              // NOTE : The int passed to the action is not the overall index of the character in the string,
              // but the index into the "virtual" array of separated strings.
              // E.g., if the separator was [| '\n' |] the index value would be the line number.
  
              notImpl "String.Split.iteri"
  
          //
          [<CompiledName("Fold")>]
          let fold (separator : char[], options : System.StringSplitOptions) (folder : 'State -> substring -> 'State) (state : 'State) (str : string) : 'State =
              // Preconditions
              checkNonNull "separator" separator
              checkNonNull "str" str
              // TODO : What if separator is empty?
  
              notImpl "String.Split.fold"
  
          //
          [<CompiledName("FoldIndexed")>]
          let foldi (separator : char[], options : System.StringSplitOptions) (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"
  
  
  //
  module StringOperators =
      type System.String with
          member this.GetSlice (startIndex, finishIndex) : substring =
              let startIndex = defaultArg startIndex 0 
              let finishIndex = defaultArg finishIndex this.Length
              Substring (this, startIndex, finishIndex - startIndex + 1)
  
      type System.Text.StringBuilder with
          /// Appends a copy of the specified substring to this instance.
          member this.Append (value : substring) : System.Text.StringBuilder =
              // OPTIMIZATION : If the substring is null, return immediately.
              let len = value.Length
              if len = 0 then this
              else
                  this.EnsureCapacity (this.Capacity + value.Length) |> ignore
  
                  for i = 0 to len - 1 do
                      this.Append value.[i] |> ignore
                  this
              
          /// Appends a copy of the specified substring to this instance, appending a newline.
          member this.AppendLine (value : substring) : System.Text.StringBuilder =
              let this = this.Append value
              this.AppendLine ()
  