anchor.diff:              // Create a new string from the chosen characters.
               ofArray chosenChars.[..chosenCount-1]
   
  +    /// <summary>
       /// Applies a function to each character in the string and the character which
       /// follows it, threading an accumulator argument through the computation.
  +    /// </summary>
  +    /// <param name="folder"></param>
  +    /// <param name="state"></param>
  +    /// <param name="str"></param>
  +    /// <returns></returns>
       [<CompiledName("FoldPairwise")>]
       let foldPairwise (folder : 'State -> char -> char -> 'State) state (str : string) =
           // Preconditions
  
positive.code:     [<CompiledName("Empty")>]
      let [<Literal>] empty = ""
  
      /// Gets a character from a string.
      [<CompiledName("Get")>]
      let inline get (str : string) (index : int) =
          str.[index]
  
      /// Indicates whether the specified string is empty.
      [<CompiledName("IsEmpty")>]
      let inline isEmpty (str : string) =
          str.Length < 1
  
      /// Indicates whether the specified string is null or empty.
      [<CompiledName("IsNullOrEmpty")>]
      let inline isNullOrEmpty (str : string) =
          System.String.IsNullOrEmpty str
  
      /// Creates a string from an F# option value.
      /// If the option value is <c>None</c>, returns an empty string;
      /// returns <c>s</c> when the option value is <c>Some s</c>
      [<CompiledName("OfOption")>]
      let inline ofOption value =
          match value with
          | None -> empty
          | Some str -> str
  
      /// Builds a string from the given character array.
      [<CompiledName("OfArray")>]
      let inline ofArray (chars : char[]) =
          System.String (chars)
  
      /// Creates an F# option value from the specified string.
      /// If the string 's' is null or empty, returns None; otherwise, returns Some s.
      [<CompiledName("ToOption")>]
      let inline toOption str =
          if System.String.IsNullOrEmpty str then None
          else Some str
  
      /// Builds a character array from the given string.
      [<CompiledName("ToArray")>]
      let inline toArray (str : string) =
          str.ToCharArray ()
  
      /// Returns a copy of the given string, converted to lowercase using the
      /// casing rules of the invariant culture.
      [<CompiledName("ToLowerInvariant")>]
      let inline toLower (str : string) : string =
          str.ToLowerInvariant ()
  
      /// Returns a copy of the given string, converted to lowercase using the
      /// casing rules of the invariant culture.
      [<CompiledName("ToUpperInvariant")>]
      let inline toUpper (str : string) : string =
          str.ToUpperInvariant ()
  
      /// Returns a new string created by instantiating the substring.
      [<CompiledName("OfSubstring")>]
      let inline ofSubstring (substr : substring) : string =
          Substring.toString substr
  
      /// Returns a new substring spanning the specified string.
      [<CompiledName("ToSubstring")>]
      let inline toSubstring (str : string) : substring =
          Substring.ofString str
  
      /// Determines whether the beginning of a string matches the specified string.
      [<CompiledName("StartsWith")>]
      let inline startsWith (value : string) (str : string) : bool =
          str.StartsWith value
  
      /// Determines whether the end of a string matches the specified string.
      [<CompiledName("EndsWith")>]
      let inline endsWith (value : string) (str : string) : bool =
          str.EndsWith value
  
      /// Returns a new string in which all occurrences of a specified string
      /// within the given string are replaced with another specified string.
      [<CompiledName("Replace")>]
      let inline replace (oldValue : string) (newValue : string) (str : string) : string =
          str.Replace (oldValue, newValue)
  
      /// Returns a string array that contains the substrings in a string that are delimited
      /// by elements of the given Unicode character array. The returned array will be empty
      /// if and only if the input string is empty.
      [<CompiledName("Split")>]
      let split (chars : char[]) (str : string) =
          if isEmpty str then Array.empty
          else str.Split chars
  
      /// Returns a string array that contains the substrings in a string that are delimited
      /// by elements of a specified string array. The returned array will be empty
      /// if and only if the input string is empty.
      [<CompiledName("Splits")>]
      let splits (strings : string[]) (str : string) =
          if isEmpty str then Array.empty
          else str.Split (strings, System.StringSplitOptions.None)
  
      /// <summary>Returns a new string created by concatenating the strings in the specified string array.</summary>
      /// <remarks>
      /// For a smaller number (&lt;10) of fairly short strings, this method is empirically known
      /// as the fastest way to concatenate them.
      /// </remarks>
      [<CompiledName("ConcatArray")>]
      let inline concatArray (arr : string[]) =
          System.String.Join (empty, arr)
  
      /// Creates a new string by joining the specified strings using
      /// an environment-specific newline character sequence.
      [<CompiledName("OfLines")>]
      let inline ofLines (lines : string[]) =
          System.String.Join (System.Environment.NewLine, lines)
  
      /// Splits a string into individual lines.
      [<CompiledName("ToLines")>]
      let inline toLines (str : string) =
          str.Split ([| "\r\n"; "\r"; "\n" |], System.StringSplitOptions.None)
  
      /// Gets a substring of a string.
      [<CompiledName("Sub")>]
      let inline sub (str : string) offset count : substring =
          substring (str, offset, count)
  
      /// Returns the index of the first occurrence of a specified character within a string.
      [<CompiledName("TryFindIndexOf")>]
      let tryFindIndexOf (c : char) (str : string) =
          // Preconditions
  
negative.code:                 state <- folder.Invoke (str1.[i], str2.[i], state)
              state
  
      /// <summary>Applies the given function to each character of the string.</summary>
      /// <param name="action"></param>
      /// <param name="str"></param>
      /// <returns></returns>
      [<CompiledName("Iterate")>]
      let iter (action : char -> unit) (str : string) : unit =
          // Preconditions
  