Enum textwrap::word_splitters::WordSplitter

pub enum WordSplitter {
    NoHyphenation,
    HyphenSplitter,
    Custom(fn(word: &str) -> Vec<usize>),
}

The WordSplitter enum describes where words can be split.

If the textwrap crate has been compiled with the hyphenation Cargo feature enabled, you will find a [WordSplitter::Hyphenation] variant. Use this struct for language-aware hyphenation:

#[cfg(feature = "hyphenation")] {
    use hyphenation::{Language, Load, Standard};
    use textwrap::{wrap, Options, WordSplitter};

    let text = "Oxidation is the loss of electrons.";
    let dictionary = Standard::from_embedded(Language::EnglishUS).unwrap();
    let options = Options::new(8).word_splitter(WordSplitter::Hyphenation(dictionary));
    assert_eq!(wrap(text, &options), vec!["Oxida-",
                                          "tion is",
                                          "the loss",
                                          "of elec-",
                                          "trons."]);
}

Please see the documentation for the hyphenation crate for more details.

Variants

NoHyphenation

Use this as a Options.word_splitter to avoid any kind of hyphenation:

use textwrap::{wrap, Options, WordSplitter};

let options = Options::new(8).word_splitter(WordSplitter::NoHyphenation);
assert_eq!(wrap("foo bar-baz", &options),
           vec!["foo", "bar-baz"]);

HyphenSplitter

HyphenSplitter is the default WordSplitter used by Options::new. It will split words on existing hyphens in the word.

It will only use hyphens that are surrounded by alphanumeric characters, which prevents a word like "--foo-bar" from being split into "--" and "foo-bar".

Examples

use textwrap::WordSplitter;

assert_eq!(WordSplitter::HyphenSplitter.split_points("--foo-bar"),
           vec![6]);

Custom(fn(word: &str) -> Vec<usize>)

Use a custom function as the word splitter.

This variant lets you implement a custom word splitter using your own function.

Examples

use textwrap::WordSplitter;

fn split_at_underscore(word: &str) -> Vec<usize> {
    word.match_indices('_').map(|(idx, _)| idx + 1).collect()
}

let word_splitter = WordSplitter::Custom(split_at_underscore);
assert_eq!(word_splitter.split_points("a_long_identifier"),
           vec![2, 7]);

Implementations

impl WordSplitter

pub fn split_points(&self, word: &str) -> Vec<usize>

Return all possible indices where word can be split.

The indices are in the range 0..word.len(). They point to the index after the split point, i.e., after - if splitting on hyphens. This way, word.split_at(idx) will break the word into two well-formed pieces.

Examples

use textwrap::WordSplitter;
assert_eq!(WordSplitter::NoHyphenation.split_points("cannot-be-split"), vec![]);
assert_eq!(WordSplitter::HyphenSplitter.split_points("can-be-split"), vec![4, 7]);
assert_eq!(WordSplitter::Custom(|word| vec![word.len()/2]).split_points("middle"), vec![3]);

Trait Implementations

impl Clone for WordSplitter

fn clone(&self) -> WordSplitter

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for WordSplitter

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for WordSplitter

fn eq(&self, other: &WordSplitter) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.