Struct WordBreakOptions 

#[non_exhaustive]
pub struct WordBreakOptions<'a> {
    pub content_locale: Option<&'a LanguageIdentifier>,
    pub invariant_options: WordBreakInvariantOptions,
}

Options to tailor word breaking behavior.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

content_locale: Option<&'a LanguageIdentifier>

Content locale for word segmenter

If you know the language of the text being segmented, provide it here in order to produce higher quality breakpoints.

Examples

Normally, a colon character ‘:’ is a word separator:

use icu::segmenter::WordSegmenter;

let segmenter = WordSegmenter::new_auto(Default::default());

let breakpoints: Vec<usize> = segmenter.segment_str("EU:ssa").collect();
assert_eq!(&breakpoints, &[0, 2, 3, 6]);

But not in Finnish, where it is used for loanwords:

use icu::locale::langid;
use icu::segmenter::options::WordBreakOptions;
use icu::segmenter::WordSegmenter;

let mut options = WordBreakOptions::default();
let langid = &langid!("fi");
options.content_locale = Some(langid);
let segmenter = WordSegmenter::try_new_auto(options).unwrap();

let breakpoints: Vec<usize> =
    segmenter.as_borrowed().segment_str("EU:ssa").collect();
assert_eq!(&breakpoints, &[0, 6]);

invariant_options: WordBreakInvariantOptions

Options independent of the locale

Trait Implementations

impl<'a> Clone for WordBreakOptions<'a>

fn clone(&self) -> WordBreakOptions<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for WordBreakOptions<'a>

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

Formats the value using the given formatter.

impl<'a> Default for WordBreakOptions<'a>

fn default() -> WordBreakOptions<'a>

Returns the “default value” for a type.

impl<'a> PartialEq for WordBreakOptions<'a>

fn eq(&self, other: &WordBreakOptions<'a>) -> 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.

impl<'a> Copy for WordBreakOptions<'a>

impl<'a> Eq for WordBreakOptions<'a>

impl<'a> StructuralPartialEq for WordBreakOptions<'a>