module 0.3.1

Modular NixOS-style configuration crate.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use super::cell::MergeCell;
use super::{Error, Merge};

/// Extension trait for [`Iterator`].
///
/// This trait is automatically implemented for every [`Iterator`].
pub trait IteratorExt: Iterator {
    /// Takes an iterator and merges together its items.
    ///
    /// # Panics
    ///
    /// If the iterator is empty. For the non-panicking version of this
    /// method, see: [`try_merge()`].
    ///
    /// # Example
    ///
    /// ```rust
    /// # use module::merge::{Merge, IteratorExt};
    /// let iter = [
    ///     vec![0, 6],
    ///     vec![2, 3, 7],
    ///     vec![],
    ///     vec![1, 5],
    ///     vec![4]
    /// ].into_iter();
    ///
    /// let merged = iter.merge().unwrap();
    ///
    /// assert_eq!(merged, &[0, 6, 2, 3, 7, 1, 5, 4]);
    /// ```
    ///
    /// [`try_merge()`]: Self::try_merge
    fn merge(self) -> Result<Self::Item, Error>
    where
        Self::Item: Merge,
        Self: Sized;

    /// Takes an iterator and merges together its items.
    ///
    /// This is the non-panicking version of [`merge()`].
    ///
    /// Returns [`None`] if the iterator yields no items.
    ///
    /// # Example
    ///
    /// ```rust
    /// # use module::merge::{Merge, IteratorExt};
    /// let iter = std::iter::empty::<()>();
    ///
    /// let r = iter.try_merge();
    ///
    /// assert!(r.is_none());
    /// ```
    ///
    /// [`merge()`]: Self::merge
    fn try_merge(self) -> Option<Result<Self::Item, Error>>
    where
        Self::Item: Merge,
        Self: Sized;
}

impl<I> IteratorExt for I
where
    I: Iterator,
{
    fn merge(self) -> Result<Self::Item, Error>
    where
        Self::Item: Merge,
        Self: Sized,
    {
        self.try_merge()
            .expect("tried to .merge() an empty iterator")
    }

    fn try_merge(self) -> Option<Result<Self::Item, Error>>
    where
        Self::Item: Merge,
        Self: Sized,
    {
        let mut cell = MergeCell::empty();

        for item in self {
            cell.merge(item);
        }

        cell.try_finish()
    }
}