anchor.diff:     * The length of the string.
      *
      * Returns the number of UTF-16 code units in this string. The number
  -   * of [runes] might be less, if the string contains characters outside
  -   * the basic multilingual plane (plane 0).
  +   * of [runes] might be fewer, if the string contains characters outside
  +   * the Basic Multilingual Plane (plane 0):
  +   *
  +   *     'Dart'.length;          // 4
  +   *     'Dart'.runes.length;    // 4
  +   *
  +   *     var clef = '\u{1D11E}';
  +   *     clef.length;            // 2
  +   *     clef.runes.length;      // 1
      */
     int get length;
   
     /**
  -   * Returns whether the two strings are equal.
  +   * Returns true if the two strings are equal. False, otherwise.
      *
      * This method compares each individual code unit of the strings.
  -   * Equivalently (for strings that are well-formed UTF-16) it compares each
  -   * individual rune (code point).  It does not check for Unicode equivalence.
  -   * For example the two following strings both represent the string "Amélie"
  -   * but, due to their different encoding will not return equal.
  -   *
  -   *     "Am\xe9lie"
  -   *     "Ame\u{301}lie"
  -   *
  -   * In the first string the "é" is encoded as a single unicode code unit (also
  -   * a single rune), whereas the second string encodes it as "e" with the
  -   * combining accent character "◌́".
  +   * It does not check for Unicode equivalence.
  +   * For example, both the following strings represent the string 'Amélie',
  +   * but due to their different encoding, are not equal:
  +   *
  +   *     'Am\xe9lie' == 'Ame\u{301}lie'; // false
  +   *
  +   * The first string encodes 'é' as a single unicode code unit (also
  +   * a single rune), whereas the second string encodes it as 'e' with the
  +   * combining accent character '◌́'.
      */
     bool operator ==(var other);
   
     /**
  -   * Returns whether this string ends with [other].
  +   * Returns true if this string ends with [other]. For example:
  +   *
  +   *     'Dart'.endsWith('t'); // true
      */
     bool endsWith(String other);
   
     /**
  -   * Returns whether this string starts with a match of [pattern].
  -   *
  -   * If [index] is provided, instead check if the substring starting
  -   * at that index starts with a match of [pattern].
  -   *
  -   * It is an error if [index] is negative or greater than [length].
  -   *
  -   * A [RegExp] containing "^" will not match if the [index] is greater than
  +   * Returns true if this string starts with a match of [pattern].
  +   *
  +   *     var string = 'Dart';
  +   *     string.startsWith('D');                       // true
  +   *     string.startsWith(new RegExp(r'[A-Z][a-z]')); // true
  +   *
  +   * If [index] is provided, this method checks if the substring starting
  +   * at that index starts with a match of [pattern]:
  +   *
  +   *     string.startsWith('art', 1);                  // true
  +   *     string.startsWith(new RegExp(r'\w{3}'));      // true
  +   *
  +   * [index] must not be negative or greater than [length].
  +   *
  +   * A [RegExp] containing '^' does not match if the [index] is greater than
      * zero. The pattern works on the string as a whole, and does not extract
  -   * a substring starting at [index] first. That is.
  -   *     "abc".startsWith(new RegExp("^.", 1)) == false
  +   * a substring starting at [index] first:
  +   *
  +   *     string.startsWith(new RegExp(r'^art'), 1);    // false
  +   *     string.startsWith(new RegExp(r'art'), 1);     // true
      */
     bool startsWith(Pattern pattern, [int index = 0]);
   
     /**
  -   * Returns the first position of a match of [pattern] in this string,
  -   * starting at [start] (inclusive).
  -   *
  -   * Returns -1 if a match could not be found.
  -   *
  -   * It is an error if start is negative or greater than [length].
  +   * Returns the position of the first match of [pattern] in this string,
  +   * starting at [start], inclusive:
  +   *
  +   *     var string = 'Dartisans';
  +   *     string.indexOf('art');                     // 1
  +   *     string.indexOf(new RegExp(r'[A-Z][a-z]')); // 0
  +   *
  +   * Returns -1 if no match is found:
  +   *
  +   *     string.indexOf(new RegExp(r'dart'));       // -1
  +   *
  +   * [start] must not be negative or greater than [length].
      */
     int indexOf(Pattern pattern, [int start]);
   
     /**
  -   * Returns the last position of a match [pattern] in this string, searching
  -   * backward starting at [start] (inclusive).
  +   * Returns the position of the last match [pattern] in this string, searching
  +   * backward starting at [start], inclusive:
  +   *
  +   *     var string = 'Dartisans';
  +   *     string.lastIndexOf('a');                    // 6
  +   *     string.lastIndexOf(new RegExp(r'a(r|n)'));  // 6
      *
      * Returns -1 if [other] could not be found.
      *
  -   * It is an error if start is negative or greater than [length].
  +   *     string.lastIndexOf(new RegExp(r'DART'));    // -1
  +   *
  +   * [start] must not be negative or greater than [length].
      */
     int lastIndexOf(Pattern pattern, [int start]);
   
     /**
  -   * Returns whether this string is empty.
  +   * Returns true if this string is empty.
      */
     bool get isEmpty;
   
     /**
  -   * Returns whether this string is not empty.
  +   * Returns true if this string is not empty.
      */
     bool get isNotEmpty;
   
     /**
      * Creates a new string by concatenating this string with [other].
      *
  -   * A sequence of strings can be concatenated by using [Iterable.join]:
  -   *
  -   *     var strings = ['foo', 'bar', 'geez'];
  -   *     var concatenated = strings.join();
  +   *     'dart' + 'lang'; // 'dartlang'
      */
     String operator +(String other);
   
     /**
  -   * Returns a substring of this string in the given range.
  -   * [startIndex] is inclusive and [endIndex] is exclusive.
  +   * Returns the substring of this string that extends from [startIndex],
  +   * inclusive, to [endIndex], exclusive.
  +   *
  +   *     var string = 'dartlang';
  +   *     string.substring(1);    // 'artlang'
  +   *     string.substring(1, 4); // 'art'
      */
     String substring(int startIndex, [int endIndex]);
   
     /**
      * Removes leading and trailing whitespace from a string.
      *
  -   * If the string contains leading or trailing whitespace a new string with no
  -   * leading and no trailing whitespace is returned. Otherwise, the string
  -   * itself is returned.
  +   * If the string contains leading or trailing whitespace, a new string with no
  +   * leading and no trailing whitespace is returned:
  +   *
  +   *     '\tDart is fun\n'.trim(); // 'Dart is fun'
  +   *
  +   * Otherwise, the original string itself is returned:
  +   *
  +   *     var str1 = 'Dart';
  +   *     var str2 = str1.trim();
  +   *     identical(str1, str2);    // true
      *
      * Whitespace is defined by the Unicode White_Space property (as defined in
      * version 6.2 or later) and the BOM character, 0xFEFF.
  
positive.code:   String trim();
  
    /**
     * Returns whether this string contains a match of [other].
     *
     * If [startIndex] is provided, only matches at or after that index
     * are considered.
     *
     * It is an error if [startIndex] is negative or greater than [length].
     */
    bool contains(Pattern other, [int startIndex = 0]);
  
    /**
     * Returns a new string where the first occurence of [from] in this string
     * is replaced with [to].
     */
    String replaceFirst(Pattern from, String to);
  
    /**
     * Replaces all substrings matching [from] with [replace].
     *
     * Returns a new string where the non-overlapping substrings that match
     * [from] (the ones iterated by `from.allMatches(thisString)`) are replaced
     * by the literal string [replace].
     *
     * Notice that the [replace] string is not interpreted. If the replacement
     * depends on the match (for example on a [RegExp]'s capture groups), use
  
negative.code:    * [onNonMatch] is omitted, the non-matching part is used.
     *
     * Then all the converted parts are combined into the resulting string.
     *
     *     'Eats shoots leaves'.splitMapJoin((new RegExp(r'shoots')),
     *         onMatch:    (m) => '${m.group(0)}',
     *         onNonMatch: (n) => '*'); // *shoots*
     */
    String splitMapJoin(Pattern pattern,
                        {String onMatch(Match match),
  