Switch to static dispatch by default.

This commit essentially changes the return type of `Options::new` from
`Options<Box<dyn WordSplitter>>` to `Options<HyphenSplitter>`, also making
it a `const fn` in the process.

Also the `Options::splitter` method is changed in order to allow returning
a `Options` with a different type parameter, which is sort of necessary for
static dispatch. However, this also allows to change to dynamic dispatch.
This also make the `Options::new(w).splitter(s)` combination consistently
equivalent to `Options::with_splitter(w, s)`, tho only the latter is a
`const fn`.

Also test cases have been adapted to favor static dispatch.

benches/linear.rs

@@ -23,11 +23,16 @@ pub fn benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("String lengths");
     for length in [100, 200, 400, 800, 1600].iter() {
         let text = lorem_ipsum(*length);
-        let mut options = textwrap::Options::new(LINE_LENGTH);
+        let options = textwrap::Options::new(LINE_LENGTH);
         group.bench_with_input(BenchmarkId::new("fill", length), &text, |b, text| {
             b.iter(|| textwrap::fill(text, &options));
         });
 
+        let options: textwrap::Options = options.splitter(Box::new(textwrap::HyphenSplitter));
+        group.bench_with_input(BenchmarkId::new("fill_boxed", length), &text, |b, text| {
+            b.iter(|| textwrap::fill(text, &options));
+        });
+
         group.bench_with_input(BenchmarkId::new("fill_usize", length), &text, |b, text| {
             b.iter(|| textwrap::fill(text, LINE_LENGTH));
         });
@@ -39,11 +44,11 @@ pub fn benchmark(c: &mut Criterion) {
                 .join("benches")
                 .join("la.standard.bincode");
             let dictionary = Standard::from_path(Language::Latin, &path).unwrap();
-            options.splitter = Box::new(dictionary);
+            let options = options.splitter(dictionary);
             group.bench_with_input(BenchmarkId::new("hyphenation", length), &text, |b, text| {
                 b.iter(|| textwrap::fill(text, &options));
             });
-        }
+        };
     }
     group.finish();
 }

examples/hyphenation.rs

@@ -12,6 +12,6 @@ fn main() {
 fn main() {
     let text = "textwrap: a small library for wrapping text.";
     let dictionary = Standard::from_embedded(Language::EnglishUS).unwrap();
-    let options = textwrap::Options::new(18).splitter(Box::new(dictionary));
+    let options = textwrap::Options::new(18).splitter(dictionary);
     println!("{}", textwrap::fill(text, &options));
 }

examples/interactive.rs

@@ -164,7 +164,7 @@ mod unix_only {
         }
 
         let mut label = labels.pop().unwrap();
-        let mut options = Options::new(initial_width);
+        let mut options: Options = Options::new(initial_width).splitter(Box::new(HyphenSplitter));
         options.break_words = false;
         options.splitter = splitters.pop().unwrap();
 
@@ -203,7 +203,7 @@ mod unix_only {
 
         // TODO: change to cursor::DefaultStyle if
         // https://github.com/redox-os/termion/pull/157 is merged.
-        screen.write(b"\x1b[0 q")?;
+        screen.write_all(b"\x1b[0 q")?;
         screen.flush()
     }
 }

examples/layout.rs

@@ -1,12 +1,12 @@
-use textwrap::{wrap, Options};
+use textwrap::{wrap, HyphenSplitter, Options};
 
 fn main() {
     let example = "Memory safety without garbage collection. \
                    Concurrency without data races. \
                    Zero-cost abstractions.";
     let mut prev_lines = vec![];
 
-    let mut options = Options::new(0);
+    let mut options: Options = Options::new(0).splitter(Box::new(HyphenSplitter));
     #[cfg(feature = "hyphenation")]
     {
         use hyphenation::Load;

examples/termwidth.rs

@@ -21,9 +21,9 @@ fn main() {
     #[cfg(feature = "hyphenation")]
     let (msg, options) = (
         "with hyphenation",
-        Options::with_termwidth().splitter(Box::new(
+        Options::with_termwidth().splitter(
             hyphenation::Standard::from_embedded(hyphenation::Language::EnglishUS).unwrap(),
-        )),
+        ),
     );
 
     println!("Formatted {} in {} columns:", msg, options.width);

src/core.rs

@@ -236,7 +236,7 @@ pub fn find_words(line: &str) -> impl Iterator<Item = Word> {
 /// );
 ///
 /// // The NoHyphenation splitter ignores the '-':
-/// let options = Options::new(80).splitter(Box::new(NoHyphenation));
+/// let options = Options::new(80).splitter(NoHyphenation);
 /// assert_eq!(
 ///     split_words(vec![Word::from("foo-bar")], &&options).collect::<Vec<_>>(),
 ///     vec![Word::from("foo-bar")]
@@ -548,7 +548,7 @@ mod tests {
             }
         }
 
-        let options = Options::new(80).splitter(Box::new(FixedSplitPoint));
+        let options = Options::new(80).splitter(FixedSplitPoint);
         assert_iter_eq!(
             split_words(vec![Word::from("foobar")].into_iter(), &&options),
             vec![