### 6.9 Modification of Strings

procedure: string-replace string char1 char2
procedure: substring-replace string start end char1 char2
procedure: string-replace! string char1 char2
procedure: substring-replace! string start end char1 char2

  These procedures replace all occurrences of char1 with char2 in the original string (substring). `string-replace` and `substring-replace` return a newly allocated string containing the result. `string-replace!` and `substring-replace!` destructively modify string and return an unspecified value.

      (define str "a few words")              ⇒  unspecified
      (string-replace str #\space #\-)        ⇒  "a-few-words"
      (substring-replace str 2 9 #\space #\-) ⇒  "a few-words"
      str                                     ⇒  "a few words"
      (string-replace! str #\space #\-)       ⇒  unspecified
      str                                     ⇒  "a-few-words"

procedure: string-fill! string char

  Stores char in every element of string and returns an unspecified value.

procedure: substring-fill! string start end char

  Stores char in elements start (inclusive) to end (exclusive) of string and returns an unspecified value.

      (define s (make-string 10 #\space))     ⇒  unspecified
      (substring-fill! s 2 8 #\*)             ⇒  unspecified
      s                                       ⇒  "  ******  "

procedure: substring-move-left! string1 start1 end1 string2 start2
procedure: substring-move-right! string1 start1 end1 string2 start2

  Copies the characters from start1 to end1 of string1 into string2 at the start2-th position. The characters are copied as follows (note that this is only important when string1 and string2 are `eqv?`):

  `substring-move-left!`

    The copy starts at the left end and moves toward the right (from smaller indices to larger). Thus if string1 and string2 are the same, this procedure moves the characters toward the left inside the string.

  `substring-move-right!`

    The copy starts at the right end and moves toward the left (from larger indices to smaller). Thus if string1 and string2 are the same, this procedure moves the characters toward the right inside the string.

  The following example shows how these procedures can be used to build up a string (it would have been easier to use `string-append`):

      (define answer (make-string 9 #\*))         ⇒  unspecified
      answer                                      ⇒  "*********"
      (substring-move-left! "start" 0 5 answer 0) ⇒  unspecified
      answer                                      ⇒  "start****"
      (substring-move-left! "-end" 0 4 answer 5)  ⇒  unspecified
      answer                                      ⇒  "start-end"

procedure: reverse-string string
procedure: reverse-substring string start end
procedure: reverse-string! string
procedure: reverse-substring! string start end

  Reverses the order of the characters in the given string or substring. `reverse-string` and `reverse-substring` return newly allocated strings; `reverse-string!` and `reverse-substring!` modify their argument strings and return an unspecified value.

      (reverse-string "foo bar baz")          ⇒ "zab rab oof"
      (reverse-substring "foo bar baz" 4 7)   ⇒ "rab"
      (let ((foo "foo bar baz"))
        (reverse-string! foo)
        foo)                                  ⇒ "zab rab oof"
      (let ((foo "foo bar baz"))
        (reverse-substring! foo 4 7)
        foo)                                  ⇒ "foo rab baz"