      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
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116

    use super::plumbing::*;
    use super::ParallelIterator;

    pub(super) fn reduce<PI, R, ID, T>(pi: PI, identity: ID, reduce_op: R) -> T
    where
        PI: ParallelIterator<Item = T>,
        R: Fn(T, T) -> T + Sync,
        ID: Fn() -> T + Sync,
        T: Send,
    {
        let consumer = ReduceConsumer {
            identity: &identity,
            reduce_op: &reduce_op,
        };
        pi.drive_unindexed(consumer)
    }

    struct ReduceConsumer<'r, R: 'r, ID: 'r> {
        identity: &'r ID,
        reduce_op: &'r R,
    }

    impl<'r, R, ID> Copy for ReduceConsumer<'r, R, ID> {}

    impl<'r, R, ID> Clone for ReduceConsumer<'r, R, ID> {
        fn clone(&self) -> Self {
            *self
        }
    }

    impl<'r, R, ID, T> Consumer<T> for ReduceConsumer<'r, R, ID>
    where
        R: Fn(T, T) -> T + Sync,
        ID: Fn() -> T + Sync,
        T: Send,
    {
        type Folder = ReduceFolder<'r, R, T>;
        type Reducer = Self;
        type Result = T;

        fn split_at(self, _index: usize) -> (Self, Self, Self) {
            (self, self, self)
        }

        fn into_folder(self) -> Self::Folder {
            ReduceFolder {
                reduce_op: self.reduce_op,
                item: (self.identity)(),
            }
        }

        fn full(&self) -> bool {
            false
        }
    }

    impl<'r, R, ID, T> UnindexedConsumer<T> for ReduceConsumer<'r, R, ID>
    where
        R: Fn(T, T) -> T + Sync,
        ID: Fn() -> T + Sync,
        T: Send,
    {
        fn split_off_left(&self) -> Self {
            *self
        }

        fn to_reducer(&self) -> Self::Reducer {
            *self
        }
    }

    impl<'r, R, ID, T> Reducer<T> for ReduceConsumer<'r, R, ID>
    where
        R: Fn(T, T) -> T + Sync,
    {
        fn reduce(self, left: T, right: T) -> T {
            (self.reduce_op)(left, right)
        }
    }

    struct ReduceFolder<'r, R: 'r, T> {
        reduce_op: &'r R,
        item: T,
    }

    impl<'r, R, T> Folder<T> for ReduceFolder<'r, R, T>
    where
        R: Fn(T, T) -> T,
    {
        type Result = T;

        fn consume(self, item: T) -> Self {
            ReduceFolder {
                reduce_op: self.reduce_op,
                item: (self.reduce_op)(self.item, item),
            }
        }

        fn consume_iter<I>(self, iter: I) -> Self
        where
            I: IntoIterator<Item = T>,
        {
            ReduceFolder {
                reduce_op: self.reduce_op,
                item: iter.into_iter().fold(self.item, self.reduce_op),
            }
        }

        fn complete(self) -> T {
            self.item
        }

        fn full(&self) -> bool {
            false
        }
    }

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)