Segmenter cleanups, part 2 (reduce trait complexity) (#6417)

First set of followups after
#6409

This:

 - Removes lifetimes and `?Sized` from the BreakType traits
- Coalesces the BreakType markers into a single set of RuleBreakTypeFoo
markers
 - Makes LineBreakType depend on RuleBreakType
 - Adds a new WordBreakType that depends on RuleBreakType


previously the wordbreaktype distinction was awkwardly handled by
`unreachable!()`s and trait impls; which meant it was not
straightforward to make WordBreak use RuleBreakType instead of
WordBreakType. Moving that required moving it to a function, but it
seemed to work well.

This does not intend to finalize the module structure, it's still doing
cleanups, I didn't wish to have these be blocked on module structure
decisions.

A cleanup I may make is to use a secondary type parameter on
RuleBReakIterator instead of a function pointer. It ought not matter,
though.



<!--
Thank you for your pull request to ICU4X!

Reminder: try to use [Conventional
Comments](https://conventionalcomments.org/) to make comments clearer.

Please see
https://github.com/unicode-org/icu4x/blob/main/CONTRIBUTING.md for
general
information on contributing to ICU4X.
-->

Author: Manishearth

components/segmenter/src/complex/dictionary.rs

@@ -9,9 +9,9 @@ use core::str::CharIndices;
 use icu_collections::char16trie::{Char16Trie, TrieResult};
 
 /// A trait for dictionary based iterator
-trait DictionaryType<'l, 's> {
+trait DictionaryType {
     /// The iterator over characters.
-    type IterAttr: Iterator<Item = (usize, Self::CharType)> + Clone;
+    type IterAttr<'s>: Iterator<Item = (usize, Self::CharType)> + Clone;
 
     /// The character type.
     type CharType: Copy + Into<u32>;
@@ -23,11 +23,11 @@ trait DictionaryType<'l, 's> {
 struct DictionaryBreakIterator<
     'l,
     's,
-    Y: DictionaryType<'l, 's> + ?Sized,
+    Y: DictionaryType + ?Sized,
     X: Iterator<Item = usize> + ?Sized,
 > {
     trie: Char16Trie<'l>,
-    iter: Y::IterAttr,
+    iter: Y::IterAttr<'s>,
     len: usize,
     grapheme_iter: X,
     // TODO transform value for byte trie
@@ -41,8 +41,8 @@ struct DictionaryBreakIterator<
 /// - `'s` = lifetime of the string being segmented
 ///
 /// [`Iterator`]: core::iter::Iterator
-impl<'l, 's, Y: DictionaryType<'l, 's> + ?Sized, X: Iterator<Item = usize> + ?Sized> Iterator
-    for DictionaryBreakIterator<'l, 's, Y, X>
+impl<Y: DictionaryType + ?Sized, X: Iterator<Item = usize> + ?Sized> Iterator
+    for DictionaryBreakIterator<'_, '_, Y, X>
 {
     type Item = usize;
 
@@ -106,8 +106,8 @@ impl<'l, 's, Y: DictionaryType<'l, 's> + ?Sized, X: Iterator<Item = usize> + ?Si
     }
 }
 
-impl<'s> DictionaryType<'_, 's> for u32 {
-    type IterAttr = Utf16Indices<'s>;
+impl DictionaryType for u32 {
+    type IterAttr<'s> = Utf16Indices<'s>;
     type CharType = u32;
 
     fn to_char(c: u32) -> char {
@@ -123,8 +123,8 @@ impl<'s> DictionaryType<'_, 's> for u32 {
     }
 }
 
-impl<'s> DictionaryType<'_, 's> for char {
-    type IterAttr = CharIndices<'s>;
+impl DictionaryType for char {
+    type IterAttr<'s> = CharIndices<'s>;
     type CharType = char;
 
     fn to_char(c: char) -> char {

components/segmenter/src/grapheme.rs

@@ -24,7 +24,7 @@ use utf8_iter::Utf8CharIndices;
 ///
 /// For examples of use, see [`GraphemeClusterSegmenter`].
 #[derive(Debug)]
-pub struct GraphemeClusterBreakIterator<'data, 's, Y: RuleBreakType<'s> + ?Sized>(
+pub struct GraphemeClusterBreakIterator<'data, 's, Y: RuleBreakType>(
     RuleBreakIterator<'data, 's, Y>,
 );
 
@@ -34,25 +34,25 @@ derive_usize_iterator_with_type!(GraphemeClusterBreakIterator, 'data);
 ///
 /// For examples of use, see [`GraphemeClusterSegmenter`].
 pub type GraphemeClusterBreakIteratorUtf8<'data, 's> =
-    GraphemeClusterBreakIterator<'data, 's, RuleBreakTypeUtf8>;
+    GraphemeClusterBreakIterator<'data, 's, Utf8>;
 
 /// Grapheme cluster break iterator for a potentially invalid UTF-8 string.
 ///
 /// For examples of use, see [`GraphemeClusterSegmenter`].
 pub type GraphemeClusterBreakIteratorPotentiallyIllFormedUtf8<'data, 's> =
-    GraphemeClusterBreakIterator<'data, 's, RuleBreakTypePotentiallyIllFormedUtf8>;
+    GraphemeClusterBreakIterator<'data, 's, PotentiallyIllFormedUtf8>;
 
 /// Grapheme cluster break iterator for a Latin-1 (8-bit) string.
 ///
 /// For examples of use, see [`GraphemeClusterSegmenter`].
 pub type GraphemeClusterBreakIteratorLatin1<'data, 's> =
-    GraphemeClusterBreakIterator<'data, 's, RuleBreakTypeLatin1>;
+    GraphemeClusterBreakIterator<'data, 's, Latin1>;
 
 /// Grapheme cluster break iterator for a UTF-16 string.
 ///
 /// For examples of use, see [`GraphemeClusterSegmenter`].
 pub type GraphemeClusterBreakIteratorUtf16<'data, 's> =
-    GraphemeClusterBreakIterator<'data, 's, RuleBreakTypeUtf16>;
+    GraphemeClusterBreakIterator<'data, 's, Utf16>;
 
 /// Segments a string into grapheme clusters.
 ///
@@ -195,6 +195,7 @@ impl<'data> GraphemeClusterSegmenterBorrowed<'data> {
             complex: None,
             boundary_property: 0,
             locale_override: None,
+            handle_complex_language: empty_handle_complex_language,
         })
     }
     /// Creates a grapheme cluster break iterator for a potentially ill-formed UTF8 string
@@ -215,6 +216,7 @@ impl<'data> GraphemeClusterSegmenterBorrowed<'data> {
             complex: None,
             boundary_property: 0,
             locale_override: None,
+            handle_complex_language: empty_handle_complex_language,
         })
     }
     /// Creates a grapheme cluster break iterator for a Latin-1 (8-bit) string.
@@ -233,6 +235,7 @@ impl<'data> GraphemeClusterSegmenterBorrowed<'data> {
             complex: None,
             boundary_property: 0,
             locale_override: None,
+            handle_complex_language: empty_handle_complex_language,
         })
     }
 
@@ -252,6 +255,7 @@ impl<'data> GraphemeClusterSegmenterBorrowed<'data> {
             complex: None,
             boundary_property: 0,
             locale_override: None,
+            handle_complex_language: empty_handle_complex_language,
         })
     }
 }

components/segmenter/src/iterator_helpers.rs

@@ -6,7 +6,7 @@
 
 macro_rules! derive_usize_iterator_with_type {
     ($ty:tt, $($lt:lifetime),* ) => {
-        impl<$($lt,)* 's, Y: RuleBreakType<'s> + ?Sized> Iterator for $ty<$($lt,)* 's, Y> {
+        impl<$($lt,)* 's, Y: RuleBreakType> Iterator for $ty<$($lt,)* 's, Y> {
             type Item = usize;
             #[inline]
             fn next(&mut self) -> Option<Self::Item> {

components/segmenter/src/lib.rs

@@ -162,10 +162,9 @@ pub mod options {
 
 /// Largely-internal scaffolding types (You should very rarely need to reference these directly)
 pub mod scaffold {
-    pub use crate::rule_segmenter::{
-        RuleBreakType, RuleBreakTypeLatin1, RuleBreakTypePotentiallyIllFormedUtf8,
-        RuleBreakTypeUtf16, RuleBreakTypeUtf8,
-    };
+    pub use crate::line::LineBreakType;
+    pub use crate::rule_segmenter::{Latin1, PotentiallyIllFormedUtf8, RuleBreakType, Utf16, Utf8};
+    pub use crate::word::WordBreakType;
 }
 
 pub(crate) mod private {