Remove `str::{windows,chunks}` and `<[T]>::subslice_offset`

text/0000-slice-string-symmetry.md

@@ -5,63 +5,64 @@

# Summary

Add some methods that already exist on slices to strings and vice versa.
Specifically, the following methods should be added:
Add some methods that already exist on slices to strings. Specifically, the
following methods should be added:

- `str::chunks`
- `str::windows`
- `str::into_string`
- `String::into_boxed_slice`
- `<[T]>::subslice_offset`
- `String::into_boxed_str`

# Motivation

Conceptually, strings and slices are similar types. Many methods are already
shared between the two types due to their similarity. However, not all methods
are shared between the types, even though many could be. This is a little
unexpected and inconsistent. Because of that, this RFC proposes to remedy this
by adding a few methods to both strings and slices to even out these two types’
available methods.
by adding a few methods to strings to even out these two types’ available
methods.

# Detailed design

Add the following methods to `str`, presumably as inherent methods:
Specifically, it is currently very difficult to construct a `Box<str>`, while it
is fairly simple to make a `Box<[T]>` by using `Vec::into_boxed_slice`. This RFC
proposes a means of creating a `Box<str>` by converting a `String`.

- `chunks(&self, n: usize) -> Chunks`: Returns an iterator that yields the
  *characters* (not bytes) of the string in groups of `n` at a time. Iterator
  element type: `&str`.
# Detailed design

- `windows(&self, n: usize) -> Windows`: Returns an iterator over all contiguous
  windows of character length `n`. Iterator element type: `&str`.
Add the following method to `str`, presumably as an inherent method:

- `into_string(self: Box<str>) -> String`: Returns `self` as a `String`. This is
  equivalent to `[T]`’s `into_vec`.

`split_at(&self, mid: usize) -> (&str, &str)` would also be on this list, but
there is [an existing RFC](https://github.com/rust-lang/rfcs/pull/1123) for it.

Add the following method to `String` as an inherent method:

- `into_boxed_slice(self) -> Box<str>`: Returns `self` as a `Box<str>`,
- `into_boxed_str(self) -> Box<str>`: Returns `self` as a `Box<str>`,
  reallocating to cut off any excess capacity if needed. This is required to
  provide a safe means of creating `Box<str>`.

Add the following method to `[T]` (for all `T`), presumably as an inherent
method:
  provide a safe means of creating `Box<str>`. This is equivalent to `Vec<T>`’s
  `into_boxed_slice`.

- `subslice_offset(&self, inner: &[T]) -> usize`: Returns the offset (in
  elements) of an inner slice relative to an outer slice. Panics of `inner` is
  not contained within `self`.

# Drawbacks

- `str::subslice_offset` is already unstable, so creating a similar method on
  `[T]` is perhaps not such a good idea.
None, yet.

# Alternatives

- Do a subset of the proposal. For example, the `Box<str>`-related methods could
  be removed.
- The original version of this RFC had a few extra methods:
  - `str::chunks(&self, n: usize) -> Chunks`: Returns an iterator that yields
    the *characters* (not bytes) of the string in groups of `n` at a time.
    Iterator element type: `&str`.

  - `str::windows(&self, n: usize) -> Windows`: Returns an iterator over all
    contiguous windows of character length `n`. Iterator element type: `&str`.

    This and `str::chunks` aren’t really useful without proper treatment of
    graphemes, so they were removed from the RFC.

  - `<[T]>::subslice_offset(&self, inner: &[T]) -> usize`: Returns the offset
    (in elements) of an inner slice relative to an outer slice. Panics of
    `inner` is not contained within `self`.

    `str::subslice_offset` isn’t yet stable and its usefulness is dubious, so
    this method was removed from the RFC.


# Unresolved questions