RPM build fix (reverted CI changes which will need to be un-reverted or made conditional) and vendor Rust dependencies to make builds much faster in any CI system.
This commit is contained in:
Adam Ierymenko
1
zeroidc/vendor/itertools/.cargo-checksum.json
vendored
Normal file
1
zeroidc/vendor/itertools/.cargo-checksum.json
vendored
Normal file
File diff suppressed because one or more lines are too long
373
zeroidc/vendor/itertools/CHANGELOG.md
vendored
Normal file
373
zeroidc/vendor/itertools/CHANGELOG.md
vendored
Normal file
@@ -0,0 +1,373 @@
|
||||
# Changelog
|
||||
|
||||
## 0.10.2
|
||||
- Add `Itertools::multiunzip` (#362, #565)
|
||||
- Add `intersperse` and `intersperse_with` free functions (#555)
|
||||
- Add `Itertools::sorted_by_cached_key` (#424, #575)
|
||||
- Specialize `ProcessResults::fold` (#563)
|
||||
- Fix subtraction overflow in `DuplicatesBy::size_hint` (#552)
|
||||
- Fix specialization tests (#574)
|
||||
- More `Debug` impls (#573)
|
||||
- Deprecate `fold1` (use `reduce` instead) (#580)
|
||||
- Documentation fixes (`HomogenousTuple`, `into_group_map`, `into_group_map_by`, `MultiPeek::peek`) (#543 et al.)
|
||||
|
||||
## 0.10.1
|
||||
- Add `Itertools::contains` (#514)
|
||||
- Add `Itertools::counts_by` (#515)
|
||||
- Add `Itertools::partition_result` (#511)
|
||||
- Add `Itertools::all_unique` (#241)
|
||||
- Add `Itertools::duplicates` and `Itertools::duplicates_by` (#502)
|
||||
- Add `chain!` (#525)
|
||||
- Add `Itertools::at_most_one` (#523)
|
||||
- Add `Itertools::flatten_ok` (#527)
|
||||
- Add `EitherOrBoth::or_default` (#583)
|
||||
- Add `Itertools::find_or_last` and `Itertools::find_or_first` (#535)
|
||||
- Implement `FusedIterator` for `FilterOk`, `FilterMapOk`, `InterleaveShortest`, `KMergeBy`, `MergeBy`, `PadUsing`, `Positions`, `Product` , `RcIter`, `TupleWindows`, `Unique`, `UniqueBy`, `Update`, `WhileSome`, `Combinations`, `CombinationsWithReplacement`, `Powerset`, `RepeatN`, and `WithPosition` (#550)
|
||||
- Implement `FusedIterator` for `Interleave`, `IntersperseWith`, and `ZipLongest` (#548)
|
||||
|
||||
## 0.10.0
|
||||
- **Increase minimum supported Rust version to 1.32.0**
|
||||
- Improve macro hygiene (#507)
|
||||
- Add `Itertools::powerset` (#335)
|
||||
- Add `Itertools::sorted_unstable`, `Itertools::sorted_unstable_by`, and `Itertools::sorted_unstable_by_key` (#494)
|
||||
- Implement `Error` for `ExactlyOneError` (#484)
|
||||
- Undeprecate `Itertools::fold_while` (#476)
|
||||
- Tuple-related adapters work for tuples of arity up to 12 (#475)
|
||||
- `use_alloc` feature for users who have `alloc`, but not `std` (#474)
|
||||
- Add `Itertools::k_smallest` (#473)
|
||||
- Add `Itertools::into_grouping_map` and `GroupingMap` (#465)
|
||||
- Add `Itertools::into_grouping_map_by` and `GroupingMapBy` (#465)
|
||||
- Add `Itertools::counts` (#468)
|
||||
- Add implementation of `DoubleEndedIterator` for `Unique` (#442)
|
||||
- Add implementation of `DoubleEndedIterator` for `UniqueBy` (#442)
|
||||
- Add implementation of `DoubleEndedIterator` for `Zip` (#346)
|
||||
- Add `Itertools::multipeek` (#435)
|
||||
- Add `Itertools::dedup_with_count` and `DedupWithCount` (#423)
|
||||
- Add `Itertools::dedup_by_with_count` and `DedupByWithCount` (#423)
|
||||
- Add `Itertools::intersperse_with` and `IntersperseWith` (#381)
|
||||
- Add `Itertools::filter_ok` and `FilterOk` (#377)
|
||||
- Add `Itertools::filter_map_ok` and `FilterMapOk` (#377)
|
||||
- Deprecate `Itertools::fold_results`, use `Itertools::fold_ok` instead (#377)
|
||||
- Deprecate `Itertools::map_results`, use `Itertools::map_ok` instead (#377)
|
||||
- Deprecate `FoldResults`, use `FoldOk` instead (#377)
|
||||
- Deprecate `MapResults`, use `MapOk` instead (#377)
|
||||
- Add `Itertools::circular_tuple_windows` and `CircularTupleWindows` (#350)
|
||||
- Add `peek_nth` and `PeekNth` (#303)
|
||||
|
||||
## 0.9.0
|
||||
- Fix potential overflow in `MergeJoinBy::size_hint` (#385)
|
||||
- Add `derive(Clone)` where possible (#382)
|
||||
- Add `try_collect` method (#394)
|
||||
- Add `HomogeneousTuple` trait (#389)
|
||||
- Fix `combinations(0)` and `combinations_with_replacement(0)` (#383)
|
||||
- Don't require `ParitalEq` to the `Item` of `DedupBy` (#397)
|
||||
- Implement missing specializations on the `PutBack` adaptor and on the `MergeJoinBy` iterator (#372)
|
||||
- Add `position_*` methods (#412)
|
||||
- Derive `Hash` for `EitherOrBoth` (#417)
|
||||
- Increase minimum supported Rust version to 1.32.0
|
||||
|
||||
## 0.8.2
|
||||
- Use `slice::iter` instead of `into_iter` to avoid future breakage (#378, by @LukasKalbertodt)
|
||||
## 0.8.1
|
||||
- Added a [`.exactly_one()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.exactly_one) iterator method that, on success, extracts the single value of an iterator ; by @Xaeroxe
|
||||
- Added combinatory iterator adaptors:
|
||||
- [`.permutations(k)`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.permutations):
|
||||
|
||||
`[0, 1, 2].iter().permutations(2)` yields
|
||||
|
||||
```rust
|
||||
[
|
||||
vec![0, 1],
|
||||
vec![0, 2],
|
||||
vec![1, 0],
|
||||
vec![1, 2],
|
||||
vec![2, 0],
|
||||
vec![2, 1],
|
||||
]
|
||||
```
|
||||
|
||||
; by @tobz1000
|
||||
|
||||
- [`.combinations_with_replacement(k)`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.combinations_with_replacement):
|
||||
|
||||
`[0, 1, 2].iter().combinations_with_replacement(2)` yields
|
||||
|
||||
```rust
|
||||
[
|
||||
vec![0, 0],
|
||||
vec![0, 1],
|
||||
vec![0, 2],
|
||||
vec![1, 1],
|
||||
vec![1, 2],
|
||||
vec![2, 2],
|
||||
]
|
||||
```
|
||||
|
||||
; by @tommilligan
|
||||
|
||||
- For reference, these methods join the already existing [`.combinations(k)`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.combinations):
|
||||
|
||||
`[0, 1, 2].iter().combinations(2)` yields
|
||||
|
||||
```rust
|
||||
[
|
||||
vec![0, 1],
|
||||
vec![0, 2],
|
||||
vec![1, 2],
|
||||
]
|
||||
```
|
||||
|
||||
- Improved the performance of [`.fold()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.fold)-based internal iteration for the [`.intersperse()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.intersperse) iterator ; by @jswrenn
|
||||
- Added [`.dedup_by()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.dedup_by), [`.merge_by()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.merge_by) and [`.kmerge_by()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.kmerge_by) adaptors that work like [`.dedup()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.dedup), [`.merge()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.merge) and [`.kmerge()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.kmerge), but taking an additional custom comparison closure parameter. ; by @phimuemue
|
||||
- Improved the performance of [`.all_equal()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.all_equal) ; by @fyrchik
|
||||
- Loosened the bounds on [`.partition_map()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.partition_map) to take just a `FnMut` closure rather than a `Fn` closure, and made its implementation use internal iteration for better performance ; by @danielhenrymantilla
|
||||
- Added convenience methods to [`EitherOrBoth`](https://docs.rs/itertools/0.8.1/itertools/enum.EitherOrBoth.html) elements yielded from the [`.zip_longest()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.zip_longest) iterator adaptor ; by @Avi-D-coder
|
||||
- Added [`.sum1()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.sum1) and [`.product1()`](https://docs.rs/itertools/0.8.1/itertools/trait.Itertools.html#method.product1) iterator methods that respectively try to return the sum and the product of the elements of an iterator **when it is not empty**, otherwise they return `None` ; by @Emerentius
|
||||
## 0.8.0
|
||||
- Added new adaptor `.map_into()` for conversions using `Into` by @vorner
|
||||
- Improved `Itertools` docs by @JohnHeitmann
|
||||
- The return type of `.sorted_by_by_key()` is now an iterator, not a Vec.
|
||||
- The return type of the `izip!(x, y)` macro with exactly two arguments is now the usual `Iterator::zip`.
|
||||
- Remove `.flatten()` in favour of std's `.flatten()`
|
||||
- Deprecate `.foreach()` in favour of std's `.for_each()`
|
||||
- Deprecate `.step()` in favour of std's `.step_by()`
|
||||
- Deprecate `repeat_call` in favour of std's `repeat_with`
|
||||
- Deprecate `.fold_while()` in favour of std's `.try_fold()`
|
||||
- Require Rust 1.24 as minimal version.
|
||||
## 0.7.11
|
||||
- Add convenience methods to `EitherOrBoth`, making it more similar to `Option` and `Either` by @jethrogb
|
||||
## 0.7.10
|
||||
- No changes.
|
||||
## 0.7.9
|
||||
- New inclusion policy: See the readme about suggesting features for std before accepting them in itertools.
|
||||
- The `FoldWhile` type now implements `Eq` and `PartialEq` by @jturner314
|
||||
## 0.7.8
|
||||
- Add new iterator method `.tree_fold1()` which is like `.fold1()` except items are combined in a tree structure (see its docs). By @scottmcm
|
||||
- Add more `Debug` impls by @phimuemue: KMerge, KMergeBy, MergeJoinBy, ConsTuples, Intersperse, ProcessResults, RcIter, Tee, TupleWindows, Tee, ZipLongest, ZipEq, Zip.
|
||||
## 0.7.7
|
||||
- Add new iterator method `.into_group_map() -> HashMap<K, Vec<V>>` which turns an iterator of `(K, V)` elements into such a hash table, where values are grouped by key. By @tobz1000
|
||||
- Add new free function `flatten` for the `.flatten()` adaptor. **NOTE:** recent Rust nightlies have `Iterator::flatten` and thus a clash with our flatten adaptor. One workaround is to use the itertools `flatten` free function.
|
||||
## 0.7.6
|
||||
- Add new adaptor `.multi_cartesian_product()` which is an n-ary product iterator by @tobz1000
|
||||
- Add new method `.sorted_by_key()` by @Xion
|
||||
- Provide simpler and faster `.count()` for `.unique()` and `.unique_by()`
|
||||
## 0.7.5
|
||||
- `.multipeek()` now implements `PeekingNext`, by @nicopap.
|
||||
## 0.7.4
|
||||
- Add new adaptor `.update()` by @lucasem; this adaptor is used to modify an element before passing it on in an iterator chain.
|
||||
## 0.7.3
|
||||
- Add new method `.collect_tuple()` by @matklad; it makes a tuple out of the iterator's elements if the number of them matches **exactly**.
|
||||
- Implement `fold` and `collect` for `.map_results()` which means it reuses the code of the standard `.map()` for these methods.
|
||||
## 0.7.2
|
||||
- Add new adaptor `.merge_join_by` by @srijs; a heterogeneous merge join for two ordered sequences.
|
||||
## 0.7.1
|
||||
- Iterator adaptors and iterators in itertools now use the same `must_use` reminder that the standard library adaptors do, by @matematikaedit and @bluss *“iterator adaptors are lazy and do nothing unless consumed”*.
|
||||
## 0.7.0
|
||||
- Faster `izip!()` by @krdln
|
||||
- `izip!()` is now a wrapper for repeated regular `.zip()` and a single `.map()`. This means it optimizes as well as the standard library `.zip()` it uses. **Note:** `multizip` and `izip!()` are now different! The former has a named type but the latter optimizes better.
|
||||
- Faster `.unique()`
|
||||
- `no_std` support, which is opt-in!
|
||||
- Many lovable features are still there without std, like `izip!()` or `.format()` or `.merge()`, but not those that use collections.
|
||||
- Trait bounds were required up front instead of just on the type: `group_by`'s `PartialEq` by @Phlosioneer and `repeat_call`'s `FnMut`.
|
||||
- Removed deprecated constructor `Zip::new` — use `izip!()` or `multizip()`
|
||||
## 0.6.5
|
||||
- Fix bug in `.cartesian_product()`'s fold (which only was visible for unfused iterators).
|
||||
## 0.6.4
|
||||
- Add specific `fold` implementations for `.cartesian_product()` and `cons_tuples()`, which improves their performance in fold, foreach, and iterator consumers derived from them.
|
||||
## 0.6.3
|
||||
- Add iterator adaptor `.positions(predicate)` by @tmccombs
|
||||
## 0.6.2
|
||||
- Add function `process_results` which can “lift” a function of the regular values of an iterator so that it can process the `Ok` values from an iterator of `Results` instead, by @shepmaster
|
||||
- Add iterator method `.concat()` which combines all iterator elements into a single collection using the `Extend` trait, by @srijs
|
||||
## 0.6.1
|
||||
- Better size hint testing and subsequent size hint bugfixes by @rkarp. Fixes bugs in product, `interleave_shortest` size hints.
|
||||
- New iterator method `.all_equal()` by @phimuemue
|
||||
## 0.6.0
|
||||
- Deprecated names were removed in favour of their replacements
|
||||
- `.flatten()` does not implement double ended iteration anymore
|
||||
- `.fold_while()` uses `&mut self` and returns `FoldWhile<T>`, for composability #168
|
||||
- `.foreach()` and `.fold1()` use `self`, like `.fold()` does.
|
||||
- `.combinations(0)` now produces a single empty vector. #174
|
||||
## 0.5.10
|
||||
- Add itertools method `.kmerge_by()` (and corresponding free function)
|
||||
- Relaxed trait requirement of `.kmerge()` and `.minmax()` to PartialOrd.
|
||||
## 0.5.9
|
||||
- Add multipeek method `.reset_peek()`
|
||||
- Add categories
|
||||
## 0.5.8
|
||||
- Add iterator adaptor `.peeking_take_while()` and its trait `PeekingNext`.
|
||||
## 0.5.7
|
||||
- Add iterator adaptor `.with_position()`
|
||||
- Fix multipeek's performance for long peeks by using `VecDeque`.
|
||||
## 0.5.6
|
||||
- Add `.map_results()`
|
||||
## 0.5.5
|
||||
- Many more adaptors now implement `Debug`
|
||||
- Add free function constructor `repeat_n`. `RepeatN::new` is now deprecated.
|
||||
## 0.5.4
|
||||
- Add infinite generator function `iterate`, that takes a seed and a closure.
|
||||
## 0.5.3
|
||||
- Special-cased `.fold()` for flatten and put back. `.foreach()` now uses fold on the iterator, to pick up any iterator specific loop implementation.
|
||||
- `.combinations(n)` asserts up front that `n != 0`, instead of running into an error on the second iterator element.
|
||||
## 0.5.2
|
||||
- Add `.tuples::<T>()` that iterates by two, three or four elements at a time (where `T` is a tuple type).
|
||||
- Add `.tuple_windows::<T>()` that iterates using a window of the two, three or four most recent elements.
|
||||
- Add `.next_tuple::<T>()` method, that picks the next two, three or four elements in one go.
|
||||
- `.interleave()` now has an accurate size hint.
|
||||
## 0.5.1
|
||||
- Workaround module/function name clash that made racer crash on completing itertools. Only internal changes needed.
|
||||
## 0.5.0
|
||||
- [Release announcement](https://bluss.github.io/rust/2016/09/26/itertools-0.5.0/)
|
||||
- Renamed:
|
||||
- `combinations` is now `tuple_combinations`
|
||||
- `combinations_n` to `combinations`
|
||||
- `group_by_lazy`, `chunks_lazy` to `group_by`, `chunks`
|
||||
- `Unfold::new` to `unfold()`
|
||||
- `RepeatCall::new` to `repeat_call()`
|
||||
- `Zip::new` to `multizip`
|
||||
- `PutBack::new`, `PutBackN::new` to `put_back`, `put_back_n`
|
||||
- `PutBack::with_value` is now a builder setter, not a constructor
|
||||
- `MultiPeek::new`, `.multipeek()` to `multipeek()`
|
||||
- `format` to `format_with` and `format_default` to `format`
|
||||
- `.into_rc()` to `rciter`
|
||||
- `Partition` enum is now `Either`
|
||||
- Module reorganization:
|
||||
- All iterator structs are under `itertools::structs` but also reexported to the top level, for backwards compatibility
|
||||
- All free functions are reexported at the root, `itertools::free` will be removed in the next version
|
||||
- Removed:
|
||||
- `ZipSlices`, use `.zip()` instead
|
||||
- `.enumerate_from()`, `ZipTrusted`, due to being unstable
|
||||
- `.mend_slices()`, moved to crate `odds`
|
||||
- Stride, StrideMut, moved to crate `odds`
|
||||
- `linspace()`, moved to crate `itertools-num`
|
||||
- `.sort_by()`, use `.sorted_by()`
|
||||
- `.is_empty_hint()`, use `.size_hint()`
|
||||
- `.dropn()`, use `.dropping()`
|
||||
- `.map_fn()`, use `.map()`
|
||||
- `.slice()`, use `.take()` / `.skip()`
|
||||
- helper traits in `misc`
|
||||
- `new` constructors on iterator structs, use `Itertools` trait or free functions instead
|
||||
- `itertools::size_hint` is now private
|
||||
- Behaviour changes:
|
||||
- `format` and `format_with` helpers now panic if you try to format them more than once.
|
||||
- `repeat_call` is not double ended anymore
|
||||
- New features:
|
||||
- tuple flattening iterator is constructible with `cons_tuples`
|
||||
- itertools reexports `Either` from the `either` crate. `Either<L, R>` is an iterator when `L, R` are.
|
||||
- `MinMaxResult` now implements `Copy` and `Clone`
|
||||
- `tuple_combinations` supports 1-4 tuples of combinations (previously just 2)
|
||||
## 0.4.19
|
||||
- Add `.minmax_by()`
|
||||
- Add `itertools::free::cloned`
|
||||
- Add `itertools::free::rciter`
|
||||
- Improve `.step(n)` slightly to take advantage of specialized Fuse better.
|
||||
## 0.4.18
|
||||
- Only changes related to the "unstable" crate feature. This feature is more or less deprecated.
|
||||
- Use deprecated warnings when unstable is enabled. `.enumerate_from()` will be removed imminently since it's using a deprecated libstd trait.
|
||||
## 0.4.17
|
||||
- Fix bug in `.kmerge()` that caused it to often produce the wrong order #134
|
||||
## 0.4.16
|
||||
- Improve precision of the `interleave_shortest` adaptor's size hint (it is now computed exactly when possible).
|
||||
## 0.4.15
|
||||
- Fixup on top of the workaround in 0.4.14. A function in `itertools::free` was removed by mistake and now it is added back again.
|
||||
## 0.4.14
|
||||
- Workaround an upstream regression in a Rust nightly build that broke compilation of of `itertools::free::{interleave, merge}`
|
||||
## 0.4.13
|
||||
- Add `.minmax()` and `.minmax_by_key()`, iterator methods for finding both minimum and maximum in one scan.
|
||||
- Add `.format_default()`, a simpler version of `.format()` (lazy formatting for iterators).
|
||||
## 0.4.12
|
||||
- Add `.zip_eq()`, an adaptor like `.zip()` except it ensures iterators of inequal length don't pass silently (instead it panics).
|
||||
- Add `.fold_while()`, an iterator method that is a fold that can short-circuit.
|
||||
- Add `.partition_map()`, an iterator method that can separate elements into two collections.
|
||||
## 0.4.11
|
||||
- Add `.get()` for `Stride{,Mut}` and `.get_mut()` for `StrideMut`
|
||||
## 0.4.10
|
||||
- Improve performance of `.kmerge()`
|
||||
## 0.4.9
|
||||
- Add k-ary merge adaptor `.kmerge()`
|
||||
- Fix a bug in `.islice()` with ranges `a..b` where a `> b`.
|
||||
## 0.4.8
|
||||
- Implement `Clone`, `Debug` for `Linspace`
|
||||
## 0.4.7
|
||||
- Add function `diff_with()` that compares two iterators
|
||||
- Add `.combinations_n()`, an n-ary combinations iterator
|
||||
- Add methods `PutBack::with_value` and `PutBack::into_parts`.
|
||||
## 0.4.6
|
||||
- Add method `.sorted()`
|
||||
- Add module `itertools::free` with free function variants of common iterator adaptors and methods. For example `enumerate(iterable)`, `rev(iterable)`, and so on.
|
||||
## 0.4.5
|
||||
- Add `.flatten()`
|
||||
## 0.4.4
|
||||
- Allow composing `ZipSlices` with itself
|
||||
## 0.4.3
|
||||
- Write `iproduct!()` as a single expression; this allows temporary values in its arguments.
|
||||
## 0.4.2
|
||||
- Add `.fold_options()`
|
||||
- Require Rust 1.1 or later
|
||||
## 0.4.1
|
||||
- Update `.dropping()` to take advantage of `.nth()`
|
||||
## 0.4.0
|
||||
- `.merge()`, `.unique()` and `.dedup()` now perform better due to not using function pointers
|
||||
- Add free functions `enumerate()` and `rev()`
|
||||
- Breaking changes:
|
||||
- Return types of `.merge()` and `.merge_by()` renamed and changed
|
||||
- Method `Merge::new` removed
|
||||
- `.merge_by()` now takes a closure that returns bool.
|
||||
- Return type of `.dedup()` changed
|
||||
- Return type of `.mend_slices()` changed
|
||||
- Return type of `.unique()` changed
|
||||
- Removed function `times()`, struct `Times`: use a range instead
|
||||
- Removed deprecated macro `icompr!()`
|
||||
- Removed deprecated `FnMap` and method `.fn_map()`: use `.map_fn()`
|
||||
- `.interleave_shortest()` is no longer guaranteed to act like fused
|
||||
## 0.3.25
|
||||
- Rename `.sort_by()` to `.sorted_by()`. Old name is deprecated.
|
||||
- Fix well-formedness warnings from RFC 1214, no user visible impact
|
||||
## 0.3.24
|
||||
- Improve performance of `.merge()`'s ordering function slightly
|
||||
## 0.3.23
|
||||
- Added `.chunks()`, similar to (and based on) `.group_by_lazy()`.
|
||||
- Tweak linspace to match numpy.linspace and make it double ended.
|
||||
## 0.3.22
|
||||
- Added `ZipSlices`, a fast zip for slices
|
||||
## 0.3.21
|
||||
- Remove `Debug` impl for `Format`, it will have different use later
|
||||
## 0.3.20
|
||||
- Optimize `.group_by_lazy()`
|
||||
## 0.3.19
|
||||
- Added `.group_by_lazy()`, a possibly nonallocating group by
|
||||
- Added `.format()`, a nonallocating formatting helper for iterators
|
||||
- Remove uses of `RandomAccessIterator` since it has been deprecated in Rust.
|
||||
## 0.3.17
|
||||
- Added (adopted) `Unfold` from Rust
|
||||
## 0.3.16
|
||||
- Added adaptors `.unique()`, `.unique_by()`
|
||||
## 0.3.15
|
||||
- Added method `.sort_by()`
|
||||
## 0.3.14
|
||||
- Added adaptor `.while_some()`
|
||||
## 0.3.13
|
||||
- Added adaptor `.interleave_shortest()`
|
||||
- Added adaptor `.pad_using()`
|
||||
## 0.3.11
|
||||
- Added `assert_equal` function
|
||||
## 0.3.10
|
||||
- Bugfix `.combinations()` `size_hint`.
|
||||
## 0.3.8
|
||||
- Added source `RepeatCall`
|
||||
## 0.3.7
|
||||
- Added adaptor `PutBackN`
|
||||
- Added adaptor `.combinations()`
|
||||
## 0.3.6
|
||||
- Added `itertools::partition`, partition a sequence in place based on a predicate.
|
||||
- Deprecate `icompr!()` with no replacement.
|
||||
## 0.3.5
|
||||
- `.map_fn()` replaces deprecated `.fn_map()`.
|
||||
## 0.3.4
|
||||
- `.take_while_ref()` *by-ref adaptor*
|
||||
- `.coalesce()` *adaptor*
|
||||
- `.mend_slices()` *adaptor*
|
||||
## 0.3.3
|
||||
- `.dropping_back()` *method*
|
||||
- `.fold1()` *method*
|
||||
- `.is_empty_hint()` *method*
|
||||
726
zeroidc/vendor/itertools/Cargo.lock
generated
vendored
Normal file
726
zeroidc/vendor/itertools/Cargo.lock
generated
vendored
Normal file
@@ -0,0 +1,726 @@
|
||||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 3
|
||||
|
||||
[[package]]
|
||||
name = "atty"
|
||||
version = "0.2.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
|
||||
dependencies = [
|
||||
"hermit-abi",
|
||||
"libc",
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "autocfg"
|
||||
version = "1.0.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
|
||||
|
||||
[[package]]
|
||||
name = "bitflags"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"
|
||||
|
||||
[[package]]
|
||||
name = "bstr"
|
||||
version = "0.2.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "90682c8d613ad3373e66de8c6411e0ae2ab2571e879d2efbf73558cc66f21279"
|
||||
dependencies = [
|
||||
"lazy_static",
|
||||
"memchr",
|
||||
"regex-automata",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "bumpalo"
|
||||
version = "3.7.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9c59e7af012c713f529e7a3ee57ce9b31ddd858d4b512923602f74608b009631"
|
||||
|
||||
[[package]]
|
||||
name = "cast"
|
||||
version = "0.2.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "57cdfa5d50aad6cb4d44dcab6101a7f79925bd59d82ca42f38a9856a28865374"
|
||||
dependencies = [
|
||||
"rustc_version",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "2.33.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37e58ac78573c40708d45522f0d80fa2f01cc4f9b4e2bf749807255454312002"
|
||||
dependencies = [
|
||||
"bitflags",
|
||||
"textwrap",
|
||||
"unicode-width",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion"
|
||||
version = "0.3.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ab327ed7354547cc2ef43cbe20ef68b988e70b4b593cbd66a2a61733123a3d23"
|
||||
dependencies = [
|
||||
"atty",
|
||||
"cast",
|
||||
"clap",
|
||||
"criterion-plot",
|
||||
"csv",
|
||||
"itertools 0.10.0",
|
||||
"lazy_static",
|
||||
"num-traits",
|
||||
"oorandom",
|
||||
"plotters",
|
||||
"rayon",
|
||||
"regex",
|
||||
"serde",
|
||||
"serde_cbor",
|
||||
"serde_derive",
|
||||
"serde_json",
|
||||
"tinytemplate",
|
||||
"walkdir",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "criterion-plot"
|
||||
version = "0.4.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e022feadec601fba1649cfa83586381a4ad31c6bf3a9ab7d408118b05dd9889d"
|
||||
dependencies = [
|
||||
"cast",
|
||||
"itertools 0.9.0",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-channel"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "06ed27e177f16d65f0f0c22a213e17c696ace5dd64b14258b52f9417ccb52db4"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-deque"
|
||||
version = "0.8.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "94af6efb46fef72616855b036a624cf27ba656ffc9be1b9a3c931cfc7749a9a9"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crossbeam-epoch",
|
||||
"crossbeam-utils",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-epoch"
|
||||
version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4ec02e091aa634e2c3ada4a392989e7c3116673ef0ac5b72232439094d73b7fd"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"crossbeam-utils",
|
||||
"lazy_static",
|
||||
"memoffset",
|
||||
"scopeguard",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crossbeam-utils"
|
||||
version = "0.8.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d82cfc11ce7f2c3faef78d8a684447b40d503d9681acebed6cb728d45940c4db"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"lazy_static",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "csv"
|
||||
version = "1.1.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "22813a6dc45b335f9bade10bf7271dc477e81113e89eb251a0bc2a8a81c536e1"
|
||||
dependencies = [
|
||||
"bstr",
|
||||
"csv-core",
|
||||
"itoa",
|
||||
"ryu",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "csv-core"
|
||||
version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "2b2466559f260f48ad25fe6317b3c8dac77b5bdb5763ac7d9d6103530663bc90"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "either"
|
||||
version = "1.6.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e78d4f1cc4ae33bbfc157ed5d5a5ef3bc29227303d595861deb238fcec4e9457"
|
||||
|
||||
[[package]]
|
||||
name = "getrandom"
|
||||
version = "0.1.16"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"libc",
|
||||
"wasi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "half"
|
||||
version = "1.7.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "62aca2aba2d62b4a7f5b33f3712cb1b0692779a56fb510499d5c0aa594daeaf3"
|
||||
|
||||
[[package]]
|
||||
name = "hermit-abi"
|
||||
version = "0.1.18"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "322f4de77956e22ed0e5032c359a0f1273f1f7f0d79bfa3b8ffbc730d7fbcc5c"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.9.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.10.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "37d572918e350e82412fe766d24b15e6682fb2ed2bbe018280caa810397cb319"
|
||||
dependencies = [
|
||||
"either",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itertools"
|
||||
version = "0.10.3"
|
||||
dependencies = [
|
||||
"criterion",
|
||||
"either",
|
||||
"paste",
|
||||
"permutohedron",
|
||||
"quickcheck",
|
||||
"rand",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "itoa"
|
||||
version = "0.4.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "dd25036021b0de88a0aff6b850051563c6516d0bf53f8638938edbb9de732736"
|
||||
|
||||
[[package]]
|
||||
name = "js-sys"
|
||||
version = "0.3.51"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "83bdfbace3a0e81a4253f73b49e960b053e396a11012cbd49b9b74d6a2b67062"
|
||||
dependencies = [
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "lazy_static"
|
||||
version = "1.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.96"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5600b4e6efc5421841a2138a6b082e07fe12f9aaa12783d50e5d13325b26b4fc"
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
version = "0.4.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "memchr"
|
||||
version = "2.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b16bd47d9e329435e309c58469fe0791c2d0d1ba96ec0954152a5ae2b04387dc"
|
||||
|
||||
[[package]]
|
||||
name = "memoffset"
|
||||
version = "0.6.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "59accc507f1338036a0477ef61afdae33cde60840f4dfe481319ce3ad116ddf9"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num-traits"
|
||||
version = "0.2.14"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9a64b1ec5cda2586e284722486d802acf1f7dbdc623e2bfc57e65ca1cd099290"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "num_cpus"
|
||||
version = "1.13.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "05499f3756671c15885fee9034446956fff3f243d6077b91e5767df161f766b3"
|
||||
dependencies = [
|
||||
"hermit-abi",
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "oorandom"
|
||||
version = "11.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575"
|
||||
|
||||
[[package]]
|
||||
name = "paste"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "acbf547ad0c65e31259204bd90935776d1c693cec2f4ff7abb7a1bbbd40dfe58"
|
||||
|
||||
[[package]]
|
||||
name = "permutohedron"
|
||||
version = "0.2.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b687ff7b5da449d39e418ad391e5e08da53ec334903ddbb921db208908fc372c"
|
||||
|
||||
[[package]]
|
||||
name = "pest"
|
||||
version = "2.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "10f4872ae94d7b90ae48754df22fd42ad52ce740b8f370b03da4835417403e53"
|
||||
dependencies = [
|
||||
"ucd-trie",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "plotters"
|
||||
version = "0.3.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "32a3fd9ec30b9749ce28cd91f255d569591cdf937fe280c312143e3c4bad6f2a"
|
||||
dependencies = [
|
||||
"num-traits",
|
||||
"plotters-backend",
|
||||
"plotters-svg",
|
||||
"wasm-bindgen",
|
||||
"web-sys",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "plotters-backend"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b07fffcddc1cb3a1de753caa4e4df03b79922ba43cf882acc1bdd7e8df9f4590"
|
||||
|
||||
[[package]]
|
||||
name = "plotters-svg"
|
||||
version = "0.3.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b38a02e23bd9604b842a812063aec4ef702b57989c37b655254bb61c471ad211"
|
||||
dependencies = [
|
||||
"plotters-backend",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ppv-lite86"
|
||||
version = "0.2.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ac74c624d6b2d21f425f752262f42188365d7b8ff1aff74c82e45136510a4857"
|
||||
|
||||
[[package]]
|
||||
name = "proc-macro2"
|
||||
version = "1.0.27"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0d8caf72986c1a598726adc988bb5984792ef84f5ee5aa50209145ee8077038"
|
||||
dependencies = [
|
||||
"unicode-xid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quickcheck"
|
||||
version = "0.9.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a44883e74aa97ad63db83c4bf8ca490f02b2fc02f92575e720c8551e843c945f"
|
||||
dependencies = [
|
||||
"rand",
|
||||
"rand_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quote"
|
||||
version = "1.0.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c3d0b9745dc2debf507c8422de05d7226cc1f0644216dfdfead988f9b1ab32a7"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand"
|
||||
version = "0.7.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
|
||||
dependencies = [
|
||||
"getrandom",
|
||||
"libc",
|
||||
"rand_chacha",
|
||||
"rand_core",
|
||||
"rand_hc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_chacha"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402"
|
||||
dependencies = [
|
||||
"ppv-lite86",
|
||||
"rand_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_core"
|
||||
version = "0.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
|
||||
dependencies = [
|
||||
"getrandom",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rand_hc"
|
||||
version = "0.2.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c"
|
||||
dependencies = [
|
||||
"rand_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rayon"
|
||||
version = "1.5.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c06aca804d41dbc8ba42dfd964f0d01334eceb64314b9ecf7c5fad5188a06d90"
|
||||
dependencies = [
|
||||
"autocfg",
|
||||
"crossbeam-deque",
|
||||
"either",
|
||||
"rayon-core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "rayon-core"
|
||||
version = "1.9.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d78120e2c850279833f1dd3582f730c4ab53ed95aeaaaa862a2a5c71b1656d8e"
|
||||
dependencies = [
|
||||
"crossbeam-channel",
|
||||
"crossbeam-deque",
|
||||
"crossbeam-utils",
|
||||
"lazy_static",
|
||||
"num_cpus",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex"
|
||||
version = "1.5.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
|
||||
dependencies = [
|
||||
"regex-syntax",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "regex-automata"
|
||||
version = "0.1.10"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
|
||||
|
||||
[[package]]
|
||||
name = "regex-syntax"
|
||||
version = "0.6.25"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
|
||||
|
||||
[[package]]
|
||||
name = "rustc_version"
|
||||
version = "0.3.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f0dfe2087c51c460008730de8b57e6a320782fbfb312e1f4d520e6c6fae155ee"
|
||||
dependencies = [
|
||||
"semver",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ryu"
|
||||
version = "1.0.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "71d301d4193d031abdd79ff7e3dd721168a9572ef3fe51a1517aba235bd8f86e"
|
||||
|
||||
[[package]]
|
||||
name = "same-file"
|
||||
version = "1.0.6"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
|
||||
dependencies = [
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "scopeguard"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
|
||||
|
||||
[[package]]
|
||||
name = "semver"
|
||||
version = "0.11.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "f301af10236f6df4160f7c3f04eec6dbc70ace82d23326abad5edee88801c6b6"
|
||||
dependencies = [
|
||||
"semver-parser",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "semver-parser"
|
||||
version = "0.10.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "00b0bef5b7f9e0df16536d3961cfb6e84331c065b4066afb39768d0e319411f7"
|
||||
dependencies = [
|
||||
"pest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde"
|
||||
version = "1.0.126"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ec7505abeacaec74ae4778d9d9328fe5a5d04253220a85c4ee022239fc996d03"
|
||||
|
||||
[[package]]
|
||||
name = "serde_cbor"
|
||||
version = "0.11.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1e18acfa2f90e8b735b2836ab8d538de304cbb6729a7360729ea5a895d15a622"
|
||||
dependencies = [
|
||||
"half",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_derive"
|
||||
version = "1.0.126"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "963a7dbc9895aeac7ac90e74f34a5d5261828f79df35cbed41e10189d3804d43"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "serde_json"
|
||||
version = "1.0.64"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
|
||||
dependencies = [
|
||||
"itoa",
|
||||
"ryu",
|
||||
"serde",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "syn"
|
||||
version = "1.0.72"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a1e8cdbefb79a9a5a65e0db8b47b723ee907b7c7f8496c76a1770b5c310bab82"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"unicode-xid",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "textwrap"
|
||||
version = "0.11.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
|
||||
dependencies = [
|
||||
"unicode-width",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tinytemplate"
|
||||
version = "1.2.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
|
||||
dependencies = [
|
||||
"serde",
|
||||
"serde_json",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "ucd-trie"
|
||||
version = "0.1.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "56dee185309b50d1f11bfedef0fe6d036842e3fb77413abef29f8f8d1c5d4c1c"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-width"
|
||||
version = "0.1.8"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3"
|
||||
|
||||
[[package]]
|
||||
name = "unicode-xid"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3"
|
||||
|
||||
[[package]]
|
||||
name = "walkdir"
|
||||
version = "2.3.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "808cf2735cd4b6866113f648b791c6adc5714537bc222d9347bb203386ffda56"
|
||||
dependencies = [
|
||||
"same-file",
|
||||
"winapi",
|
||||
"winapi-util",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasi"
|
||||
version = "0.9.0+wasi-snapshot-preview1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.74"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d54ee1d4ed486f78874278e63e4069fc1ab9f6a18ca492076ffb90c5eb2997fd"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"wasm-bindgen-macro",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-backend"
|
||||
version = "0.2.74"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3b33f6a0694ccfea53d94db8b2ed1c3a8a4c86dd936b13b9f0a15ec4a451b900"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"lazy_static",
|
||||
"log",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"wasm-bindgen-shared",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.74"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "088169ca61430fe1e58b8096c24975251700e7b1f6fd91cc9d59b04fb9b18bd4"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"wasm-bindgen-macro-support",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro-support"
|
||||
version = "0.2.74"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "be2241542ff3d9f241f5e2cb6dd09b37efe786df8851c54957683a49f0987a97"
|
||||
dependencies = [
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn",
|
||||
"wasm-bindgen-backend",
|
||||
"wasm-bindgen-shared",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-shared"
|
||||
version = "0.2.74"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d7cff876b8f18eed75a66cf49b65e7f967cb354a7aa16003fb55dbfd25b44b4f"
|
||||
|
||||
[[package]]
|
||||
name = "web-sys"
|
||||
version = "0.3.51"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e828417b379f3df7111d3a2a9e5753706cae29c41f7c4029ee9fd77f3e09e582"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi"
|
||||
version = "0.3.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
|
||||
dependencies = [
|
||||
"winapi-i686-pc-windows-gnu",
|
||||
"winapi-x86_64-pc-windows-gnu",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-i686-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
|
||||
|
||||
[[package]]
|
||||
name = "winapi-util"
|
||||
version = "0.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
|
||||
dependencies = [
|
||||
"winapi",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "winapi-x86_64-pc-windows-gnu"
|
||||
version = "0.4.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||
88
zeroidc/vendor/itertools/Cargo.toml
vendored
Normal file
88
zeroidc/vendor/itertools/Cargo.toml
vendored
Normal file
@@ -0,0 +1,88 @@
|
||||
# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
|
||||
#
|
||||
# When uploading crates to the registry Cargo will automatically
|
||||
# "normalize" Cargo.toml files for maximal compatibility
|
||||
# with all versions of Cargo and also rewrite `path` dependencies
|
||||
# to registry (e.g., crates.io) dependencies
|
||||
#
|
||||
# If you believe there's an error in this file please file an
|
||||
# issue against the rust-lang/cargo repository. If you're
|
||||
# editing this file be aware that the upstream Cargo.toml
|
||||
# will likely look very different (and much more reasonable)
|
||||
|
||||
[package]
|
||||
edition = "2018"
|
||||
name = "itertools"
|
||||
version = "0.10.3"
|
||||
authors = ["bluss"]
|
||||
exclude = ["/bors.toml"]
|
||||
description = "Extra iterator adaptors, iterator methods, free functions, and macros."
|
||||
documentation = "https://docs.rs/itertools/"
|
||||
readme = "README.md"
|
||||
keywords = ["iterator", "data-structure", "zip", "product", "group-by"]
|
||||
categories = ["algorithms", "rust-patterns"]
|
||||
license = "MIT/Apache-2.0"
|
||||
repository = "https://github.com/rust-itertools/itertools"
|
||||
[package.metadata.release]
|
||||
no-dev-version = true
|
||||
[profile.bench]
|
||||
debug = true
|
||||
|
||||
[lib]
|
||||
test = false
|
||||
bench = false
|
||||
|
||||
[[bench]]
|
||||
name = "tuple_combinations"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "tuples"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "fold_specialization"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "combinations_with_replacement"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "tree_fold1"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "bench1"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "combinations"
|
||||
harness = false
|
||||
|
||||
[[bench]]
|
||||
name = "powerset"
|
||||
harness = false
|
||||
[dependencies.either]
|
||||
version = "1.0"
|
||||
default-features = false
|
||||
[dev-dependencies.criterion]
|
||||
version = "=0"
|
||||
|
||||
[dev-dependencies.paste]
|
||||
version = "1.0.0"
|
||||
|
||||
[dev-dependencies.permutohedron]
|
||||
version = "0.2"
|
||||
|
||||
[dev-dependencies.quickcheck]
|
||||
version = "0.9"
|
||||
default-features = false
|
||||
|
||||
[dev-dependencies.rand]
|
||||
version = "0.7"
|
||||
|
||||
[features]
|
||||
default = ["use_std"]
|
||||
use_alloc = []
|
||||
use_std = ["use_alloc"]
|
||||
201
zeroidc/vendor/itertools/LICENSE-APACHE
vendored
Normal file
201
zeroidc/vendor/itertools/LICENSE-APACHE
vendored
Normal file
@@ -0,0 +1,201 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
25
zeroidc/vendor/itertools/LICENSE-MIT
vendored
Normal file
25
zeroidc/vendor/itertools/LICENSE-MIT
vendored
Normal file
@@ -0,0 +1,25 @@
|
||||
Copyright (c) 2015
|
||||
|
||||
Permission is hereby granted, free of charge, to any
|
||||
person obtaining a copy of this software and associated
|
||||
documentation files (the "Software"), to deal in the
|
||||
Software without restriction, including without
|
||||
limitation the rights to use, copy, modify, merge,
|
||||
publish, distribute, sublicense, and/or sell copies of
|
||||
the Software, and to permit persons to whom the Software
|
||||
is furnished to do so, subject to the following
|
||||
conditions:
|
||||
|
||||
The above copyright notice and this permission notice
|
||||
shall be included in all copies or substantial portions
|
||||
of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
|
||||
ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
|
||||
TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
|
||||
PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
|
||||
SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
|
||||
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
||||
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
|
||||
IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
||||
44
zeroidc/vendor/itertools/README.md
vendored
Normal file
44
zeroidc/vendor/itertools/README.md
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
# Itertools
|
||||
|
||||
Extra iterator adaptors, functions and macros.
|
||||
|
||||
Please read the [API documentation here](https://docs.rs/itertools/).
|
||||
|
||||
[](https://github.com/rust-itertools/itertools/actions)
|
||||
[](https://crates.io/crates/itertools)
|
||||
|
||||
How to use with Cargo:
|
||||
|
||||
```toml
|
||||
[dependencies]
|
||||
itertools = "0.10.2"
|
||||
```
|
||||
|
||||
How to use in your crate:
|
||||
|
||||
```rust
|
||||
use itertools::Itertools;
|
||||
```
|
||||
|
||||
## How to contribute
|
||||
|
||||
- Fix a bug or implement a new thing
|
||||
- Include tests for your new feature, preferably a QuickCheck test
|
||||
- Make a Pull Request
|
||||
|
||||
For new features, please first consider filing a PR to [rust-lang/rust](https://github.com/rust-lang/rust),
|
||||
adding your new feature to the `Iterator` trait of the standard library, if you believe it is reasonable.
|
||||
If it isn't accepted there, proposing it for inclusion in ``itertools`` is a good idea.
|
||||
The reason for doing is this is so that we avoid future breakage as with ``.flatten()``.
|
||||
However, if your feature involves heap allocation, such as storing elements in a ``Vec<T>``,
|
||||
then it can't be accepted into ``libcore``, and you should propose it for ``itertools`` directly instead.
|
||||
|
||||
## License
|
||||
|
||||
Dual-licensed to be compatible with the Rust project.
|
||||
|
||||
Licensed under the Apache License, Version 2.0
|
||||
https://www.apache.org/licenses/LICENSE-2.0 or the MIT license
|
||||
https://opensource.org/licenses/MIT, at your
|
||||
option. This file may not be copied, modified, or distributed
|
||||
except according to those terms.
|
||||
877
zeroidc/vendor/itertools/benches/bench1.rs
vendored
Normal file
877
zeroidc/vendor/itertools/benches/bench1.rs
vendored
Normal file
@@ -0,0 +1,877 @@
|
||||
use criterion::{black_box, criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
use itertools::free::cloned;
|
||||
use itertools::iproduct;
|
||||
|
||||
use std::iter::repeat;
|
||||
use std::cmp;
|
||||
use std::ops::{Add, Range};
|
||||
|
||||
mod extra;
|
||||
|
||||
use crate::extra::ZipSlices;
|
||||
|
||||
fn slice_iter(c: &mut Criterion) {
|
||||
let xs: Vec<_> = repeat(1i32).take(20).collect();
|
||||
|
||||
c.bench_function("slice iter", move |b| {
|
||||
b.iter(|| for elt in xs.iter() {
|
||||
black_box(elt);
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn slice_iter_rev(c: &mut Criterion) {
|
||||
let xs: Vec<_> = repeat(1i32).take(20).collect();
|
||||
|
||||
c.bench_function("slice iter rev", move |b| {
|
||||
b.iter(|| for elt in xs.iter().rev() {
|
||||
black_box(elt);
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zip_default_zip(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zip default zip", move |b| {
|
||||
b.iter(|| {
|
||||
for (&x, &y) in xs.iter().zip(&ys) {
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_i32_default_zip(c: &mut Criterion) {
|
||||
let xs = vec![2; 1024];
|
||||
let ys = vec![2; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot i32 default zip", move |b| {
|
||||
b.iter(|| {
|
||||
let mut s = 0;
|
||||
for (&x, &y) in xs.iter().zip(&ys) {
|
||||
s += x * y;
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_f32_default_zip(c: &mut Criterion) {
|
||||
let xs = vec![2f32; 1024];
|
||||
let ys = vec![2f32; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot f32 default zip", move |b| {
|
||||
b.iter(|| {
|
||||
let mut s = 0.;
|
||||
for (&x, &y) in xs.iter().zip(&ys) {
|
||||
s += x * y;
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zip_default_zip3(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let zs = vec![0; 766];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
let zs = black_box(zs);
|
||||
|
||||
c.bench_function("zip default zip3", move |b| {
|
||||
b.iter(|| {
|
||||
for ((&x, &y), &z) in xs.iter().zip(&ys).zip(&zs) {
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
black_box(z);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zip_slices_ziptuple(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
|
||||
c.bench_function("zip slices ziptuple", move |b| {
|
||||
b.iter(|| {
|
||||
let xs = black_box(&xs);
|
||||
let ys = black_box(&ys);
|
||||
for (&x, &y) in itertools::multizip((xs, ys)) {
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipslices(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipslices", move |b| {
|
||||
b.iter(|| {
|
||||
for (&x, &y) in ZipSlices::new(&xs, &ys) {
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipslices_mut(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let xs = black_box(xs);
|
||||
let mut ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipslices mut", move |b| {
|
||||
b.iter(|| {
|
||||
for (&x, &mut y) in ZipSlices::from_slices(&xs[..], &mut ys[..]) {
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_i32_zipslices(c: &mut Criterion) {
|
||||
let xs = vec![2; 1024];
|
||||
let ys = vec![2; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot i32 zipslices", move |b| {
|
||||
b.iter(|| {
|
||||
let mut s = 0i32;
|
||||
for (&x, &y) in ZipSlices::new(&xs, &ys) {
|
||||
s += x * y;
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_f32_zipslices(c: &mut Criterion) {
|
||||
let xs = vec![2f32; 1024];
|
||||
let ys = vec![2f32; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot f32 zipslices", move |b| {
|
||||
b.iter(|| {
|
||||
let mut s = 0.;
|
||||
for (&x, &y) in ZipSlices::new(&xs, &ys) {
|
||||
s += x * y;
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zip_checked_counted_loop(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zip checked counted loop", move |b| {
|
||||
b.iter(|| {
|
||||
// Must slice to equal lengths, and then bounds checks are eliminated!
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
let xs = &xs[..len];
|
||||
let ys = &ys[..len];
|
||||
|
||||
for i in 0..len {
|
||||
let x = xs[i];
|
||||
let y = ys[i];
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_i32_checked_counted_loop(c: &mut Criterion) {
|
||||
let xs = vec![2; 1024];
|
||||
let ys = vec![2; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot i32 checked counted loop", move |b| {
|
||||
b.iter(|| {
|
||||
// Must slice to equal lengths, and then bounds checks are eliminated!
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
let xs = &xs[..len];
|
||||
let ys = &ys[..len];
|
||||
|
||||
let mut s = 0i32;
|
||||
|
||||
for i in 0..len {
|
||||
s += xs[i] * ys[i];
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_f32_checked_counted_loop(c: &mut Criterion) {
|
||||
let xs = vec![2f32; 1024];
|
||||
let ys = vec![2f32; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot f32 checked counted loop", move |b| {
|
||||
b.iter(|| {
|
||||
// Must slice to equal lengths, and then bounds checks are eliminated!
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
let xs = &xs[..len];
|
||||
let ys = &ys[..len];
|
||||
|
||||
let mut s = 0.;
|
||||
|
||||
for i in 0..len {
|
||||
s += xs[i] * ys[i];
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_f32_checked_counted_unrolled_loop(c: &mut Criterion) {
|
||||
let xs = vec![2f32; 1024];
|
||||
let ys = vec![2f32; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot f32 checked counted unrolled loop", move |b| {
|
||||
b.iter(|| {
|
||||
// Must slice to equal lengths, and then bounds checks are eliminated!
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
let mut xs = &xs[..len];
|
||||
let mut ys = &ys[..len];
|
||||
|
||||
let mut s = 0.;
|
||||
let (mut p0, mut p1, mut p2, mut p3, mut p4, mut p5, mut p6, mut p7) =
|
||||
(0., 0., 0., 0., 0., 0., 0., 0.);
|
||||
|
||||
// how to unroll and have bounds checks eliminated (by cristicbz)
|
||||
// split sum into eight parts to enable vectorization (by bluss)
|
||||
while xs.len() >= 8 {
|
||||
p0 += xs[0] * ys[0];
|
||||
p1 += xs[1] * ys[1];
|
||||
p2 += xs[2] * ys[2];
|
||||
p3 += xs[3] * ys[3];
|
||||
p4 += xs[4] * ys[4];
|
||||
p5 += xs[5] * ys[5];
|
||||
p6 += xs[6] * ys[6];
|
||||
p7 += xs[7] * ys[7];
|
||||
|
||||
xs = &xs[8..];
|
||||
ys = &ys[8..];
|
||||
}
|
||||
s += p0 + p4;
|
||||
s += p1 + p5;
|
||||
s += p2 + p6;
|
||||
s += p3 + p7;
|
||||
|
||||
for i in 0..xs.len() {
|
||||
s += xs[i] * ys[i];
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zip_unchecked_counted_loop(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zip unchecked counted loop", move |b| {
|
||||
b.iter(|| {
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
for i in 0..len {
|
||||
unsafe {
|
||||
let x = *xs.get_unchecked(i);
|
||||
let y = *ys.get_unchecked(i);
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_i32_unchecked_counted_loop(c: &mut Criterion) {
|
||||
let xs = vec![2; 1024];
|
||||
let ys = vec![2; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot i32 unchecked counted loop", move |b| {
|
||||
b.iter(|| {
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
let mut s = 0i32;
|
||||
for i in 0..len {
|
||||
unsafe {
|
||||
let x = *xs.get_unchecked(i);
|
||||
let y = *ys.get_unchecked(i);
|
||||
s += x * y;
|
||||
}
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zipdot_f32_unchecked_counted_loop(c: &mut Criterion) {
|
||||
let xs = vec![2.; 1024];
|
||||
let ys = vec![2.; 768];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
|
||||
c.bench_function("zipdot f32 unchecked counted loop", move |b| {
|
||||
b.iter(|| {
|
||||
let len = cmp::min(xs.len(), ys.len());
|
||||
let mut s = 0f32;
|
||||
for i in 0..len {
|
||||
unsafe {
|
||||
let x = *xs.get_unchecked(i);
|
||||
let y = *ys.get_unchecked(i);
|
||||
s += x * y;
|
||||
}
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn zip_unchecked_counted_loop3(c: &mut Criterion) {
|
||||
let xs = vec![0; 1024];
|
||||
let ys = vec![0; 768];
|
||||
let zs = vec![0; 766];
|
||||
let xs = black_box(xs);
|
||||
let ys = black_box(ys);
|
||||
let zs = black_box(zs);
|
||||
|
||||
c.bench_function("zip unchecked counted loop3", move |b| {
|
||||
b.iter(|| {
|
||||
let len = cmp::min(xs.len(), cmp::min(ys.len(), zs.len()));
|
||||
for i in 0..len {
|
||||
unsafe {
|
||||
let x = *xs.get_unchecked(i);
|
||||
let y = *ys.get_unchecked(i);
|
||||
let z = *zs.get_unchecked(i);
|
||||
black_box(x);
|
||||
black_box(y);
|
||||
black_box(z);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn group_by_lazy_1(c: &mut Criterion) {
|
||||
let mut data = vec![0; 1024];
|
||||
for (index, elt) in data.iter_mut().enumerate() {
|
||||
*elt = index / 10;
|
||||
}
|
||||
|
||||
let data = black_box(data);
|
||||
|
||||
c.bench_function("group by lazy 1", move |b| {
|
||||
b.iter(|| {
|
||||
for (_key, group) in &data.iter().group_by(|elt| **elt) {
|
||||
for elt in group {
|
||||
black_box(elt);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn group_by_lazy_2(c: &mut Criterion) {
|
||||
let mut data = vec![0; 1024];
|
||||
for (index, elt) in data.iter_mut().enumerate() {
|
||||
*elt = index / 2;
|
||||
}
|
||||
|
||||
let data = black_box(data);
|
||||
|
||||
c.bench_function("group by lazy 2", move |b| {
|
||||
b.iter(|| {
|
||||
for (_key, group) in &data.iter().group_by(|elt| **elt) {
|
||||
for elt in group {
|
||||
black_box(elt);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn slice_chunks(c: &mut Criterion) {
|
||||
let data = vec![0; 1024];
|
||||
|
||||
let data = black_box(data);
|
||||
let sz = black_box(10);
|
||||
|
||||
c.bench_function("slice chunks", move |b| {
|
||||
b.iter(|| {
|
||||
for group in data.chunks(sz) {
|
||||
for elt in group {
|
||||
black_box(elt);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn chunks_lazy_1(c: &mut Criterion) {
|
||||
let data = vec![0; 1024];
|
||||
|
||||
let data = black_box(data);
|
||||
let sz = black_box(10);
|
||||
|
||||
c.bench_function("chunks lazy 1", move |b| {
|
||||
b.iter(|| {
|
||||
for group in &data.iter().chunks(sz) {
|
||||
for elt in group {
|
||||
black_box(elt);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn equal(c: &mut Criterion) {
|
||||
let data = vec![7; 1024];
|
||||
let l = data.len();
|
||||
let alpha = black_box(&data[1..]);
|
||||
let beta = black_box(&data[..l - 1]);
|
||||
|
||||
c.bench_function("equal", move |b| {
|
||||
b.iter(|| {
|
||||
itertools::equal(alpha, beta)
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn merge_default(c: &mut Criterion) {
|
||||
let mut data1 = vec![0; 1024];
|
||||
let mut data2 = vec![0; 800];
|
||||
let mut x = 0;
|
||||
for (_, elt) in data1.iter_mut().enumerate() {
|
||||
*elt = x;
|
||||
x += 1;
|
||||
}
|
||||
|
||||
let mut y = 0;
|
||||
for (i, elt) in data2.iter_mut().enumerate() {
|
||||
*elt += y;
|
||||
if i % 3 == 0 {
|
||||
y += 3;
|
||||
} else {
|
||||
y += 0;
|
||||
}
|
||||
}
|
||||
let data1 = black_box(data1);
|
||||
let data2 = black_box(data2);
|
||||
|
||||
c.bench_function("merge default", move |b| {
|
||||
b.iter(|| {
|
||||
data1.iter().merge(&data2).count()
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn merge_by_cmp(c: &mut Criterion) {
|
||||
let mut data1 = vec![0; 1024];
|
||||
let mut data2 = vec![0; 800];
|
||||
let mut x = 0;
|
||||
for (_, elt) in data1.iter_mut().enumerate() {
|
||||
*elt = x;
|
||||
x += 1;
|
||||
}
|
||||
|
||||
let mut y = 0;
|
||||
for (i, elt) in data2.iter_mut().enumerate() {
|
||||
*elt += y;
|
||||
if i % 3 == 0 {
|
||||
y += 3;
|
||||
} else {
|
||||
y += 0;
|
||||
}
|
||||
}
|
||||
let data1 = black_box(data1);
|
||||
let data2 = black_box(data2);
|
||||
|
||||
c.bench_function("merge by cmp", move |b| {
|
||||
b.iter(|| {
|
||||
data1.iter().merge_by(&data2, PartialOrd::le).count()
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn merge_by_lt(c: &mut Criterion) {
|
||||
let mut data1 = vec![0; 1024];
|
||||
let mut data2 = vec![0; 800];
|
||||
let mut x = 0;
|
||||
for (_, elt) in data1.iter_mut().enumerate() {
|
||||
*elt = x;
|
||||
x += 1;
|
||||
}
|
||||
|
||||
let mut y = 0;
|
||||
for (i, elt) in data2.iter_mut().enumerate() {
|
||||
*elt += y;
|
||||
if i % 3 == 0 {
|
||||
y += 3;
|
||||
} else {
|
||||
y += 0;
|
||||
}
|
||||
}
|
||||
let data1 = black_box(data1);
|
||||
let data2 = black_box(data2);
|
||||
|
||||
c.bench_function("merge by lt", move |b| {
|
||||
b.iter(|| {
|
||||
data1.iter().merge_by(&data2, |a, b| a <= b).count()
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn kmerge_default(c: &mut Criterion) {
|
||||
let mut data1 = vec![0; 1024];
|
||||
let mut data2 = vec![0; 800];
|
||||
let mut x = 0;
|
||||
for (_, elt) in data1.iter_mut().enumerate() {
|
||||
*elt = x;
|
||||
x += 1;
|
||||
}
|
||||
|
||||
let mut y = 0;
|
||||
for (i, elt) in data2.iter_mut().enumerate() {
|
||||
*elt += y;
|
||||
if i % 3 == 0 {
|
||||
y += 3;
|
||||
} else {
|
||||
y += 0;
|
||||
}
|
||||
}
|
||||
let data1 = black_box(data1);
|
||||
let data2 = black_box(data2);
|
||||
let its = &[data1.iter(), data2.iter()];
|
||||
|
||||
c.bench_function("kmerge default", move |b| {
|
||||
b.iter(|| {
|
||||
its.iter().cloned().kmerge().count()
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn kmerge_tenway(c: &mut Criterion) {
|
||||
let mut data = vec![0; 10240];
|
||||
|
||||
let mut state = 1729u16;
|
||||
fn rng(state: &mut u16) -> u16 {
|
||||
let new = state.wrapping_mul(31421) + 6927;
|
||||
*state = new;
|
||||
new
|
||||
}
|
||||
|
||||
for elt in &mut data {
|
||||
*elt = rng(&mut state);
|
||||
}
|
||||
|
||||
let mut chunks = Vec::new();
|
||||
let mut rest = &mut data[..];
|
||||
while rest.len() > 0 {
|
||||
let chunk_len = 1 + rng(&mut state) % 512;
|
||||
let chunk_len = cmp::min(rest.len(), chunk_len as usize);
|
||||
let (fst, tail) = {rest}.split_at_mut(chunk_len);
|
||||
fst.sort();
|
||||
chunks.push(fst.iter().cloned());
|
||||
rest = tail;
|
||||
}
|
||||
|
||||
// println!("Chunk lengths: {}", chunks.iter().format_with(", ", |elt, f| f(&elt.len())));
|
||||
|
||||
c.bench_function("kmerge tenway", move |b| {
|
||||
b.iter(|| {
|
||||
chunks.iter().cloned().kmerge().count()
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn fast_integer_sum<I>(iter: I) -> I::Item
|
||||
where I: IntoIterator,
|
||||
I::Item: Default + Add<Output=I::Item>
|
||||
{
|
||||
iter.into_iter().fold(<_>::default(), |x, y| x + y)
|
||||
}
|
||||
|
||||
fn step_vec_2(c: &mut Criterion) {
|
||||
let v = vec![0; 1024];
|
||||
|
||||
c.bench_function("step vec 2", move |b| {
|
||||
b.iter(|| {
|
||||
fast_integer_sum(cloned(v.iter().step_by(2)))
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn step_vec_10(c: &mut Criterion) {
|
||||
let v = vec![0; 1024];
|
||||
|
||||
c.bench_function("step vec 10", move |b| {
|
||||
b.iter(|| {
|
||||
fast_integer_sum(cloned(v.iter().step_by(10)))
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn step_range_2(c: &mut Criterion) {
|
||||
let v = black_box(0..1024);
|
||||
|
||||
c.bench_function("step range 2", move |b| {
|
||||
b.iter(|| {
|
||||
fast_integer_sum(v.clone().step_by(2))
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn step_range_10(c: &mut Criterion) {
|
||||
let v = black_box(0..1024);
|
||||
|
||||
c.bench_function("step range 10", move |b| {
|
||||
b.iter(|| {
|
||||
fast_integer_sum(v.clone().step_by(10))
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn cartesian_product_iterator(c: &mut Criterion) {
|
||||
let xs = vec![0; 16];
|
||||
|
||||
c.bench_function("cartesian product iterator", move |b| {
|
||||
b.iter(|| {
|
||||
let mut sum = 0;
|
||||
for (&x, &y, &z) in iproduct!(&xs, &xs, &xs) {
|
||||
sum += x;
|
||||
sum += y;
|
||||
sum += z;
|
||||
}
|
||||
sum
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn cartesian_product_fold(c: &mut Criterion) {
|
||||
let xs = vec![0; 16];
|
||||
|
||||
c.bench_function("cartesian product fold", move |b| {
|
||||
b.iter(|| {
|
||||
let mut sum = 0;
|
||||
iproduct!(&xs, &xs, &xs).fold((), |(), (&x, &y, &z)| {
|
||||
sum += x;
|
||||
sum += y;
|
||||
sum += z;
|
||||
});
|
||||
sum
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn multi_cartesian_product_iterator(c: &mut Criterion) {
|
||||
let xs = [vec![0; 16], vec![0; 16], vec![0; 16]];
|
||||
|
||||
c.bench_function("multi cartesian product iterator", move |b| {
|
||||
b.iter(|| {
|
||||
let mut sum = 0;
|
||||
for x in xs.iter().multi_cartesian_product() {
|
||||
sum += x[0];
|
||||
sum += x[1];
|
||||
sum += x[2];
|
||||
}
|
||||
sum
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn multi_cartesian_product_fold(c: &mut Criterion) {
|
||||
let xs = [vec![0; 16], vec![0; 16], vec![0; 16]];
|
||||
|
||||
c.bench_function("multi cartesian product fold", move |b| {
|
||||
b.iter(|| {
|
||||
let mut sum = 0;
|
||||
xs.iter().multi_cartesian_product().fold((), |(), x| {
|
||||
sum += x[0];
|
||||
sum += x[1];
|
||||
sum += x[2];
|
||||
});
|
||||
sum
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn cartesian_product_nested_for(c: &mut Criterion) {
|
||||
let xs = vec![0; 16];
|
||||
|
||||
c.bench_function("cartesian product nested for", move |b| {
|
||||
b.iter(|| {
|
||||
let mut sum = 0;
|
||||
for &x in &xs {
|
||||
for &y in &xs {
|
||||
for &z in &xs {
|
||||
sum += x;
|
||||
sum += y;
|
||||
sum += z;
|
||||
}
|
||||
}
|
||||
}
|
||||
sum
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn all_equal(c: &mut Criterion) {
|
||||
let mut xs = vec![0; 5_000_000];
|
||||
xs.extend(vec![1; 5_000_000]);
|
||||
|
||||
c.bench_function("all equal", move |b| {
|
||||
b.iter(|| xs.iter().all_equal())
|
||||
});
|
||||
}
|
||||
|
||||
fn all_equal_for(c: &mut Criterion) {
|
||||
let mut xs = vec![0; 5_000_000];
|
||||
xs.extend(vec![1; 5_000_000]);
|
||||
|
||||
c.bench_function("all equal for", move |b| {
|
||||
b.iter(|| {
|
||||
for &x in &xs {
|
||||
if x != xs[0] {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn all_equal_default(c: &mut Criterion) {
|
||||
let mut xs = vec![0; 5_000_000];
|
||||
xs.extend(vec![1; 5_000_000]);
|
||||
|
||||
c.bench_function("all equal default", move |b| {
|
||||
b.iter(|| xs.iter().dedup().nth(1).is_none())
|
||||
});
|
||||
}
|
||||
|
||||
const PERM_COUNT: usize = 6;
|
||||
|
||||
fn permutations_iter(c: &mut Criterion) {
|
||||
struct NewIterator(Range<usize>);
|
||||
|
||||
impl Iterator for NewIterator {
|
||||
type Item = usize;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.0.next()
|
||||
}
|
||||
}
|
||||
|
||||
c.bench_function("permutations iter", move |b| {
|
||||
b.iter(|| {
|
||||
for _ in NewIterator(0..PERM_COUNT).permutations(PERM_COUNT) {
|
||||
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn permutations_range(c: &mut Criterion) {
|
||||
c.bench_function("permutations range", move |b| {
|
||||
b.iter(|| {
|
||||
for _ in (0..PERM_COUNT).permutations(PERM_COUNT) {
|
||||
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn permutations_slice(c: &mut Criterion) {
|
||||
let v = (0..PERM_COUNT).collect_vec();
|
||||
|
||||
c.bench_function("permutations slice", move |b| {
|
||||
b.iter(|| {
|
||||
for _ in v.as_slice().iter().permutations(PERM_COUNT) {
|
||||
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
slice_iter,
|
||||
slice_iter_rev,
|
||||
zip_default_zip,
|
||||
zipdot_i32_default_zip,
|
||||
zipdot_f32_default_zip,
|
||||
zip_default_zip3,
|
||||
zip_slices_ziptuple,
|
||||
zipslices,
|
||||
zipslices_mut,
|
||||
zipdot_i32_zipslices,
|
||||
zipdot_f32_zipslices,
|
||||
zip_checked_counted_loop,
|
||||
zipdot_i32_checked_counted_loop,
|
||||
zipdot_f32_checked_counted_loop,
|
||||
zipdot_f32_checked_counted_unrolled_loop,
|
||||
zip_unchecked_counted_loop,
|
||||
zipdot_i32_unchecked_counted_loop,
|
||||
zipdot_f32_unchecked_counted_loop,
|
||||
zip_unchecked_counted_loop3,
|
||||
group_by_lazy_1,
|
||||
group_by_lazy_2,
|
||||
slice_chunks,
|
||||
chunks_lazy_1,
|
||||
equal,
|
||||
merge_default,
|
||||
merge_by_cmp,
|
||||
merge_by_lt,
|
||||
kmerge_default,
|
||||
kmerge_tenway,
|
||||
step_vec_2,
|
||||
step_vec_10,
|
||||
step_range_2,
|
||||
step_range_10,
|
||||
cartesian_product_iterator,
|
||||
cartesian_product_fold,
|
||||
multi_cartesian_product_iterator,
|
||||
multi_cartesian_product_fold,
|
||||
cartesian_product_nested_for,
|
||||
all_equal,
|
||||
all_equal_for,
|
||||
all_equal_default,
|
||||
permutations_iter,
|
||||
permutations_range,
|
||||
permutations_slice,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
125
zeroidc/vendor/itertools/benches/combinations.rs
vendored
Normal file
125
zeroidc/vendor/itertools/benches/combinations.rs
vendored
Normal file
@@ -0,0 +1,125 @@
|
||||
use criterion::{black_box, criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
|
||||
// approximate 100_000 iterations for each combination
|
||||
const N1: usize = 100_000;
|
||||
const N2: usize = 448;
|
||||
const N3: usize = 86;
|
||||
const N4: usize = 41;
|
||||
const N14: usize = 21;
|
||||
|
||||
fn comb_for1(c: &mut Criterion) {
|
||||
c.bench_function("comb for1", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N1 {
|
||||
black_box(vec![i]);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_for2(c: &mut Criterion) {
|
||||
c.bench_function("comb for2", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N2 {
|
||||
for j in (i + 1)..N2 {
|
||||
black_box(vec![i, j]);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_for3(c: &mut Criterion) {
|
||||
c.bench_function("comb for3", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N3 {
|
||||
for j in (i + 1)..N3 {
|
||||
for k in (j + 1)..N3 {
|
||||
black_box(vec![i, j, k]);
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_for4(c: &mut Criterion) {
|
||||
c.bench_function("comb for4", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N4 {
|
||||
for j in (i + 1)..N4 {
|
||||
for k in (j + 1)..N4 {
|
||||
for l in (k + 1)..N4 {
|
||||
black_box(vec![i, j, k, l]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_c1(c: &mut Criterion) {
|
||||
c.bench_function("comb c1", move |b| {
|
||||
b.iter(|| {
|
||||
for combo in (0..N1).combinations(1) {
|
||||
black_box(combo);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_c2(c: &mut Criterion) {
|
||||
c.bench_function("comb c2", move |b| {
|
||||
b.iter(|| {
|
||||
for combo in (0..N2).combinations(2) {
|
||||
black_box(combo);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_c3(c: &mut Criterion) {
|
||||
c.bench_function("comb c3", move |b| {
|
||||
b.iter(|| {
|
||||
for combo in (0..N3).combinations(3) {
|
||||
black_box(combo);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_c4(c: &mut Criterion) {
|
||||
c.bench_function("comb c4", move |b| {
|
||||
b.iter(|| {
|
||||
for combo in (0..N4).combinations(4) {
|
||||
black_box(combo);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_c14(c: &mut Criterion) {
|
||||
c.bench_function("comb c14", move |b| {
|
||||
b.iter(|| {
|
||||
for combo in (0..N14).combinations(14) {
|
||||
black_box(combo);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
comb_for1,
|
||||
comb_for2,
|
||||
comb_for3,
|
||||
comb_for4,
|
||||
comb_c1,
|
||||
comb_c2,
|
||||
comb_c3,
|
||||
comb_c4,
|
||||
comb_c14,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
40
zeroidc/vendor/itertools/benches/combinations_with_replacement.rs
vendored
Normal file
40
zeroidc/vendor/itertools/benches/combinations_with_replacement.rs
vendored
Normal file
@@ -0,0 +1,40 @@
|
||||
use criterion::{black_box, criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
|
||||
fn comb_replacement_n10_k5(c: &mut Criterion) {
|
||||
c.bench_function("comb replacement n10k5", move |b| {
|
||||
b.iter(|| {
|
||||
for i in (0..10).combinations_with_replacement(5) {
|
||||
black_box(i);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_replacement_n5_k10(c: &mut Criterion) {
|
||||
c.bench_function("comb replacement n5 k10", move |b| {
|
||||
b.iter(|| {
|
||||
for i in (0..5).combinations_with_replacement(10) {
|
||||
black_box(i);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn comb_replacement_n10_k10(c: &mut Criterion) {
|
||||
c.bench_function("comb replacement n10 k10", move |b| {
|
||||
b.iter(|| {
|
||||
for i in (0..10).combinations_with_replacement(10) {
|
||||
black_box(i);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
comb_replacement_n10_k5,
|
||||
comb_replacement_n5_k10,
|
||||
comb_replacement_n10_k10,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
2
zeroidc/vendor/itertools/benches/extra/mod.rs
vendored
Normal file
2
zeroidc/vendor/itertools/benches/extra/mod.rs
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
pub use self::zipslices::ZipSlices;
|
||||
mod zipslices;
|
||||
188
zeroidc/vendor/itertools/benches/extra/zipslices.rs
vendored
Normal file
188
zeroidc/vendor/itertools/benches/extra/zipslices.rs
vendored
Normal file
@@ -0,0 +1,188 @@
|
||||
use std::cmp;
|
||||
|
||||
// Note: There are different ways to implement ZipSlices.
|
||||
// This version performed the best in benchmarks.
|
||||
//
|
||||
// I also implemented a version with three pointes (tptr, tend, uptr),
|
||||
// that mimiced slice::Iter and only checked bounds by using tptr == tend,
|
||||
// but that was inferior to this solution.
|
||||
|
||||
/// An iterator which iterates two slices simultaneously.
|
||||
///
|
||||
/// `ZipSlices` acts like a double-ended `.zip()` iterator.
|
||||
///
|
||||
/// It was intended to be more efficient than `.zip()`, and it was, then
|
||||
/// rustc changed how it optimizes so it can not promise improved performance
|
||||
/// at this time.
|
||||
///
|
||||
/// Note that elements past the end of the shortest of the two slices are ignored.
|
||||
///
|
||||
/// Iterator element type for `ZipSlices<T, U>` is `(T::Item, U::Item)`. For example,
|
||||
/// for a `ZipSlices<&'a [A], &'b mut [B]>`, the element type is `(&'a A, &'b mut B)`.
|
||||
#[derive(Clone)]
|
||||
pub struct ZipSlices<T, U> {
|
||||
t: T,
|
||||
u: U,
|
||||
len: usize,
|
||||
index: usize,
|
||||
}
|
||||
|
||||
impl<'a, 'b, A, B> ZipSlices<&'a [A], &'b [B]> {
|
||||
/// Create a new `ZipSlices` from slices `a` and `b`.
|
||||
///
|
||||
/// Act like a double-ended `.zip()` iterator, but more efficiently.
|
||||
///
|
||||
/// Note that elements past the end of the shortest of the two slices are ignored.
|
||||
#[inline(always)]
|
||||
pub fn new(a: &'a [A], b: &'b [B]) -> Self {
|
||||
let minl = cmp::min(a.len(), b.len());
|
||||
ZipSlices {
|
||||
t: a,
|
||||
u: b,
|
||||
len: minl,
|
||||
index: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> ZipSlices<T, U>
|
||||
where T: Slice,
|
||||
U: Slice
|
||||
{
|
||||
/// Create a new `ZipSlices` from slices `a` and `b`.
|
||||
///
|
||||
/// Act like a double-ended `.zip()` iterator, but more efficiently.
|
||||
///
|
||||
/// Note that elements past the end of the shortest of the two slices are ignored.
|
||||
#[inline(always)]
|
||||
pub fn from_slices(a: T, b: U) -> Self {
|
||||
let minl = cmp::min(a.len(), b.len());
|
||||
ZipSlices {
|
||||
t: a,
|
||||
u: b,
|
||||
len: minl,
|
||||
index: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> Iterator for ZipSlices<T, U>
|
||||
where T: Slice,
|
||||
U: Slice
|
||||
{
|
||||
type Item = (T::Item, U::Item);
|
||||
|
||||
#[inline(always)]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
unsafe {
|
||||
if self.index >= self.len {
|
||||
None
|
||||
} else {
|
||||
let i = self.index;
|
||||
self.index += 1;
|
||||
Some((
|
||||
self.t.get_unchecked(i),
|
||||
self.u.get_unchecked(i)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let len = self.len - self.index;
|
||||
(len, Some(len))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> DoubleEndedIterator for ZipSlices<T, U>
|
||||
where T: Slice,
|
||||
U: Slice
|
||||
{
|
||||
#[inline(always)]
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
unsafe {
|
||||
if self.index >= self.len {
|
||||
None
|
||||
} else {
|
||||
self.len -= 1;
|
||||
let i = self.len;
|
||||
Some((
|
||||
self.t.get_unchecked(i),
|
||||
self.u.get_unchecked(i)))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> ExactSizeIterator for ZipSlices<T, U>
|
||||
where T: Slice,
|
||||
U: Slice
|
||||
{}
|
||||
|
||||
unsafe impl<T, U> Slice for ZipSlices<T, U>
|
||||
where T: Slice,
|
||||
U: Slice
|
||||
{
|
||||
type Item = (T::Item, U::Item);
|
||||
|
||||
fn len(&self) -> usize {
|
||||
self.len - self.index
|
||||
}
|
||||
|
||||
unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item {
|
||||
(self.t.get_unchecked(i),
|
||||
self.u.get_unchecked(i))
|
||||
}
|
||||
}
|
||||
|
||||
/// A helper trait to let `ZipSlices` accept both `&[T]` and `&mut [T]`.
|
||||
///
|
||||
/// Unsafe trait because:
|
||||
///
|
||||
/// - Implementors must guarantee that `get_unchecked` is valid for all indices `0..len()`.
|
||||
pub unsafe trait Slice {
|
||||
/// The type of a reference to the slice's elements
|
||||
type Item;
|
||||
#[doc(hidden)]
|
||||
fn len(&self) -> usize;
|
||||
#[doc(hidden)]
|
||||
unsafe fn get_unchecked(&mut self, i: usize) -> Self::Item;
|
||||
}
|
||||
|
||||
unsafe impl<'a, T> Slice for &'a [T] {
|
||||
type Item = &'a T;
|
||||
#[inline(always)]
|
||||
fn len(&self) -> usize { (**self).len() }
|
||||
#[inline(always)]
|
||||
unsafe fn get_unchecked(&mut self, i: usize) -> &'a T {
|
||||
debug_assert!(i < self.len());
|
||||
(**self).get_unchecked(i)
|
||||
}
|
||||
}
|
||||
|
||||
unsafe impl<'a, T> Slice for &'a mut [T] {
|
||||
type Item = &'a mut T;
|
||||
#[inline(always)]
|
||||
fn len(&self) -> usize { (**self).len() }
|
||||
#[inline(always)]
|
||||
unsafe fn get_unchecked(&mut self, i: usize) -> &'a mut T {
|
||||
debug_assert!(i < self.len());
|
||||
// override the lifetime constraints of &mut &'a mut [T]
|
||||
(*(*self as *mut [T])).get_unchecked_mut(i)
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zipslices() {
|
||||
|
||||
let xs = [1, 2, 3, 4, 5, 6];
|
||||
let ys = [1, 2, 3, 7];
|
||||
::itertools::assert_equal(ZipSlices::new(&xs, &ys), xs.iter().zip(&ys));
|
||||
|
||||
let xs = [1, 2, 3, 4, 5, 6];
|
||||
let mut ys = [0; 6];
|
||||
for (x, y) in ZipSlices::from_slices(&xs[..], &mut ys[..]) {
|
||||
*y = *x;
|
||||
}
|
||||
::itertools::assert_equal(&xs, &ys);
|
||||
}
|
||||
73
zeroidc/vendor/itertools/benches/fold_specialization.rs
vendored
Normal file
73
zeroidc/vendor/itertools/benches/fold_specialization.rs
vendored
Normal file
@@ -0,0 +1,73 @@
|
||||
use criterion::{criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
|
||||
struct Unspecialized<I>(I);
|
||||
|
||||
impl<I> Iterator for Unspecialized<I>
|
||||
where I: Iterator
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
#[inline(always)]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.0.next()
|
||||
}
|
||||
|
||||
#[inline(always)]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.0.size_hint()
|
||||
}
|
||||
}
|
||||
|
||||
mod specialization {
|
||||
use super::*;
|
||||
|
||||
pub mod intersperse {
|
||||
use super::*;
|
||||
|
||||
pub fn external(c: &mut Criterion)
|
||||
{
|
||||
let arr = [1; 1024];
|
||||
|
||||
c.bench_function("external", move |b| {
|
||||
b.iter(|| {
|
||||
let mut sum = 0;
|
||||
for &x in arr.iter().intersperse(&0) {
|
||||
sum += x;
|
||||
}
|
||||
sum
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
pub fn internal_specialized(c: &mut Criterion)
|
||||
{
|
||||
let arr = [1; 1024];
|
||||
|
||||
c.bench_function("internal specialized", move |b| {
|
||||
b.iter(|| {
|
||||
arr.iter().intersperse(&0).fold(0, |acc, x| acc + x)
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
pub fn internal_unspecialized(c: &mut Criterion)
|
||||
{
|
||||
let arr = [1; 1024];
|
||||
|
||||
c.bench_function("internal unspecialized", move |b| {
|
||||
b.iter(|| {
|
||||
Unspecialized(arr.iter().intersperse(&0)).fold(0, |acc, x| acc + x)
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
specialization::intersperse::external,
|
||||
specialization::intersperse::internal_specialized,
|
||||
specialization::intersperse::internal_unspecialized,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
44
zeroidc/vendor/itertools/benches/powerset.rs
vendored
Normal file
44
zeroidc/vendor/itertools/benches/powerset.rs
vendored
Normal file
@@ -0,0 +1,44 @@
|
||||
use criterion::{black_box, criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
|
||||
// Keep aggregate generated elements the same, regardless of powerset length.
|
||||
const TOTAL_ELEMENTS: usize = 1 << 12;
|
||||
const fn calc_iters(n: usize) -> usize {
|
||||
TOTAL_ELEMENTS / (1 << n)
|
||||
}
|
||||
|
||||
fn powerset_n(c: &mut Criterion, n: usize) {
|
||||
let id = format!("powerset {}", n);
|
||||
c.bench_function(id.as_str(), move |b| {
|
||||
b.iter(|| {
|
||||
for _ in 0..calc_iters(n) {
|
||||
for elt in (0..n).powerset() {
|
||||
black_box(elt);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn powerset_0(c: &mut Criterion) { powerset_n(c, 0); }
|
||||
|
||||
fn powerset_1(c: &mut Criterion) { powerset_n(c, 1); }
|
||||
|
||||
fn powerset_2(c: &mut Criterion) { powerset_n(c, 2); }
|
||||
|
||||
fn powerset_4(c: &mut Criterion) { powerset_n(c, 4); }
|
||||
|
||||
fn powerset_8(c: &mut Criterion) { powerset_n(c, 8); }
|
||||
|
||||
fn powerset_12(c: &mut Criterion) { powerset_n(c, 12); }
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
powerset_0,
|
||||
powerset_1,
|
||||
powerset_2,
|
||||
powerset_4,
|
||||
powerset_8,
|
||||
powerset_12,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
144
zeroidc/vendor/itertools/benches/tree_fold1.rs
vendored
Normal file
144
zeroidc/vendor/itertools/benches/tree_fold1.rs
vendored
Normal file
@@ -0,0 +1,144 @@
|
||||
use criterion::{criterion_group, criterion_main, Criterion};
|
||||
use itertools::{Itertools, cloned};
|
||||
|
||||
trait IterEx : Iterator {
|
||||
// Another efficient implementation against which to compare,
|
||||
// but needs `std` so is less desirable.
|
||||
fn tree_fold1_vec<F>(self, mut f: F) -> Option<Self::Item>
|
||||
where F: FnMut(Self::Item, Self::Item) -> Self::Item,
|
||||
Self: Sized,
|
||||
{
|
||||
let hint = self.size_hint().0;
|
||||
let cap = std::mem::size_of::<usize>() * 8 - hint.leading_zeros() as usize;
|
||||
let mut stack = Vec::with_capacity(cap);
|
||||
self.enumerate().for_each(|(mut i, mut x)| {
|
||||
while (i & 1) != 0 {
|
||||
x = f(stack.pop().unwrap(), x);
|
||||
i >>= 1;
|
||||
}
|
||||
stack.push(x);
|
||||
});
|
||||
stack.into_iter().fold1(f)
|
||||
}
|
||||
}
|
||||
impl<T:Iterator> IterEx for T {}
|
||||
|
||||
macro_rules! def_benchs {
|
||||
($N:expr,
|
||||
$FUN:ident,
|
||||
$BENCH_NAME:ident,
|
||||
) => (
|
||||
mod $BENCH_NAME {
|
||||
use super::*;
|
||||
|
||||
pub fn sum(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0.. $N).collect();
|
||||
|
||||
c.bench_function(&(stringify!($BENCH_NAME).replace('_', " ") + " sum"), move |b| {
|
||||
b.iter(|| {
|
||||
cloned(&v).$FUN(|x, y| x + y)
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
pub fn complex_iter(c: &mut Criterion) {
|
||||
let u = (3..).take($N / 2);
|
||||
let v = (5..).take($N / 2);
|
||||
let it = u.chain(v);
|
||||
|
||||
c.bench_function(&(stringify!($BENCH_NAME).replace('_', " ") + " complex iter"), move |b| {
|
||||
b.iter(|| {
|
||||
it.clone().map(|x| x as f32).$FUN(f32::atan2)
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
pub fn string_format(c: &mut Criterion) {
|
||||
// This goes quadratic with linear `fold1`, so use a smaller
|
||||
// size to not waste too much time in travis. The allocations
|
||||
// in here are so expensive anyway that it'll still take
|
||||
// way longer per iteration than the other two benchmarks.
|
||||
let v: Vec<u32> = (0.. ($N/4)).collect();
|
||||
|
||||
c.bench_function(&(stringify!($BENCH_NAME).replace('_', " ") + " string format"), move |b| {
|
||||
b.iter(|| {
|
||||
cloned(&v).map(|x| x.to_string()).$FUN(|x, y| format!("{} + {}", x, y))
|
||||
})
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
$BENCH_NAME,
|
||||
$BENCH_NAME::sum,
|
||||
$BENCH_NAME::complex_iter,
|
||||
$BENCH_NAME::string_format,
|
||||
);
|
||||
)
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
10_000,
|
||||
fold1,
|
||||
fold1_10k,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
10_000,
|
||||
tree_fold1,
|
||||
tree_fold1_stack_10k,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
10_000,
|
||||
tree_fold1_vec,
|
||||
tree_fold1_vec_10k,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
100,
|
||||
fold1,
|
||||
fold1_100,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
100,
|
||||
tree_fold1,
|
||||
tree_fold1_stack_100,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
100,
|
||||
tree_fold1_vec,
|
||||
tree_fold1_vec_100,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
8,
|
||||
fold1,
|
||||
fold1_08,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
8,
|
||||
tree_fold1,
|
||||
tree_fold1_stack_08,
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
8,
|
||||
tree_fold1_vec,
|
||||
tree_fold1_vec_08,
|
||||
}
|
||||
|
||||
criterion_main!(
|
||||
fold1_10k,
|
||||
tree_fold1_stack_10k,
|
||||
tree_fold1_vec_10k,
|
||||
fold1_100,
|
||||
tree_fold1_stack_100,
|
||||
tree_fold1_vec_100,
|
||||
fold1_08,
|
||||
tree_fold1_stack_08,
|
||||
tree_fold1_vec_08,
|
||||
);
|
||||
113
zeroidc/vendor/itertools/benches/tuple_combinations.rs
vendored
Normal file
113
zeroidc/vendor/itertools/benches/tuple_combinations.rs
vendored
Normal file
@@ -0,0 +1,113 @@
|
||||
use criterion::{black_box, criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
|
||||
// approximate 100_000 iterations for each combination
|
||||
const N1: usize = 100_000;
|
||||
const N2: usize = 448;
|
||||
const N3: usize = 86;
|
||||
const N4: usize = 41;
|
||||
|
||||
fn tuple_comb_for1(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb for1", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N1 {
|
||||
black_box(i);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_for2(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb for2", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N2 {
|
||||
for j in (i + 1)..N2 {
|
||||
black_box(i + j);
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_for3(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb for3", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N3 {
|
||||
for j in (i + 1)..N3 {
|
||||
for k in (j + 1)..N3 {
|
||||
black_box(i + j + k);
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_for4(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb for4", move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..N4 {
|
||||
for j in (i + 1)..N4 {
|
||||
for k in (j + 1)..N4 {
|
||||
for l in (k + 1)..N4 {
|
||||
black_box(i + j + k + l);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_c1(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb c1", move |b| {
|
||||
b.iter(|| {
|
||||
for (i,) in (0..N1).tuple_combinations() {
|
||||
black_box(i);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_c2(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb c2", move |b| {
|
||||
b.iter(|| {
|
||||
for (i, j) in (0..N2).tuple_combinations() {
|
||||
black_box(i + j);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_c3(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb c3", move |b| {
|
||||
b.iter(|| {
|
||||
for (i, j, k) in (0..N3).tuple_combinations() {
|
||||
black_box(i + j + k);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn tuple_comb_c4(c: &mut Criterion) {
|
||||
c.bench_function("tuple comb c4", move |b| {
|
||||
b.iter(|| {
|
||||
for (i, j, k, l) in (0..N4).tuple_combinations() {
|
||||
black_box(i + j + k + l);
|
||||
}
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
benches,
|
||||
tuple_comb_for1,
|
||||
tuple_comb_for2,
|
||||
tuple_comb_for3,
|
||||
tuple_comb_for4,
|
||||
tuple_comb_c1,
|
||||
tuple_comb_c2,
|
||||
tuple_comb_c3,
|
||||
tuple_comb_c4,
|
||||
);
|
||||
criterion_main!(benches);
|
||||
213
zeroidc/vendor/itertools/benches/tuples.rs
vendored
Normal file
213
zeroidc/vendor/itertools/benches/tuples.rs
vendored
Normal file
@@ -0,0 +1,213 @@
|
||||
use criterion::{criterion_group, criterion_main, Criterion};
|
||||
use itertools::Itertools;
|
||||
|
||||
fn s1(a: u32) -> u32 {
|
||||
a
|
||||
}
|
||||
|
||||
fn s2(a: u32, b: u32) -> u32 {
|
||||
a + b
|
||||
}
|
||||
|
||||
fn s3(a: u32, b: u32, c: u32) -> u32 {
|
||||
a + b + c
|
||||
}
|
||||
|
||||
fn s4(a: u32, b: u32, c: u32, d: u32) -> u32 {
|
||||
a + b + c + d
|
||||
}
|
||||
|
||||
fn sum_s1(s: &[u32]) -> u32 {
|
||||
s1(s[0])
|
||||
}
|
||||
|
||||
fn sum_s2(s: &[u32]) -> u32 {
|
||||
s2(s[0], s[1])
|
||||
}
|
||||
|
||||
fn sum_s3(s: &[u32]) -> u32 {
|
||||
s3(s[0], s[1], s[2])
|
||||
}
|
||||
|
||||
fn sum_s4(s: &[u32]) -> u32 {
|
||||
s4(s[0], s[1], s[2], s[3])
|
||||
}
|
||||
|
||||
fn sum_t1(s: &(&u32, )) -> u32 {
|
||||
s1(*s.0)
|
||||
}
|
||||
|
||||
fn sum_t2(s: &(&u32, &u32)) -> u32 {
|
||||
s2(*s.0, *s.1)
|
||||
}
|
||||
|
||||
fn sum_t3(s: &(&u32, &u32, &u32)) -> u32 {
|
||||
s3(*s.0, *s.1, *s.2)
|
||||
}
|
||||
|
||||
fn sum_t4(s: &(&u32, &u32, &u32, &u32)) -> u32 {
|
||||
s4(*s.0, *s.1, *s.2, *s.3)
|
||||
}
|
||||
|
||||
macro_rules! def_benchs {
|
||||
($N:expr;
|
||||
$BENCH_GROUP:ident,
|
||||
$TUPLE_FUN:ident,
|
||||
$TUPLES:ident,
|
||||
$TUPLE_WINDOWS:ident;
|
||||
$SLICE_FUN:ident,
|
||||
$CHUNKS:ident,
|
||||
$WINDOWS:ident;
|
||||
$FOR_CHUNKS:ident,
|
||||
$FOR_WINDOWS:ident
|
||||
) => (
|
||||
fn $FOR_CHUNKS(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0.. $N * 1_000).collect();
|
||||
let mut s = 0;
|
||||
c.bench_function(&stringify!($FOR_CHUNKS).replace('_', " "), move |b| {
|
||||
b.iter(|| {
|
||||
let mut j = 0;
|
||||
for _ in 0..1_000 {
|
||||
s += $SLICE_FUN(&v[j..(j + $N)]);
|
||||
j += $N;
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn $FOR_WINDOWS(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0..1_000).collect();
|
||||
let mut s = 0;
|
||||
c.bench_function(&stringify!($FOR_WINDOWS).replace('_', " "), move |b| {
|
||||
b.iter(|| {
|
||||
for i in 0..(1_000 - $N) {
|
||||
s += $SLICE_FUN(&v[i..(i + $N)]);
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn $TUPLES(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0.. $N * 1_000).collect();
|
||||
let mut s = 0;
|
||||
c.bench_function(&stringify!($TUPLES).replace('_', " "), move |b| {
|
||||
b.iter(|| {
|
||||
for x in v.iter().tuples() {
|
||||
s += $TUPLE_FUN(&x);
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn $CHUNKS(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0.. $N * 1_000).collect();
|
||||
let mut s = 0;
|
||||
c.bench_function(&stringify!($CHUNKS).replace('_', " "), move |b| {
|
||||
b.iter(|| {
|
||||
for x in v.chunks($N) {
|
||||
s += $SLICE_FUN(x);
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn $TUPLE_WINDOWS(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0..1_000).collect();
|
||||
let mut s = 0;
|
||||
c.bench_function(&stringify!($TUPLE_WINDOWS).replace('_', " "), move |b| {
|
||||
b.iter(|| {
|
||||
for x in v.iter().tuple_windows() {
|
||||
s += $TUPLE_FUN(&x);
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
fn $WINDOWS(c: &mut Criterion) {
|
||||
let v: Vec<u32> = (0..1_000).collect();
|
||||
let mut s = 0;
|
||||
c.bench_function(&stringify!($WINDOWS).replace('_', " "), move |b| {
|
||||
b.iter(|| {
|
||||
for x in v.windows($N) {
|
||||
s += $SLICE_FUN(x);
|
||||
}
|
||||
s
|
||||
})
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(
|
||||
$BENCH_GROUP,
|
||||
$FOR_CHUNKS,
|
||||
$FOR_WINDOWS,
|
||||
$TUPLES,
|
||||
$CHUNKS,
|
||||
$TUPLE_WINDOWS,
|
||||
$WINDOWS,
|
||||
);
|
||||
)
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
1;
|
||||
benches_1,
|
||||
sum_t1,
|
||||
tuple_chunks_1,
|
||||
tuple_windows_1;
|
||||
sum_s1,
|
||||
slice_chunks_1,
|
||||
slice_windows_1;
|
||||
for_chunks_1,
|
||||
for_windows_1
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
2;
|
||||
benches_2,
|
||||
sum_t2,
|
||||
tuple_chunks_2,
|
||||
tuple_windows_2;
|
||||
sum_s2,
|
||||
slice_chunks_2,
|
||||
slice_windows_2;
|
||||
for_chunks_2,
|
||||
for_windows_2
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
3;
|
||||
benches_3,
|
||||
sum_t3,
|
||||
tuple_chunks_3,
|
||||
tuple_windows_3;
|
||||
sum_s3,
|
||||
slice_chunks_3,
|
||||
slice_windows_3;
|
||||
for_chunks_3,
|
||||
for_windows_3
|
||||
}
|
||||
|
||||
def_benchs!{
|
||||
4;
|
||||
benches_4,
|
||||
sum_t4,
|
||||
tuple_chunks_4,
|
||||
tuple_windows_4;
|
||||
sum_s4,
|
||||
slice_chunks_4,
|
||||
slice_windows_4;
|
||||
for_chunks_4,
|
||||
for_windows_4
|
||||
}
|
||||
|
||||
criterion_main!(
|
||||
benches_1,
|
||||
benches_2,
|
||||
benches_3,
|
||||
benches_4,
|
||||
);
|
||||
150
zeroidc/vendor/itertools/examples/iris.data
vendored
Normal file
150
zeroidc/vendor/itertools/examples/iris.data
vendored
Normal file
@@ -0,0 +1,150 @@
|
||||
5.1,3.5,1.4,0.2,Iris-setosa
|
||||
4.9,3.0,1.4,0.2,Iris-setosa
|
||||
4.7,3.2,1.3,0.2,Iris-setosa
|
||||
4.6,3.1,1.5,0.2,Iris-setosa
|
||||
5.0,3.6,1.4,0.2,Iris-setosa
|
||||
5.4,3.9,1.7,0.4,Iris-setosa
|
||||
4.6,3.4,1.4,0.3,Iris-setosa
|
||||
5.0,3.4,1.5,0.2,Iris-setosa
|
||||
4.4,2.9,1.4,0.2,Iris-setosa
|
||||
4.9,3.1,1.5,0.1,Iris-setosa
|
||||
5.4,3.7,1.5,0.2,Iris-setosa
|
||||
4.8,3.4,1.6,0.2,Iris-setosa
|
||||
4.8,3.0,1.4,0.1,Iris-setosa
|
||||
4.3,3.0,1.1,0.1,Iris-setosa
|
||||
5.8,4.0,1.2,0.2,Iris-setosa
|
||||
5.7,4.4,1.5,0.4,Iris-setosa
|
||||
5.4,3.9,1.3,0.4,Iris-setosa
|
||||
5.1,3.5,1.4,0.3,Iris-setosa
|
||||
5.7,3.8,1.7,0.3,Iris-setosa
|
||||
5.1,3.8,1.5,0.3,Iris-setosa
|
||||
5.4,3.4,1.7,0.2,Iris-setosa
|
||||
5.1,3.7,1.5,0.4,Iris-setosa
|
||||
4.6,3.6,1.0,0.2,Iris-setosa
|
||||
5.1,3.3,1.7,0.5,Iris-setosa
|
||||
4.8,3.4,1.9,0.2,Iris-setosa
|
||||
5.0,3.0,1.6,0.2,Iris-setosa
|
||||
5.0,3.4,1.6,0.4,Iris-setosa
|
||||
5.2,3.5,1.5,0.2,Iris-setosa
|
||||
5.2,3.4,1.4,0.2,Iris-setosa
|
||||
4.7,3.2,1.6,0.2,Iris-setosa
|
||||
4.8,3.1,1.6,0.2,Iris-setosa
|
||||
5.4,3.4,1.5,0.4,Iris-setosa
|
||||
5.2,4.1,1.5,0.1,Iris-setosa
|
||||
5.5,4.2,1.4,0.2,Iris-setosa
|
||||
4.9,3.1,1.5,0.1,Iris-setosa
|
||||
5.0,3.2,1.2,0.2,Iris-setosa
|
||||
5.5,3.5,1.3,0.2,Iris-setosa
|
||||
4.9,3.1,1.5,0.1,Iris-setosa
|
||||
4.4,3.0,1.3,0.2,Iris-setosa
|
||||
5.1,3.4,1.5,0.2,Iris-setosa
|
||||
5.0,3.5,1.3,0.3,Iris-setosa
|
||||
4.5,2.3,1.3,0.3,Iris-setosa
|
||||
4.4,3.2,1.3,0.2,Iris-setosa
|
||||
5.0,3.5,1.6,0.6,Iris-setosa
|
||||
5.1,3.8,1.9,0.4,Iris-setosa
|
||||
4.8,3.0,1.4,0.3,Iris-setosa
|
||||
5.1,3.8,1.6,0.2,Iris-setosa
|
||||
4.6,3.2,1.4,0.2,Iris-setosa
|
||||
5.3,3.7,1.5,0.2,Iris-setosa
|
||||
5.0,3.3,1.4,0.2,Iris-setosa
|
||||
7.0,3.2,4.7,1.4,Iris-versicolor
|
||||
6.4,3.2,4.5,1.5,Iris-versicolor
|
||||
6.9,3.1,4.9,1.5,Iris-versicolor
|
||||
5.5,2.3,4.0,1.3,Iris-versicolor
|
||||
6.5,2.8,4.6,1.5,Iris-versicolor
|
||||
5.7,2.8,4.5,1.3,Iris-versicolor
|
||||
6.3,3.3,4.7,1.6,Iris-versicolor
|
||||
4.9,2.4,3.3,1.0,Iris-versicolor
|
||||
6.6,2.9,4.6,1.3,Iris-versicolor
|
||||
5.2,2.7,3.9,1.4,Iris-versicolor
|
||||
5.0,2.0,3.5,1.0,Iris-versicolor
|
||||
5.9,3.0,4.2,1.5,Iris-versicolor
|
||||
6.0,2.2,4.0,1.0,Iris-versicolor
|
||||
6.1,2.9,4.7,1.4,Iris-versicolor
|
||||
5.6,2.9,3.6,1.3,Iris-versicolor
|
||||
6.7,3.1,4.4,1.4,Iris-versicolor
|
||||
5.6,3.0,4.5,1.5,Iris-versicolor
|
||||
5.8,2.7,4.1,1.0,Iris-versicolor
|
||||
6.2,2.2,4.5,1.5,Iris-versicolor
|
||||
5.6,2.5,3.9,1.1,Iris-versicolor
|
||||
5.9,3.2,4.8,1.8,Iris-versicolor
|
||||
6.1,2.8,4.0,1.3,Iris-versicolor
|
||||
6.3,2.5,4.9,1.5,Iris-versicolor
|
||||
6.1,2.8,4.7,1.2,Iris-versicolor
|
||||
6.4,2.9,4.3,1.3,Iris-versicolor
|
||||
6.6,3.0,4.4,1.4,Iris-versicolor
|
||||
6.8,2.8,4.8,1.4,Iris-versicolor
|
||||
6.7,3.0,5.0,1.7,Iris-versicolor
|
||||
6.0,2.9,4.5,1.5,Iris-versicolor
|
||||
5.7,2.6,3.5,1.0,Iris-versicolor
|
||||
5.5,2.4,3.8,1.1,Iris-versicolor
|
||||
5.5,2.4,3.7,1.0,Iris-versicolor
|
||||
5.8,2.7,3.9,1.2,Iris-versicolor
|
||||
6.0,2.7,5.1,1.6,Iris-versicolor
|
||||
5.4,3.0,4.5,1.5,Iris-versicolor
|
||||
6.0,3.4,4.5,1.6,Iris-versicolor
|
||||
6.7,3.1,4.7,1.5,Iris-versicolor
|
||||
6.3,2.3,4.4,1.3,Iris-versicolor
|
||||
5.6,3.0,4.1,1.3,Iris-versicolor
|
||||
5.5,2.5,4.0,1.3,Iris-versicolor
|
||||
5.5,2.6,4.4,1.2,Iris-versicolor
|
||||
6.1,3.0,4.6,1.4,Iris-versicolor
|
||||
5.8,2.6,4.0,1.2,Iris-versicolor
|
||||
5.0,2.3,3.3,1.0,Iris-versicolor
|
||||
5.6,2.7,4.2,1.3,Iris-versicolor
|
||||
5.7,3.0,4.2,1.2,Iris-versicolor
|
||||
5.7,2.9,4.2,1.3,Iris-versicolor
|
||||
6.2,2.9,4.3,1.3,Iris-versicolor
|
||||
5.1,2.5,3.0,1.1,Iris-versicolor
|
||||
5.7,2.8,4.1,1.3,Iris-versicolor
|
||||
6.3,3.3,6.0,2.5,Iris-virginica
|
||||
5.8,2.7,5.1,1.9,Iris-virginica
|
||||
7.1,3.0,5.9,2.1,Iris-virginica
|
||||
6.3,2.9,5.6,1.8,Iris-virginica
|
||||
6.5,3.0,5.8,2.2,Iris-virginica
|
||||
7.6,3.0,6.6,2.1,Iris-virginica
|
||||
4.9,2.5,4.5,1.7,Iris-virginica
|
||||
7.3,2.9,6.3,1.8,Iris-virginica
|
||||
6.7,2.5,5.8,1.8,Iris-virginica
|
||||
7.2,3.6,6.1,2.5,Iris-virginica
|
||||
6.5,3.2,5.1,2.0,Iris-virginica
|
||||
6.4,2.7,5.3,1.9,Iris-virginica
|
||||
6.8,3.0,5.5,2.1,Iris-virginica
|
||||
5.7,2.5,5.0,2.0,Iris-virginica
|
||||
5.8,2.8,5.1,2.4,Iris-virginica
|
||||
6.4,3.2,5.3,2.3,Iris-virginica
|
||||
6.5,3.0,5.5,1.8,Iris-virginica
|
||||
7.7,3.8,6.7,2.2,Iris-virginica
|
||||
7.7,2.6,6.9,2.3,Iris-virginica
|
||||
6.0,2.2,5.0,1.5,Iris-virginica
|
||||
6.9,3.2,5.7,2.3,Iris-virginica
|
||||
5.6,2.8,4.9,2.0,Iris-virginica
|
||||
7.7,2.8,6.7,2.0,Iris-virginica
|
||||
6.3,2.7,4.9,1.8,Iris-virginica
|
||||
6.7,3.3,5.7,2.1,Iris-virginica
|
||||
7.2,3.2,6.0,1.8,Iris-virginica
|
||||
6.2,2.8,4.8,1.8,Iris-virginica
|
||||
6.1,3.0,4.9,1.8,Iris-virginica
|
||||
6.4,2.8,5.6,2.1,Iris-virginica
|
||||
7.2,3.0,5.8,1.6,Iris-virginica
|
||||
7.4,2.8,6.1,1.9,Iris-virginica
|
||||
7.9,3.8,6.4,2.0,Iris-virginica
|
||||
6.4,2.8,5.6,2.2,Iris-virginica
|
||||
6.3,2.8,5.1,1.5,Iris-virginica
|
||||
6.1,2.6,5.6,1.4,Iris-virginica
|
||||
7.7,3.0,6.1,2.3,Iris-virginica
|
||||
6.3,3.4,5.6,2.4,Iris-virginica
|
||||
6.4,3.1,5.5,1.8,Iris-virginica
|
||||
6.0,3.0,4.8,1.8,Iris-virginica
|
||||
6.9,3.1,5.4,2.1,Iris-virginica
|
||||
6.7,3.1,5.6,2.4,Iris-virginica
|
||||
6.9,3.1,5.1,2.3,Iris-virginica
|
||||
5.8,2.7,5.1,1.9,Iris-virginica
|
||||
6.8,3.2,5.9,2.3,Iris-virginica
|
||||
6.7,3.3,5.7,2.5,Iris-virginica
|
||||
6.7,3.0,5.2,2.3,Iris-virginica
|
||||
6.3,2.5,5.0,1.9,Iris-virginica
|
||||
6.5,3.0,5.2,2.0,Iris-virginica
|
||||
6.2,3.4,5.4,2.3,Iris-virginica
|
||||
5.9,3.0,5.1,1.8,Iris-virginica
|
||||
137
zeroidc/vendor/itertools/examples/iris.rs
vendored
Normal file
137
zeroidc/vendor/itertools/examples/iris.rs
vendored
Normal file
@@ -0,0 +1,137 @@
|
||||
///
|
||||
/// This example parses, sorts and groups the iris dataset
|
||||
/// and does some simple manipulations.
|
||||
///
|
||||
/// Iterators and itertools functionality are used throughout.
|
||||
|
||||
use itertools::Itertools;
|
||||
use std::collections::HashMap;
|
||||
use std::iter::repeat;
|
||||
use std::num::ParseFloatError;
|
||||
use std::str::FromStr;
|
||||
|
||||
static DATA: &'static str = include_str!("iris.data");
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
struct Iris {
|
||||
name: String,
|
||||
data: [f32; 4],
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum ParseError {
|
||||
Numeric(ParseFloatError),
|
||||
Other(&'static str),
|
||||
}
|
||||
|
||||
impl From<ParseFloatError> for ParseError {
|
||||
fn from(err: ParseFloatError) -> Self {
|
||||
ParseError::Numeric(err)
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse an Iris from a comma-separated line
|
||||
impl FromStr for Iris {
|
||||
type Err = ParseError;
|
||||
|
||||
fn from_str(s: &str) -> Result<Self, Self::Err> {
|
||||
let mut iris = Iris { name: "".into(), data: [0.; 4] };
|
||||
let mut parts = s.split(",").map(str::trim);
|
||||
|
||||
// using Iterator::by_ref()
|
||||
for (index, part) in parts.by_ref().take(4).enumerate() {
|
||||
iris.data[index] = part.parse::<f32>()?;
|
||||
}
|
||||
if let Some(name) = parts.next() {
|
||||
iris.name = name.into();
|
||||
} else {
|
||||
return Err(ParseError::Other("Missing name"))
|
||||
}
|
||||
Ok(iris)
|
||||
}
|
||||
}
|
||||
|
||||
fn main() {
|
||||
// using Itertools::fold_results to create the result of parsing
|
||||
let irises = DATA.lines()
|
||||
.map(str::parse)
|
||||
.fold_ok(Vec::new(), |mut v, iris: Iris| {
|
||||
v.push(iris);
|
||||
v
|
||||
});
|
||||
let mut irises = match irises {
|
||||
Err(e) => {
|
||||
println!("Error parsing: {:?}", e);
|
||||
std::process::exit(1);
|
||||
}
|
||||
Ok(data) => data,
|
||||
};
|
||||
|
||||
// Sort them and group them
|
||||
irises.sort_by(|a, b| Ord::cmp(&a.name, &b.name));
|
||||
|
||||
// using Iterator::cycle()
|
||||
let mut plot_symbols = "+ox".chars().cycle();
|
||||
let mut symbolmap = HashMap::new();
|
||||
|
||||
// using Itertools::group_by
|
||||
for (species, species_group) in &irises.iter().group_by(|iris| &iris.name) {
|
||||
// assign a plot symbol
|
||||
symbolmap.entry(species).or_insert_with(|| {
|
||||
plot_symbols.next().unwrap()
|
||||
});
|
||||
println!("{} (symbol={})", species, symbolmap[species]);
|
||||
|
||||
for iris in species_group {
|
||||
// using Itertools::format for lazy formatting
|
||||
println!("{:>3.1}", iris.data.iter().format(", "));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Look at all combinations of the four columns
|
||||
//
|
||||
// See https://en.wikipedia.org/wiki/Iris_flower_data_set
|
||||
//
|
||||
let n = 30; // plot size
|
||||
let mut plot = vec![' '; n * n];
|
||||
|
||||
// using Itertools::tuple_combinations
|
||||
for (a, b) in (0..4).tuple_combinations() {
|
||||
println!("Column {} vs {}:", a, b);
|
||||
|
||||
// Clear plot
|
||||
//
|
||||
// using std::iter::repeat;
|
||||
// using Itertools::set_from
|
||||
plot.iter_mut().set_from(repeat(' '));
|
||||
|
||||
// using Itertools::minmax
|
||||
let min_max = |data: &[Iris], col| {
|
||||
data.iter()
|
||||
.map(|iris| iris.data[col])
|
||||
.minmax()
|
||||
.into_option()
|
||||
.expect("Can't find min/max of empty iterator")
|
||||
};
|
||||
let (min_x, max_x) = min_max(&irises, a);
|
||||
let (min_y, max_y) = min_max(&irises, b);
|
||||
|
||||
// Plot the data points
|
||||
let round_to_grid = |x, min, max| ((x - min) / (max - min) * ((n - 1) as f32)) as usize;
|
||||
let flip = |ix| n - 1 - ix; // reverse axis direction
|
||||
|
||||
for iris in &irises {
|
||||
let ix = round_to_grid(iris.data[a], min_x, max_x);
|
||||
let iy = flip(round_to_grid(iris.data[b], min_y, max_y));
|
||||
plot[n * iy + ix] = symbolmap[&iris.name];
|
||||
}
|
||||
|
||||
// render plot
|
||||
//
|
||||
// using Itertools::join
|
||||
for line in plot.chunks(n) {
|
||||
println!("{}", line.iter().join(" "))
|
||||
}
|
||||
}
|
||||
}
|
||||
237
zeroidc/vendor/itertools/src/adaptors/coalesce.rs
vendored
Normal file
237
zeroidc/vendor/itertools/src/adaptors/coalesce.rs
vendored
Normal file
@@ -0,0 +1,237 @@
|
||||
use std::fmt;
|
||||
use std::iter::FusedIterator;
|
||||
|
||||
use crate::size_hint;
|
||||
|
||||
pub struct CoalesceBy<I, F, T>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
iter: I,
|
||||
last: Option<T>,
|
||||
f: F,
|
||||
}
|
||||
|
||||
impl<I: Clone, F: Clone, T: Clone> Clone for CoalesceBy<I, F, T>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
clone_fields!(last, iter, f);
|
||||
}
|
||||
|
||||
impl<I, F, T> fmt::Debug for CoalesceBy<I, F, T>
|
||||
where
|
||||
I: Iterator + fmt::Debug,
|
||||
T: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(CoalesceBy, iter);
|
||||
}
|
||||
|
||||
pub trait CoalescePredicate<Item, T> {
|
||||
fn coalesce_pair(&mut self, t: T, item: Item) -> Result<T, (T, T)>;
|
||||
}
|
||||
|
||||
impl<I, F, T> Iterator for CoalesceBy<I, F, T>
|
||||
where
|
||||
I: Iterator,
|
||||
F: CoalescePredicate<I::Item, T>,
|
||||
{
|
||||
type Item = T;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
// this fuses the iterator
|
||||
let last = self.last.take()?;
|
||||
|
||||
let self_last = &mut self.last;
|
||||
let self_f = &mut self.f;
|
||||
Some(
|
||||
self.iter
|
||||
.try_fold(last, |last, next| match self_f.coalesce_pair(last, next) {
|
||||
Ok(joined) => Ok(joined),
|
||||
Err((last_, next_)) => {
|
||||
*self_last = Some(next_);
|
||||
Err(last_)
|
||||
}
|
||||
})
|
||||
.unwrap_or_else(|x| x),
|
||||
)
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let (low, hi) = size_hint::add_scalar(self.iter.size_hint(), self.last.is_some() as usize);
|
||||
((low > 0) as usize, hi)
|
||||
}
|
||||
|
||||
fn fold<Acc, FnAcc>(self, acc: Acc, mut fn_acc: FnAcc) -> Acc
|
||||
where
|
||||
FnAcc: FnMut(Acc, Self::Item) -> Acc,
|
||||
{
|
||||
if let Some(last) = self.last {
|
||||
let mut f = self.f;
|
||||
let (last, acc) = self.iter.fold((last, acc), |(last, acc), elt| {
|
||||
match f.coalesce_pair(last, elt) {
|
||||
Ok(joined) => (joined, acc),
|
||||
Err((last_, next_)) => (next_, fn_acc(acc, last_)),
|
||||
}
|
||||
});
|
||||
fn_acc(acc, last)
|
||||
} else {
|
||||
acc
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Iterator, F: CoalescePredicate<I::Item, T>, T> FusedIterator for CoalesceBy<I, F, T> {}
|
||||
|
||||
/// An iterator adaptor that may join together adjacent elements.
|
||||
///
|
||||
/// See [`.coalesce()`](crate::Itertools::coalesce) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub type Coalesce<I, F> = CoalesceBy<I, F, <I as Iterator>::Item>;
|
||||
|
||||
impl<F, Item, T> CoalescePredicate<Item, T> for F
|
||||
where
|
||||
F: FnMut(T, Item) -> Result<T, (T, T)>,
|
||||
{
|
||||
fn coalesce_pair(&mut self, t: T, item: Item) -> Result<T, (T, T)> {
|
||||
self(t, item)
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new `Coalesce`.
|
||||
pub fn coalesce<I, F>(mut iter: I, f: F) -> Coalesce<I, F>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
Coalesce {
|
||||
last: iter.next(),
|
||||
iter,
|
||||
f,
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that removes repeated duplicates, determining equality using a comparison function.
|
||||
///
|
||||
/// See [`.dedup_by()`](crate::Itertools::dedup_by) or [`.dedup()`](crate::Itertools::dedup) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub type DedupBy<I, Pred> = CoalesceBy<I, DedupPred2CoalescePred<Pred>, <I as Iterator>::Item>;
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct DedupPred2CoalescePred<DP>(DP);
|
||||
|
||||
impl<DP> fmt::Debug for DedupPred2CoalescePred<DP> {
|
||||
debug_fmt_fields!(DedupPred2CoalescePred,);
|
||||
}
|
||||
|
||||
pub trait DedupPredicate<T> {
|
||||
// TODO replace by Fn(&T, &T)->bool once Rust supports it
|
||||
fn dedup_pair(&mut self, a: &T, b: &T) -> bool;
|
||||
}
|
||||
|
||||
impl<DP, T> CoalescePredicate<T, T> for DedupPred2CoalescePred<DP>
|
||||
where
|
||||
DP: DedupPredicate<T>,
|
||||
{
|
||||
fn coalesce_pair(&mut self, t: T, item: T) -> Result<T, (T, T)> {
|
||||
if self.0.dedup_pair(&t, &item) {
|
||||
Ok(t)
|
||||
} else {
|
||||
Err((t, item))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct DedupEq;
|
||||
|
||||
impl<T: PartialEq> DedupPredicate<T> for DedupEq {
|
||||
fn dedup_pair(&mut self, a: &T, b: &T) -> bool {
|
||||
a == b
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, F: FnMut(&T, &T) -> bool> DedupPredicate<T> for F {
|
||||
fn dedup_pair(&mut self, a: &T, b: &T) -> bool {
|
||||
self(a, b)
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new `DedupBy`.
|
||||
pub fn dedup_by<I, Pred>(mut iter: I, dedup_pred: Pred) -> DedupBy<I, Pred>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
DedupBy {
|
||||
last: iter.next(),
|
||||
iter,
|
||||
f: DedupPred2CoalescePred(dedup_pred),
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that removes repeated duplicates.
|
||||
///
|
||||
/// See [`.dedup()`](crate::Itertools::dedup) for more information.
|
||||
pub type Dedup<I> = DedupBy<I, DedupEq>;
|
||||
|
||||
/// Create a new `Dedup`.
|
||||
pub fn dedup<I>(iter: I) -> Dedup<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
dedup_by(iter, DedupEq)
|
||||
}
|
||||
|
||||
/// An iterator adaptor that removes repeated duplicates, while keeping a count of how many
|
||||
/// repeated elements were present. This will determine equality using a comparison function.
|
||||
///
|
||||
/// See [`.dedup_by_with_count()`](crate::Itertools::dedup_by_with_count) or
|
||||
/// [`.dedup_with_count()`](crate::Itertools::dedup_with_count) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub type DedupByWithCount<I, Pred> =
|
||||
CoalesceBy<I, DedupPredWithCount2CoalescePred<Pred>, (usize, <I as Iterator>::Item)>;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct DedupPredWithCount2CoalescePred<DP>(DP);
|
||||
|
||||
impl<DP, T> CoalescePredicate<T, (usize, T)> for DedupPredWithCount2CoalescePred<DP>
|
||||
where
|
||||
DP: DedupPredicate<T>,
|
||||
{
|
||||
fn coalesce_pair(
|
||||
&mut self,
|
||||
(c, t): (usize, T),
|
||||
item: T,
|
||||
) -> Result<(usize, T), ((usize, T), (usize, T))> {
|
||||
if self.0.dedup_pair(&t, &item) {
|
||||
Ok((c + 1, t))
|
||||
} else {
|
||||
Err(((c, t), (1, item)))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that removes repeated duplicates, while keeping a count of how many
|
||||
/// repeated elements were present.
|
||||
///
|
||||
/// See [`.dedup_with_count()`](crate::Itertools::dedup_with_count) for more information.
|
||||
pub type DedupWithCount<I> = DedupByWithCount<I, DedupEq>;
|
||||
|
||||
/// Create a new `DedupByWithCount`.
|
||||
pub fn dedup_by_with_count<I, Pred>(mut iter: I, dedup_pred: Pred) -> DedupByWithCount<I, Pred>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
DedupByWithCount {
|
||||
last: iter.next().map(|v| (1, v)),
|
||||
iter,
|
||||
f: DedupPredWithCount2CoalescePred(dedup_pred),
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new `DedupWithCount`.
|
||||
pub fn dedup_with_count<I>(iter: I) -> DedupWithCount<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
dedup_by_with_count(iter, DedupEq)
|
||||
}
|
||||
124
zeroidc/vendor/itertools/src/adaptors/map.rs
vendored
Normal file
124
zeroidc/vendor/itertools/src/adaptors/map.rs
vendored
Normal file
@@ -0,0 +1,124 @@
|
||||
use std::iter::FromIterator;
|
||||
use std::marker::PhantomData;
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct MapSpecialCase<I, F> {
|
||||
iter: I,
|
||||
f: F,
|
||||
}
|
||||
|
||||
pub trait MapSpecialCaseFn<T> {
|
||||
type Out;
|
||||
fn call(&mut self, t: T) -> Self::Out;
|
||||
}
|
||||
|
||||
impl<I, R> Iterator for MapSpecialCase<I, R>
|
||||
where
|
||||
I: Iterator,
|
||||
R: MapSpecialCaseFn<I::Item>,
|
||||
{
|
||||
type Item = R::Out;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.iter.next().map(|i| self.f.call(i))
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.iter.size_hint()
|
||||
}
|
||||
|
||||
fn fold<Acc, Fold>(self, init: Acc, mut fold_f: Fold) -> Acc
|
||||
where
|
||||
Fold: FnMut(Acc, Self::Item) -> Acc,
|
||||
{
|
||||
let mut f = self.f;
|
||||
self.iter.fold(init, move |acc, v| fold_f(acc, f.call(v)))
|
||||
}
|
||||
|
||||
fn collect<C>(self) -> C
|
||||
where
|
||||
C: FromIterator<Self::Item>,
|
||||
{
|
||||
let mut f = self.f;
|
||||
self.iter.map(move |v| f.call(v)).collect()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, R> DoubleEndedIterator for MapSpecialCase<I, R>
|
||||
where
|
||||
I: DoubleEndedIterator,
|
||||
R: MapSpecialCaseFn<I::Item>,
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
self.iter.next_back().map(|i| self.f.call(i))
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, R> ExactSizeIterator for MapSpecialCase<I, R>
|
||||
where
|
||||
I: ExactSizeIterator,
|
||||
R: MapSpecialCaseFn<I::Item>,
|
||||
{
|
||||
}
|
||||
|
||||
/// An iterator adapter to apply a transformation within a nested `Result::Ok`.
|
||||
///
|
||||
/// See [`.map_ok()`](crate::Itertools::map_ok) for more information.
|
||||
pub type MapOk<I, F> = MapSpecialCase<I, MapSpecialCaseFnOk<F>>;
|
||||
|
||||
/// See [`MapOk`].
|
||||
#[deprecated(note = "Use MapOk instead", since = "0.10.0")]
|
||||
pub type MapResults<I, F> = MapOk<I, F>;
|
||||
|
||||
impl<F, T, U, E> MapSpecialCaseFn<Result<T, E>> for MapSpecialCaseFnOk<F>
|
||||
where
|
||||
F: FnMut(T) -> U,
|
||||
{
|
||||
type Out = Result<U, E>;
|
||||
fn call(&mut self, t: Result<T, E>) -> Self::Out {
|
||||
t.map(|v| self.0(v))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct MapSpecialCaseFnOk<F>(F);
|
||||
|
||||
impl<F> std::fmt::Debug for MapSpecialCaseFnOk<F> {
|
||||
debug_fmt_fields!(MapSpecialCaseFnOk,);
|
||||
}
|
||||
|
||||
/// Create a new `MapOk` iterator.
|
||||
pub fn map_ok<I, F, T, U, E>(iter: I, f: F) -> MapOk<I, F>
|
||||
where
|
||||
I: Iterator<Item = Result<T, E>>,
|
||||
F: FnMut(T) -> U,
|
||||
{
|
||||
MapSpecialCase {
|
||||
iter,
|
||||
f: MapSpecialCaseFnOk(f),
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adapter to apply `Into` conversion to each element.
|
||||
///
|
||||
/// See [`.map_into()`](crate::Itertools::map_into) for more information.
|
||||
pub type MapInto<I, R> = MapSpecialCase<I, MapSpecialCaseFnInto<R>>;
|
||||
|
||||
impl<T: Into<U>, U> MapSpecialCaseFn<T> for MapSpecialCaseFnInto<U> {
|
||||
type Out = U;
|
||||
fn call(&mut self, t: T) -> Self::Out {
|
||||
t.into()
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MapSpecialCaseFnInto<U>(PhantomData<U>);
|
||||
|
||||
/// Create a new [`MapInto`] iterator.
|
||||
pub fn map_into<I, R>(iter: I) -> MapInto<I, R> {
|
||||
MapSpecialCase {
|
||||
iter,
|
||||
f: MapSpecialCaseFnInto(PhantomData),
|
||||
}
|
||||
}
|
||||
1159
zeroidc/vendor/itertools/src/adaptors/mod.rs
vendored
Normal file
1159
zeroidc/vendor/itertools/src/adaptors/mod.rs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
230
zeroidc/vendor/itertools/src/adaptors/multi_product.rs
vendored
Normal file
230
zeroidc/vendor/itertools/src/adaptors/multi_product.rs
vendored
Normal file
@@ -0,0 +1,230 @@
|
||||
#![cfg(feature = "use_alloc")]
|
||||
|
||||
use crate::size_hint;
|
||||
use crate::Itertools;
|
||||
|
||||
use alloc::vec::Vec;
|
||||
|
||||
#[derive(Clone)]
|
||||
/// An iterator adaptor that iterates over the cartesian product of
|
||||
/// multiple iterators of type `I`.
|
||||
///
|
||||
/// An iterator element type is `Vec<I>`.
|
||||
///
|
||||
/// See [`.multi_cartesian_product()`](crate::Itertools::multi_cartesian_product)
|
||||
/// for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct MultiProduct<I>(Vec<MultiProductIter<I>>)
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone;
|
||||
|
||||
impl<I> std::fmt::Debug for MultiProduct<I>
|
||||
where
|
||||
I: Iterator + Clone + std::fmt::Debug,
|
||||
I::Item: Clone + std::fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(CoalesceBy, 0);
|
||||
}
|
||||
|
||||
/// Create a new cartesian product iterator over an arbitrary number
|
||||
/// of iterators of the same type.
|
||||
///
|
||||
/// Iterator element is of type `Vec<H::Item::Item>`.
|
||||
pub fn multi_cartesian_product<H>(iters: H) -> MultiProduct<<H::Item as IntoIterator>::IntoIter>
|
||||
where H: Iterator,
|
||||
H::Item: IntoIterator,
|
||||
<H::Item as IntoIterator>::IntoIter: Clone,
|
||||
<H::Item as IntoIterator>::Item: Clone
|
||||
{
|
||||
MultiProduct(iters.map(|i| MultiProductIter::new(i.into_iter())).collect())
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
/// Holds the state of a single iterator within a MultiProduct.
|
||||
struct MultiProductIter<I>
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone
|
||||
{
|
||||
cur: Option<I::Item>,
|
||||
iter: I,
|
||||
iter_orig: I,
|
||||
}
|
||||
|
||||
/// Holds the current state during an iteration of a MultiProduct.
|
||||
#[derive(Debug)]
|
||||
enum MultiProductIterState {
|
||||
StartOfIter,
|
||||
MidIter { on_first_iter: bool },
|
||||
}
|
||||
|
||||
impl<I> MultiProduct<I>
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone
|
||||
{
|
||||
/// Iterates the rightmost iterator, then recursively iterates iterators
|
||||
/// to the left if necessary.
|
||||
///
|
||||
/// Returns true if the iteration succeeded, else false.
|
||||
fn iterate_last(
|
||||
multi_iters: &mut [MultiProductIter<I>],
|
||||
mut state: MultiProductIterState
|
||||
) -> bool {
|
||||
use self::MultiProductIterState::*;
|
||||
|
||||
if let Some((last, rest)) = multi_iters.split_last_mut() {
|
||||
let on_first_iter = match state {
|
||||
StartOfIter => {
|
||||
let on_first_iter = !last.in_progress();
|
||||
state = MidIter { on_first_iter };
|
||||
on_first_iter
|
||||
},
|
||||
MidIter { on_first_iter } => on_first_iter
|
||||
};
|
||||
|
||||
if !on_first_iter {
|
||||
last.iterate();
|
||||
}
|
||||
|
||||
if last.in_progress() {
|
||||
true
|
||||
} else if MultiProduct::iterate_last(rest, state) {
|
||||
last.reset();
|
||||
last.iterate();
|
||||
// If iterator is None twice consecutively, then iterator is
|
||||
// empty; whole product is empty.
|
||||
last.in_progress()
|
||||
} else {
|
||||
false
|
||||
}
|
||||
} else {
|
||||
// Reached end of iterator list. On initialisation, return true.
|
||||
// At end of iteration (final iterator finishes), finish.
|
||||
match state {
|
||||
StartOfIter => false,
|
||||
MidIter { on_first_iter } => on_first_iter
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the unwrapped value of the next iteration.
|
||||
fn curr_iterator(&self) -> Vec<I::Item> {
|
||||
self.0.iter().map(|multi_iter| {
|
||||
multi_iter.cur.clone().unwrap()
|
||||
}).collect()
|
||||
}
|
||||
|
||||
/// Returns true if iteration has started and has not yet finished; false
|
||||
/// otherwise.
|
||||
fn in_progress(&self) -> bool {
|
||||
if let Some(last) = self.0.last() {
|
||||
last.in_progress()
|
||||
} else {
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> MultiProductIter<I>
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone
|
||||
{
|
||||
fn new(iter: I) -> Self {
|
||||
MultiProductIter {
|
||||
cur: None,
|
||||
iter: iter.clone(),
|
||||
iter_orig: iter
|
||||
}
|
||||
}
|
||||
|
||||
/// Iterate the managed iterator.
|
||||
fn iterate(&mut self) {
|
||||
self.cur = self.iter.next();
|
||||
}
|
||||
|
||||
/// Reset the managed iterator.
|
||||
fn reset(&mut self) {
|
||||
self.iter = self.iter_orig.clone();
|
||||
}
|
||||
|
||||
/// Returns true if the current iterator has been started and has not yet
|
||||
/// finished; false otherwise.
|
||||
fn in_progress(&self) -> bool {
|
||||
self.cur.is_some()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for MultiProduct<I>
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone
|
||||
{
|
||||
type Item = Vec<I::Item>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if MultiProduct::iterate_last(
|
||||
&mut self.0,
|
||||
MultiProductIterState::StartOfIter
|
||||
) {
|
||||
Some(self.curr_iterator())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn count(self) -> usize {
|
||||
if self.0.is_empty() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if !self.in_progress() {
|
||||
return self.0.into_iter().fold(1, |acc, multi_iter| {
|
||||
acc * multi_iter.iter.count()
|
||||
});
|
||||
}
|
||||
|
||||
self.0.into_iter().fold(
|
||||
0,
|
||||
|acc, MultiProductIter { iter, iter_orig, cur: _ }| {
|
||||
let total_count = iter_orig.count();
|
||||
let cur_count = iter.count();
|
||||
acc * total_count + cur_count
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
// Not ExactSizeIterator because size may be larger than usize
|
||||
if self.0.is_empty() {
|
||||
return (0, Some(0));
|
||||
}
|
||||
|
||||
if !self.in_progress() {
|
||||
return self.0.iter().fold((1, Some(1)), |acc, multi_iter| {
|
||||
size_hint::mul(acc, multi_iter.iter.size_hint())
|
||||
});
|
||||
}
|
||||
|
||||
self.0.iter().fold(
|
||||
(0, Some(0)),
|
||||
|acc, &MultiProductIter { ref iter, ref iter_orig, cur: _ }| {
|
||||
let cur_size = iter.size_hint();
|
||||
let total_size = iter_orig.size_hint();
|
||||
size_hint::add(size_hint::mul(acc, total_size), cur_size)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
fn last(self) -> Option<Self::Item> {
|
||||
let iter_count = self.0.len();
|
||||
|
||||
let lasts: Self::Item = self.0.into_iter()
|
||||
.map(|multi_iter| multi_iter.iter.last())
|
||||
.while_some()
|
||||
.collect();
|
||||
|
||||
if lasts.len() == iter_count {
|
||||
Some(lasts)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
128
zeroidc/vendor/itertools/src/combinations.rs
vendored
Normal file
128
zeroidc/vendor/itertools/src/combinations.rs
vendored
Normal file
@@ -0,0 +1,128 @@
|
||||
use std::fmt;
|
||||
use std::iter::FusedIterator;
|
||||
|
||||
use super::lazy_buffer::LazyBuffer;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
/// An iterator to iterate through all the `k`-length combinations in an iterator.
|
||||
///
|
||||
/// See [`.combinations()`](crate::Itertools::combinations) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Combinations<I: Iterator> {
|
||||
indices: Vec<usize>,
|
||||
pool: LazyBuffer<I>,
|
||||
first: bool,
|
||||
}
|
||||
|
||||
impl<I> Clone for Combinations<I>
|
||||
where I: Clone + Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
clone_fields!(indices, pool, first);
|
||||
}
|
||||
|
||||
impl<I> fmt::Debug for Combinations<I>
|
||||
where I: Iterator + fmt::Debug,
|
||||
I::Item: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(Combinations, indices, pool, first);
|
||||
}
|
||||
|
||||
/// Create a new `Combinations` from a clonable iterator.
|
||||
pub fn combinations<I>(iter: I, k: usize) -> Combinations<I>
|
||||
where I: Iterator
|
||||
{
|
||||
let mut pool = LazyBuffer::new(iter);
|
||||
pool.prefill(k);
|
||||
|
||||
Combinations {
|
||||
indices: (0..k).collect(),
|
||||
pool,
|
||||
first: true,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Iterator> Combinations<I> {
|
||||
/// Returns the length of a combination produced by this iterator.
|
||||
#[inline]
|
||||
pub fn k(&self) -> usize { self.indices.len() }
|
||||
|
||||
/// Returns the (current) length of the pool from which combination elements are
|
||||
/// selected. This value can change between invocations of [`next`](Combinations::next).
|
||||
#[inline]
|
||||
pub fn n(&self) -> usize { self.pool.len() }
|
||||
|
||||
/// Returns a reference to the source iterator.
|
||||
#[inline]
|
||||
pub(crate) fn src(&self) -> &I { &self.pool.it }
|
||||
|
||||
/// Resets this `Combinations` back to an initial state for combinations of length
|
||||
/// `k` over the same pool data source. If `k` is larger than the current length
|
||||
/// of the data pool an attempt is made to prefill the pool so that it holds `k`
|
||||
/// elements.
|
||||
pub(crate) fn reset(&mut self, k: usize) {
|
||||
self.first = true;
|
||||
|
||||
if k < self.indices.len() {
|
||||
self.indices.truncate(k);
|
||||
for i in 0..k {
|
||||
self.indices[i] = i;
|
||||
}
|
||||
|
||||
} else {
|
||||
for i in 0..self.indices.len() {
|
||||
self.indices[i] = i;
|
||||
}
|
||||
self.indices.extend(self.indices.len()..k);
|
||||
self.pool.prefill(k);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for Combinations<I>
|
||||
where I: Iterator,
|
||||
I::Item: Clone
|
||||
{
|
||||
type Item = Vec<I::Item>;
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.first {
|
||||
if self.k() > self.n() {
|
||||
return None;
|
||||
}
|
||||
self.first = false;
|
||||
} else if self.indices.is_empty() {
|
||||
return None;
|
||||
} else {
|
||||
// Scan from the end, looking for an index to increment
|
||||
let mut i: usize = self.indices.len() - 1;
|
||||
|
||||
// Check if we need to consume more from the iterator
|
||||
if self.indices[i] == self.pool.len() - 1 {
|
||||
self.pool.get_next(); // may change pool size
|
||||
}
|
||||
|
||||
while self.indices[i] == i + self.pool.len() - self.indices.len() {
|
||||
if i > 0 {
|
||||
i -= 1;
|
||||
} else {
|
||||
// Reached the last combination
|
||||
return None;
|
||||
}
|
||||
}
|
||||
|
||||
// Increment index, and reset the ones to its right
|
||||
self.indices[i] += 1;
|
||||
for j in i+1..self.indices.len() {
|
||||
self.indices[j] = self.indices[j - 1] + 1;
|
||||
}
|
||||
}
|
||||
|
||||
// Create result vector based on the indices
|
||||
Some(self.indices.iter().map(|i| self.pool[*i].clone()).collect())
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> FusedIterator for Combinations<I>
|
||||
where I: Iterator,
|
||||
I::Item: Clone
|
||||
{}
|
||||
109
zeroidc/vendor/itertools/src/combinations_with_replacement.rs
vendored
Normal file
109
zeroidc/vendor/itertools/src/combinations_with_replacement.rs
vendored
Normal file
@@ -0,0 +1,109 @@
|
||||
use alloc::vec::Vec;
|
||||
use std::fmt;
|
||||
use std::iter::FusedIterator;
|
||||
|
||||
use super::lazy_buffer::LazyBuffer;
|
||||
|
||||
/// An iterator to iterate through all the `n`-length combinations in an iterator, with replacement.
|
||||
///
|
||||
/// See [`.combinations_with_replacement()`](crate::Itertools::combinations_with_replacement)
|
||||
/// for more information.
|
||||
#[derive(Clone)]
|
||||
pub struct CombinationsWithReplacement<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
indices: Vec<usize>,
|
||||
pool: LazyBuffer<I>,
|
||||
first: bool,
|
||||
}
|
||||
|
||||
impl<I> fmt::Debug for CombinationsWithReplacement<I>
|
||||
where
|
||||
I: Iterator + fmt::Debug,
|
||||
I::Item: fmt::Debug + Clone,
|
||||
{
|
||||
debug_fmt_fields!(Combinations, indices, pool, first);
|
||||
}
|
||||
|
||||
impl<I> CombinationsWithReplacement<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
/// Map the current mask over the pool to get an output combination
|
||||
fn current(&self) -> Vec<I::Item> {
|
||||
self.indices.iter().map(|i| self.pool[*i].clone()).collect()
|
||||
}
|
||||
}
|
||||
|
||||
/// Create a new `CombinationsWithReplacement` from a clonable iterator.
|
||||
pub fn combinations_with_replacement<I>(iter: I, k: usize) -> CombinationsWithReplacement<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
let indices: Vec<usize> = alloc::vec![0; k];
|
||||
let pool: LazyBuffer<I> = LazyBuffer::new(iter);
|
||||
|
||||
CombinationsWithReplacement {
|
||||
indices,
|
||||
pool,
|
||||
first: true,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for CombinationsWithReplacement<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
type Item = Vec<I::Item>;
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
// If this is the first iteration, return early
|
||||
if self.first {
|
||||
// In empty edge cases, stop iterating immediately
|
||||
return if self.indices.len() != 0 && !self.pool.get_next() {
|
||||
None
|
||||
// Otherwise, yield the initial state
|
||||
} else {
|
||||
self.first = false;
|
||||
Some(self.current())
|
||||
};
|
||||
}
|
||||
|
||||
// Check if we need to consume more from the iterator
|
||||
// This will run while we increment our first index digit
|
||||
self.pool.get_next();
|
||||
|
||||
// Work out where we need to update our indices
|
||||
let mut increment: Option<(usize, usize)> = None;
|
||||
for (i, indices_int) in self.indices.iter().enumerate().rev() {
|
||||
if *indices_int < self.pool.len()-1 {
|
||||
increment = Some((i, indices_int + 1));
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
match increment {
|
||||
// If we can update the indices further
|
||||
Some((increment_from, increment_value)) => {
|
||||
// We need to update the rightmost non-max value
|
||||
// and all those to the right
|
||||
for indices_index in increment_from..self.indices.len() {
|
||||
self.indices[indices_index] = increment_value
|
||||
}
|
||||
Some(self.current())
|
||||
}
|
||||
// Otherwise, we're done
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> FusedIterator for CombinationsWithReplacement<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{}
|
||||
22
zeroidc/vendor/itertools/src/concat_impl.rs
vendored
Normal file
22
zeroidc/vendor/itertools/src/concat_impl.rs
vendored
Normal file
@@ -0,0 +1,22 @@
|
||||
use crate::Itertools;
|
||||
|
||||
/// Combine all an iterator's elements into one element by using [`Extend`].
|
||||
///
|
||||
/// [`IntoIterator`]-enabled version of [`Itertools::concat`].
|
||||
///
|
||||
/// This combinator will extend the first item with each of the rest of the
|
||||
/// items of the iterator. If the iterator is empty, the default value of
|
||||
/// `I::Item` is returned.
|
||||
///
|
||||
/// ```rust
|
||||
/// use itertools::concat;
|
||||
///
|
||||
/// let input = vec![vec![1], vec![2, 3], vec![4, 5, 6]];
|
||||
/// assert_eq!(concat(input), vec![1, 2, 3, 4, 5, 6]);
|
||||
/// ```
|
||||
pub fn concat<I>(iterable: I) -> I::Item
|
||||
where I: IntoIterator,
|
||||
I::Item: Extend<<<I as IntoIterator>::Item as IntoIterator>::Item> + IntoIterator + Default
|
||||
{
|
||||
iterable.into_iter().fold1(|mut a, b| { a.extend(b); a }).unwrap_or_else(<_>::default)
|
||||
}
|
||||
64
zeroidc/vendor/itertools/src/cons_tuples_impl.rs
vendored
Normal file
64
zeroidc/vendor/itertools/src/cons_tuples_impl.rs
vendored
Normal file
@@ -0,0 +1,64 @@
|
||||
|
||||
macro_rules! impl_cons_iter(
|
||||
($_A:ident, $_B:ident, ) => (); // stop
|
||||
|
||||
($A:ident, $($B:ident,)*) => (
|
||||
impl_cons_iter!($($B,)*);
|
||||
#[allow(non_snake_case)]
|
||||
impl<X, Iter, $($B),*> Iterator for ConsTuples<Iter, (($($B,)*), X)>
|
||||
where Iter: Iterator<Item = (($($B,)*), X)>,
|
||||
{
|
||||
type Item = ($($B,)* X, );
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.iter.next().map(|(($($B,)*), x)| ($($B,)* x, ))
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.iter.size_hint()
|
||||
}
|
||||
fn fold<Acc, Fold>(self, accum: Acc, mut f: Fold) -> Acc
|
||||
where Fold: FnMut(Acc, Self::Item) -> Acc,
|
||||
{
|
||||
self.iter.fold(accum, move |acc, (($($B,)*), x)| f(acc, ($($B,)* x, )))
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
impl<X, Iter, $($B),*> DoubleEndedIterator for ConsTuples<Iter, (($($B,)*), X)>
|
||||
where Iter: DoubleEndedIterator<Item = (($($B,)*), X)>,
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
self.iter.next().map(|(($($B,)*), x)| ($($B,)* x, ))
|
||||
}
|
||||
}
|
||||
|
||||
);
|
||||
);
|
||||
|
||||
impl_cons_iter!(A, B, C, D, E, F, G, H, I, J, K, L,);
|
||||
|
||||
/// An iterator that maps an iterator of tuples like
|
||||
/// `((A, B), C)` to an iterator of `(A, B, C)`.
|
||||
///
|
||||
/// Used by the `iproduct!()` macro.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
#[derive(Debug)]
|
||||
pub struct ConsTuples<I, J>
|
||||
where I: Iterator<Item=J>,
|
||||
{
|
||||
iter: I,
|
||||
}
|
||||
|
||||
impl<I, J> Clone for ConsTuples<I, J>
|
||||
where I: Clone + Iterator<Item=J>,
|
||||
{
|
||||
clone_fields!(iter);
|
||||
}
|
||||
|
||||
/// Create an iterator that maps for example iterators of
|
||||
/// `((A, B), C)` to `(A, B, C)`.
|
||||
pub fn cons_tuples<I, J>(iterable: I) -> ConsTuples<I::IntoIter, J>
|
||||
where I: IntoIterator<Item=J>
|
||||
{
|
||||
ConsTuples { iter: iterable.into_iter() }
|
||||
}
|
||||
61
zeroidc/vendor/itertools/src/diff.rs
vendored
Normal file
61
zeroidc/vendor/itertools/src/diff.rs
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
//! "Diff"ing iterators for caching elements to sequential collections without requiring the new
|
||||
//! elements' iterator to be `Clone`.
|
||||
//!
|
||||
//! - [`Diff`] (produced by the [`diff_with`] function)
|
||||
//! describes the difference between two non-`Clone` iterators `I` and `J` after breaking ASAP from
|
||||
//! a lock-step comparison.
|
||||
|
||||
use crate::free::put_back;
|
||||
use crate::structs::PutBack;
|
||||
|
||||
/// A type returned by the [`diff_with`] function.
|
||||
///
|
||||
/// `Diff` represents the way in which the elements yielded by the iterator `I` differ to some
|
||||
/// iterator `J`.
|
||||
pub enum Diff<I, J>
|
||||
where I: Iterator,
|
||||
J: Iterator
|
||||
{
|
||||
/// The index of the first non-matching element along with both iterator's remaining elements
|
||||
/// starting with the first mis-match.
|
||||
FirstMismatch(usize, PutBack<I>, PutBack<J>),
|
||||
/// The total number of elements that were in `J` along with the remaining elements of `I`.
|
||||
Shorter(usize, PutBack<I>),
|
||||
/// The total number of elements that were in `I` along with the remaining elements of `J`.
|
||||
Longer(usize, PutBack<J>),
|
||||
}
|
||||
|
||||
/// Compares every element yielded by both `i` and `j` with the given function in lock-step and
|
||||
/// returns a [`Diff`] which describes how `j` differs from `i`.
|
||||
///
|
||||
/// If the number of elements yielded by `j` is less than the number of elements yielded by `i`,
|
||||
/// the number of `j` elements yielded will be returned along with `i`'s remaining elements as
|
||||
/// `Diff::Shorter`.
|
||||
///
|
||||
/// If the two elements of a step differ, the index of those elements along with the remaining
|
||||
/// elements of both `i` and `j` are returned as `Diff::FirstMismatch`.
|
||||
///
|
||||
/// If `i` becomes exhausted before `j` becomes exhausted, the number of elements in `i` along with
|
||||
/// the remaining `j` elements will be returned as `Diff::Longer`.
|
||||
pub fn diff_with<I, J, F>(i: I, j: J, is_equal: F)
|
||||
-> Option<Diff<I::IntoIter, J::IntoIter>>
|
||||
where I: IntoIterator,
|
||||
J: IntoIterator,
|
||||
F: Fn(&I::Item, &J::Item) -> bool
|
||||
{
|
||||
let mut i = i.into_iter();
|
||||
let mut j = j.into_iter();
|
||||
let mut idx = 0;
|
||||
while let Some(i_elem) = i.next() {
|
||||
match j.next() {
|
||||
None => return Some(Diff::Shorter(idx, put_back(i).with_value(i_elem))),
|
||||
Some(j_elem) => if !is_equal(&i_elem, &j_elem) {
|
||||
let remaining_i = put_back(i).with_value(i_elem);
|
||||
let remaining_j = put_back(j).with_value(j_elem);
|
||||
return Some(Diff::FirstMismatch(idx, remaining_i, remaining_j));
|
||||
},
|
||||
}
|
||||
idx += 1;
|
||||
}
|
||||
j.next().map(|j_elem| Diff::Longer(idx, put_back(j).with_value(j_elem)))
|
||||
}
|
||||
217
zeroidc/vendor/itertools/src/duplicates_impl.rs
vendored
Normal file
217
zeroidc/vendor/itertools/src/duplicates_impl.rs
vendored
Normal file
@@ -0,0 +1,217 @@
|
||||
use std::hash::Hash;
|
||||
|
||||
mod private {
|
||||
use std::collections::HashMap;
|
||||
use std::hash::Hash;
|
||||
use std::fmt;
|
||||
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct DuplicatesBy<I: Iterator, Key, F> {
|
||||
pub(crate) iter: I,
|
||||
pub(crate) meta: Meta<Key, F>,
|
||||
}
|
||||
|
||||
impl<I, V, F> fmt::Debug for DuplicatesBy<I, V, F>
|
||||
where
|
||||
I: Iterator + fmt::Debug,
|
||||
V: fmt::Debug + Hash + Eq,
|
||||
{
|
||||
debug_fmt_fields!(DuplicatesBy, iter, meta.used);
|
||||
}
|
||||
|
||||
impl<I: Iterator, Key: Eq + Hash, F> DuplicatesBy<I, Key, F> {
|
||||
pub(crate) fn new(iter: I, key_method: F) -> Self {
|
||||
DuplicatesBy {
|
||||
iter,
|
||||
meta: Meta {
|
||||
used: HashMap::new(),
|
||||
pending: 0,
|
||||
key_method,
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone)]
|
||||
pub struct Meta<Key, F> {
|
||||
used: HashMap<Key, bool>,
|
||||
pending: usize,
|
||||
key_method: F,
|
||||
}
|
||||
|
||||
impl<Key, F> Meta<Key, F>
|
||||
where
|
||||
Key: Eq + Hash,
|
||||
{
|
||||
/// Takes an item and returns it back to the caller if it's the second time we see it.
|
||||
/// Otherwise the item is consumed and None is returned
|
||||
#[inline(always)]
|
||||
fn filter<I>(&mut self, item: I) -> Option<I>
|
||||
where
|
||||
F: KeyMethod<Key, I>,
|
||||
{
|
||||
let kv = self.key_method.make(item);
|
||||
match self.used.get_mut(kv.key_ref()) {
|
||||
None => {
|
||||
self.used.insert(kv.key(), false);
|
||||
self.pending += 1;
|
||||
None
|
||||
}
|
||||
Some(true) => None,
|
||||
Some(produced) => {
|
||||
*produced = true;
|
||||
self.pending -= 1;
|
||||
Some(kv.value())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, Key, F> Iterator for DuplicatesBy<I, Key, F>
|
||||
where
|
||||
I: Iterator,
|
||||
Key: Eq + Hash,
|
||||
F: KeyMethod<Key, I::Item>,
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let DuplicatesBy { iter, meta } = self;
|
||||
iter.find_map(|v| meta.filter(v))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let (_, hi) = self.iter.size_hint();
|
||||
let hi = hi.map(|hi| {
|
||||
if hi <= self.meta.pending {
|
||||
// fewer or equally many iter-remaining elements than pending elements
|
||||
// => at most, each iter-remaining element is matched
|
||||
hi
|
||||
} else {
|
||||
// fewer pending elements than iter-remaining elements
|
||||
// => at most:
|
||||
// * each pending element is matched
|
||||
// * the other iter-remaining elements come in pairs
|
||||
self.meta.pending + (hi - self.meta.pending) / 2
|
||||
}
|
||||
});
|
||||
// The lower bound is always 0 since we might only get unique items from now on
|
||||
(0, hi)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, Key, F> DoubleEndedIterator for DuplicatesBy<I, Key, F>
|
||||
where
|
||||
I: DoubleEndedIterator,
|
||||
Key: Eq + Hash,
|
||||
F: KeyMethod<Key, I::Item>,
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
let DuplicatesBy { iter, meta } = self;
|
||||
iter.rev().find_map(|v| meta.filter(v))
|
||||
}
|
||||
}
|
||||
|
||||
/// A keying method for use with `DuplicatesBy`
|
||||
pub trait KeyMethod<K, V> {
|
||||
type Container: KeyXorValue<K, V>;
|
||||
|
||||
fn make(&mut self, value: V) -> Self::Container;
|
||||
}
|
||||
|
||||
/// Apply the identity function to elements before checking them for equality.
|
||||
#[derive(Debug)]
|
||||
pub struct ById;
|
||||
impl<V> KeyMethod<V, V> for ById {
|
||||
type Container = JustValue<V>;
|
||||
|
||||
fn make(&mut self, v: V) -> Self::Container {
|
||||
JustValue(v)
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply a user-supplied function to elements before checking them for equality.
|
||||
pub struct ByFn<F>(pub(crate) F);
|
||||
impl<F> fmt::Debug for ByFn<F> {
|
||||
debug_fmt_fields!(ByFn,);
|
||||
}
|
||||
impl<K, V, F> KeyMethod<K, V> for ByFn<F>
|
||||
where
|
||||
F: FnMut(&V) -> K,
|
||||
{
|
||||
type Container = KeyValue<K, V>;
|
||||
|
||||
fn make(&mut self, v: V) -> Self::Container {
|
||||
KeyValue((self.0)(&v), v)
|
||||
}
|
||||
}
|
||||
|
||||
// Implementors of this trait can hold onto a key and a value but only give access to one of them
|
||||
// at a time. This allows the key and the value to be the same value internally
|
||||
pub trait KeyXorValue<K, V> {
|
||||
fn key_ref(&self) -> &K;
|
||||
fn key(self) -> K;
|
||||
fn value(self) -> V;
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct KeyValue<K, V>(K, V);
|
||||
impl<K, V> KeyXorValue<K, V> for KeyValue<K, V> {
|
||||
fn key_ref(&self) -> &K {
|
||||
&self.0
|
||||
}
|
||||
fn key(self) -> K {
|
||||
self.0
|
||||
}
|
||||
fn value(self) -> V {
|
||||
self.1
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug)]
|
||||
pub struct JustValue<V>(V);
|
||||
impl<V> KeyXorValue<V, V> for JustValue<V> {
|
||||
fn key_ref(&self) -> &V {
|
||||
&self.0
|
||||
}
|
||||
fn key(self) -> V {
|
||||
self.0
|
||||
}
|
||||
fn value(self) -> V {
|
||||
self.0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adapter to filter for duplicate elements.
|
||||
///
|
||||
/// See [`.duplicates_by()`](crate::Itertools::duplicates_by) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub type DuplicatesBy<I, V, F> = private::DuplicatesBy<I, V, private::ByFn<F>>;
|
||||
|
||||
/// Create a new `DuplicatesBy` iterator.
|
||||
pub fn duplicates_by<I, Key, F>(iter: I, f: F) -> DuplicatesBy<I, Key, F>
|
||||
where
|
||||
Key: Eq + Hash,
|
||||
F: FnMut(&I::Item) -> Key,
|
||||
I: Iterator,
|
||||
{
|
||||
DuplicatesBy::new(iter, private::ByFn(f))
|
||||
}
|
||||
|
||||
/// An iterator adapter to filter out duplicate elements.
|
||||
///
|
||||
/// See [`.duplicates()`](crate::Itertools::duplicates) for more information.
|
||||
pub type Duplicates<I> = private::DuplicatesBy<I, <I as Iterator>::Item, private::ById>;
|
||||
|
||||
/// Create a new `Duplicates` iterator.
|
||||
pub fn duplicates<I>(iter: I) -> Duplicates<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Eq + Hash,
|
||||
{
|
||||
Duplicates::new(iter, private::ById)
|
||||
}
|
||||
|
||||
205
zeroidc/vendor/itertools/src/either_or_both.rs
vendored
Normal file
205
zeroidc/vendor/itertools/src/either_or_both.rs
vendored
Normal file
@@ -0,0 +1,205 @@
|
||||
use crate::EitherOrBoth::*;
|
||||
|
||||
use either::Either;
|
||||
|
||||
/// Value that either holds a single A or B, or both.
|
||||
#[derive(Clone, PartialEq, Eq, Hash, Debug)]
|
||||
pub enum EitherOrBoth<A, B> {
|
||||
/// Both values are present.
|
||||
Both(A, B),
|
||||
/// Only the left value of type `A` is present.
|
||||
Left(A),
|
||||
/// Only the right value of type `B` is present.
|
||||
Right(B),
|
||||
}
|
||||
|
||||
impl<A, B> EitherOrBoth<A, B> {
|
||||
/// If `Left`, or `Both`, return true, otherwise, return false.
|
||||
pub fn has_left(&self) -> bool {
|
||||
self.as_ref().left().is_some()
|
||||
}
|
||||
|
||||
/// If `Right`, or `Both`, return true, otherwise, return false.
|
||||
pub fn has_right(&self) -> bool {
|
||||
self.as_ref().right().is_some()
|
||||
}
|
||||
|
||||
/// If Left, return true otherwise, return false.
|
||||
/// Exclusive version of [`has_left`](EitherOrBoth::has_left).
|
||||
pub fn is_left(&self) -> bool {
|
||||
match *self {
|
||||
Left(_) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// If Right, return true otherwise, return false.
|
||||
/// Exclusive version of [`has_right`](EitherOrBoth::has_right).
|
||||
pub fn is_right(&self) -> bool {
|
||||
match *self {
|
||||
Right(_) => true,
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// If Right, return true otherwise, return false.
|
||||
/// Equivalent to `self.as_ref().both().is_some()`.
|
||||
pub fn is_both(&self) -> bool {
|
||||
self.as_ref().both().is_some()
|
||||
}
|
||||
|
||||
/// If `Left`, or `Both`, return `Some` with the left value, otherwise, return `None`.
|
||||
pub fn left(self) -> Option<A> {
|
||||
match self {
|
||||
Left(left) | Both(left, _) => Some(left),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If `Right`, or `Both`, return `Some` with the right value, otherwise, return `None`.
|
||||
pub fn right(self) -> Option<B> {
|
||||
match self {
|
||||
Right(right) | Both(_, right) => Some(right),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// If Both, return `Some` tuple containing left and right.
|
||||
pub fn both(self) -> Option<(A, B)> {
|
||||
match self {
|
||||
Both(a, b) => Some((a, b)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts from `&EitherOrBoth<A, B>` to `EitherOrBoth<&A, &B>`.
|
||||
pub fn as_ref(&self) -> EitherOrBoth<&A, &B> {
|
||||
match *self {
|
||||
Left(ref left) => Left(left),
|
||||
Right(ref right) => Right(right),
|
||||
Both(ref left, ref right) => Both(left, right),
|
||||
}
|
||||
}
|
||||
|
||||
/// Converts from `&mut EitherOrBoth<A, B>` to `EitherOrBoth<&mut A, &mut B>`.
|
||||
pub fn as_mut(&mut self) -> EitherOrBoth<&mut A, &mut B> {
|
||||
match *self {
|
||||
Left(ref mut left) => Left(left),
|
||||
Right(ref mut right) => Right(right),
|
||||
Both(ref mut left, ref mut right) => Both(left, right),
|
||||
}
|
||||
}
|
||||
|
||||
/// Convert `EitherOrBoth<A, B>` to `EitherOrBoth<B, A>`.
|
||||
pub fn flip(self) -> EitherOrBoth<B, A> {
|
||||
match self {
|
||||
Left(a) => Right(a),
|
||||
Right(b) => Left(b),
|
||||
Both(a, b) => Both(b, a),
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the function `f` on the value `a` in `Left(a)` or `Both(a, b)` variants. If it is
|
||||
/// present rewrapping the result in `self`'s original variant.
|
||||
pub fn map_left<F, M>(self, f: F) -> EitherOrBoth<M, B>
|
||||
where
|
||||
F: FnOnce(A) -> M,
|
||||
{
|
||||
match self {
|
||||
Both(a, b) => Both(f(a), b),
|
||||
Left(a) => Left(f(a)),
|
||||
Right(b) => Right(b),
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the function `f` on the value `b` in `Right(b)` or `Both(a, b)` variants.
|
||||
/// If it is present rewrapping the result in `self`'s original variant.
|
||||
pub fn map_right<F, M>(self, f: F) -> EitherOrBoth<A, M>
|
||||
where
|
||||
F: FnOnce(B) -> M,
|
||||
{
|
||||
match self {
|
||||
Left(a) => Left(a),
|
||||
Right(b) => Right(f(b)),
|
||||
Both(a, b) => Both(a, f(b)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the functions `f` and `g` on the value `a` and `b` respectively;
|
||||
/// found in `Left(a)`, `Right(b)`, or `Both(a, b)` variants.
|
||||
/// The Result is rewrapped `self`'s original variant.
|
||||
pub fn map_any<F, L, G, R>(self, f: F, g: G) -> EitherOrBoth<L, R>
|
||||
where
|
||||
F: FnOnce(A) -> L,
|
||||
G: FnOnce(B) -> R,
|
||||
{
|
||||
match self {
|
||||
Left(a) => Left(f(a)),
|
||||
Right(b) => Right(g(b)),
|
||||
Both(a, b) => Both(f(a), g(b)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the function `f` on the value `a` in `Left(a)` or `Both(a, _)` variants if it is
|
||||
/// present.
|
||||
pub fn left_and_then<F, L>(self, f: F) -> EitherOrBoth<L, B>
|
||||
where
|
||||
F: FnOnce(A) -> EitherOrBoth<L, B>,
|
||||
{
|
||||
match self {
|
||||
Left(a) | Both(a, _) => f(a),
|
||||
Right(b) => Right(b),
|
||||
}
|
||||
}
|
||||
|
||||
/// Apply the function `f` on the value `b`
|
||||
/// in `Right(b)` or `Both(_, b)` variants if it is present.
|
||||
pub fn right_and_then<F, R>(self, f: F) -> EitherOrBoth<A, R>
|
||||
where
|
||||
F: FnOnce(B) -> EitherOrBoth<A, R>,
|
||||
{
|
||||
match self {
|
||||
Left(a) => Left(a),
|
||||
Right(b) | Both(_, b) => f(b),
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a tuple consisting of the `l` and `r` in `Both(l, r)`, if present.
|
||||
/// Otherwise, returns the wrapped value for the present element, and the [`default`](Default::default)
|
||||
/// for the other.
|
||||
pub fn or_default(self) -> (A, B)
|
||||
where
|
||||
A: Default,
|
||||
B: Default,
|
||||
{
|
||||
match self {
|
||||
EitherOrBoth::Left(l) => (l, B::default()),
|
||||
EitherOrBoth::Right(r) => (A::default(), r),
|
||||
EitherOrBoth::Both(l, r) => (l, r),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> EitherOrBoth<T, T> {
|
||||
/// Return either value of left, right, or the product of `f` applied where `Both` are present.
|
||||
pub fn reduce<F>(self, f: F) -> T
|
||||
where
|
||||
F: FnOnce(T, T) -> T,
|
||||
{
|
||||
match self {
|
||||
Left(a) => a,
|
||||
Right(b) => b,
|
||||
Both(a, b) => f(a, b),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<A, B> Into<Option<Either<A, B>>> for EitherOrBoth<A, B> {
|
||||
fn into(self) -> Option<Either<A, B>> {
|
||||
match self {
|
||||
EitherOrBoth::Left(l) => Some(Either::Left(l)),
|
||||
EitherOrBoth::Right(r) => Some(Either::Right(r)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
110
zeroidc/vendor/itertools/src/exactly_one_err.rs
vendored
Normal file
110
zeroidc/vendor/itertools/src/exactly_one_err.rs
vendored
Normal file
@@ -0,0 +1,110 @@
|
||||
#[cfg(feature = "use_std")]
|
||||
use std::error::Error;
|
||||
use std::fmt::{Debug, Display, Formatter, Result as FmtResult};
|
||||
|
||||
use std::iter::ExactSizeIterator;
|
||||
|
||||
use either::Either;
|
||||
|
||||
use crate::size_hint;
|
||||
|
||||
/// Iterator returned for the error case of `IterTools::exactly_one()`
|
||||
/// This iterator yields exactly the same elements as the input iterator.
|
||||
///
|
||||
/// During the execution of exactly_one the iterator must be mutated. This wrapper
|
||||
/// effectively "restores" the state of the input iterator when it's handed back.
|
||||
///
|
||||
/// This is very similar to PutBackN except this iterator only supports 0-2 elements and does not
|
||||
/// use a `Vec`.
|
||||
#[derive(Clone)]
|
||||
pub struct ExactlyOneError<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
first_two: Option<Either<[I::Item; 2], I::Item>>,
|
||||
inner: I,
|
||||
}
|
||||
|
||||
impl<I> ExactlyOneError<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
/// Creates a new `ExactlyOneErr` iterator.
|
||||
pub(crate) fn new(first_two: Option<Either<[I::Item; 2], I::Item>>, inner: I) -> Self {
|
||||
Self { first_two, inner }
|
||||
}
|
||||
|
||||
fn additional_len(&self) -> usize {
|
||||
match self.first_two {
|
||||
Some(Either::Left(_)) => 2,
|
||||
Some(Either::Right(_)) => 1,
|
||||
None => 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for ExactlyOneError<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match self.first_two.take() {
|
||||
Some(Either::Left([first, second])) => {
|
||||
self.first_two = Some(Either::Right(second));
|
||||
Some(first)
|
||||
},
|
||||
Some(Either::Right(second)) => {
|
||||
Some(second)
|
||||
}
|
||||
None => {
|
||||
self.inner.next()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::add_scalar(self.inner.size_hint(), self.additional_len())
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl<I> ExactSizeIterator for ExactlyOneError<I> where I: ExactSizeIterator {}
|
||||
|
||||
impl<I> Display for ExactlyOneError<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
fn fmt(&self, f: &mut Formatter) -> FmtResult {
|
||||
let additional = self.additional_len();
|
||||
if additional > 0 {
|
||||
write!(f, "got at least 2 elements when exactly one was expected")
|
||||
} else {
|
||||
write!(f, "got zero elements when exactly one was expected")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Debug for ExactlyOneError<I>
|
||||
where I: Iterator + Debug,
|
||||
I::Item: Debug,
|
||||
{
|
||||
fn fmt(&self, f: &mut Formatter) -> FmtResult {
|
||||
match &self.first_two {
|
||||
Some(Either::Left([first, second])) => {
|
||||
write!(f, "ExactlyOneError[First: {:?}, Second: {:?}, RemainingIter: {:?}]", first, second, self.inner)
|
||||
},
|
||||
Some(Either::Right(second)) => {
|
||||
write!(f, "ExactlyOneError[Second: {:?}, RemainingIter: {:?}]", second, self.inner)
|
||||
}
|
||||
None => {
|
||||
write!(f, "ExactlyOneError[RemainingIter: {:?}]", self.inner)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "use_std")]
|
||||
impl<I> Error for ExactlyOneError<I> where I: Iterator + Debug, I::Item: Debug, {}
|
||||
|
||||
|
||||
166
zeroidc/vendor/itertools/src/flatten_ok.rs
vendored
Normal file
166
zeroidc/vendor/itertools/src/flatten_ok.rs
vendored
Normal file
@@ -0,0 +1,166 @@
|
||||
use crate::size_hint;
|
||||
use std::{
|
||||
fmt,
|
||||
iter::{DoubleEndedIterator, FusedIterator},
|
||||
};
|
||||
|
||||
pub fn flatten_ok<I, T, E>(iter: I) -> FlattenOk<I, T, E>
|
||||
where
|
||||
I: Iterator<Item = Result<T, E>>,
|
||||
T: IntoIterator,
|
||||
{
|
||||
FlattenOk {
|
||||
iter,
|
||||
inner_front: None,
|
||||
inner_back: None,
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that flattens `Result::Ok` values and
|
||||
/// allows `Result::Err` values through unchanged.
|
||||
///
|
||||
/// See [`.flatten_ok()`](crate::Itertools::flatten_ok) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct FlattenOk<I, T, E>
|
||||
where
|
||||
I: Iterator<Item = Result<T, E>>,
|
||||
T: IntoIterator,
|
||||
{
|
||||
iter: I,
|
||||
inner_front: Option<T::IntoIter>,
|
||||
inner_back: Option<T::IntoIter>,
|
||||
}
|
||||
|
||||
impl<I, T, E> Iterator for FlattenOk<I, T, E>
|
||||
where
|
||||
I: Iterator<Item = Result<T, E>>,
|
||||
T: IntoIterator,
|
||||
{
|
||||
type Item = Result<T::Item, E>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
loop {
|
||||
// Handle the front inner iterator.
|
||||
if let Some(inner) = &mut self.inner_front {
|
||||
if let Some(item) = inner.next() {
|
||||
return Some(Ok(item));
|
||||
} else {
|
||||
// This is necessary for the iterator to implement `FusedIterator`
|
||||
// with only the orginal iterator being fused.
|
||||
self.inner_front = None;
|
||||
}
|
||||
}
|
||||
|
||||
match self.iter.next() {
|
||||
Some(Ok(ok)) => self.inner_front = Some(ok.into_iter()),
|
||||
Some(Err(e)) => return Some(Err(e)),
|
||||
None => {
|
||||
// Handle the back inner iterator.
|
||||
if let Some(inner) = &mut self.inner_back {
|
||||
if let Some(item) = inner.next() {
|
||||
return Some(Ok(item));
|
||||
} else {
|
||||
// This is necessary for the iterator to implement `FusedIterator`
|
||||
// with only the orginal iterator being fused.
|
||||
self.inner_back = None;
|
||||
}
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let inner_hint = |inner: &Option<T::IntoIter>| {
|
||||
inner
|
||||
.as_ref()
|
||||
.map(Iterator::size_hint)
|
||||
.unwrap_or((0, Some(0)))
|
||||
};
|
||||
let inner_front = inner_hint(&self.inner_front);
|
||||
let inner_back = inner_hint(&self.inner_back);
|
||||
// The outer iterator `Ok` case could be (0, None) as we don't know its size_hint yet.
|
||||
let outer = match self.iter.size_hint() {
|
||||
(0, Some(0)) => (0, Some(0)),
|
||||
_ => (0, None),
|
||||
};
|
||||
|
||||
size_hint::add(size_hint::add(inner_front, inner_back), outer)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T, E> DoubleEndedIterator for FlattenOk<I, T, E>
|
||||
where
|
||||
I: DoubleEndedIterator<Item = Result<T, E>>,
|
||||
T: IntoIterator,
|
||||
T::IntoIter: DoubleEndedIterator,
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
loop {
|
||||
// Handle the back inner iterator.
|
||||
if let Some(inner) = &mut self.inner_back {
|
||||
if let Some(item) = inner.next_back() {
|
||||
return Some(Ok(item));
|
||||
} else {
|
||||
// This is necessary for the iterator to implement `FusedIterator`
|
||||
// with only the orginal iterator being fused.
|
||||
self.inner_back = None;
|
||||
}
|
||||
}
|
||||
|
||||
match self.iter.next_back() {
|
||||
Some(Ok(ok)) => self.inner_back = Some(ok.into_iter()),
|
||||
Some(Err(e)) => return Some(Err(e)),
|
||||
None => {
|
||||
// Handle the front inner iterator.
|
||||
if let Some(inner) = &mut self.inner_front {
|
||||
if let Some(item) = inner.next_back() {
|
||||
return Some(Ok(item));
|
||||
} else {
|
||||
// This is necessary for the iterator to implement `FusedIterator`
|
||||
// with only the orginal iterator being fused.
|
||||
self.inner_front = None;
|
||||
}
|
||||
} else {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T, E> Clone for FlattenOk<I, T, E>
|
||||
where
|
||||
I: Iterator<Item = Result<T, E>> + Clone,
|
||||
T: IntoIterator,
|
||||
T::IntoIter: Clone,
|
||||
{
|
||||
#[inline]
|
||||
clone_fields!(iter, inner_front, inner_back);
|
||||
}
|
||||
|
||||
impl<I, T, E> fmt::Debug for FlattenOk<I, T, E>
|
||||
where
|
||||
I: Iterator<Item = Result<T, E>> + fmt::Debug,
|
||||
T: IntoIterator,
|
||||
T::IntoIter: fmt::Debug,
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
f.debug_struct("FlattenOk")
|
||||
.field("iter", &self.iter)
|
||||
.field("inner_front", &self.inner_front)
|
||||
.field("inner_back", &self.inner_back)
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
|
||||
/// Only the iterator being flattened needs to implement [`FusedIterator`].
|
||||
impl<I, T, E> FusedIterator for FlattenOk<I, T, E>
|
||||
where
|
||||
I: FusedIterator<Item = Result<T, E>>,
|
||||
T: IntoIterator,
|
||||
{
|
||||
}
|
||||
113
zeroidc/vendor/itertools/src/format.rs
vendored
Normal file
113
zeroidc/vendor/itertools/src/format.rs
vendored
Normal file
@@ -0,0 +1,113 @@
|
||||
use std::fmt;
|
||||
use std::cell::RefCell;
|
||||
|
||||
/// Format all iterator elements lazily, separated by `sep`.
|
||||
///
|
||||
/// The format value can only be formatted once, after that the iterator is
|
||||
/// exhausted.
|
||||
///
|
||||
/// See [`.format_with()`](crate::Itertools::format_with) for more information.
|
||||
#[derive(Clone)]
|
||||
pub struct FormatWith<'a, I, F> {
|
||||
sep: &'a str,
|
||||
/// FormatWith uses interior mutability because Display::fmt takes &self.
|
||||
inner: RefCell<Option<(I, F)>>,
|
||||
}
|
||||
|
||||
/// Format all iterator elements lazily, separated by `sep`.
|
||||
///
|
||||
/// The format value can only be formatted once, after that the iterator is
|
||||
/// exhausted.
|
||||
///
|
||||
/// See [`.format()`](crate::Itertools::format)
|
||||
/// for more information.
|
||||
#[derive(Clone)]
|
||||
pub struct Format<'a, I> {
|
||||
sep: &'a str,
|
||||
/// Format uses interior mutability because Display::fmt takes &self.
|
||||
inner: RefCell<Option<I>>,
|
||||
}
|
||||
|
||||
pub fn new_format<I, F>(iter: I, separator: &str, f: F) -> FormatWith<'_, I, F>
|
||||
where I: Iterator,
|
||||
F: FnMut(I::Item, &mut dyn FnMut(&dyn fmt::Display) -> fmt::Result) -> fmt::Result
|
||||
{
|
||||
FormatWith {
|
||||
sep: separator,
|
||||
inner: RefCell::new(Some((iter, f))),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn new_format_default<I>(iter: I, separator: &str) -> Format<'_, I>
|
||||
where I: Iterator,
|
||||
{
|
||||
Format {
|
||||
sep: separator,
|
||||
inner: RefCell::new(Some(iter)),
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, I, F> fmt::Display for FormatWith<'a, I, F>
|
||||
where I: Iterator,
|
||||
F: FnMut(I::Item, &mut dyn FnMut(&dyn fmt::Display) -> fmt::Result) -> fmt::Result
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
let (mut iter, mut format) = match self.inner.borrow_mut().take() {
|
||||
Some(t) => t,
|
||||
None => panic!("FormatWith: was already formatted once"),
|
||||
};
|
||||
|
||||
if let Some(fst) = iter.next() {
|
||||
format(fst, &mut |disp: &dyn fmt::Display| disp.fmt(f))?;
|
||||
iter.try_for_each(|elt| {
|
||||
if !self.sep.is_empty() {
|
||||
f.write_str(self.sep)?;
|
||||
}
|
||||
format(elt, &mut |disp: &dyn fmt::Display| disp.fmt(f))
|
||||
})?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, I> Format<'a, I>
|
||||
where I: Iterator,
|
||||
{
|
||||
fn format<F>(&self, f: &mut fmt::Formatter, mut cb: F) -> fmt::Result
|
||||
where F: FnMut(&I::Item, &mut fmt::Formatter) -> fmt::Result,
|
||||
{
|
||||
let mut iter = match self.inner.borrow_mut().take() {
|
||||
Some(t) => t,
|
||||
None => panic!("Format: was already formatted once"),
|
||||
};
|
||||
|
||||
if let Some(fst) = iter.next() {
|
||||
cb(&fst, f)?;
|
||||
iter.try_for_each(|elt| {
|
||||
if !self.sep.is_empty() {
|
||||
f.write_str(self.sep)?;
|
||||
}
|
||||
cb(&elt, f)
|
||||
})?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! impl_format {
|
||||
($($fmt_trait:ident)*) => {
|
||||
$(
|
||||
impl<'a, I> fmt::$fmt_trait for Format<'a, I>
|
||||
where I: Iterator,
|
||||
I::Item: fmt::$fmt_trait,
|
||||
{
|
||||
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
|
||||
self.format(f, fmt::$fmt_trait::fmt)
|
||||
}
|
||||
}
|
||||
)*
|
||||
}
|
||||
}
|
||||
|
||||
impl_format!{Display Debug
|
||||
UpperExp LowerExp UpperHex LowerHex Octal Binary Pointer}
|
||||
276
zeroidc/vendor/itertools/src/free.rs
vendored
Normal file
276
zeroidc/vendor/itertools/src/free.rs
vendored
Normal file
@@ -0,0 +1,276 @@
|
||||
//! Free functions that create iterator adaptors or call iterator methods.
|
||||
//!
|
||||
//! The benefit of free functions is that they accept any [`IntoIterator`] as
|
||||
//! argument, so the resulting code may be easier to read.
|
||||
|
||||
#[cfg(feature = "use_alloc")]
|
||||
use std::fmt::Display;
|
||||
use std::iter::{self, Zip};
|
||||
#[cfg(feature = "use_alloc")]
|
||||
type VecIntoIter<T> = alloc::vec::IntoIter<T>;
|
||||
|
||||
#[cfg(feature = "use_alloc")]
|
||||
use alloc::{
|
||||
string::String,
|
||||
};
|
||||
|
||||
use crate::Itertools;
|
||||
use crate::intersperse::{Intersperse, IntersperseWith};
|
||||
|
||||
pub use crate::adaptors::{
|
||||
interleave,
|
||||
merge,
|
||||
put_back,
|
||||
};
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub use crate::put_back_n_impl::put_back_n;
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub use crate::multipeek_impl::multipeek;
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub use crate::peek_nth::peek_nth;
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub use crate::kmerge_impl::kmerge;
|
||||
pub use crate::zip_eq_impl::zip_eq;
|
||||
pub use crate::merge_join::merge_join_by;
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub use crate::rciter_impl::rciter;
|
||||
|
||||
/// Iterate `iterable` with a particular value inserted between each element.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::intersperse`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::intersperse;
|
||||
///
|
||||
/// itertools::assert_equal(intersperse((0..3), 8), vec![0, 8, 1, 8, 2]);
|
||||
/// ```
|
||||
pub fn intersperse<I>(iterable: I, element: I::Item) -> Intersperse<I::IntoIter>
|
||||
where I: IntoIterator,
|
||||
<I as IntoIterator>::Item: Clone
|
||||
{
|
||||
Itertools::intersperse(iterable.into_iter(), element)
|
||||
}
|
||||
|
||||
/// Iterate `iterable` with a particular value created by a function inserted
|
||||
/// between each element.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::intersperse_with`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::intersperse_with;
|
||||
///
|
||||
/// let mut i = 10;
|
||||
/// itertools::assert_equal(intersperse_with((0..3), || { i -= 1; i }), vec![0, 9, 1, 8, 2]);
|
||||
/// assert_eq!(i, 8);
|
||||
/// ```
|
||||
pub fn intersperse_with<I, F>(iterable: I, element: F) -> IntersperseWith<I::IntoIter, F>
|
||||
where I: IntoIterator,
|
||||
F: FnMut() -> I::Item
|
||||
{
|
||||
Itertools::intersperse_with(iterable.into_iter(), element)
|
||||
}
|
||||
|
||||
/// Iterate `iterable` with a running index.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::enumerate`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::enumerate;
|
||||
///
|
||||
/// for (i, elt) in enumerate(&[1, 2, 3]) {
|
||||
/// /* loop body */
|
||||
/// }
|
||||
/// ```
|
||||
pub fn enumerate<I>(iterable: I) -> iter::Enumerate<I::IntoIter>
|
||||
where I: IntoIterator
|
||||
{
|
||||
iterable.into_iter().enumerate()
|
||||
}
|
||||
|
||||
/// Iterate `iterable` in reverse.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::rev`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::rev;
|
||||
///
|
||||
/// for elt in rev(&[1, 2, 3]) {
|
||||
/// /* loop body */
|
||||
/// }
|
||||
/// ```
|
||||
pub fn rev<I>(iterable: I) -> iter::Rev<I::IntoIter>
|
||||
where I: IntoIterator,
|
||||
I::IntoIter: DoubleEndedIterator
|
||||
{
|
||||
iterable.into_iter().rev()
|
||||
}
|
||||
|
||||
/// Iterate `i` and `j` in lock step.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::zip`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::zip;
|
||||
///
|
||||
/// let data = [1, 2, 3, 4, 5];
|
||||
/// for (a, b) in zip(&data, &data[1..]) {
|
||||
/// /* loop body */
|
||||
/// }
|
||||
/// ```
|
||||
pub fn zip<I, J>(i: I, j: J) -> Zip<I::IntoIter, J::IntoIter>
|
||||
where I: IntoIterator,
|
||||
J: IntoIterator
|
||||
{
|
||||
i.into_iter().zip(j)
|
||||
}
|
||||
|
||||
/// Create an iterator that first iterates `i` and then `j`.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::chain`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::chain;
|
||||
///
|
||||
/// for elt in chain(&[1, 2, 3], &[4]) {
|
||||
/// /* loop body */
|
||||
/// }
|
||||
/// ```
|
||||
pub fn chain<I, J>(i: I, j: J) -> iter::Chain<<I as IntoIterator>::IntoIter, <J as IntoIterator>::IntoIter>
|
||||
where I: IntoIterator,
|
||||
J: IntoIterator<Item = I::Item>
|
||||
{
|
||||
i.into_iter().chain(j)
|
||||
}
|
||||
|
||||
/// Create an iterator that clones each element from &T to T
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::cloned`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::cloned;
|
||||
///
|
||||
/// assert_eq!(cloned(b"abc").next(), Some(b'a'));
|
||||
/// ```
|
||||
pub fn cloned<'a, I, T: 'a>(iterable: I) -> iter::Cloned<I::IntoIter>
|
||||
where I: IntoIterator<Item=&'a T>,
|
||||
T: Clone,
|
||||
{
|
||||
iterable.into_iter().cloned()
|
||||
}
|
||||
|
||||
/// Perform a fold operation over the iterable.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::fold`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::fold;
|
||||
///
|
||||
/// assert_eq!(fold(&[1., 2., 3.], 0., |a, &b| f32::max(a, b)), 3.);
|
||||
/// ```
|
||||
pub fn fold<I, B, F>(iterable: I, init: B, f: F) -> B
|
||||
where I: IntoIterator,
|
||||
F: FnMut(B, I::Item) -> B
|
||||
{
|
||||
iterable.into_iter().fold(init, f)
|
||||
}
|
||||
|
||||
/// Test whether the predicate holds for all elements in the iterable.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::all`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::all;
|
||||
///
|
||||
/// assert!(all(&[1, 2, 3], |elt| *elt > 0));
|
||||
/// ```
|
||||
pub fn all<I, F>(iterable: I, f: F) -> bool
|
||||
where I: IntoIterator,
|
||||
F: FnMut(I::Item) -> bool
|
||||
{
|
||||
iterable.into_iter().all(f)
|
||||
}
|
||||
|
||||
/// Test whether the predicate holds for any elements in the iterable.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::any`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::any;
|
||||
///
|
||||
/// assert!(any(&[0, -1, 2], |elt| *elt > 0));
|
||||
/// ```
|
||||
pub fn any<I, F>(iterable: I, f: F) -> bool
|
||||
where I: IntoIterator,
|
||||
F: FnMut(I::Item) -> bool
|
||||
{
|
||||
iterable.into_iter().any(f)
|
||||
}
|
||||
|
||||
/// Return the maximum value of the iterable.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::max`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::max;
|
||||
///
|
||||
/// assert_eq!(max(0..10), Some(9));
|
||||
/// ```
|
||||
pub fn max<I>(iterable: I) -> Option<I::Item>
|
||||
where I: IntoIterator,
|
||||
I::Item: Ord
|
||||
{
|
||||
iterable.into_iter().max()
|
||||
}
|
||||
|
||||
/// Return the minimum value of the iterable.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Iterator::min`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::min;
|
||||
///
|
||||
/// assert_eq!(min(0..10), Some(0));
|
||||
/// ```
|
||||
pub fn min<I>(iterable: I) -> Option<I::Item>
|
||||
where I: IntoIterator,
|
||||
I::Item: Ord
|
||||
{
|
||||
iterable.into_iter().min()
|
||||
}
|
||||
|
||||
|
||||
/// Combine all iterator elements into one String, seperated by `sep`.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Itertools::join`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::join;
|
||||
///
|
||||
/// assert_eq!(join(&[1, 2, 3], ", "), "1, 2, 3");
|
||||
/// ```
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub fn join<I>(iterable: I, sep: &str) -> String
|
||||
where I: IntoIterator,
|
||||
I::Item: Display
|
||||
{
|
||||
iterable.into_iter().join(sep)
|
||||
}
|
||||
|
||||
/// Sort all iterator elements into a new iterator in ascending order.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Itertools::sorted`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::sorted;
|
||||
/// use itertools::assert_equal;
|
||||
///
|
||||
/// assert_equal(sorted("rust".chars()), "rstu".chars());
|
||||
/// ```
|
||||
#[cfg(feature = "use_alloc")]
|
||||
pub fn sorted<I>(iterable: I) -> VecIntoIter<I::Item>
|
||||
where I: IntoIterator,
|
||||
I::Item: Ord
|
||||
{
|
||||
iterable.into_iter().sorted()
|
||||
}
|
||||
|
||||
32
zeroidc/vendor/itertools/src/group_map.rs
vendored
Normal file
32
zeroidc/vendor/itertools/src/group_map.rs
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
#![cfg(feature = "use_std")]
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::hash::Hash;
|
||||
use std::iter::Iterator;
|
||||
|
||||
/// Return a `HashMap` of keys mapped to a list of their corresponding values.
|
||||
///
|
||||
/// See [`.into_group_map()`](crate::Itertools::into_group_map)
|
||||
/// for more information.
|
||||
pub fn into_group_map<I, K, V>(iter: I) -> HashMap<K, Vec<V>>
|
||||
where I: Iterator<Item=(K, V)>,
|
||||
K: Hash + Eq,
|
||||
{
|
||||
let mut lookup = HashMap::new();
|
||||
|
||||
iter.for_each(|(key, val)| {
|
||||
lookup.entry(key).or_insert_with(Vec::new).push(val);
|
||||
});
|
||||
|
||||
lookup
|
||||
}
|
||||
|
||||
pub fn into_group_map_by<I, K, V>(iter: I, f: impl Fn(&V) -> K) -> HashMap<K, Vec<V>>
|
||||
where
|
||||
I: Iterator<Item=V>,
|
||||
K: Hash + Eq,
|
||||
{
|
||||
into_group_map(
|
||||
iter.map(|v| (f(&v), v))
|
||||
)
|
||||
}
|
||||
571
zeroidc/vendor/itertools/src/groupbylazy.rs
vendored
Normal file
571
zeroidc/vendor/itertools/src/groupbylazy.rs
vendored
Normal file
@@ -0,0 +1,571 @@
|
||||
use std::cell::{Cell, RefCell};
|
||||
use alloc::vec::{self, Vec};
|
||||
|
||||
/// A trait to unify FnMut for GroupBy with the chunk key in IntoChunks
|
||||
trait KeyFunction<A> {
|
||||
type Key;
|
||||
fn call_mut(&mut self, arg: A) -> Self::Key;
|
||||
}
|
||||
|
||||
impl<'a, A, K, F: ?Sized> KeyFunction<A> for F
|
||||
where F: FnMut(A) -> K
|
||||
{
|
||||
type Key = K;
|
||||
#[inline]
|
||||
fn call_mut(&mut self, arg: A) -> Self::Key {
|
||||
(*self)(arg)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// ChunkIndex acts like the grouping key function for IntoChunks
|
||||
#[derive(Debug)]
|
||||
struct ChunkIndex {
|
||||
size: usize,
|
||||
index: usize,
|
||||
key: usize,
|
||||
}
|
||||
|
||||
impl ChunkIndex {
|
||||
#[inline(always)]
|
||||
fn new(size: usize) -> Self {
|
||||
ChunkIndex {
|
||||
size,
|
||||
index: 0,
|
||||
key: 0,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, A> KeyFunction<A> for ChunkIndex {
|
||||
type Key = usize;
|
||||
#[inline(always)]
|
||||
fn call_mut(&mut self, _arg: A) -> Self::Key {
|
||||
if self.index == self.size {
|
||||
self.key += 1;
|
||||
self.index = 0;
|
||||
}
|
||||
self.index += 1;
|
||||
self.key
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
struct GroupInner<K, I, F>
|
||||
where I: Iterator
|
||||
{
|
||||
key: F,
|
||||
iter: I,
|
||||
current_key: Option<K>,
|
||||
current_elt: Option<I::Item>,
|
||||
/// flag set if iterator is exhausted
|
||||
done: bool,
|
||||
/// Index of group we are currently buffering or visiting
|
||||
top_group: usize,
|
||||
/// Least index for which we still have elements buffered
|
||||
oldest_buffered_group: usize,
|
||||
/// Group index for `buffer[0]` -- the slots
|
||||
/// bottom_group..oldest_buffered_group are unused and will be erased when
|
||||
/// that range is large enough.
|
||||
bottom_group: usize,
|
||||
/// Buffered groups, from `bottom_group` (index 0) to `top_group`.
|
||||
buffer: Vec<vec::IntoIter<I::Item>>,
|
||||
/// index of last group iter that was dropped, usize::MAX == none
|
||||
dropped_group: usize,
|
||||
}
|
||||
|
||||
impl<K, I, F> GroupInner<K, I, F>
|
||||
where I: Iterator,
|
||||
F: for<'a> KeyFunction<&'a I::Item, Key=K>,
|
||||
K: PartialEq,
|
||||
{
|
||||
/// `client`: Index of group that requests next element
|
||||
#[inline(always)]
|
||||
fn step(&mut self, client: usize) -> Option<I::Item> {
|
||||
/*
|
||||
println!("client={}, bottom_group={}, oldest_buffered_group={}, top_group={}, buffers=[{}]",
|
||||
client, self.bottom_group, self.oldest_buffered_group,
|
||||
self.top_group,
|
||||
self.buffer.iter().map(|elt| elt.len()).format(", "));
|
||||
*/
|
||||
if client < self.oldest_buffered_group {
|
||||
None
|
||||
} else if client < self.top_group ||
|
||||
(client == self.top_group &&
|
||||
self.buffer.len() > self.top_group - self.bottom_group)
|
||||
{
|
||||
self.lookup_buffer(client)
|
||||
} else if self.done {
|
||||
None
|
||||
} else if self.top_group == client {
|
||||
self.step_current()
|
||||
} else {
|
||||
self.step_buffering(client)
|
||||
}
|
||||
}
|
||||
|
||||
#[inline(never)]
|
||||
fn lookup_buffer(&mut self, client: usize) -> Option<I::Item> {
|
||||
// if `bufidx` doesn't exist in self.buffer, it might be empty
|
||||
let bufidx = client - self.bottom_group;
|
||||
if client < self.oldest_buffered_group {
|
||||
return None;
|
||||
}
|
||||
let elt = self.buffer.get_mut(bufidx).and_then(|queue| queue.next());
|
||||
if elt.is_none() && client == self.oldest_buffered_group {
|
||||
// FIXME: VecDeque is unfortunately not zero allocation when empty,
|
||||
// so we do this job manually.
|
||||
// `bottom_group..oldest_buffered_group` is unused, and if it's large enough, erase it.
|
||||
self.oldest_buffered_group += 1;
|
||||
// skip forward further empty queues too
|
||||
while self.buffer.get(self.oldest_buffered_group - self.bottom_group)
|
||||
.map_or(false, |buf| buf.len() == 0)
|
||||
{
|
||||
self.oldest_buffered_group += 1;
|
||||
}
|
||||
|
||||
let nclear = self.oldest_buffered_group - self.bottom_group;
|
||||
if nclear > 0 && nclear >= self.buffer.len() / 2 {
|
||||
let mut i = 0;
|
||||
self.buffer.retain(|buf| {
|
||||
i += 1;
|
||||
debug_assert!(buf.len() == 0 || i > nclear);
|
||||
i > nclear
|
||||
});
|
||||
self.bottom_group = self.oldest_buffered_group;
|
||||
}
|
||||
}
|
||||
elt
|
||||
}
|
||||
|
||||
/// Take the next element from the iterator, and set the done
|
||||
/// flag if exhausted. Must not be called after done.
|
||||
#[inline(always)]
|
||||
fn next_element(&mut self) -> Option<I::Item> {
|
||||
debug_assert!(!self.done);
|
||||
match self.iter.next() {
|
||||
None => { self.done = true; None }
|
||||
otherwise => otherwise,
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[inline(never)]
|
||||
fn step_buffering(&mut self, client: usize) -> Option<I::Item> {
|
||||
// requested a later group -- walk through the current group up to
|
||||
// the requested group index, and buffer the elements (unless
|
||||
// the group is marked as dropped).
|
||||
// Because the `Groups` iterator is always the first to request
|
||||
// each group index, client is the next index efter top_group.
|
||||
debug_assert!(self.top_group + 1 == client);
|
||||
let mut group = Vec::new();
|
||||
|
||||
if let Some(elt) = self.current_elt.take() {
|
||||
if self.top_group != self.dropped_group {
|
||||
group.push(elt);
|
||||
}
|
||||
}
|
||||
let mut first_elt = None; // first element of the next group
|
||||
|
||||
while let Some(elt) = self.next_element() {
|
||||
let key = self.key.call_mut(&elt);
|
||||
match self.current_key.take() {
|
||||
None => {}
|
||||
Some(old_key) => if old_key != key {
|
||||
self.current_key = Some(key);
|
||||
first_elt = Some(elt);
|
||||
break;
|
||||
},
|
||||
}
|
||||
self.current_key = Some(key);
|
||||
if self.top_group != self.dropped_group {
|
||||
group.push(elt);
|
||||
}
|
||||
}
|
||||
|
||||
if self.top_group != self.dropped_group {
|
||||
self.push_next_group(group);
|
||||
}
|
||||
if first_elt.is_some() {
|
||||
self.top_group += 1;
|
||||
debug_assert!(self.top_group == client);
|
||||
}
|
||||
first_elt
|
||||
}
|
||||
|
||||
fn push_next_group(&mut self, group: Vec<I::Item>) {
|
||||
// When we add a new buffered group, fill up slots between oldest_buffered_group and top_group
|
||||
while self.top_group - self.bottom_group > self.buffer.len() {
|
||||
if self.buffer.is_empty() {
|
||||
self.bottom_group += 1;
|
||||
self.oldest_buffered_group += 1;
|
||||
} else {
|
||||
self.buffer.push(Vec::new().into_iter());
|
||||
}
|
||||
}
|
||||
self.buffer.push(group.into_iter());
|
||||
debug_assert!(self.top_group + 1 - self.bottom_group == self.buffer.len());
|
||||
}
|
||||
|
||||
/// This is the immediate case, where we use no buffering
|
||||
#[inline]
|
||||
fn step_current(&mut self) -> Option<I::Item> {
|
||||
debug_assert!(!self.done);
|
||||
if let elt @ Some(..) = self.current_elt.take() {
|
||||
return elt;
|
||||
}
|
||||
match self.next_element() {
|
||||
None => None,
|
||||
Some(elt) => {
|
||||
let key = self.key.call_mut(&elt);
|
||||
match self.current_key.take() {
|
||||
None => {}
|
||||
Some(old_key) => if old_key != key {
|
||||
self.current_key = Some(key);
|
||||
self.current_elt = Some(elt);
|
||||
self.top_group += 1;
|
||||
return None;
|
||||
},
|
||||
}
|
||||
self.current_key = Some(key);
|
||||
Some(elt)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Request the just started groups' key.
|
||||
///
|
||||
/// `client`: Index of group
|
||||
///
|
||||
/// **Panics** if no group key is available.
|
||||
fn group_key(&mut self, client: usize) -> K {
|
||||
// This can only be called after we have just returned the first
|
||||
// element of a group.
|
||||
// Perform this by simply buffering one more element, grabbing the
|
||||
// next key.
|
||||
debug_assert!(!self.done);
|
||||
debug_assert!(client == self.top_group);
|
||||
debug_assert!(self.current_key.is_some());
|
||||
debug_assert!(self.current_elt.is_none());
|
||||
let old_key = self.current_key.take().unwrap();
|
||||
if let Some(elt) = self.next_element() {
|
||||
let key = self.key.call_mut(&elt);
|
||||
if old_key != key {
|
||||
self.top_group += 1;
|
||||
}
|
||||
self.current_key = Some(key);
|
||||
self.current_elt = Some(elt);
|
||||
}
|
||||
old_key
|
||||
}
|
||||
}
|
||||
|
||||
impl<K, I, F> GroupInner<K, I, F>
|
||||
where I: Iterator,
|
||||
{
|
||||
/// Called when a group is dropped
|
||||
fn drop_group(&mut self, client: usize) {
|
||||
// It's only useful to track the maximal index
|
||||
if self.dropped_group == !0 || client > self.dropped_group {
|
||||
self.dropped_group = client;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// `GroupBy` is the storage for the lazy grouping operation.
|
||||
///
|
||||
/// If the groups are consumed in their original order, or if each
|
||||
/// group is dropped without keeping it around, then `GroupBy` uses
|
||||
/// no allocations. It needs allocations only if several group iterators
|
||||
/// are alive at the same time.
|
||||
///
|
||||
/// This type implements [`IntoIterator`] (it is **not** an iterator
|
||||
/// itself), because the group iterators need to borrow from this
|
||||
/// value. It should be stored in a local variable or temporary and
|
||||
/// iterated.
|
||||
///
|
||||
/// See [`.group_by()`](crate::Itertools::group_by) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct GroupBy<K, I, F>
|
||||
where I: Iterator,
|
||||
{
|
||||
inner: RefCell<GroupInner<K, I, F>>,
|
||||
// the group iterator's current index. Keep this in the main value
|
||||
// so that simultaneous iterators all use the same state.
|
||||
index: Cell<usize>,
|
||||
}
|
||||
|
||||
/// Create a new
|
||||
pub fn new<K, J, F>(iter: J, f: F) -> GroupBy<K, J::IntoIter, F>
|
||||
where J: IntoIterator,
|
||||
F: FnMut(&J::Item) -> K,
|
||||
{
|
||||
GroupBy {
|
||||
inner: RefCell::new(GroupInner {
|
||||
key: f,
|
||||
iter: iter.into_iter(),
|
||||
current_key: None,
|
||||
current_elt: None,
|
||||
done: false,
|
||||
top_group: 0,
|
||||
oldest_buffered_group: 0,
|
||||
bottom_group: 0,
|
||||
buffer: Vec::new(),
|
||||
dropped_group: !0,
|
||||
}),
|
||||
index: Cell::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
impl<K, I, F> GroupBy<K, I, F>
|
||||
where I: Iterator,
|
||||
{
|
||||
/// `client`: Index of group that requests next element
|
||||
fn step(&self, client: usize) -> Option<I::Item>
|
||||
where F: FnMut(&I::Item) -> K,
|
||||
K: PartialEq,
|
||||
{
|
||||
self.inner.borrow_mut().step(client)
|
||||
}
|
||||
|
||||
/// `client`: Index of group
|
||||
fn drop_group(&self, client: usize) {
|
||||
self.inner.borrow_mut().drop_group(client)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, K, I, F> IntoIterator for &'a GroupBy<K, I, F>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
F: FnMut(&I::Item) -> K,
|
||||
K: PartialEq
|
||||
{
|
||||
type Item = (K, Group<'a, K, I, F>);
|
||||
type IntoIter = Groups<'a, K, I, F>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
Groups { parent: self }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// An iterator that yields the Group iterators.
|
||||
///
|
||||
/// Iterator element type is `(K, Group)`:
|
||||
/// the group's key `K` and the group's iterator.
|
||||
///
|
||||
/// See [`.group_by()`](crate::Itertools::group_by) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Groups<'a, K: 'a, I: 'a, F: 'a>
|
||||
where I: Iterator,
|
||||
I::Item: 'a
|
||||
{
|
||||
parent: &'a GroupBy<K, I, F>,
|
||||
}
|
||||
|
||||
impl<'a, K, I, F> Iterator for Groups<'a, K, I, F>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
F: FnMut(&I::Item) -> K,
|
||||
K: PartialEq
|
||||
{
|
||||
type Item = (K, Group<'a, K, I, F>);
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let index = self.parent.index.get();
|
||||
self.parent.index.set(index + 1);
|
||||
let inner = &mut *self.parent.inner.borrow_mut();
|
||||
inner.step(index).map(|elt| {
|
||||
let key = inner.group_key(index);
|
||||
(key, Group {
|
||||
parent: self.parent,
|
||||
index,
|
||||
first: Some(elt),
|
||||
})
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator for the elements in a single group.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
pub struct Group<'a, K: 'a, I: 'a, F: 'a>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
parent: &'a GroupBy<K, I, F>,
|
||||
index: usize,
|
||||
first: Option<I::Item>,
|
||||
}
|
||||
|
||||
impl<'a, K, I, F> Drop for Group<'a, K, I, F>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
fn drop(&mut self) {
|
||||
self.parent.drop_group(self.index);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, K, I, F> Iterator for Group<'a, K, I, F>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
F: FnMut(&I::Item) -> K,
|
||||
K: PartialEq,
|
||||
{
|
||||
type Item = I::Item;
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if let elt @ Some(..) = self.first.take() {
|
||||
return elt;
|
||||
}
|
||||
self.parent.step(self.index)
|
||||
}
|
||||
}
|
||||
|
||||
///// IntoChunks /////
|
||||
|
||||
/// Create a new
|
||||
pub fn new_chunks<J>(iter: J, size: usize) -> IntoChunks<J::IntoIter>
|
||||
where J: IntoIterator,
|
||||
{
|
||||
IntoChunks {
|
||||
inner: RefCell::new(GroupInner {
|
||||
key: ChunkIndex::new(size),
|
||||
iter: iter.into_iter(),
|
||||
current_key: None,
|
||||
current_elt: None,
|
||||
done: false,
|
||||
top_group: 0,
|
||||
oldest_buffered_group: 0,
|
||||
bottom_group: 0,
|
||||
buffer: Vec::new(),
|
||||
dropped_group: !0,
|
||||
}),
|
||||
index: Cell::new(0),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// `ChunkLazy` is the storage for a lazy chunking operation.
|
||||
///
|
||||
/// `IntoChunks` behaves just like `GroupBy`: it is iterable, and
|
||||
/// it only buffers if several chunk iterators are alive at the same time.
|
||||
///
|
||||
/// This type implements [`IntoIterator`] (it is **not** an iterator
|
||||
/// itself), because the chunk iterators need to borrow from this
|
||||
/// value. It should be stored in a local variable or temporary and
|
||||
/// iterated.
|
||||
///
|
||||
/// Iterator element type is `Chunk`, each chunk's iterator.
|
||||
///
|
||||
/// See [`.chunks()`](crate::Itertools::chunks) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct IntoChunks<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
inner: RefCell<GroupInner<usize, I, ChunkIndex>>,
|
||||
// the chunk iterator's current index. Keep this in the main value
|
||||
// so that simultaneous iterators all use the same state.
|
||||
index: Cell<usize>,
|
||||
}
|
||||
|
||||
|
||||
impl<I> IntoChunks<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
/// `client`: Index of chunk that requests next element
|
||||
fn step(&self, client: usize) -> Option<I::Item> {
|
||||
self.inner.borrow_mut().step(client)
|
||||
}
|
||||
|
||||
/// `client`: Index of chunk
|
||||
fn drop_group(&self, client: usize) {
|
||||
self.inner.borrow_mut().drop_group(client)
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, I> IntoIterator for &'a IntoChunks<I>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
type Item = Chunk<'a, I>;
|
||||
type IntoIter = Chunks<'a, I>;
|
||||
|
||||
fn into_iter(self) -> Self::IntoIter {
|
||||
Chunks {
|
||||
parent: self,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// An iterator that yields the Chunk iterators.
|
||||
///
|
||||
/// Iterator element type is `Chunk`.
|
||||
///
|
||||
/// See [`.chunks()`](crate::Itertools::chunks) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Chunks<'a, I: 'a>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
parent: &'a IntoChunks<I>,
|
||||
}
|
||||
|
||||
impl<'a, I> Iterator for Chunks<'a, I>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
type Item = Chunk<'a, I>;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let index = self.parent.index.get();
|
||||
self.parent.index.set(index + 1);
|
||||
let inner = &mut *self.parent.inner.borrow_mut();
|
||||
inner.step(index).map(|elt| {
|
||||
Chunk {
|
||||
parent: self.parent,
|
||||
index,
|
||||
first: Some(elt),
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator for the elements in a single chunk.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
pub struct Chunk<'a, I: 'a>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
parent: &'a IntoChunks<I>,
|
||||
index: usize,
|
||||
first: Option<I::Item>,
|
||||
}
|
||||
|
||||
impl<'a, I> Drop for Chunk<'a, I>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
fn drop(&mut self) {
|
||||
self.parent.drop_group(self.index);
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, I> Iterator for Chunk<'a, I>
|
||||
where I: Iterator,
|
||||
I::Item: 'a,
|
||||
{
|
||||
type Item = I::Item;
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if let elt @ Some(..) = self.first.take() {
|
||||
return elt;
|
||||
}
|
||||
self.parent.step(self.index)
|
||||
}
|
||||
}
|
||||
536
zeroidc/vendor/itertools/src/grouping_map.rs
vendored
Normal file
536
zeroidc/vendor/itertools/src/grouping_map.rs
vendored
Normal file
@@ -0,0 +1,536 @@
|
||||
#![cfg(feature = "use_std")]
|
||||
|
||||
use crate::MinMaxResult;
|
||||
use std::collections::HashMap;
|
||||
use std::cmp::Ordering;
|
||||
use std::hash::Hash;
|
||||
use std::iter::Iterator;
|
||||
use std::ops::{Add, Mul};
|
||||
|
||||
/// A wrapper to allow for an easy [`into_grouping_map_by`](crate::Itertools::into_grouping_map_by)
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MapForGrouping<I, F>(I, F);
|
||||
|
||||
impl<I, F> MapForGrouping<I, F> {
|
||||
pub(crate) fn new(iter: I, key_mapper: F) -> Self {
|
||||
Self(iter, key_mapper)
|
||||
}
|
||||
}
|
||||
|
||||
impl<K, V, I, F> Iterator for MapForGrouping<I, F>
|
||||
where I: Iterator<Item = V>,
|
||||
K: Hash + Eq,
|
||||
F: FnMut(&V) -> K,
|
||||
{
|
||||
type Item = (K, V);
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.0.next().map(|val| ((self.1)(&val), val))
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new `GroupingMap` from `iter`
|
||||
pub fn new<I, K, V>(iter: I) -> GroupingMap<I>
|
||||
where I: Iterator<Item = (K, V)>,
|
||||
K: Hash + Eq,
|
||||
{
|
||||
GroupingMap { iter }
|
||||
}
|
||||
|
||||
/// `GroupingMapBy` is an intermediate struct for efficient group-and-fold operations.
|
||||
///
|
||||
/// See [`GroupingMap`] for more informations.
|
||||
#[must_use = "GroupingMapBy is lazy and do nothing unless consumed"]
|
||||
pub type GroupingMapBy<I, F> = GroupingMap<MapForGrouping<I, F>>;
|
||||
|
||||
/// `GroupingMap` is an intermediate struct for efficient group-and-fold operations.
|
||||
/// It groups elements by their key and at the same time fold each group
|
||||
/// using some aggregating operation.
|
||||
///
|
||||
/// No method on this struct performs temporary allocations.
|
||||
#[derive(Clone, Debug)]
|
||||
#[must_use = "GroupingMap is lazy and do nothing unless consumed"]
|
||||
pub struct GroupingMap<I> {
|
||||
iter: I,
|
||||
}
|
||||
|
||||
impl<I, K, V> GroupingMap<I>
|
||||
where I: Iterator<Item = (K, V)>,
|
||||
K: Hash + Eq,
|
||||
{
|
||||
/// This is the generic way to perform any operation on a `GroupingMap`.
|
||||
/// It's suggested to use this method only to implement custom operations
|
||||
/// when the already provided ones are not enough.
|
||||
///
|
||||
/// Groups elements from the `GroupingMap` source by key and applies `operation` to the elements
|
||||
/// of each group sequentially, passing the previously accumulated value, a reference to the key
|
||||
/// and the current element as arguments, and stores the results in an `HashMap`.
|
||||
///
|
||||
/// The `operation` function is invoked on each element with the following parameters:
|
||||
/// - the current value of the accumulator of the group if there is currently one;
|
||||
/// - a reference to the key of the group this element belongs to;
|
||||
/// - the element from the source being aggregated;
|
||||
///
|
||||
/// If `operation` returns `Some(element)` then the accumulator is updated with `element`,
|
||||
/// otherwise the previous accumulation is discarded.
|
||||
///
|
||||
/// Return a `HashMap` associating the key of each group with the result of aggregation of
|
||||
/// that group's elements. If the aggregation of the last element of a group discards the
|
||||
/// accumulator then there won't be an entry associated to that group's key.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let data = vec![2, 8, 5, 7, 9, 0, 4, 10];
|
||||
/// let lookup = data.into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 4)
|
||||
/// .aggregate(|acc, _key, val| {
|
||||
/// if val == 0 || val == 10 {
|
||||
/// None
|
||||
/// } else {
|
||||
/// Some(acc.unwrap_or(0) + val)
|
||||
/// }
|
||||
/// });
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 4); // 0 resets the accumulator so only 4 is summed
|
||||
/// assert_eq!(lookup[&1], 5 + 9);
|
||||
/// assert_eq!(lookup.get(&2), None); // 10 resets the accumulator and nothing is summed afterward
|
||||
/// assert_eq!(lookup[&3], 7);
|
||||
/// assert_eq!(lookup.len(), 3); // The final keys are only 0, 1 and 2
|
||||
/// ```
|
||||
pub fn aggregate<FO, R>(self, mut operation: FO) -> HashMap<K, R>
|
||||
where FO: FnMut(Option<R>, &K, V) -> Option<R>,
|
||||
{
|
||||
let mut destination_map = HashMap::new();
|
||||
|
||||
self.iter.for_each(|(key, val)| {
|
||||
let acc = destination_map.remove(&key);
|
||||
if let Some(op_res) = operation(acc, &key, val) {
|
||||
destination_map.insert(key, op_res);
|
||||
}
|
||||
});
|
||||
|
||||
destination_map
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and applies `operation` to the elements
|
||||
/// of each group sequentially, passing the previously accumulated value, a reference to the key
|
||||
/// and the current element as arguments, and stores the results in a new map.
|
||||
///
|
||||
/// `init` is the value from which will be cloned the initial value of each accumulator.
|
||||
///
|
||||
/// `operation` is a function that is invoked on each element with the following parameters:
|
||||
/// - the current value of the accumulator of the group;
|
||||
/// - a reference to the key of the group this element belongs to;
|
||||
/// - the element from the source being accumulated.
|
||||
///
|
||||
/// Return a `HashMap` associating the key of each group with the result of folding that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = (1..=7)
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .fold(0, |acc, _key, val| acc + val);
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3 + 6);
|
||||
/// assert_eq!(lookup[&1], 1 + 4 + 7);
|
||||
/// assert_eq!(lookup[&2], 2 + 5);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn fold<FO, R>(self, init: R, mut operation: FO) -> HashMap<K, R>
|
||||
where R: Clone,
|
||||
FO: FnMut(R, &K, V) -> R,
|
||||
{
|
||||
self.aggregate(|acc, key, val| {
|
||||
let acc = acc.unwrap_or_else(|| init.clone());
|
||||
Some(operation(acc, key, val))
|
||||
})
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and applies `operation` to the elements
|
||||
/// of each group sequentially, passing the previously accumulated value, a reference to the key
|
||||
/// and the current element as arguments, and stores the results in a new map.
|
||||
///
|
||||
/// This is similar to [`fold`] but the initial value of the accumulator is the first element of the group.
|
||||
///
|
||||
/// `operation` is a function that is invoked on each element with the following parameters:
|
||||
/// - the current value of the accumulator of the group;
|
||||
/// - a reference to the key of the group this element belongs to;
|
||||
/// - the element from the source being accumulated.
|
||||
///
|
||||
/// Return a `HashMap` associating the key of each group with the result of folding that group's elements.
|
||||
///
|
||||
/// [`fold`]: GroupingMap::fold
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = (1..=7)
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .fold_first(|acc, _key, val| acc + val);
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3 + 6);
|
||||
/// assert_eq!(lookup[&1], 1 + 4 + 7);
|
||||
/// assert_eq!(lookup[&2], 2 + 5);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn fold_first<FO>(self, mut operation: FO) -> HashMap<K, V>
|
||||
where FO: FnMut(V, &K, V) -> V,
|
||||
{
|
||||
self.aggregate(|acc, key, val| {
|
||||
Some(match acc {
|
||||
Some(acc) => operation(acc, key, val),
|
||||
None => val,
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and collects the elements of each group in
|
||||
/// an instance of `C`. The iteration order is preserved when inserting elements.
|
||||
///
|
||||
/// Return a `HashMap` associating the key of each group with the collection containing that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
/// use std::collections::HashSet;
|
||||
///
|
||||
/// let lookup = vec![0, 1, 2, 3, 4, 5, 6, 2, 3, 6].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .collect::<HashSet<_>>();
|
||||
///
|
||||
/// assert_eq!(lookup[&0], vec![0, 3, 6].into_iter().collect::<HashSet<_>>());
|
||||
/// assert_eq!(lookup[&1], vec![1, 4].into_iter().collect::<HashSet<_>>());
|
||||
/// assert_eq!(lookup[&2], vec![2, 5].into_iter().collect::<HashSet<_>>());
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn collect<C>(self) -> HashMap<K, C>
|
||||
where C: Default + Extend<V>,
|
||||
{
|
||||
let mut destination_map = HashMap::new();
|
||||
|
||||
self.iter.for_each(|(key, val)| {
|
||||
destination_map.entry(key).or_insert_with(C::default).extend(Some(val));
|
||||
});
|
||||
|
||||
destination_map
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and finds the maximum of each group.
|
||||
///
|
||||
/// If several elements are equally maximum, the last element is picked.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the maximum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .max();
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 12);
|
||||
/// assert_eq!(lookup[&1], 7);
|
||||
/// assert_eq!(lookup[&2], 8);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn max(self) -> HashMap<K, V>
|
||||
where V: Ord,
|
||||
{
|
||||
self.max_by(|_, v1, v2| V::cmp(v1, v2))
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and finds the maximum of each group
|
||||
/// with respect to the specified comparison function.
|
||||
///
|
||||
/// If several elements are equally maximum, the last element is picked.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the maximum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .max_by(|_key, x, y| y.cmp(x));
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3);
|
||||
/// assert_eq!(lookup[&1], 1);
|
||||
/// assert_eq!(lookup[&2], 5);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn max_by<F>(self, mut compare: F) -> HashMap<K, V>
|
||||
where F: FnMut(&K, &V, &V) -> Ordering,
|
||||
{
|
||||
self.fold_first(|acc, key, val| match compare(key, &acc, &val) {
|
||||
Ordering::Less | Ordering::Equal => val,
|
||||
Ordering::Greater => acc
|
||||
})
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and finds the element of each group
|
||||
/// that gives the maximum from the specified function.
|
||||
///
|
||||
/// If several elements are equally maximum, the last element is picked.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the maximum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .max_by_key(|_key, &val| val % 4);
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3);
|
||||
/// assert_eq!(lookup[&1], 7);
|
||||
/// assert_eq!(lookup[&2], 5);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn max_by_key<F, CK>(self, mut f: F) -> HashMap<K, V>
|
||||
where F: FnMut(&K, &V) -> CK,
|
||||
CK: Ord,
|
||||
{
|
||||
self.max_by(|key, v1, v2| f(key, &v1).cmp(&f(key, &v2)))
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and finds the minimum of each group.
|
||||
///
|
||||
/// If several elements are equally minimum, the first element is picked.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the minimum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .min();
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3);
|
||||
/// assert_eq!(lookup[&1], 1);
|
||||
/// assert_eq!(lookup[&2], 5);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn min(self) -> HashMap<K, V>
|
||||
where V: Ord,
|
||||
{
|
||||
self.min_by(|_, v1, v2| V::cmp(v1, v2))
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and finds the minimum of each group
|
||||
/// with respect to the specified comparison function.
|
||||
///
|
||||
/// If several elements are equally minimum, the first element is picked.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the minimum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .min_by(|_key, x, y| y.cmp(x));
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 12);
|
||||
/// assert_eq!(lookup[&1], 7);
|
||||
/// assert_eq!(lookup[&2], 8);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn min_by<F>(self, mut compare: F) -> HashMap<K, V>
|
||||
where F: FnMut(&K, &V, &V) -> Ordering,
|
||||
{
|
||||
self.fold_first(|acc, key, val| match compare(key, &acc, &val) {
|
||||
Ordering::Less | Ordering::Equal => acc,
|
||||
Ordering::Greater => val
|
||||
})
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and finds the element of each group
|
||||
/// that gives the minimum from the specified function.
|
||||
///
|
||||
/// If several elements are equally minimum, the first element is picked.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the minimum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .min_by_key(|_key, &val| val % 4);
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 12);
|
||||
/// assert_eq!(lookup[&1], 4);
|
||||
/// assert_eq!(lookup[&2], 8);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn min_by_key<F, CK>(self, mut f: F) -> HashMap<K, V>
|
||||
where F: FnMut(&K, &V) -> CK,
|
||||
CK: Ord,
|
||||
{
|
||||
self.min_by(|key, v1, v2| f(key, &v1).cmp(&f(key, &v2)))
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and find the maximum and minimum of
|
||||
/// each group.
|
||||
///
|
||||
/// If several elements are equally maximum, the last element is picked.
|
||||
/// If several elements are equally minimum, the first element is picked.
|
||||
///
|
||||
/// See [.minmax()](crate::Itertools::minmax) for the non-grouping version.
|
||||
///
|
||||
/// Differences from the non grouping version:
|
||||
/// - It never produces a `MinMaxResult::NoElements`
|
||||
/// - It doesn't have any speedup
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the minimum and maximum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
/// use itertools::MinMaxResult::{OneElement, MinMax};
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .minmax();
|
||||
///
|
||||
/// assert_eq!(lookup[&0], MinMax(3, 12));
|
||||
/// assert_eq!(lookup[&1], MinMax(1, 7));
|
||||
/// assert_eq!(lookup[&2], OneElement(5));
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn minmax(self) -> HashMap<K, MinMaxResult<V>>
|
||||
where V: Ord,
|
||||
{
|
||||
self.minmax_by(|_, v1, v2| V::cmp(v1, v2))
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and find the maximum and minimum of
|
||||
/// each group with respect to the specified comparison function.
|
||||
///
|
||||
/// If several elements are equally maximum, the last element is picked.
|
||||
/// If several elements are equally minimum, the first element is picked.
|
||||
///
|
||||
/// It has the same differences from the non-grouping version as `minmax`.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the minimum and maximum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
/// use itertools::MinMaxResult::{OneElement, MinMax};
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .minmax_by(|_key, x, y| y.cmp(x));
|
||||
///
|
||||
/// assert_eq!(lookup[&0], MinMax(12, 3));
|
||||
/// assert_eq!(lookup[&1], MinMax(7, 1));
|
||||
/// assert_eq!(lookup[&2], OneElement(5));
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn minmax_by<F>(self, mut compare: F) -> HashMap<K, MinMaxResult<V>>
|
||||
where F: FnMut(&K, &V, &V) -> Ordering,
|
||||
{
|
||||
self.aggregate(|acc, key, val| {
|
||||
Some(match acc {
|
||||
Some(MinMaxResult::OneElement(e)) => {
|
||||
if compare(key, &val, &e) == Ordering::Less {
|
||||
MinMaxResult::MinMax(val, e)
|
||||
} else {
|
||||
MinMaxResult::MinMax(e, val)
|
||||
}
|
||||
}
|
||||
Some(MinMaxResult::MinMax(min, max)) => {
|
||||
if compare(key, &val, &min) == Ordering::Less {
|
||||
MinMaxResult::MinMax(val, max)
|
||||
} else if compare(key, &val, &max) != Ordering::Less {
|
||||
MinMaxResult::MinMax(min, val)
|
||||
} else {
|
||||
MinMaxResult::MinMax(min, max)
|
||||
}
|
||||
}
|
||||
None => MinMaxResult::OneElement(val),
|
||||
Some(MinMaxResult::NoElements) => unreachable!(),
|
||||
})
|
||||
})
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and find the elements of each group
|
||||
/// that gives the minimum and maximum from the specified function.
|
||||
///
|
||||
/// If several elements are equally maximum, the last element is picked.
|
||||
/// If several elements are equally minimum, the first element is picked.
|
||||
///
|
||||
/// It has the same differences from the non-grouping version as `minmax`.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the minimum and maximum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
/// use itertools::MinMaxResult::{OneElement, MinMax};
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .minmax_by_key(|_key, &val| val % 4);
|
||||
///
|
||||
/// assert_eq!(lookup[&0], MinMax(12, 3));
|
||||
/// assert_eq!(lookup[&1], MinMax(4, 7));
|
||||
/// assert_eq!(lookup[&2], OneElement(5));
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn minmax_by_key<F, CK>(self, mut f: F) -> HashMap<K, MinMaxResult<V>>
|
||||
where F: FnMut(&K, &V) -> CK,
|
||||
CK: Ord,
|
||||
{
|
||||
self.minmax_by(|key, v1, v2| f(key, &v1).cmp(&f(key, &v2)))
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and sums them.
|
||||
///
|
||||
/// This is just a shorthand for `self.fold_first(|acc, _, val| acc + val)`.
|
||||
/// It is more limited than `Iterator::sum` since it doesn't use the `Sum` trait.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the sum of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .sum();
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3 + 9 + 12);
|
||||
/// assert_eq!(lookup[&1], 1 + 4 + 7);
|
||||
/// assert_eq!(lookup[&2], 5 + 8);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn sum(self) -> HashMap<K, V>
|
||||
where V: Add<V, Output = V>
|
||||
{
|
||||
self.fold_first(|acc, _, val| acc + val)
|
||||
}
|
||||
|
||||
/// Groups elements from the `GroupingMap` source by key and multiply them.
|
||||
///
|
||||
/// This is just a shorthand for `self.fold_first(|acc, _, val| acc * val)`.
|
||||
/// It is more limited than `Iterator::product` since it doesn't use the `Product` trait.
|
||||
///
|
||||
/// Returns a `HashMap` associating the key of each group with the product of that group's elements.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let lookup = vec![1, 3, 4, 5, 7, 8, 9, 12].into_iter()
|
||||
/// .into_grouping_map_by(|&n| n % 3)
|
||||
/// .product();
|
||||
///
|
||||
/// assert_eq!(lookup[&0], 3 * 9 * 12);
|
||||
/// assert_eq!(lookup[&1], 1 * 4 * 7);
|
||||
/// assert_eq!(lookup[&2], 5 * 8);
|
||||
/// assert_eq!(lookup.len(), 3);
|
||||
/// ```
|
||||
pub fn product(self) -> HashMap<K, V>
|
||||
where V: Mul<V, Output = V>,
|
||||
{
|
||||
self.fold_first(|acc, _, val| acc * val)
|
||||
}
|
||||
}
|
||||
28
zeroidc/vendor/itertools/src/impl_macros.rs
vendored
Normal file
28
zeroidc/vendor/itertools/src/impl_macros.rs
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
//!
|
||||
//! Implementation's internal macros
|
||||
|
||||
macro_rules! debug_fmt_fields {
|
||||
($tyname:ident, $($($field:tt/*TODO ideally we would accept ident or tuple element here*/).+),*) => {
|
||||
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
||||
f.debug_struct(stringify!($tyname))
|
||||
$(
|
||||
.field(stringify!($($field).+), &self.$($field).+)
|
||||
)*
|
||||
.finish()
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! clone_fields {
|
||||
($($field:ident),*) => {
|
||||
fn clone(&self) -> Self {
|
||||
Self {
|
||||
$($field: self.$field.clone(),)*
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! ignore_ident{
|
||||
($id:ident, $($t:tt)*) => {$($t)*};
|
||||
}
|
||||
119
zeroidc/vendor/itertools/src/intersperse.rs
vendored
Normal file
119
zeroidc/vendor/itertools/src/intersperse.rs
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
use std::iter::{Fuse, FusedIterator};
|
||||
use super::size_hint;
|
||||
|
||||
pub trait IntersperseElement<Item> {
|
||||
fn generate(&mut self) -> Item;
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct IntersperseElementSimple<Item>(Item);
|
||||
|
||||
impl<Item: Clone> IntersperseElement<Item> for IntersperseElementSimple<Item> {
|
||||
fn generate(&mut self) -> Item {
|
||||
self.0.clone()
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor to insert a particular value
|
||||
/// between each element of the adapted iterator.
|
||||
///
|
||||
/// Iterator element type is `I::Item`
|
||||
///
|
||||
/// This iterator is *fused*.
|
||||
///
|
||||
/// See [`.intersperse()`](crate::Itertools::intersperse) for more information.
|
||||
pub type Intersperse<I> = IntersperseWith<I, IntersperseElementSimple<<I as Iterator>::Item>>;
|
||||
|
||||
/// Create a new Intersperse iterator
|
||||
pub fn intersperse<I>(iter: I, elt: I::Item) -> Intersperse<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
intersperse_with(iter, IntersperseElementSimple(elt))
|
||||
}
|
||||
|
||||
impl<Item, F: FnMut()->Item> IntersperseElement<Item> for F {
|
||||
fn generate(&mut self) -> Item {
|
||||
self()
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor to insert a particular value created by a function
|
||||
/// between each element of the adapted iterator.
|
||||
///
|
||||
/// Iterator element type is `I::Item`
|
||||
///
|
||||
/// This iterator is *fused*.
|
||||
///
|
||||
/// See [`.intersperse_with()`](crate::Itertools::intersperse_with) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct IntersperseWith<I, ElemF>
|
||||
where I: Iterator,
|
||||
{
|
||||
element: ElemF,
|
||||
iter: Fuse<I>,
|
||||
peek: Option<I::Item>,
|
||||
}
|
||||
|
||||
/// Create a new IntersperseWith iterator
|
||||
pub fn intersperse_with<I, ElemF>(iter: I, elt: ElemF) -> IntersperseWith<I, ElemF>
|
||||
where I: Iterator,
|
||||
{
|
||||
let mut iter = iter.fuse();
|
||||
IntersperseWith {
|
||||
peek: iter.next(),
|
||||
iter,
|
||||
element: elt,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, ElemF> Iterator for IntersperseWith<I, ElemF>
|
||||
where I: Iterator,
|
||||
ElemF: IntersperseElement<I::Item>
|
||||
{
|
||||
type Item = I::Item;
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.peek.is_some() {
|
||||
self.peek.take()
|
||||
} else {
|
||||
self.peek = self.iter.next();
|
||||
if self.peek.is_some() {
|
||||
Some(self.element.generate())
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
// 2 * SH + { 1 or 0 }
|
||||
let has_peek = self.peek.is_some() as usize;
|
||||
let sh = self.iter.size_hint();
|
||||
size_hint::add_scalar(size_hint::add(sh, sh), has_peek)
|
||||
}
|
||||
|
||||
fn fold<B, F>(mut self, init: B, mut f: F) -> B where
|
||||
Self: Sized, F: FnMut(B, Self::Item) -> B,
|
||||
{
|
||||
let mut accum = init;
|
||||
|
||||
if let Some(x) = self.peek.take() {
|
||||
accum = f(accum, x);
|
||||
}
|
||||
|
||||
let element = &mut self.element;
|
||||
|
||||
self.iter.fold(accum,
|
||||
|accum, x| {
|
||||
let accum = f(accum, element.generate());
|
||||
let accum = f(accum, x);
|
||||
accum
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, ElemF> FusedIterator for IntersperseWith<I, ElemF>
|
||||
where I: Iterator,
|
||||
ElemF: IntersperseElement<I::Item>
|
||||
{}
|
||||
20
zeroidc/vendor/itertools/src/k_smallest.rs
vendored
Normal file
20
zeroidc/vendor/itertools/src/k_smallest.rs
vendored
Normal file
@@ -0,0 +1,20 @@
|
||||
use alloc::collections::BinaryHeap;
|
||||
use core::cmp::Ord;
|
||||
|
||||
pub(crate) fn k_smallest<T: Ord, I: Iterator<Item = T>>(mut iter: I, k: usize) -> BinaryHeap<T> {
|
||||
if k == 0 { return BinaryHeap::new(); }
|
||||
|
||||
let mut heap = iter.by_ref().take(k).collect::<BinaryHeap<_>>();
|
||||
|
||||
iter.for_each(|i| {
|
||||
debug_assert_eq!(heap.len(), k);
|
||||
// Equivalent to heap.push(min(i, heap.pop())) but more efficient.
|
||||
// This should be done with a single `.peek_mut().unwrap()` but
|
||||
// `PeekMut` sifts-down unconditionally on Rust 1.46.0 and prior.
|
||||
if *heap.peek().unwrap() > i {
|
||||
*heap.peek_mut().unwrap() = i;
|
||||
}
|
||||
});
|
||||
|
||||
heap
|
||||
}
|
||||
227
zeroidc/vendor/itertools/src/kmerge_impl.rs
vendored
Normal file
227
zeroidc/vendor/itertools/src/kmerge_impl.rs
vendored
Normal file
@@ -0,0 +1,227 @@
|
||||
use crate::size_hint;
|
||||
use crate::Itertools;
|
||||
|
||||
use alloc::vec::Vec;
|
||||
use std::iter::FusedIterator;
|
||||
use std::mem::replace;
|
||||
use std::fmt;
|
||||
|
||||
/// Head element and Tail iterator pair
|
||||
///
|
||||
/// `PartialEq`, `Eq`, `PartialOrd` and `Ord` are implemented by comparing sequences based on
|
||||
/// first items (which are guaranteed to exist).
|
||||
///
|
||||
/// The meanings of `PartialOrd` and `Ord` are reversed so as to turn the heap used in
|
||||
/// `KMerge` into a min-heap.
|
||||
#[derive(Debug)]
|
||||
struct HeadTail<I>
|
||||
where I: Iterator
|
||||
{
|
||||
head: I::Item,
|
||||
tail: I,
|
||||
}
|
||||
|
||||
impl<I> HeadTail<I>
|
||||
where I: Iterator
|
||||
{
|
||||
/// Constructs a `HeadTail` from an `Iterator`. Returns `None` if the `Iterator` is empty.
|
||||
fn new(mut it: I) -> Option<HeadTail<I>> {
|
||||
let head = it.next();
|
||||
head.map(|h| {
|
||||
HeadTail {
|
||||
head: h,
|
||||
tail: it,
|
||||
}
|
||||
})
|
||||
}
|
||||
|
||||
/// Get the next element and update `head`, returning the old head in `Some`.
|
||||
///
|
||||
/// Returns `None` when the tail is exhausted (only `head` then remains).
|
||||
fn next(&mut self) -> Option<I::Item> {
|
||||
if let Some(next) = self.tail.next() {
|
||||
Some(replace(&mut self.head, next))
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
/// Hints at the size of the sequence, same as the `Iterator` method.
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::add_scalar(self.tail.size_hint(), 1)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Clone for HeadTail<I>
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone
|
||||
{
|
||||
clone_fields!(head, tail);
|
||||
}
|
||||
|
||||
/// Make `data` a heap (min-heap w.r.t the sorting).
|
||||
fn heapify<T, S>(data: &mut [T], mut less_than: S)
|
||||
where S: FnMut(&T, &T) -> bool
|
||||
{
|
||||
for i in (0..data.len() / 2).rev() {
|
||||
sift_down(data, i, &mut less_than);
|
||||
}
|
||||
}
|
||||
|
||||
/// Sift down element at `index` (`heap` is a min-heap wrt the ordering)
|
||||
fn sift_down<T, S>(heap: &mut [T], index: usize, mut less_than: S)
|
||||
where S: FnMut(&T, &T) -> bool
|
||||
{
|
||||
debug_assert!(index <= heap.len());
|
||||
let mut pos = index;
|
||||
let mut child = 2 * pos + 1;
|
||||
// Require the right child to be present
|
||||
// This allows to find the index of the smallest child without a branch
|
||||
// that wouldn't be predicted if present
|
||||
while child + 1 < heap.len() {
|
||||
// pick the smaller of the two children
|
||||
// use aritmethic to avoid an unpredictable branch
|
||||
child += less_than(&heap[child+1], &heap[child]) as usize;
|
||||
|
||||
// sift down is done if we are already in order
|
||||
if !less_than(&heap[child], &heap[pos]) {
|
||||
return;
|
||||
}
|
||||
heap.swap(pos, child);
|
||||
pos = child;
|
||||
child = 2 * pos + 1;
|
||||
}
|
||||
// Check if the last (left) child was an only child
|
||||
// if it is then it has to be compared with the parent
|
||||
if child + 1 == heap.len() && less_than(&heap[child], &heap[pos]) {
|
||||
heap.swap(pos, child);
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that merges an abitrary number of base iterators in ascending order.
|
||||
/// If all base iterators are sorted (ascending), the result is sorted.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
///
|
||||
/// See [`.kmerge()`](crate::Itertools::kmerge) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub type KMerge<I> = KMergeBy<I, KMergeByLt>;
|
||||
|
||||
pub trait KMergePredicate<T> {
|
||||
fn kmerge_pred(&mut self, a: &T, b: &T) -> bool;
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct KMergeByLt;
|
||||
|
||||
impl<T: PartialOrd> KMergePredicate<T> for KMergeByLt {
|
||||
fn kmerge_pred(&mut self, a: &T, b: &T) -> bool {
|
||||
a < b
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, F: FnMut(&T, &T)->bool> KMergePredicate<T> for F {
|
||||
fn kmerge_pred(&mut self, a: &T, b: &T) -> bool {
|
||||
self(a, b)
|
||||
}
|
||||
}
|
||||
|
||||
/// Create an iterator that merges elements of the contained iterators using
|
||||
/// the ordering function.
|
||||
///
|
||||
/// Equivalent to `iterable.into_iter().kmerge()`.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::kmerge;
|
||||
///
|
||||
/// for elt in kmerge(vec![vec![0, 2, 4], vec![1, 3, 5], vec![6, 7]]) {
|
||||
/// /* loop body */
|
||||
/// }
|
||||
/// ```
|
||||
pub fn kmerge<I>(iterable: I) -> KMerge<<I::Item as IntoIterator>::IntoIter>
|
||||
where I: IntoIterator,
|
||||
I::Item: IntoIterator,
|
||||
<<I as IntoIterator>::Item as IntoIterator>::Item: PartialOrd
|
||||
{
|
||||
kmerge_by(iterable, KMergeByLt)
|
||||
}
|
||||
|
||||
/// An iterator adaptor that merges an abitrary number of base iterators
|
||||
/// according to an ordering function.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
///
|
||||
/// See [`.kmerge_by()`](crate::Itertools::kmerge_by) for more
|
||||
/// information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct KMergeBy<I, F>
|
||||
where I: Iterator,
|
||||
{
|
||||
heap: Vec<HeadTail<I>>,
|
||||
less_than: F,
|
||||
}
|
||||
|
||||
impl<I, F> fmt::Debug for KMergeBy<I, F>
|
||||
where I: Iterator + fmt::Debug,
|
||||
I::Item: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(KMergeBy, heap);
|
||||
}
|
||||
|
||||
/// Create an iterator that merges elements of the contained iterators.
|
||||
///
|
||||
/// Equivalent to `iterable.into_iter().kmerge_by(less_than)`.
|
||||
pub fn kmerge_by<I, F>(iterable: I, mut less_than: F)
|
||||
-> KMergeBy<<I::Item as IntoIterator>::IntoIter, F>
|
||||
where I: IntoIterator,
|
||||
I::Item: IntoIterator,
|
||||
F: KMergePredicate<<<I as IntoIterator>::Item as IntoIterator>::Item>,
|
||||
{
|
||||
let iter = iterable.into_iter();
|
||||
let (lower, _) = iter.size_hint();
|
||||
let mut heap: Vec<_> = Vec::with_capacity(lower);
|
||||
heap.extend(iter.filter_map(|it| HeadTail::new(it.into_iter())));
|
||||
heapify(&mut heap, |a, b| less_than.kmerge_pred(&a.head, &b.head));
|
||||
KMergeBy { heap, less_than }
|
||||
}
|
||||
|
||||
impl<I, F> Clone for KMergeBy<I, F>
|
||||
where I: Iterator + Clone,
|
||||
I::Item: Clone,
|
||||
F: Clone,
|
||||
{
|
||||
clone_fields!(heap, less_than);
|
||||
}
|
||||
|
||||
impl<I, F> Iterator for KMergeBy<I, F>
|
||||
where I: Iterator,
|
||||
F: KMergePredicate<I::Item>
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.heap.is_empty() {
|
||||
return None;
|
||||
}
|
||||
let result = if let Some(next) = self.heap[0].next() {
|
||||
next
|
||||
} else {
|
||||
self.heap.swap_remove(0).head
|
||||
};
|
||||
let less_than = &mut self.less_than;
|
||||
sift_down(&mut self.heap, 0, |a, b| less_than.kmerge_pred(&a.head, &b.head));
|
||||
Some(result)
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.heap.iter()
|
||||
.map(|i| i.size_hint())
|
||||
.fold1(size_hint::add)
|
||||
.unwrap_or((0, Some(0)))
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, F> FusedIterator for KMergeBy<I, F>
|
||||
where I: Iterator,
|
||||
F: KMergePredicate<I::Item>
|
||||
{}
|
||||
67
zeroidc/vendor/itertools/src/lazy_buffer.rs
vendored
Normal file
67
zeroidc/vendor/itertools/src/lazy_buffer.rs
vendored
Normal file
@@ -0,0 +1,67 @@
|
||||
use std::ops::Index;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct LazyBuffer<I: Iterator> {
|
||||
pub it: I,
|
||||
done: bool,
|
||||
buffer: Vec<I::Item>,
|
||||
}
|
||||
|
||||
impl<I> LazyBuffer<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
pub fn new(it: I) -> LazyBuffer<I> {
|
||||
LazyBuffer {
|
||||
it,
|
||||
done: false,
|
||||
buffer: Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn len(&self) -> usize {
|
||||
self.buffer.len()
|
||||
}
|
||||
|
||||
pub fn get_next(&mut self) -> bool {
|
||||
if self.done {
|
||||
return false;
|
||||
}
|
||||
let next_item = self.it.next();
|
||||
match next_item {
|
||||
Some(x) => {
|
||||
self.buffer.push(x);
|
||||
true
|
||||
}
|
||||
None => {
|
||||
self.done = true;
|
||||
false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
pub fn prefill(&mut self, len: usize) {
|
||||
let buffer_len = self.buffer.len();
|
||||
|
||||
if !self.done && len > buffer_len {
|
||||
let delta = len - buffer_len;
|
||||
|
||||
self.buffer.extend(self.it.by_ref().take(delta));
|
||||
self.done = self.buffer.len() < len;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, J> Index<J> for LazyBuffer<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Sized,
|
||||
Vec<I::Item>: Index<J>
|
||||
{
|
||||
type Output = <Vec<I::Item> as Index<J>>::Output;
|
||||
|
||||
fn index(&self, _index: J) -> &Self::Output {
|
||||
self.buffer.index(_index)
|
||||
}
|
||||
}
|
||||
3608
zeroidc/vendor/itertools/src/lib.rs
vendored
Normal file
3608
zeroidc/vendor/itertools/src/lib.rs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
167
zeroidc/vendor/itertools/src/merge_join.rs
vendored
Normal file
167
zeroidc/vendor/itertools/src/merge_join.rs
vendored
Normal file
@@ -0,0 +1,167 @@
|
||||
use std::cmp::Ordering;
|
||||
use std::iter::Fuse;
|
||||
use std::fmt;
|
||||
|
||||
use super::adaptors::{PutBack, put_back};
|
||||
use crate::either_or_both::EitherOrBoth;
|
||||
|
||||
/// Return an iterator adaptor that merge-joins items from the two base iterators in ascending order.
|
||||
///
|
||||
/// See [`.merge_join_by()`](crate::Itertools::merge_join_by) for more information.
|
||||
pub fn merge_join_by<I, J, F>(left: I, right: J, cmp_fn: F)
|
||||
-> MergeJoinBy<I::IntoIter, J::IntoIter, F>
|
||||
where I: IntoIterator,
|
||||
J: IntoIterator,
|
||||
F: FnMut(&I::Item, &J::Item) -> Ordering
|
||||
{
|
||||
MergeJoinBy {
|
||||
left: put_back(left.into_iter().fuse()),
|
||||
right: put_back(right.into_iter().fuse()),
|
||||
cmp_fn,
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that merge-joins items from the two base iterators in ascending order.
|
||||
///
|
||||
/// See [`.merge_join_by()`](crate::Itertools::merge_join_by) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct MergeJoinBy<I: Iterator, J: Iterator, F> {
|
||||
left: PutBack<Fuse<I>>,
|
||||
right: PutBack<Fuse<J>>,
|
||||
cmp_fn: F
|
||||
}
|
||||
|
||||
impl<I, J, F> Clone for MergeJoinBy<I, J, F>
|
||||
where I: Iterator,
|
||||
J: Iterator,
|
||||
PutBack<Fuse<I>>: Clone,
|
||||
PutBack<Fuse<J>>: Clone,
|
||||
F: Clone,
|
||||
{
|
||||
clone_fields!(left, right, cmp_fn);
|
||||
}
|
||||
|
||||
impl<I, J, F> fmt::Debug for MergeJoinBy<I, J, F>
|
||||
where I: Iterator + fmt::Debug,
|
||||
I::Item: fmt::Debug,
|
||||
J: Iterator + fmt::Debug,
|
||||
J::Item: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(MergeJoinBy, left, right);
|
||||
}
|
||||
|
||||
impl<I, J, F> Iterator for MergeJoinBy<I, J, F>
|
||||
where I: Iterator,
|
||||
J: Iterator,
|
||||
F: FnMut(&I::Item, &J::Item) -> Ordering
|
||||
{
|
||||
type Item = EitherOrBoth<I::Item, J::Item>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match (self.left.next(), self.right.next()) {
|
||||
(None, None) => None,
|
||||
(Some(left), None) =>
|
||||
Some(EitherOrBoth::Left(left)),
|
||||
(None, Some(right)) =>
|
||||
Some(EitherOrBoth::Right(right)),
|
||||
(Some(left), Some(right)) => {
|
||||
match (self.cmp_fn)(&left, &right) {
|
||||
Ordering::Equal =>
|
||||
Some(EitherOrBoth::Both(left, right)),
|
||||
Ordering::Less => {
|
||||
self.right.put_back(right);
|
||||
Some(EitherOrBoth::Left(left))
|
||||
},
|
||||
Ordering::Greater => {
|
||||
self.left.put_back(left);
|
||||
Some(EitherOrBoth::Right(right))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let (a_lower, a_upper) = self.left.size_hint();
|
||||
let (b_lower, b_upper) = self.right.size_hint();
|
||||
|
||||
let lower = ::std::cmp::max(a_lower, b_lower);
|
||||
|
||||
let upper = match (a_upper, b_upper) {
|
||||
(Some(x), Some(y)) => x.checked_add(y),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
(lower, upper)
|
||||
}
|
||||
|
||||
fn count(mut self) -> usize {
|
||||
let mut count = 0;
|
||||
loop {
|
||||
match (self.left.next(), self.right.next()) {
|
||||
(None, None) => break count,
|
||||
(Some(_left), None) => break count + 1 + self.left.into_parts().1.count(),
|
||||
(None, Some(_right)) => break count + 1 + self.right.into_parts().1.count(),
|
||||
(Some(left), Some(right)) => {
|
||||
count += 1;
|
||||
match (self.cmp_fn)(&left, &right) {
|
||||
Ordering::Equal => {}
|
||||
Ordering::Less => self.right.put_back(right),
|
||||
Ordering::Greater => self.left.put_back(left),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn last(mut self) -> Option<Self::Item> {
|
||||
let mut previous_element = None;
|
||||
loop {
|
||||
match (self.left.next(), self.right.next()) {
|
||||
(None, None) => break previous_element,
|
||||
(Some(left), None) => {
|
||||
break Some(EitherOrBoth::Left(
|
||||
self.left.into_parts().1.last().unwrap_or(left),
|
||||
))
|
||||
}
|
||||
(None, Some(right)) => {
|
||||
break Some(EitherOrBoth::Right(
|
||||
self.right.into_parts().1.last().unwrap_or(right),
|
||||
))
|
||||
}
|
||||
(Some(left), Some(right)) => {
|
||||
previous_element = match (self.cmp_fn)(&left, &right) {
|
||||
Ordering::Equal => Some(EitherOrBoth::Both(left, right)),
|
||||
Ordering::Less => {
|
||||
self.right.put_back(right);
|
||||
Some(EitherOrBoth::Left(left))
|
||||
}
|
||||
Ordering::Greater => {
|
||||
self.left.put_back(left);
|
||||
Some(EitherOrBoth::Right(right))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn nth(&mut self, mut n: usize) -> Option<Self::Item> {
|
||||
loop {
|
||||
if n == 0 {
|
||||
break self.next();
|
||||
}
|
||||
n -= 1;
|
||||
match (self.left.next(), self.right.next()) {
|
||||
(None, None) => break None,
|
||||
(Some(_left), None) => break self.left.nth(n).map(EitherOrBoth::Left),
|
||||
(None, Some(_right)) => break self.right.nth(n).map(EitherOrBoth::Right),
|
||||
(Some(left), Some(right)) => match (self.cmp_fn)(&left, &right) {
|
||||
Ordering::Equal => {}
|
||||
Ordering::Less => self.right.put_back(right),
|
||||
Ordering::Greater => self.left.put_back(left),
|
||||
},
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
115
zeroidc/vendor/itertools/src/minmax.rs
vendored
Normal file
115
zeroidc/vendor/itertools/src/minmax.rs
vendored
Normal file
@@ -0,0 +1,115 @@
|
||||
|
||||
/// `MinMaxResult` is an enum returned by `minmax`.
|
||||
///
|
||||
/// See [`.minmax()`](crate::Itertools::minmax) for more detail.
|
||||
#[derive(Copy, Clone, PartialEq, Debug)]
|
||||
pub enum MinMaxResult<T> {
|
||||
/// Empty iterator
|
||||
NoElements,
|
||||
|
||||
/// Iterator with one element, so the minimum and maximum are the same
|
||||
OneElement(T),
|
||||
|
||||
/// More than one element in the iterator, the first element is not larger
|
||||
/// than the second
|
||||
MinMax(T, T)
|
||||
}
|
||||
|
||||
impl<T: Clone> MinMaxResult<T> {
|
||||
/// `into_option` creates an `Option` of type `(T, T)`. The returned `Option`
|
||||
/// has variant `None` if and only if the `MinMaxResult` has variant
|
||||
/// `NoElements`. Otherwise `Some((x, y))` is returned where `x <= y`.
|
||||
/// If the `MinMaxResult` has variant `OneElement(x)`, performing this
|
||||
/// operation will make one clone of `x`.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::MinMaxResult::{self, NoElements, OneElement, MinMax};
|
||||
///
|
||||
/// let r: MinMaxResult<i32> = NoElements;
|
||||
/// assert_eq!(r.into_option(), None);
|
||||
///
|
||||
/// let r = OneElement(1);
|
||||
/// assert_eq!(r.into_option(), Some((1, 1)));
|
||||
///
|
||||
/// let r = MinMax(1, 2);
|
||||
/// assert_eq!(r.into_option(), Some((1, 2)));
|
||||
/// ```
|
||||
pub fn into_option(self) -> Option<(T,T)> {
|
||||
match self {
|
||||
MinMaxResult::NoElements => None,
|
||||
MinMaxResult::OneElement(x) => Some((x.clone(), x)),
|
||||
MinMaxResult::MinMax(x, y) => Some((x, y))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Implementation guts for `minmax` and `minmax_by_key`.
|
||||
pub fn minmax_impl<I, K, F, L>(mut it: I, mut key_for: F,
|
||||
mut lt: L) -> MinMaxResult<I::Item>
|
||||
where I: Iterator,
|
||||
F: FnMut(&I::Item) -> K,
|
||||
L: FnMut(&I::Item, &I::Item, &K, &K) -> bool,
|
||||
{
|
||||
let (mut min, mut max, mut min_key, mut max_key) = match it.next() {
|
||||
None => return MinMaxResult::NoElements,
|
||||
Some(x) => {
|
||||
match it.next() {
|
||||
None => return MinMaxResult::OneElement(x),
|
||||
Some(y) => {
|
||||
let xk = key_for(&x);
|
||||
let yk = key_for(&y);
|
||||
if !lt(&y, &x, &yk, &xk) {(x, y, xk, yk)} else {(y, x, yk, xk)}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
loop {
|
||||
// `first` and `second` are the two next elements we want to look
|
||||
// at. We first compare `first` and `second` (#1). The smaller one
|
||||
// is then compared to current minimum (#2). The larger one is
|
||||
// compared to current maximum (#3). This way we do 3 comparisons
|
||||
// for 2 elements.
|
||||
let first = match it.next() {
|
||||
None => break,
|
||||
Some(x) => x
|
||||
};
|
||||
let second = match it.next() {
|
||||
None => {
|
||||
let first_key = key_for(&first);
|
||||
if lt(&first, &min, &first_key, &min_key) {
|
||||
min = first;
|
||||
} else if !lt(&first, &max, &first_key, &max_key) {
|
||||
max = first;
|
||||
}
|
||||
break;
|
||||
}
|
||||
Some(x) => x
|
||||
};
|
||||
let first_key = key_for(&first);
|
||||
let second_key = key_for(&second);
|
||||
if !lt(&second, &first, &second_key, &first_key) {
|
||||
if lt(&first, &min, &first_key, &min_key) {
|
||||
min = first;
|
||||
min_key = first_key;
|
||||
}
|
||||
if !lt(&second, &max, &second_key, &max_key) {
|
||||
max = second;
|
||||
max_key = second_key;
|
||||
}
|
||||
} else {
|
||||
if lt(&second, &min, &second_key, &min_key) {
|
||||
min = second;
|
||||
min_key = second_key;
|
||||
}
|
||||
if !lt(&first, &max, &first_key, &max_key) {
|
||||
max = first;
|
||||
max_key = first_key;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
MinMaxResult::MinMax(min, max)
|
||||
}
|
||||
99
zeroidc/vendor/itertools/src/multipeek_impl.rs
vendored
Normal file
99
zeroidc/vendor/itertools/src/multipeek_impl.rs
vendored
Normal file
@@ -0,0 +1,99 @@
|
||||
use std::iter::Fuse;
|
||||
use alloc::collections::VecDeque;
|
||||
use crate::size_hint;
|
||||
use crate::PeekingNext;
|
||||
|
||||
/// See [`multipeek()`] for more information.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct MultiPeek<I>
|
||||
where I: Iterator
|
||||
{
|
||||
iter: Fuse<I>,
|
||||
buf: VecDeque<I::Item>,
|
||||
index: usize,
|
||||
}
|
||||
|
||||
/// An iterator adaptor that allows the user to peek at multiple `.next()`
|
||||
/// values without advancing the base iterator.
|
||||
pub fn multipeek<I>(iterable: I) -> MultiPeek<I::IntoIter>
|
||||
where I: IntoIterator
|
||||
{
|
||||
MultiPeek {
|
||||
iter: iterable.into_iter().fuse(),
|
||||
buf: VecDeque::new(),
|
||||
index: 0,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> MultiPeek<I>
|
||||
where I: Iterator
|
||||
{
|
||||
/// Reset the peeking “cursor”
|
||||
pub fn reset_peek(&mut self) {
|
||||
self.index = 0;
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Iterator> MultiPeek<I> {
|
||||
/// Works exactly like `.next()` with the only difference that it doesn't
|
||||
/// advance itself. `.peek()` can be called multiple times, to peek
|
||||
/// further ahead.
|
||||
/// When `.next()` is called, reset the peeking “cursor”.
|
||||
pub fn peek(&mut self) -> Option<&I::Item> {
|
||||
let ret = if self.index < self.buf.len() {
|
||||
Some(&self.buf[self.index])
|
||||
} else {
|
||||
match self.iter.next() {
|
||||
Some(x) => {
|
||||
self.buf.push_back(x);
|
||||
Some(&self.buf[self.index])
|
||||
}
|
||||
None => return None,
|
||||
}
|
||||
};
|
||||
|
||||
self.index += 1;
|
||||
ret
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> PeekingNext for MultiPeek<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where F: FnOnce(&Self::Item) -> bool
|
||||
{
|
||||
if self.buf.is_empty() {
|
||||
if let Some(r) = self.peek() {
|
||||
if !accept(r) { return None }
|
||||
}
|
||||
} else {
|
||||
if let Some(r) = self.buf.get(0) {
|
||||
if !accept(r) { return None }
|
||||
}
|
||||
}
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for MultiPeek<I>
|
||||
where I: Iterator
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.index = 0;
|
||||
self.buf.pop_front().or_else(|| self.iter.next())
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::add_scalar(self.iter.size_hint(), self.buf.len())
|
||||
}
|
||||
}
|
||||
|
||||
// Same size
|
||||
impl<I> ExactSizeIterator for MultiPeek<I>
|
||||
where I: ExactSizeIterator
|
||||
{}
|
||||
|
||||
|
||||
96
zeroidc/vendor/itertools/src/pad_tail.rs
vendored
Normal file
96
zeroidc/vendor/itertools/src/pad_tail.rs
vendored
Normal file
@@ -0,0 +1,96 @@
|
||||
use std::iter::{Fuse, FusedIterator};
|
||||
use crate::size_hint;
|
||||
|
||||
/// An iterator adaptor that pads a sequence to a minimum length by filling
|
||||
/// missing elements using a closure.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
///
|
||||
/// See [`.pad_using()`](crate::Itertools::pad_using) for more information.
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct PadUsing<I, F> {
|
||||
iter: Fuse<I>,
|
||||
min: usize,
|
||||
pos: usize,
|
||||
filler: F,
|
||||
}
|
||||
|
||||
impl<I, F> std::fmt::Debug for PadUsing<I, F>
|
||||
where
|
||||
I: std::fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(PadUsing, iter, min, pos);
|
||||
}
|
||||
|
||||
/// Create a new **PadUsing** iterator.
|
||||
pub fn pad_using<I, F>(iter: I, min: usize, filler: F) -> PadUsing<I, F>
|
||||
where I: Iterator,
|
||||
F: FnMut(usize) -> I::Item
|
||||
{
|
||||
PadUsing {
|
||||
iter: iter.fuse(),
|
||||
min,
|
||||
pos: 0,
|
||||
filler,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, F> Iterator for PadUsing<I, F>
|
||||
where I: Iterator,
|
||||
F: FnMut(usize) -> I::Item
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match self.iter.next() {
|
||||
None => {
|
||||
if self.pos < self.min {
|
||||
let e = Some((self.filler)(self.pos));
|
||||
self.pos += 1;
|
||||
e
|
||||
} else {
|
||||
None
|
||||
}
|
||||
},
|
||||
e => {
|
||||
self.pos += 1;
|
||||
e
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let tail = self.min.saturating_sub(self.pos);
|
||||
size_hint::max(self.iter.size_hint(), (tail, Some(tail)))
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, F> DoubleEndedIterator for PadUsing<I, F>
|
||||
where I: DoubleEndedIterator + ExactSizeIterator,
|
||||
F: FnMut(usize) -> I::Item
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
if self.min == 0 {
|
||||
self.iter.next_back()
|
||||
} else if self.iter.len() >= self.min {
|
||||
self.min -= 1;
|
||||
self.iter.next_back()
|
||||
} else {
|
||||
self.min -= 1;
|
||||
Some((self.filler)(self.min))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, F> ExactSizeIterator for PadUsing<I, F>
|
||||
where I: ExactSizeIterator,
|
||||
F: FnMut(usize) -> I::Item
|
||||
{}
|
||||
|
||||
|
||||
impl<I, F> FusedIterator for PadUsing<I, F>
|
||||
where I: FusedIterator,
|
||||
F: FnMut(usize) -> I::Item
|
||||
{}
|
||||
102
zeroidc/vendor/itertools/src/peek_nth.rs
vendored
Normal file
102
zeroidc/vendor/itertools/src/peek_nth.rs
vendored
Normal file
@@ -0,0 +1,102 @@
|
||||
use crate::size_hint;
|
||||
use crate::PeekingNext;
|
||||
use alloc::collections::VecDeque;
|
||||
use std::iter::Fuse;
|
||||
|
||||
/// See [`peek_nth()`] for more information.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct PeekNth<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
iter: Fuse<I>,
|
||||
buf: VecDeque<I::Item>,
|
||||
}
|
||||
|
||||
/// A drop-in replacement for [`std::iter::Peekable`] which adds a `peek_nth`
|
||||
/// method allowing the user to `peek` at a value several iterations forward
|
||||
/// without advancing the base iterator.
|
||||
///
|
||||
/// This differs from `multipeek` in that subsequent calls to `peek` or
|
||||
/// `peek_nth` will always return the same value until `next` is called
|
||||
/// (making `reset_peek` unnecessary).
|
||||
pub fn peek_nth<I>(iterable: I) -> PeekNth<I::IntoIter>
|
||||
where
|
||||
I: IntoIterator,
|
||||
{
|
||||
PeekNth {
|
||||
iter: iterable.into_iter().fuse(),
|
||||
buf: VecDeque::new(),
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> PeekNth<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
/// Works exactly like the `peek` method in `std::iter::Peekable`
|
||||
pub fn peek(&mut self) -> Option<&I::Item> {
|
||||
self.peek_nth(0)
|
||||
}
|
||||
|
||||
/// Returns a reference to the `nth` value without advancing the iterator.
|
||||
///
|
||||
/// # Examples
|
||||
///
|
||||
/// Basic usage:
|
||||
///
|
||||
/// ```rust
|
||||
/// use itertools::peek_nth;
|
||||
///
|
||||
/// let xs = vec![1,2,3];
|
||||
/// let mut iter = peek_nth(xs.iter());
|
||||
///
|
||||
/// assert_eq!(iter.peek_nth(0), Some(&&1));
|
||||
/// assert_eq!(iter.next(), Some(&1));
|
||||
///
|
||||
/// // The iterator does not advance even if we call `peek_nth` multiple times
|
||||
/// assert_eq!(iter.peek_nth(0), Some(&&2));
|
||||
/// assert_eq!(iter.peek_nth(1), Some(&&3));
|
||||
/// assert_eq!(iter.next(), Some(&2));
|
||||
///
|
||||
/// // Calling `peek_nth` past the end of the iterator will return `None`
|
||||
/// assert_eq!(iter.peek_nth(1), None);
|
||||
/// ```
|
||||
pub fn peek_nth(&mut self, n: usize) -> Option<&I::Item> {
|
||||
let unbuffered_items = (n + 1).saturating_sub(self.buf.len());
|
||||
|
||||
self.buf.extend(self.iter.by_ref().take(unbuffered_items));
|
||||
|
||||
self.buf.get(n)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for PeekNth<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.buf.pop_front().or_else(|| self.iter.next())
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::add_scalar(self.iter.size_hint(), self.buf.len())
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> ExactSizeIterator for PeekNth<I> where I: ExactSizeIterator {}
|
||||
|
||||
impl<I> PeekingNext for PeekNth<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where
|
||||
F: FnOnce(&Self::Item) -> bool,
|
||||
{
|
||||
self.peek().filter(|item| accept(item))?;
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
154
zeroidc/vendor/itertools/src/peeking_take_while.rs
vendored
Normal file
154
zeroidc/vendor/itertools/src/peeking_take_while.rs
vendored
Normal file
@@ -0,0 +1,154 @@
|
||||
use std::iter::Peekable;
|
||||
use crate::PutBack;
|
||||
#[cfg(feature = "use_alloc")]
|
||||
use crate::PutBackN;
|
||||
|
||||
/// An iterator that allows peeking at an element before deciding to accept it.
|
||||
///
|
||||
/// See [`.peeking_take_while()`](crate::Itertools::peeking_take_while)
|
||||
/// for more information.
|
||||
///
|
||||
/// This is implemented by peeking adaptors like peekable and put back,
|
||||
/// but also by a few iterators that can be peeked natively, like the slice’s
|
||||
/// by reference iterator (`std::slice::Iter`).
|
||||
pub trait PeekingNext : Iterator {
|
||||
/// Pass a reference to the next iterator element to the closure `accept`;
|
||||
/// if `accept` returns true, return it as the next element,
|
||||
/// else None.
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where F: FnOnce(&Self::Item) -> bool;
|
||||
}
|
||||
|
||||
impl<I> PeekingNext for Peekable<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where F: FnOnce(&Self::Item) -> bool
|
||||
{
|
||||
if let Some(r) = self.peek() {
|
||||
if !accept(r) {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> PeekingNext for PutBack<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where F: FnOnce(&Self::Item) -> bool
|
||||
{
|
||||
if let Some(r) = self.next() {
|
||||
if !accept(&r) {
|
||||
self.put_back(r);
|
||||
return None;
|
||||
}
|
||||
Some(r)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(feature = "use_alloc")]
|
||||
impl<I> PeekingNext for PutBackN<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where F: FnOnce(&Self::Item) -> bool
|
||||
{
|
||||
if let Some(r) = self.next() {
|
||||
if !accept(&r) {
|
||||
self.put_back(r);
|
||||
return None;
|
||||
}
|
||||
Some(r)
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator adaptor that takes items while a closure returns `true`.
|
||||
///
|
||||
/// See [`.peeking_take_while()`](crate::Itertools::peeking_take_while)
|
||||
/// for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct PeekingTakeWhile<'a, I: 'a, F>
|
||||
where I: Iterator,
|
||||
{
|
||||
iter: &'a mut I,
|
||||
f: F,
|
||||
}
|
||||
|
||||
impl<'a, I: 'a, F> std::fmt::Debug for PeekingTakeWhile<'a, I, F>
|
||||
where
|
||||
I: Iterator + std::fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(PeekingTakeWhile, iter);
|
||||
}
|
||||
|
||||
/// Create a PeekingTakeWhile
|
||||
pub fn peeking_take_while<I, F>(iter: &mut I, f: F) -> PeekingTakeWhile<I, F>
|
||||
where I: Iterator,
|
||||
{
|
||||
PeekingTakeWhile {
|
||||
iter,
|
||||
f,
|
||||
}
|
||||
}
|
||||
|
||||
impl<'a, I, F> Iterator for PeekingTakeWhile<'a, I, F>
|
||||
where I: PeekingNext,
|
||||
F: FnMut(&I::Item) -> bool,
|
||||
|
||||
{
|
||||
type Item = I::Item;
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.iter.peeking_next(&mut self.f)
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(0, self.iter.size_hint().1)
|
||||
}
|
||||
}
|
||||
|
||||
// Some iterators are so lightweight we can simply clone them to save their
|
||||
// state and use that for peeking.
|
||||
macro_rules! peeking_next_by_clone {
|
||||
([$($typarm:tt)*] $type_:ty) => {
|
||||
impl<$($typarm)*> PeekingNext for $type_ {
|
||||
fn peeking_next<F>(&mut self, accept: F) -> Option<Self::Item>
|
||||
where F: FnOnce(&Self::Item) -> bool
|
||||
{
|
||||
let saved_state = self.clone();
|
||||
if let Some(r) = self.next() {
|
||||
if !accept(&r) {
|
||||
*self = saved_state;
|
||||
} else {
|
||||
return Some(r)
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
peeking_next_by_clone! { ['a, T] ::std::slice::Iter<'a, T> }
|
||||
peeking_next_by_clone! { ['a] ::std::str::Chars<'a> }
|
||||
peeking_next_by_clone! { ['a] ::std::str::CharIndices<'a> }
|
||||
peeking_next_by_clone! { ['a] ::std::str::Bytes<'a> }
|
||||
peeking_next_by_clone! { ['a, T] ::std::option::Iter<'a, T> }
|
||||
peeking_next_by_clone! { ['a, T] ::std::result::Iter<'a, T> }
|
||||
peeking_next_by_clone! { [T] ::std::iter::Empty<T> }
|
||||
#[cfg(feature = "use_alloc")]
|
||||
peeking_next_by_clone! { ['a, T] alloc::collections::linked_list::Iter<'a, T> }
|
||||
#[cfg(feature = "use_alloc")]
|
||||
peeking_next_by_clone! { ['a, T] alloc::collections::vec_deque::Iter<'a, T> }
|
||||
|
||||
// cloning a Rev has no extra overhead; peekable and put backs are never DEI.
|
||||
peeking_next_by_clone! { [I: Clone + PeekingNext + DoubleEndedIterator]
|
||||
::std::iter::Rev<I> }
|
||||
280
zeroidc/vendor/itertools/src/permutations.rs
vendored
Normal file
280
zeroidc/vendor/itertools/src/permutations.rs
vendored
Normal file
@@ -0,0 +1,280 @@
|
||||
use alloc::vec::Vec;
|
||||
use std::fmt;
|
||||
use std::iter::once;
|
||||
|
||||
use super::lazy_buffer::LazyBuffer;
|
||||
|
||||
/// An iterator adaptor that iterates through all the `k`-permutations of the
|
||||
/// elements from an iterator.
|
||||
///
|
||||
/// See [`.permutations()`](crate::Itertools::permutations) for
|
||||
/// more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Permutations<I: Iterator> {
|
||||
vals: LazyBuffer<I>,
|
||||
state: PermutationState,
|
||||
}
|
||||
|
||||
impl<I> Clone for Permutations<I>
|
||||
where I: Clone + Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
clone_fields!(vals, state);
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum PermutationState {
|
||||
StartUnknownLen {
|
||||
k: usize,
|
||||
},
|
||||
OngoingUnknownLen {
|
||||
k: usize,
|
||||
min_n: usize,
|
||||
},
|
||||
Complete(CompleteState),
|
||||
Empty,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug)]
|
||||
enum CompleteState {
|
||||
Start {
|
||||
n: usize,
|
||||
k: usize,
|
||||
},
|
||||
Ongoing {
|
||||
indices: Vec<usize>,
|
||||
cycles: Vec<usize>,
|
||||
}
|
||||
}
|
||||
|
||||
enum CompleteStateRemaining {
|
||||
Known(usize),
|
||||
Overflow,
|
||||
}
|
||||
|
||||
impl<I> fmt::Debug for Permutations<I>
|
||||
where I: Iterator + fmt::Debug,
|
||||
I::Item: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(Permutations, vals, state);
|
||||
}
|
||||
|
||||
pub fn permutations<I: Iterator>(iter: I, k: usize) -> Permutations<I> {
|
||||
let mut vals = LazyBuffer::new(iter);
|
||||
|
||||
if k == 0 {
|
||||
// Special case, yields single empty vec; `n` is irrelevant
|
||||
let state = PermutationState::Complete(CompleteState::Start { n: 0, k: 0 });
|
||||
|
||||
return Permutations {
|
||||
vals,
|
||||
state
|
||||
};
|
||||
}
|
||||
|
||||
let mut enough_vals = true;
|
||||
|
||||
while vals.len() < k {
|
||||
if !vals.get_next() {
|
||||
enough_vals = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
let state = if enough_vals {
|
||||
PermutationState::StartUnknownLen { k }
|
||||
} else {
|
||||
PermutationState::Empty
|
||||
};
|
||||
|
||||
Permutations {
|
||||
vals,
|
||||
state
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for Permutations<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone
|
||||
{
|
||||
type Item = Vec<I::Item>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.advance();
|
||||
|
||||
let &mut Permutations { ref vals, ref state } = self;
|
||||
|
||||
match *state {
|
||||
PermutationState::StartUnknownLen { .. } => panic!("unexpected iterator state"),
|
||||
PermutationState::OngoingUnknownLen { k, min_n } => {
|
||||
let latest_idx = min_n - 1;
|
||||
let indices = (0..(k - 1)).chain(once(latest_idx));
|
||||
|
||||
Some(indices.map(|i| vals[i].clone()).collect())
|
||||
}
|
||||
PermutationState::Complete(CompleteState::Start { .. }) => None,
|
||||
PermutationState::Complete(CompleteState::Ongoing { ref indices, ref cycles }) => {
|
||||
let k = cycles.len();
|
||||
|
||||
Some(indices[0..k].iter().map(|&i| vals[i].clone()).collect())
|
||||
},
|
||||
PermutationState::Empty => None
|
||||
}
|
||||
}
|
||||
|
||||
fn count(self) -> usize {
|
||||
let Permutations { vals, state } = self;
|
||||
|
||||
fn from_complete(complete_state: CompleteState) -> usize {
|
||||
match complete_state.remaining() {
|
||||
CompleteStateRemaining::Known(count) => count,
|
||||
CompleteStateRemaining::Overflow => {
|
||||
panic!("Iterator count greater than usize::MAX");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match state {
|
||||
PermutationState::StartUnknownLen { k } => {
|
||||
let n = vals.len() + vals.it.count();
|
||||
let complete_state = CompleteState::Start { n, k };
|
||||
|
||||
from_complete(complete_state)
|
||||
}
|
||||
PermutationState::OngoingUnknownLen { k, min_n } => {
|
||||
let prev_iteration_count = min_n - k + 1;
|
||||
let n = vals.len() + vals.it.count();
|
||||
let complete_state = CompleteState::Start { n, k };
|
||||
|
||||
from_complete(complete_state) - prev_iteration_count
|
||||
},
|
||||
PermutationState::Complete(state) => from_complete(state),
|
||||
PermutationState::Empty => 0
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
match self.state {
|
||||
PermutationState::StartUnknownLen { .. } |
|
||||
PermutationState::OngoingUnknownLen { .. } => (0, None), // TODO can we improve this lower bound?
|
||||
PermutationState::Complete(ref state) => match state.remaining() {
|
||||
CompleteStateRemaining::Known(count) => (count, Some(count)),
|
||||
CompleteStateRemaining::Overflow => (::std::usize::MAX, None)
|
||||
}
|
||||
PermutationState::Empty => (0, Some(0))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Permutations<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone
|
||||
{
|
||||
fn advance(&mut self) {
|
||||
let &mut Permutations { ref mut vals, ref mut state } = self;
|
||||
|
||||
*state = match *state {
|
||||
PermutationState::StartUnknownLen { k } => {
|
||||
PermutationState::OngoingUnknownLen { k, min_n: k }
|
||||
}
|
||||
PermutationState::OngoingUnknownLen { k, min_n } => {
|
||||
if vals.get_next() {
|
||||
PermutationState::OngoingUnknownLen { k, min_n: min_n + 1 }
|
||||
} else {
|
||||
let n = min_n;
|
||||
let prev_iteration_count = n - k + 1;
|
||||
let mut complete_state = CompleteState::Start { n, k };
|
||||
|
||||
// Advance the complete-state iterator to the correct point
|
||||
for _ in 0..(prev_iteration_count + 1) {
|
||||
complete_state.advance();
|
||||
}
|
||||
|
||||
PermutationState::Complete(complete_state)
|
||||
}
|
||||
}
|
||||
PermutationState::Complete(ref mut state) => {
|
||||
state.advance();
|
||||
|
||||
return;
|
||||
}
|
||||
PermutationState::Empty => { return; }
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
impl CompleteState {
|
||||
fn advance(&mut self) {
|
||||
*self = match *self {
|
||||
CompleteState::Start { n, k } => {
|
||||
let indices = (0..n).collect();
|
||||
let cycles = ((n - k)..n).rev().collect();
|
||||
|
||||
CompleteState::Ongoing {
|
||||
cycles,
|
||||
indices
|
||||
}
|
||||
},
|
||||
CompleteState::Ongoing { ref mut indices, ref mut cycles } => {
|
||||
let n = indices.len();
|
||||
let k = cycles.len();
|
||||
|
||||
for i in (0..k).rev() {
|
||||
if cycles[i] == 0 {
|
||||
cycles[i] = n - i - 1;
|
||||
|
||||
let to_push = indices.remove(i);
|
||||
indices.push(to_push);
|
||||
} else {
|
||||
let swap_index = n - cycles[i];
|
||||
indices.swap(i, swap_index);
|
||||
|
||||
cycles[i] -= 1;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
CompleteState::Start { n, k }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn remaining(&self) -> CompleteStateRemaining {
|
||||
use self::CompleteStateRemaining::{Known, Overflow};
|
||||
|
||||
match *self {
|
||||
CompleteState::Start { n, k } => {
|
||||
if n < k {
|
||||
return Known(0);
|
||||
}
|
||||
|
||||
let count: Option<usize> = (n - k + 1..n + 1).fold(Some(1), |acc, i| {
|
||||
acc.and_then(|acc| acc.checked_mul(i))
|
||||
});
|
||||
|
||||
match count {
|
||||
Some(count) => Known(count),
|
||||
None => Overflow
|
||||
}
|
||||
}
|
||||
CompleteState::Ongoing { ref indices, ref cycles } => {
|
||||
let mut count: usize = 0;
|
||||
|
||||
for (i, &c) in cycles.iter().enumerate() {
|
||||
let radix = indices.len() - i;
|
||||
let next_count = count.checked_mul(radix)
|
||||
.and_then(|count| count.checked_add(c));
|
||||
|
||||
count = match next_count {
|
||||
Some(count) => count,
|
||||
None => { return Overflow; }
|
||||
};
|
||||
}
|
||||
|
||||
Known(count)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
90
zeroidc/vendor/itertools/src/powerset.rs
vendored
Normal file
90
zeroidc/vendor/itertools/src/powerset.rs
vendored
Normal file
@@ -0,0 +1,90 @@
|
||||
use std::fmt;
|
||||
use std::iter::FusedIterator;
|
||||
use std::usize;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use super::combinations::{Combinations, combinations};
|
||||
use super::size_hint;
|
||||
|
||||
/// An iterator to iterate through the powerset of the elements from an iterator.
|
||||
///
|
||||
/// See [`.powerset()`](crate::Itertools::powerset) for more
|
||||
/// information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Powerset<I: Iterator> {
|
||||
combs: Combinations<I>,
|
||||
// Iterator `position` (equal to count of yielded elements).
|
||||
pos: usize,
|
||||
}
|
||||
|
||||
impl<I> Clone for Powerset<I>
|
||||
where I: Clone + Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
clone_fields!(combs, pos);
|
||||
}
|
||||
|
||||
impl<I> fmt::Debug for Powerset<I>
|
||||
where I: Iterator + fmt::Debug,
|
||||
I::Item: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(Powerset, combs, pos);
|
||||
}
|
||||
|
||||
/// Create a new `Powerset` from a clonable iterator.
|
||||
pub fn powerset<I>(src: I) -> Powerset<I>
|
||||
where I: Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
Powerset {
|
||||
combs: combinations(src, 0),
|
||||
pos: 0,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> Iterator for Powerset<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
type Item = Vec<I::Item>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if let Some(elt) = self.combs.next() {
|
||||
self.pos = self.pos.saturating_add(1);
|
||||
Some(elt)
|
||||
} else if self.combs.k() < self.combs.n()
|
||||
|| self.combs.k() == 0
|
||||
{
|
||||
self.combs.reset(self.combs.k() + 1);
|
||||
self.combs.next().map(|elt| {
|
||||
self.pos = self.pos.saturating_add(1);
|
||||
elt
|
||||
})
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
// Total bounds for source iterator.
|
||||
let src_total = size_hint::add_scalar(self.combs.src().size_hint(), self.combs.n());
|
||||
|
||||
// Total bounds for self ( length(powerset(set) == 2 ^ length(set) )
|
||||
let self_total = size_hint::pow_scalar_base(2, src_total);
|
||||
|
||||
if self.pos < usize::MAX {
|
||||
// Subtract count of elements already yielded from total.
|
||||
size_hint::sub_scalar(self_total, self.pos)
|
||||
} else {
|
||||
// Fallback: self.pos is saturated and no longer reliable.
|
||||
(0, self_total.1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> FusedIterator for Powerset<I>
|
||||
where
|
||||
I: Iterator,
|
||||
I::Item: Clone,
|
||||
{}
|
||||
97
zeroidc/vendor/itertools/src/process_results_impl.rs
vendored
Normal file
97
zeroidc/vendor/itertools/src/process_results_impl.rs
vendored
Normal file
@@ -0,0 +1,97 @@
|
||||
|
||||
/// An iterator that produces only the `T` values as long as the
|
||||
/// inner iterator produces `Ok(T)`.
|
||||
///
|
||||
/// Used by [`process_results`](crate::process_results), see its docs
|
||||
/// for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
#[derive(Debug)]
|
||||
pub struct ProcessResults<'a, I, E: 'a> {
|
||||
error: &'a mut Result<(), E>,
|
||||
iter: I,
|
||||
}
|
||||
|
||||
impl<'a, I, T, E> Iterator for ProcessResults<'a, I, E>
|
||||
where I: Iterator<Item = Result<T, E>>
|
||||
{
|
||||
type Item = T;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match self.iter.next() {
|
||||
Some(Ok(x)) => Some(x),
|
||||
Some(Err(e)) => {
|
||||
*self.error = Err(e);
|
||||
None
|
||||
}
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(0, self.iter.size_hint().1)
|
||||
}
|
||||
|
||||
fn fold<B, F>(mut self, init: B, mut f: F) -> B
|
||||
where
|
||||
Self: Sized,
|
||||
F: FnMut(B, Self::Item) -> B,
|
||||
{
|
||||
let error = self.error;
|
||||
self.iter
|
||||
.try_fold(init, |acc, opt| match opt {
|
||||
Ok(x) => Ok(f(acc, x)),
|
||||
Err(e) => {
|
||||
*error = Err(e);
|
||||
Err(acc)
|
||||
}
|
||||
})
|
||||
.unwrap_or_else(|e| e)
|
||||
}
|
||||
}
|
||||
|
||||
/// “Lift” a function of the values of an iterator so that it can process
|
||||
/// an iterator of `Result` values instead.
|
||||
///
|
||||
/// `iterable` is an iterator or iterable with `Result<T, E>` elements, where
|
||||
/// `T` is the value type and `E` the error type.
|
||||
///
|
||||
/// `processor` is a closure that receives an adapted version of the iterable
|
||||
/// as the only argument — the adapted iterator produces elements of type `T`,
|
||||
/// as long as the original iterator produces `Ok` values.
|
||||
///
|
||||
/// If the original iterable produces an error at any point, the adapted
|
||||
/// iterator ends and the `process_results` function will return the
|
||||
/// error iself.
|
||||
///
|
||||
/// Otherwise, the return value from the closure is returned wrapped
|
||||
/// inside `Ok`.
|
||||
///
|
||||
/// # Example
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::process_results;
|
||||
///
|
||||
/// type R = Result<i32, &'static str>;
|
||||
///
|
||||
/// let first_values: Vec<R> = vec![Ok(1), Ok(0), Ok(3)];
|
||||
/// let second_values: Vec<R> = vec![Ok(2), Ok(1), Err("overflow")];
|
||||
///
|
||||
/// // “Lift” the iterator .max() method to work on the values in Results using process_results
|
||||
///
|
||||
/// let first_max = process_results(first_values, |iter| iter.max().unwrap_or(0));
|
||||
/// let second_max = process_results(second_values, |iter| iter.max().unwrap_or(0));
|
||||
///
|
||||
/// assert_eq!(first_max, Ok(3));
|
||||
/// assert!(second_max.is_err());
|
||||
/// ```
|
||||
pub fn process_results<I, F, T, E, R>(iterable: I, processor: F) -> Result<R, E>
|
||||
where I: IntoIterator<Item = Result<T, E>>,
|
||||
F: FnOnce(ProcessResults<I::IntoIter, E>) -> R
|
||||
{
|
||||
let iter = iterable.into_iter();
|
||||
let mut error = Ok(());
|
||||
|
||||
let result = processor(ProcessResults { error: &mut error, iter });
|
||||
|
||||
error.map(|_| result)
|
||||
}
|
||||
61
zeroidc/vendor/itertools/src/put_back_n_impl.rs
vendored
Normal file
61
zeroidc/vendor/itertools/src/put_back_n_impl.rs
vendored
Normal file
@@ -0,0 +1,61 @@
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use crate::size_hint;
|
||||
|
||||
/// An iterator adaptor that allows putting multiple
|
||||
/// items in front of the iterator.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct PutBackN<I: Iterator> {
|
||||
top: Vec<I::Item>,
|
||||
iter: I,
|
||||
}
|
||||
|
||||
/// Create an iterator where you can put back multiple values to the front
|
||||
/// of the iteration.
|
||||
///
|
||||
/// Iterator element type is `I::Item`.
|
||||
pub fn put_back_n<I>(iterable: I) -> PutBackN<I::IntoIter>
|
||||
where I: IntoIterator
|
||||
{
|
||||
PutBackN {
|
||||
top: Vec::new(),
|
||||
iter: iterable.into_iter(),
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Iterator> PutBackN<I> {
|
||||
/// Puts x in front of the iterator.
|
||||
/// The values are yielded in order of the most recently put back
|
||||
/// values first.
|
||||
///
|
||||
/// ```rust
|
||||
/// use itertools::put_back_n;
|
||||
///
|
||||
/// let mut it = put_back_n(1..5);
|
||||
/// it.next();
|
||||
/// it.put_back(1);
|
||||
/// it.put_back(0);
|
||||
///
|
||||
/// assert!(itertools::equal(it, 0..5));
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn put_back(&mut self, x: I::Item) {
|
||||
self.top.push(x);
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Iterator> Iterator for PutBackN<I> {
|
||||
type Item = I::Item;
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.top.pop().or_else(|| self.iter.next())
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::add_scalar(self.iter.size_hint(), self.top.len())
|
||||
}
|
||||
}
|
||||
|
||||
100
zeroidc/vendor/itertools/src/rciter_impl.rs
vendored
Normal file
100
zeroidc/vendor/itertools/src/rciter_impl.rs
vendored
Normal file
@@ -0,0 +1,100 @@
|
||||
|
||||
use std::iter::{FusedIterator, IntoIterator};
|
||||
use alloc::rc::Rc;
|
||||
use std::cell::RefCell;
|
||||
|
||||
/// A wrapper for `Rc<RefCell<I>>`, that implements the `Iterator` trait.
|
||||
#[derive(Debug)]
|
||||
pub struct RcIter<I> {
|
||||
/// The boxed iterator.
|
||||
pub rciter: Rc<RefCell<I>>,
|
||||
}
|
||||
|
||||
/// Return an iterator inside a `Rc<RefCell<_>>` wrapper.
|
||||
///
|
||||
/// The returned `RcIter` can be cloned, and each clone will refer back to the
|
||||
/// same original iterator.
|
||||
///
|
||||
/// `RcIter` allows doing interesting things like using `.zip()` on an iterator with
|
||||
/// itself, at the cost of runtime borrow checking which may have a performance
|
||||
/// penalty.
|
||||
///
|
||||
/// Iterator element type is `Self::Item`.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::rciter;
|
||||
/// use itertools::zip;
|
||||
///
|
||||
/// // In this example a range iterator is created and we iterate it using
|
||||
/// // three separate handles (two of them given to zip).
|
||||
/// // We also use the IntoIterator implementation for `&RcIter`.
|
||||
///
|
||||
/// let mut iter = rciter(0..9);
|
||||
/// let mut z = zip(&iter, &iter);
|
||||
///
|
||||
/// assert_eq!(z.next(), Some((0, 1)));
|
||||
/// assert_eq!(z.next(), Some((2, 3)));
|
||||
/// assert_eq!(z.next(), Some((4, 5)));
|
||||
/// assert_eq!(iter.next(), Some(6));
|
||||
/// assert_eq!(z.next(), Some((7, 8)));
|
||||
/// assert_eq!(z.next(), None);
|
||||
/// ```
|
||||
///
|
||||
/// **Panics** in iterator methods if a borrow error is encountered in the
|
||||
/// iterator methods. It can only happen if the `RcIter` is reentered in
|
||||
/// `.next()`, i.e. if it somehow participates in an “iterator knot”
|
||||
/// where it is an adaptor of itself.
|
||||
pub fn rciter<I>(iterable: I) -> RcIter<I::IntoIter>
|
||||
where I: IntoIterator
|
||||
{
|
||||
RcIter { rciter: Rc::new(RefCell::new(iterable.into_iter())) }
|
||||
}
|
||||
|
||||
impl<I> Clone for RcIter<I> {
|
||||
#[inline]
|
||||
clone_fields!(rciter);
|
||||
}
|
||||
|
||||
impl<A, I> Iterator for RcIter<I>
|
||||
where I: Iterator<Item = A>
|
||||
{
|
||||
type Item = A;
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.rciter.borrow_mut().next()
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
// To work sanely with other API that assume they own an iterator,
|
||||
// so it can't change in other places, we can't guarantee as much
|
||||
// in our size_hint. Other clones may drain values under our feet.
|
||||
(0, self.rciter.borrow().size_hint().1)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> DoubleEndedIterator for RcIter<I>
|
||||
where I: DoubleEndedIterator
|
||||
{
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
self.rciter.borrow_mut().next_back()
|
||||
}
|
||||
}
|
||||
|
||||
/// Return an iterator from `&RcIter<I>` (by simply cloning it).
|
||||
impl<'a, I> IntoIterator for &'a RcIter<I>
|
||||
where I: Iterator
|
||||
{
|
||||
type Item = I::Item;
|
||||
type IntoIter = RcIter<I>;
|
||||
|
||||
fn into_iter(self) -> RcIter<I> {
|
||||
self.clone()
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
impl<A, I> FusedIterator for RcIter<I>
|
||||
where I: FusedIterator<Item = A>
|
||||
{}
|
||||
59
zeroidc/vendor/itertools/src/repeatn.rs
vendored
Normal file
59
zeroidc/vendor/itertools/src/repeatn.rs
vendored
Normal file
@@ -0,0 +1,59 @@
|
||||
use std::iter::FusedIterator;
|
||||
|
||||
/// An iterator that produces *n* repetitions of an element.
|
||||
///
|
||||
/// See [`repeat_n()`](crate::repeat_n) for more information.
|
||||
#[must_use = "iterators are lazy and do nothing unless consumed"]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct RepeatN<A> {
|
||||
elt: Option<A>,
|
||||
n: usize,
|
||||
}
|
||||
|
||||
/// Create an iterator that produces `n` repetitions of `element`.
|
||||
pub fn repeat_n<A>(element: A, n: usize) -> RepeatN<A>
|
||||
where A: Clone,
|
||||
{
|
||||
if n == 0 {
|
||||
RepeatN { elt: None, n, }
|
||||
} else {
|
||||
RepeatN { elt: Some(element), n, }
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> Iterator for RepeatN<A>
|
||||
where A: Clone
|
||||
{
|
||||
type Item = A;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if self.n > 1 {
|
||||
self.n -= 1;
|
||||
self.elt.as_ref().cloned()
|
||||
} else {
|
||||
self.n = 0;
|
||||
self.elt.take()
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(self.n, Some(self.n))
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> DoubleEndedIterator for RepeatN<A>
|
||||
where A: Clone
|
||||
{
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
self.next()
|
||||
}
|
||||
}
|
||||
|
||||
impl<A> ExactSizeIterator for RepeatN<A>
|
||||
where A: Clone
|
||||
{}
|
||||
|
||||
impl<A> FusedIterator for RepeatN<A>
|
||||
where A: Clone
|
||||
{}
|
||||
119
zeroidc/vendor/itertools/src/size_hint.rs
vendored
Normal file
119
zeroidc/vendor/itertools/src/size_hint.rs
vendored
Normal file
@@ -0,0 +1,119 @@
|
||||
//! Arithmetic on **Iterator** *.size_hint()* values.
|
||||
//!
|
||||
|
||||
use std::usize;
|
||||
use std::cmp;
|
||||
use std::u32;
|
||||
|
||||
/// **SizeHint** is the return type of **Iterator::size_hint()**.
|
||||
pub type SizeHint = (usize, Option<usize>);
|
||||
|
||||
/// Add **SizeHint** correctly.
|
||||
#[inline]
|
||||
pub fn add(a: SizeHint, b: SizeHint) -> SizeHint {
|
||||
let min = a.0.saturating_add(b.0);
|
||||
let max = match (a.1, b.1) {
|
||||
(Some(x), Some(y)) => x.checked_add(y),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
(min, max)
|
||||
}
|
||||
|
||||
/// Add **x** correctly to a **SizeHint**.
|
||||
#[inline]
|
||||
pub fn add_scalar(sh: SizeHint, x: usize) -> SizeHint {
|
||||
let (mut low, mut hi) = sh;
|
||||
low = low.saturating_add(x);
|
||||
hi = hi.and_then(|elt| elt.checked_add(x));
|
||||
(low, hi)
|
||||
}
|
||||
|
||||
/// Sbb **x** correctly to a **SizeHint**.
|
||||
#[inline]
|
||||
#[allow(dead_code)]
|
||||
pub fn sub_scalar(sh: SizeHint, x: usize) -> SizeHint {
|
||||
let (mut low, mut hi) = sh;
|
||||
low = low.saturating_sub(x);
|
||||
hi = hi.map(|elt| elt.saturating_sub(x));
|
||||
(low, hi)
|
||||
}
|
||||
|
||||
|
||||
/// Multiply **SizeHint** correctly
|
||||
///
|
||||
/// ```ignore
|
||||
/// use std::usize;
|
||||
/// use itertools::size_hint;
|
||||
///
|
||||
/// assert_eq!(size_hint::mul((3, Some(4)), (3, Some(4))),
|
||||
/// (9, Some(16)));
|
||||
///
|
||||
/// assert_eq!(size_hint::mul((3, Some(4)), (usize::MAX, None)),
|
||||
/// (usize::MAX, None));
|
||||
///
|
||||
/// assert_eq!(size_hint::mul((3, None), (0, Some(0))),
|
||||
/// (0, Some(0)));
|
||||
/// ```
|
||||
#[inline]
|
||||
pub fn mul(a: SizeHint, b: SizeHint) -> SizeHint {
|
||||
let low = a.0.saturating_mul(b.0);
|
||||
let hi = match (a.1, b.1) {
|
||||
(Some(x), Some(y)) => x.checked_mul(y),
|
||||
(Some(0), None) | (None, Some(0)) => Some(0),
|
||||
_ => None,
|
||||
};
|
||||
(low, hi)
|
||||
}
|
||||
|
||||
/// Multiply **x** correctly with a **SizeHint**.
|
||||
#[inline]
|
||||
pub fn mul_scalar(sh: SizeHint, x: usize) -> SizeHint {
|
||||
let (mut low, mut hi) = sh;
|
||||
low = low.saturating_mul(x);
|
||||
hi = hi.and_then(|elt| elt.checked_mul(x));
|
||||
(low, hi)
|
||||
}
|
||||
|
||||
/// Raise `base` correctly by a **`SizeHint`** exponent.
|
||||
#[inline]
|
||||
pub fn pow_scalar_base(base: usize, exp: SizeHint) -> SizeHint {
|
||||
let exp_low = cmp::min(exp.0, u32::MAX as usize) as u32;
|
||||
let low = base.saturating_pow(exp_low);
|
||||
|
||||
let hi = exp.1.and_then(|exp| {
|
||||
let exp_hi = cmp::min(exp, u32::MAX as usize) as u32;
|
||||
base.checked_pow(exp_hi)
|
||||
});
|
||||
|
||||
(low, hi)
|
||||
}
|
||||
|
||||
/// Return the maximum
|
||||
#[inline]
|
||||
pub fn max(a: SizeHint, b: SizeHint) -> SizeHint {
|
||||
let (a_lower, a_upper) = a;
|
||||
let (b_lower, b_upper) = b;
|
||||
|
||||
let lower = cmp::max(a_lower, b_lower);
|
||||
|
||||
let upper = match (a_upper, b_upper) {
|
||||
(Some(x), Some(y)) => Some(cmp::max(x, y)),
|
||||
_ => None,
|
||||
};
|
||||
|
||||
(lower, upper)
|
||||
}
|
||||
|
||||
/// Return the minimum
|
||||
#[inline]
|
||||
pub fn min(a: SizeHint, b: SizeHint) -> SizeHint {
|
||||
let (a_lower, a_upper) = a;
|
||||
let (b_lower, b_upper) = b;
|
||||
let lower = cmp::min(a_lower, b_lower);
|
||||
let upper = match (a_upper, b_upper) {
|
||||
(Some(u1), Some(u2)) => Some(cmp::min(u1, u2)),
|
||||
_ => a_upper.or(b_upper),
|
||||
};
|
||||
(lower, upper)
|
||||
}
|
||||
183
zeroidc/vendor/itertools/src/sources.rs
vendored
Normal file
183
zeroidc/vendor/itertools/src/sources.rs
vendored
Normal file
@@ -0,0 +1,183 @@
|
||||
//! Iterators that are sources (produce elements from parameters,
|
||||
//! not from another iterator).
|
||||
#![allow(deprecated)]
|
||||
|
||||
use std::fmt;
|
||||
use std::mem;
|
||||
|
||||
/// See [`repeat_call`](crate::repeat_call) for more information.
|
||||
#[derive(Clone)]
|
||||
#[deprecated(note="Use std repeat_with() instead", since="0.8.0")]
|
||||
pub struct RepeatCall<F> {
|
||||
f: F,
|
||||
}
|
||||
|
||||
impl<F> fmt::Debug for RepeatCall<F>
|
||||
{
|
||||
debug_fmt_fields!(RepeatCall, );
|
||||
}
|
||||
|
||||
/// An iterator source that produces elements indefinitely by calling
|
||||
/// a given closure.
|
||||
///
|
||||
/// Iterator element type is the return type of the closure.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::repeat_call;
|
||||
/// use itertools::Itertools;
|
||||
/// use std::collections::BinaryHeap;
|
||||
///
|
||||
/// let mut heap = BinaryHeap::from(vec![2, 5, 3, 7, 8]);
|
||||
///
|
||||
/// // extract each element in sorted order
|
||||
/// for element in repeat_call(|| heap.pop()).while_some() {
|
||||
/// print!("{}", element);
|
||||
/// }
|
||||
///
|
||||
/// itertools::assert_equal(
|
||||
/// repeat_call(|| 1).take(5),
|
||||
/// vec![1, 1, 1, 1, 1]
|
||||
/// );
|
||||
/// ```
|
||||
#[deprecated(note="Use std repeat_with() instead", since="0.8.0")]
|
||||
pub fn repeat_call<F, A>(function: F) -> RepeatCall<F>
|
||||
where F: FnMut() -> A
|
||||
{
|
||||
RepeatCall { f: function }
|
||||
}
|
||||
|
||||
impl<A, F> Iterator for RepeatCall<F>
|
||||
where F: FnMut() -> A
|
||||
{
|
||||
type Item = A;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
Some((self.f)())
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(usize::max_value(), None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new unfold source with the specified closure as the "iterator
|
||||
/// function" and an initial state to eventually pass to the closure
|
||||
///
|
||||
/// `unfold` is a general iterator builder: it has a mutable state value,
|
||||
/// and a closure with access to the state that produces the next value.
|
||||
///
|
||||
/// This more or less equivalent to a regular struct with an [`Iterator`]
|
||||
/// implementation, and is useful for one-off iterators.
|
||||
///
|
||||
/// ```
|
||||
/// // an iterator that yields sequential Fibonacci numbers,
|
||||
/// // and stops at the maximum representable value.
|
||||
///
|
||||
/// use itertools::unfold;
|
||||
///
|
||||
/// let mut fibonacci = unfold((1u32, 1u32), |(x1, x2)| {
|
||||
/// // Attempt to get the next Fibonacci number
|
||||
/// let next = x1.saturating_add(*x2);
|
||||
///
|
||||
/// // Shift left: ret <- x1 <- x2 <- next
|
||||
/// let ret = *x1;
|
||||
/// *x1 = *x2;
|
||||
/// *x2 = next;
|
||||
///
|
||||
/// // If addition has saturated at the maximum, we are finished
|
||||
/// if ret == *x1 && ret > 1 {
|
||||
/// None
|
||||
/// } else {
|
||||
/// Some(ret)
|
||||
/// }
|
||||
/// });
|
||||
///
|
||||
/// itertools::assert_equal(fibonacci.by_ref().take(8),
|
||||
/// vec![1, 1, 2, 3, 5, 8, 13, 21]);
|
||||
/// assert_eq!(fibonacci.last(), Some(2_971_215_073))
|
||||
/// ```
|
||||
pub fn unfold<A, St, F>(initial_state: St, f: F) -> Unfold<St, F>
|
||||
where F: FnMut(&mut St) -> Option<A>
|
||||
{
|
||||
Unfold {
|
||||
f,
|
||||
state: initial_state,
|
||||
}
|
||||
}
|
||||
|
||||
impl<St, F> fmt::Debug for Unfold<St, F>
|
||||
where St: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(Unfold, state);
|
||||
}
|
||||
|
||||
/// See [`unfold`](crate::unfold) for more information.
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterators are lazy and do nothing unless consumed"]
|
||||
pub struct Unfold<St, F> {
|
||||
f: F,
|
||||
/// Internal state that will be passed to the closure on the next iteration
|
||||
pub state: St,
|
||||
}
|
||||
|
||||
impl<A, St, F> Iterator for Unfold<St, F>
|
||||
where F: FnMut(&mut St) -> Option<A>
|
||||
{
|
||||
type Item = A;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
(self.f)(&mut self.state)
|
||||
}
|
||||
}
|
||||
|
||||
/// An iterator that infinitely applies function to value and yields results.
|
||||
///
|
||||
/// This `struct` is created by the [`iterate()`](crate::iterate) function.
|
||||
/// See its documentation for more.
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterators are lazy and do nothing unless consumed"]
|
||||
pub struct Iterate<St, F> {
|
||||
state: St,
|
||||
f: F,
|
||||
}
|
||||
|
||||
impl<St, F> fmt::Debug for Iterate<St, F>
|
||||
where St: fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(Iterate, state);
|
||||
}
|
||||
|
||||
impl<St, F> Iterator for Iterate<St, F>
|
||||
where F: FnMut(&St) -> St
|
||||
{
|
||||
type Item = St;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let next_state = (self.f)(&self.state);
|
||||
Some(mem::replace(&mut self.state, next_state))
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
(usize::max_value(), None)
|
||||
}
|
||||
}
|
||||
|
||||
/// Creates a new iterator that infinitely applies function to value and yields results.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::iterate;
|
||||
///
|
||||
/// itertools::assert_equal(iterate(1, |&i| i * 3).take(5), vec![1, 3, 9, 27, 81]);
|
||||
/// ```
|
||||
pub fn iterate<St, F>(initial_value: St, f: F) -> Iterate<St, F>
|
||||
where F: FnMut(&St) -> St
|
||||
{
|
||||
Iterate {
|
||||
state: initial_value,
|
||||
f,
|
||||
}
|
||||
}
|
||||
78
zeroidc/vendor/itertools/src/tee.rs
vendored
Normal file
78
zeroidc/vendor/itertools/src/tee.rs
vendored
Normal file
@@ -0,0 +1,78 @@
|
||||
use super::size_hint;
|
||||
|
||||
use std::cell::RefCell;
|
||||
use alloc::collections::VecDeque;
|
||||
use alloc::rc::Rc;
|
||||
|
||||
/// Common buffer object for the two tee halves
|
||||
#[derive(Debug)]
|
||||
struct TeeBuffer<A, I> {
|
||||
backlog: VecDeque<A>,
|
||||
iter: I,
|
||||
/// The owner field indicates which id should read from the backlog
|
||||
owner: bool,
|
||||
}
|
||||
|
||||
/// One half of an iterator pair where both return the same elements.
|
||||
///
|
||||
/// See [`.tee()`](crate::Itertools::tee) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
#[derive(Debug)]
|
||||
pub struct Tee<I>
|
||||
where I: Iterator
|
||||
{
|
||||
rcbuffer: Rc<RefCell<TeeBuffer<I::Item, I>>>,
|
||||
id: bool,
|
||||
}
|
||||
|
||||
pub fn new<I>(iter: I) -> (Tee<I>, Tee<I>)
|
||||
where I: Iterator
|
||||
{
|
||||
let buffer = TeeBuffer{backlog: VecDeque::new(), iter, owner: false};
|
||||
let t1 = Tee{rcbuffer: Rc::new(RefCell::new(buffer)), id: true};
|
||||
let t2 = Tee{rcbuffer: t1.rcbuffer.clone(), id: false};
|
||||
(t1, t2)
|
||||
}
|
||||
|
||||
impl<I> Iterator for Tee<I>
|
||||
where I: Iterator,
|
||||
I::Item: Clone
|
||||
{
|
||||
type Item = I::Item;
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
// .borrow_mut may fail here -- but only if the user has tied some kind of weird
|
||||
// knot where the iterator refers back to itself.
|
||||
let mut buffer = self.rcbuffer.borrow_mut();
|
||||
if buffer.owner == self.id {
|
||||
match buffer.backlog.pop_front() {
|
||||
None => {}
|
||||
some_elt => return some_elt,
|
||||
}
|
||||
}
|
||||
match buffer.iter.next() {
|
||||
None => None,
|
||||
Some(elt) => {
|
||||
buffer.backlog.push_back(elt.clone());
|
||||
buffer.owner = !self.id;
|
||||
Some(elt)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let buffer = self.rcbuffer.borrow();
|
||||
let sh = buffer.iter.size_hint();
|
||||
|
||||
if buffer.owner == self.id {
|
||||
let log_len = buffer.backlog.len();
|
||||
size_hint::add_scalar(sh, log_len)
|
||||
} else {
|
||||
sh
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> ExactSizeIterator for Tee<I>
|
||||
where I: ExactSizeIterator,
|
||||
I::Item: Clone
|
||||
{}
|
||||
331
zeroidc/vendor/itertools/src/tuple_impl.rs
vendored
Normal file
331
zeroidc/vendor/itertools/src/tuple_impl.rs
vendored
Normal file
@@ -0,0 +1,331 @@
|
||||
//! Some iterator that produces tuples
|
||||
|
||||
use std::iter::Fuse;
|
||||
use std::iter::FusedIterator;
|
||||
use std::iter::Take;
|
||||
use std::iter::Cycle;
|
||||
use std::marker::PhantomData;
|
||||
|
||||
// `HomogeneousTuple` is a public facade for `TupleCollect`, allowing
|
||||
// tuple-related methods to be used by clients in generic contexts, while
|
||||
// hiding the implementation details of `TupleCollect`.
|
||||
// See https://github.com/rust-itertools/itertools/issues/387
|
||||
|
||||
/// Implemented for homogeneous tuples of size up to 12.
|
||||
pub trait HomogeneousTuple
|
||||
: TupleCollect
|
||||
{}
|
||||
|
||||
impl<T: TupleCollect> HomogeneousTuple for T {}
|
||||
|
||||
/// An iterator over a incomplete tuple.
|
||||
///
|
||||
/// See [`.tuples()`](crate::Itertools::tuples) and
|
||||
/// [`Tuples::into_buffer()`].
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct TupleBuffer<T>
|
||||
where T: HomogeneousTuple
|
||||
{
|
||||
cur: usize,
|
||||
buf: T::Buffer,
|
||||
}
|
||||
|
||||
impl<T> TupleBuffer<T>
|
||||
where T: HomogeneousTuple
|
||||
{
|
||||
fn new(buf: T::Buffer) -> Self {
|
||||
TupleBuffer {
|
||||
cur: 0,
|
||||
buf,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> Iterator for TupleBuffer<T>
|
||||
where T: HomogeneousTuple
|
||||
{
|
||||
type Item = T::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
let s = self.buf.as_mut();
|
||||
if let Some(ref mut item) = s.get_mut(self.cur) {
|
||||
self.cur += 1;
|
||||
item.take()
|
||||
} else {
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let buffer = &self.buf.as_ref()[self.cur..];
|
||||
let len = if buffer.is_empty() {
|
||||
0
|
||||
} else {
|
||||
buffer.iter()
|
||||
.position(|x| x.is_none())
|
||||
.unwrap_or_else(|| buffer.len())
|
||||
};
|
||||
(len, Some(len))
|
||||
}
|
||||
}
|
||||
|
||||
impl<T> ExactSizeIterator for TupleBuffer<T>
|
||||
where T: HomogeneousTuple
|
||||
{
|
||||
}
|
||||
|
||||
/// An iterator that groups the items in tuples of a specific size.
|
||||
///
|
||||
/// See [`.tuples()`](crate::Itertools::tuples) for more information.
|
||||
#[derive(Clone, Debug)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Tuples<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple
|
||||
{
|
||||
iter: Fuse<I>,
|
||||
buf: T::Buffer,
|
||||
}
|
||||
|
||||
/// Create a new tuples iterator.
|
||||
pub fn tuples<I, T>(iter: I) -> Tuples<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple
|
||||
{
|
||||
Tuples {
|
||||
iter: iter.fuse(),
|
||||
buf: Default::default(),
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T> Iterator for Tuples<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple
|
||||
{
|
||||
type Item = T;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
T::collect_from_iter(&mut self.iter, &mut self.buf)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T> Tuples<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple
|
||||
{
|
||||
/// Return a buffer with the produced items that was not enough to be grouped in a tuple.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::Itertools;
|
||||
///
|
||||
/// let mut iter = (0..5).tuples();
|
||||
/// assert_eq!(Some((0, 1, 2)), iter.next());
|
||||
/// assert_eq!(None, iter.next());
|
||||
/// itertools::assert_equal(vec![3, 4], iter.into_buffer());
|
||||
/// ```
|
||||
pub fn into_buffer(self) -> TupleBuffer<T> {
|
||||
TupleBuffer::new(self.buf)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// An iterator over all contiguous windows that produces tuples of a specific size.
|
||||
///
|
||||
/// See [`.tuple_windows()`](crate::Itertools::tuple_windows) for more
|
||||
/// information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct TupleWindows<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple
|
||||
{
|
||||
iter: I,
|
||||
last: Option<T>,
|
||||
}
|
||||
|
||||
/// Create a new tuple windows iterator.
|
||||
pub fn tuple_windows<I, T>(mut iter: I) -> TupleWindows<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple,
|
||||
T::Item: Clone
|
||||
{
|
||||
use std::iter::once;
|
||||
|
||||
let mut last = None;
|
||||
if T::num_items() != 1 {
|
||||
// put in a duplicate item in front of the tuple; this simplifies
|
||||
// .next() function.
|
||||
if let Some(item) = iter.next() {
|
||||
let iter = once(item.clone()).chain(once(item)).chain(&mut iter);
|
||||
last = T::collect_from_iter_no_buf(iter);
|
||||
}
|
||||
}
|
||||
|
||||
TupleWindows {
|
||||
last,
|
||||
iter,
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T> Iterator for TupleWindows<I, T>
|
||||
where I: Iterator<Item = T::Item>,
|
||||
T: HomogeneousTuple + Clone,
|
||||
T::Item: Clone
|
||||
{
|
||||
type Item = T;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
if T::num_items() == 1 {
|
||||
return T::collect_from_iter_no_buf(&mut self.iter)
|
||||
}
|
||||
if let Some(ref mut last) = self.last {
|
||||
if let Some(new) = self.iter.next() {
|
||||
last.left_shift_push(new);
|
||||
return Some(last.clone());
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T> FusedIterator for TupleWindows<I, T>
|
||||
where I: FusedIterator<Item = T::Item>,
|
||||
T: HomogeneousTuple + Clone,
|
||||
T::Item: Clone
|
||||
{}
|
||||
|
||||
/// An iterator over all windows,wrapping back to the first elements when the
|
||||
/// window would otherwise exceed the length of the iterator, producing tuples
|
||||
/// of a specific size.
|
||||
///
|
||||
/// See [`.circular_tuple_windows()`](crate::Itertools::circular_tuple_windows) for more
|
||||
/// information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
#[derive(Debug)]
|
||||
pub struct CircularTupleWindows<I, T: Clone>
|
||||
where I: Iterator<Item = T::Item> + Clone,
|
||||
T: TupleCollect + Clone
|
||||
{
|
||||
iter: Take<TupleWindows<Cycle<I>, T>>,
|
||||
phantom_data: PhantomData<T>
|
||||
}
|
||||
|
||||
pub fn circular_tuple_windows<I, T>(iter: I) -> CircularTupleWindows<I, T>
|
||||
where I: Iterator<Item = T::Item> + Clone + ExactSizeIterator,
|
||||
T: TupleCollect + Clone,
|
||||
T::Item: Clone
|
||||
{
|
||||
let len = iter.len();
|
||||
let iter = tuple_windows(iter.cycle()).take(len);
|
||||
|
||||
CircularTupleWindows {
|
||||
iter,
|
||||
phantom_data: PhantomData{}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, T> Iterator for CircularTupleWindows<I, T>
|
||||
where I: Iterator<Item = T::Item> + Clone,
|
||||
T: TupleCollect + Clone,
|
||||
T::Item: Clone
|
||||
{
|
||||
type Item = T;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.iter.next()
|
||||
}
|
||||
}
|
||||
|
||||
pub trait TupleCollect: Sized {
|
||||
type Item;
|
||||
type Buffer: Default + AsRef<[Option<Self::Item>]> + AsMut<[Option<Self::Item>]>;
|
||||
|
||||
fn collect_from_iter<I>(iter: I, buf: &mut Self::Buffer) -> Option<Self>
|
||||
where I: IntoIterator<Item = Self::Item>;
|
||||
|
||||
fn collect_from_iter_no_buf<I>(iter: I) -> Option<Self>
|
||||
where I: IntoIterator<Item = Self::Item>;
|
||||
|
||||
fn num_items() -> usize;
|
||||
|
||||
fn left_shift_push(&mut self, item: Self::Item);
|
||||
}
|
||||
|
||||
macro_rules! count_ident{
|
||||
() => {0};
|
||||
($i0:ident, $($i:ident,)*) => {1 + count_ident!($($i,)*)};
|
||||
}
|
||||
macro_rules! rev_for_each_ident{
|
||||
($m:ident, ) => {};
|
||||
($m:ident, $i0:ident, $($i:ident,)*) => {
|
||||
rev_for_each_ident!($m, $($i,)*);
|
||||
$m!($i0);
|
||||
};
|
||||
}
|
||||
|
||||
macro_rules! impl_tuple_collect {
|
||||
($dummy:ident,) => {}; // stop
|
||||
($dummy:ident, $($Y:ident,)*) => (
|
||||
impl_tuple_collect!($($Y,)*);
|
||||
impl<A> TupleCollect for ($(ignore_ident!($Y, A),)*) {
|
||||
type Item = A;
|
||||
type Buffer = [Option<A>; count_ident!($($Y,)*) - 1];
|
||||
|
||||
#[allow(unused_assignments, unused_mut)]
|
||||
fn collect_from_iter<I>(iter: I, buf: &mut Self::Buffer) -> Option<Self>
|
||||
where I: IntoIterator<Item = A>
|
||||
{
|
||||
let mut iter = iter.into_iter();
|
||||
$(
|
||||
let mut $Y = None;
|
||||
)*
|
||||
|
||||
loop {
|
||||
$(
|
||||
$Y = iter.next();
|
||||
if $Y.is_none() {
|
||||
break
|
||||
}
|
||||
)*
|
||||
return Some(($($Y.unwrap()),*,))
|
||||
}
|
||||
|
||||
let mut i = 0;
|
||||
let mut s = buf.as_mut();
|
||||
$(
|
||||
if i < s.len() {
|
||||
s[i] = $Y;
|
||||
i += 1;
|
||||
}
|
||||
)*
|
||||
return None;
|
||||
}
|
||||
|
||||
fn collect_from_iter_no_buf<I>(iter: I) -> Option<Self>
|
||||
where I: IntoIterator<Item = A>
|
||||
{
|
||||
let mut iter = iter.into_iter();
|
||||
|
||||
Some(($(
|
||||
{ let $Y = iter.next()?; $Y },
|
||||
)*))
|
||||
}
|
||||
|
||||
fn num_items() -> usize {
|
||||
count_ident!($($Y,)*)
|
||||
}
|
||||
|
||||
fn left_shift_push(&mut self, mut item: A) {
|
||||
use std::mem::replace;
|
||||
|
||||
let &mut ($(ref mut $Y),*,) = self;
|
||||
macro_rules! replace_item{($i:ident) => {
|
||||
item = replace($i, item);
|
||||
}}
|
||||
rev_for_each_ident!(replace_item, $($Y,)*);
|
||||
drop(item);
|
||||
}
|
||||
}
|
||||
)
|
||||
}
|
||||
impl_tuple_collect!(dummy, a, b, c, d, e, f, g, h, i, j, k, l,);
|
||||
178
zeroidc/vendor/itertools/src/unique_impl.rs
vendored
Normal file
178
zeroidc/vendor/itertools/src/unique_impl.rs
vendored
Normal file
@@ -0,0 +1,178 @@
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::collections::hash_map::{Entry};
|
||||
use std::hash::Hash;
|
||||
use std::fmt;
|
||||
use std::iter::FusedIterator;
|
||||
|
||||
/// An iterator adapter to filter out duplicate elements.
|
||||
///
|
||||
/// See [`.unique_by()`](crate::Itertools::unique) for more information.
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct UniqueBy<I: Iterator, V, F> {
|
||||
iter: I,
|
||||
// Use a hashmap for the entry API
|
||||
used: HashMap<V, ()>,
|
||||
f: F,
|
||||
}
|
||||
|
||||
impl<I, V, F> fmt::Debug for UniqueBy<I, V, F>
|
||||
where I: Iterator + fmt::Debug,
|
||||
V: fmt::Debug + Hash + Eq,
|
||||
{
|
||||
debug_fmt_fields!(UniqueBy, iter, used);
|
||||
}
|
||||
|
||||
/// Create a new `UniqueBy` iterator.
|
||||
pub fn unique_by<I, V, F>(iter: I, f: F) -> UniqueBy<I, V, F>
|
||||
where V: Eq + Hash,
|
||||
F: FnMut(&I::Item) -> V,
|
||||
I: Iterator,
|
||||
{
|
||||
UniqueBy {
|
||||
iter,
|
||||
used: HashMap::new(),
|
||||
f,
|
||||
}
|
||||
}
|
||||
|
||||
// count the number of new unique keys in iterable (`used` is the set already seen)
|
||||
fn count_new_keys<I, K>(mut used: HashMap<K, ()>, iterable: I) -> usize
|
||||
where I: IntoIterator<Item=K>,
|
||||
K: Hash + Eq,
|
||||
{
|
||||
let iter = iterable.into_iter();
|
||||
let current_used = used.len();
|
||||
used.extend(iter.map(|key| (key, ())));
|
||||
used.len() - current_used
|
||||
}
|
||||
|
||||
impl<I, V, F> Iterator for UniqueBy<I, V, F>
|
||||
where I: Iterator,
|
||||
V: Eq + Hash,
|
||||
F: FnMut(&I::Item) -> V
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
while let Some(v) = self.iter.next() {
|
||||
let key = (self.f)(&v);
|
||||
if self.used.insert(key, ()).is_none() {
|
||||
return Some(v);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let (low, hi) = self.iter.size_hint();
|
||||
((low > 0 && self.used.is_empty()) as usize, hi)
|
||||
}
|
||||
|
||||
fn count(self) -> usize {
|
||||
let mut key_f = self.f;
|
||||
count_new_keys(self.used, self.iter.map(move |elt| key_f(&elt)))
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, V, F> DoubleEndedIterator for UniqueBy<I, V, F>
|
||||
where I: DoubleEndedIterator,
|
||||
V: Eq + Hash,
|
||||
F: FnMut(&I::Item) -> V
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
while let Some(v) = self.iter.next_back() {
|
||||
let key = (self.f)(&v);
|
||||
if self.used.insert(key, ()).is_none() {
|
||||
return Some(v);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, V, F> FusedIterator for UniqueBy<I, V, F>
|
||||
where I: FusedIterator,
|
||||
V: Eq + Hash,
|
||||
F: FnMut(&I::Item) -> V
|
||||
{}
|
||||
|
||||
impl<I> Iterator for Unique<I>
|
||||
where I: Iterator,
|
||||
I::Item: Eq + Hash + Clone
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
while let Some(v) = self.iter.iter.next() {
|
||||
if let Entry::Vacant(entry) = self.iter.used.entry(v) {
|
||||
let elt = entry.key().clone();
|
||||
entry.insert(());
|
||||
return Some(elt);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
let (low, hi) = self.iter.iter.size_hint();
|
||||
((low > 0 && self.iter.used.is_empty()) as usize, hi)
|
||||
}
|
||||
|
||||
fn count(self) -> usize {
|
||||
count_new_keys(self.iter.used, self.iter.iter)
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> DoubleEndedIterator for Unique<I>
|
||||
where I: DoubleEndedIterator,
|
||||
I::Item: Eq + Hash + Clone
|
||||
{
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
while let Some(v) = self.iter.iter.next_back() {
|
||||
if let Entry::Vacant(entry) = self.iter.used.entry(v) {
|
||||
let elt = entry.key().clone();
|
||||
entry.insert(());
|
||||
return Some(elt);
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> FusedIterator for Unique<I>
|
||||
where I: FusedIterator,
|
||||
I::Item: Eq + Hash + Clone
|
||||
{}
|
||||
|
||||
/// An iterator adapter to filter out duplicate elements.
|
||||
///
|
||||
/// See [`.unique()`](crate::Itertools::unique) for more information.
|
||||
#[derive(Clone)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Unique<I: Iterator> {
|
||||
iter: UniqueBy<I, I::Item, ()>,
|
||||
}
|
||||
|
||||
impl<I> fmt::Debug for Unique<I>
|
||||
where I: Iterator + fmt::Debug,
|
||||
I::Item: Hash + Eq + fmt::Debug,
|
||||
{
|
||||
debug_fmt_fields!(Unique, iter);
|
||||
}
|
||||
|
||||
pub fn unique<I>(iter: I) -> Unique<I>
|
||||
where I: Iterator,
|
||||
I::Item: Eq + Hash,
|
||||
{
|
||||
Unique {
|
||||
iter: UniqueBy {
|
||||
iter,
|
||||
used: HashMap::new(),
|
||||
f: (),
|
||||
}
|
||||
}
|
||||
}
|
||||
80
zeroidc/vendor/itertools/src/unziptuple.rs
vendored
Normal file
80
zeroidc/vendor/itertools/src/unziptuple.rs
vendored
Normal file
@@ -0,0 +1,80 @@
|
||||
/// Converts an iterator of tuples into a tuple of containers.
|
||||
///
|
||||
/// `unzip()` consumes an entire iterator of n-ary tuples, producing `n` collections, one for each
|
||||
/// column.
|
||||
///
|
||||
/// This function is, in some sense, the opposite of [`multizip`].
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::multiunzip;
|
||||
///
|
||||
/// let inputs = vec![(1, 2, 3), (4, 5, 6), (7, 8, 9)];
|
||||
///
|
||||
/// let (a, b, c): (Vec<_>, Vec<_>, Vec<_>) = multiunzip(inputs);
|
||||
///
|
||||
/// assert_eq!(a, vec![1, 4, 7]);
|
||||
/// assert_eq!(b, vec![2, 5, 8]);
|
||||
/// assert_eq!(c, vec![3, 6, 9]);
|
||||
/// ```
|
||||
///
|
||||
/// [`multizip`]: crate::multizip
|
||||
pub fn multiunzip<FromI, I>(i: I) -> FromI
|
||||
where
|
||||
I: IntoIterator,
|
||||
I::IntoIter: MultiUnzip<FromI>,
|
||||
{
|
||||
i.into_iter().multiunzip()
|
||||
}
|
||||
|
||||
/// An iterator that can be unzipped into multiple collections.
|
||||
///
|
||||
/// See [`.multiunzip()`](crate::Itertools::multiunzip) for more information.
|
||||
pub trait MultiUnzip<FromI>: Iterator {
|
||||
/// Unzip this iterator into multiple collections.
|
||||
fn multiunzip(self) -> FromI;
|
||||
}
|
||||
|
||||
macro_rules! impl_unzip_iter {
|
||||
($($T:ident => $FromT:ident),*) => (
|
||||
#[allow(non_snake_case)]
|
||||
impl<IT: Iterator<Item = ($($T,)*)>, $($T, $FromT: Default + Extend<$T>),* > MultiUnzip<($($FromT,)*)> for IT {
|
||||
fn multiunzip(self) -> ($($FromT,)*) {
|
||||
// This implementation mirrors the logic of Iterator::unzip as close as possible.
|
||||
// Unfortunately a lot of the used api there is still unstable represented by
|
||||
// the commented out parts that follow.
|
||||
//
|
||||
// https://doc.rust-lang.org/src/core/iter/traits/iterator.rs.html#2816-2844
|
||||
|
||||
let mut res = ($($FromT::default(),)*);
|
||||
let ($($FromT,)*) = &mut res;
|
||||
|
||||
// Still unstable #72631
|
||||
// let (lower_bound, _) = self.size_hint();
|
||||
// if lower_bound > 0 {
|
||||
// $($FromT.extend_reserve(lower_bound);)*
|
||||
// }
|
||||
|
||||
self.fold((), |(), ($($T,)*)| {
|
||||
// Still unstable #72631
|
||||
// $( $FromT.extend_one($T); )*
|
||||
$( $FromT.extend(std::iter::once($T)); )*
|
||||
});
|
||||
res
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
impl_unzip_iter!();
|
||||
impl_unzip_iter!(A => FromA);
|
||||
impl_unzip_iter!(A => FromA, B => FromB);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF, G => FromG);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF, G => FromG, H => FromH);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF, G => FromG, H => FromH, I => FromI);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF, G => FromG, H => FromH, I => FromI, J => FromJ);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF, G => FromG, H => FromH, I => FromI, J => FromJ, K => FromK);
|
||||
impl_unzip_iter!(A => FromA, B => FromB, C => FromC, D => FromD, E => FromE, F => FromF, G => FromG, H => FromH, I => FromI, J => FromJ, K => FromK, L => FromL);
|
||||
100
zeroidc/vendor/itertools/src/with_position.rs
vendored
Normal file
100
zeroidc/vendor/itertools/src/with_position.rs
vendored
Normal file
@@ -0,0 +1,100 @@
|
||||
use std::iter::{Fuse,Peekable, FusedIterator};
|
||||
|
||||
/// An iterator adaptor that wraps each element in an [`Position`].
|
||||
///
|
||||
/// Iterator element type is `Position<I::Item>`.
|
||||
///
|
||||
/// See [`.with_position()`](crate::Itertools::with_position) for more information.
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct WithPosition<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
handled_first: bool,
|
||||
peekable: Peekable<Fuse<I>>,
|
||||
}
|
||||
|
||||
impl<I> Clone for WithPosition<I>
|
||||
where I: Clone + Iterator,
|
||||
I::Item: Clone,
|
||||
{
|
||||
clone_fields!(handled_first, peekable);
|
||||
}
|
||||
|
||||
/// Create a new `WithPosition` iterator.
|
||||
pub fn with_position<I>(iter: I) -> WithPosition<I>
|
||||
where I: Iterator,
|
||||
{
|
||||
WithPosition {
|
||||
handled_first: false,
|
||||
peekable: iter.fuse().peekable(),
|
||||
}
|
||||
}
|
||||
|
||||
/// A value yielded by `WithPosition`.
|
||||
/// Indicates the position of this element in the iterator results.
|
||||
///
|
||||
/// See [`.with_position()`](crate::Itertools::with_position) for more information.
|
||||
#[derive(Copy, Clone, Debug, PartialEq)]
|
||||
pub enum Position<T> {
|
||||
/// This is the first element.
|
||||
First(T),
|
||||
/// This is neither the first nor the last element.
|
||||
Middle(T),
|
||||
/// This is the last element.
|
||||
Last(T),
|
||||
/// This is the only element.
|
||||
Only(T),
|
||||
}
|
||||
|
||||
impl<T> Position<T> {
|
||||
/// Return the inner value.
|
||||
pub fn into_inner(self) -> T {
|
||||
match self {
|
||||
Position::First(x) |
|
||||
Position::Middle(x) |
|
||||
Position::Last(x) |
|
||||
Position::Only(x) => x,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<I: Iterator> Iterator for WithPosition<I> {
|
||||
type Item = Position<I::Item>;
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match self.peekable.next() {
|
||||
Some(item) => {
|
||||
if !self.handled_first {
|
||||
// Haven't seen the first item yet, and there is one to give.
|
||||
self.handled_first = true;
|
||||
// Peek to see if this is also the last item,
|
||||
// in which case tag it as `Only`.
|
||||
match self.peekable.peek() {
|
||||
Some(_) => Some(Position::First(item)),
|
||||
None => Some(Position::Only(item)),
|
||||
}
|
||||
} else {
|
||||
// Have seen the first item, and there's something left.
|
||||
// Peek to see if this is the last item.
|
||||
match self.peekable.peek() {
|
||||
Some(_) => Some(Position::Middle(item)),
|
||||
None => Some(Position::Last(item)),
|
||||
}
|
||||
}
|
||||
}
|
||||
// Iterator is finished.
|
||||
None => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
self.peekable.size_hint()
|
||||
}
|
||||
}
|
||||
|
||||
impl<I> ExactSizeIterator for WithPosition<I>
|
||||
where I: ExactSizeIterator,
|
||||
{ }
|
||||
|
||||
impl<I: Iterator> FusedIterator for WithPosition<I>
|
||||
{}
|
||||
60
zeroidc/vendor/itertools/src/zip_eq_impl.rs
vendored
Normal file
60
zeroidc/vendor/itertools/src/zip_eq_impl.rs
vendored
Normal file
@@ -0,0 +1,60 @@
|
||||
use super::size_hint;
|
||||
|
||||
/// An iterator which iterates two other iterators simultaneously
|
||||
///
|
||||
/// See [`.zip_eq()`](crate::Itertools::zip_eq) for more information.
|
||||
#[derive(Clone, Debug)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct ZipEq<I, J> {
|
||||
a: I,
|
||||
b: J,
|
||||
}
|
||||
|
||||
/// Iterate `i` and `j` in lock step.
|
||||
///
|
||||
/// **Panics** if the iterators are not of the same length.
|
||||
///
|
||||
/// [`IntoIterator`] enabled version of [`Itertools::zip_eq`](crate::Itertools::zip_eq).
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::zip_eq;
|
||||
///
|
||||
/// let data = [1, 2, 3, 4, 5];
|
||||
/// for (a, b) in zip_eq(&data[..data.len() - 1], &data[1..]) {
|
||||
/// /* loop body */
|
||||
/// }
|
||||
/// ```
|
||||
pub fn zip_eq<I, J>(i: I, j: J) -> ZipEq<I::IntoIter, J::IntoIter>
|
||||
where I: IntoIterator,
|
||||
J: IntoIterator
|
||||
{
|
||||
ZipEq {
|
||||
a: i.into_iter(),
|
||||
b: j.into_iter(),
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, J> Iterator for ZipEq<I, J>
|
||||
where I: Iterator,
|
||||
J: Iterator
|
||||
{
|
||||
type Item = (I::Item, J::Item);
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match (self.a.next(), self.b.next()) {
|
||||
(None, None) => None,
|
||||
(Some(a), Some(b)) => Some((a, b)),
|
||||
(None, Some(_)) | (Some(_), None) =>
|
||||
panic!("itertools: .zip_eq() reached end of one iterator before the other")
|
||||
}
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::min(self.a.size_hint(), self.b.size_hint())
|
||||
}
|
||||
}
|
||||
|
||||
impl<I, J> ExactSizeIterator for ZipEq<I, J>
|
||||
where I: ExactSizeIterator,
|
||||
J: ExactSizeIterator
|
||||
{}
|
||||
83
zeroidc/vendor/itertools/src/zip_longest.rs
vendored
Normal file
83
zeroidc/vendor/itertools/src/zip_longest.rs
vendored
Normal file
@@ -0,0 +1,83 @@
|
||||
use std::cmp::Ordering::{Equal, Greater, Less};
|
||||
use super::size_hint;
|
||||
use std::iter::{Fuse, FusedIterator};
|
||||
|
||||
use crate::either_or_both::EitherOrBoth;
|
||||
|
||||
// ZipLongest originally written by SimonSapin,
|
||||
// and dedicated to itertools https://github.com/rust-lang/rust/pull/19283
|
||||
|
||||
/// An iterator which iterates two other iterators simultaneously
|
||||
///
|
||||
/// This iterator is *fused*.
|
||||
///
|
||||
/// See [`.zip_longest()`](crate::Itertools::zip_longest) for more information.
|
||||
#[derive(Clone, Debug)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct ZipLongest<T, U> {
|
||||
a: Fuse<T>,
|
||||
b: Fuse<U>,
|
||||
}
|
||||
|
||||
/// Create a new `ZipLongest` iterator.
|
||||
pub fn zip_longest<T, U>(a: T, b: U) -> ZipLongest<T, U>
|
||||
where T: Iterator,
|
||||
U: Iterator
|
||||
{
|
||||
ZipLongest {
|
||||
a: a.fuse(),
|
||||
b: b.fuse(),
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> Iterator for ZipLongest<T, U>
|
||||
where T: Iterator,
|
||||
U: Iterator
|
||||
{
|
||||
type Item = EitherOrBoth<T::Item, U::Item>;
|
||||
|
||||
#[inline]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
match (self.a.next(), self.b.next()) {
|
||||
(None, None) => None,
|
||||
(Some(a), None) => Some(EitherOrBoth::Left(a)),
|
||||
(None, Some(b)) => Some(EitherOrBoth::Right(b)),
|
||||
(Some(a), Some(b)) => Some(EitherOrBoth::Both(a, b)),
|
||||
}
|
||||
}
|
||||
|
||||
#[inline]
|
||||
fn size_hint(&self) -> (usize, Option<usize>) {
|
||||
size_hint::max(self.a.size_hint(), self.b.size_hint())
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> DoubleEndedIterator for ZipLongest<T, U>
|
||||
where T: DoubleEndedIterator + ExactSizeIterator,
|
||||
U: DoubleEndedIterator + ExactSizeIterator
|
||||
{
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
match self.a.len().cmp(&self.b.len()) {
|
||||
Equal => match (self.a.next_back(), self.b.next_back()) {
|
||||
(None, None) => None,
|
||||
(Some(a), Some(b)) => Some(EitherOrBoth::Both(a, b)),
|
||||
// These can only happen if .len() is inconsistent with .next_back()
|
||||
(Some(a), None) => Some(EitherOrBoth::Left(a)),
|
||||
(None, Some(b)) => Some(EitherOrBoth::Right(b)),
|
||||
},
|
||||
Greater => self.a.next_back().map(EitherOrBoth::Left),
|
||||
Less => self.b.next_back().map(EitherOrBoth::Right),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl<T, U> ExactSizeIterator for ZipLongest<T, U>
|
||||
where T: ExactSizeIterator,
|
||||
U: ExactSizeIterator
|
||||
{}
|
||||
|
||||
impl<T, U> FusedIterator for ZipLongest<T, U>
|
||||
where T: Iterator,
|
||||
U: Iterator
|
||||
{}
|
||||
137
zeroidc/vendor/itertools/src/ziptuple.rs
vendored
Normal file
137
zeroidc/vendor/itertools/src/ziptuple.rs
vendored
Normal file
@@ -0,0 +1,137 @@
|
||||
use super::size_hint;
|
||||
|
||||
/// See [`multizip`] for more information.
|
||||
#[derive(Clone, Debug)]
|
||||
#[must_use = "iterator adaptors are lazy and do nothing unless consumed"]
|
||||
pub struct Zip<T> {
|
||||
t: T,
|
||||
}
|
||||
|
||||
/// An iterator that generalizes *.zip()* and allows running multiple iterators in lockstep.
|
||||
///
|
||||
/// The iterator `Zip<(I, J, ..., M)>` is formed from a tuple of iterators (or values that
|
||||
/// implement [`IntoIterator`]) and yields elements
|
||||
/// until any of the subiterators yields `None`.
|
||||
///
|
||||
/// The iterator element type is a tuple like like `(A, B, ..., E)` where `A` to `E` are the
|
||||
/// element types of the subiterator.
|
||||
///
|
||||
/// **Note:** The result of this macro is a value of a named type (`Zip<(I, J,
|
||||
/// ..)>` of each component iterator `I, J, ...`) if each component iterator is
|
||||
/// nameable.
|
||||
///
|
||||
/// Prefer [`izip!()`] over `multizip` for the performance benefits of using the
|
||||
/// standard library `.zip()`. Prefer `multizip` if a nameable type is needed.
|
||||
///
|
||||
/// ```
|
||||
/// use itertools::multizip;
|
||||
///
|
||||
/// // iterate over three sequences side-by-side
|
||||
/// let mut results = [0, 0, 0, 0];
|
||||
/// let inputs = [3, 7, 9, 6];
|
||||
///
|
||||
/// for (r, index, input) in multizip((&mut results, 0..10, &inputs)) {
|
||||
/// *r = index * 10 + input;
|
||||
/// }
|
||||
///
|
||||
/// assert_eq!(results, [0 + 3, 10 + 7, 29, 36]);
|
||||
/// ```
|
||||
pub fn multizip<T, U>(t: U) -> Zip<T>
|
||||
where Zip<T>: From<U>,
|
||||
Zip<T>: Iterator,
|
||||
{
|
||||
Zip::from(t)
|
||||
}
|
||||
|
||||
macro_rules! impl_zip_iter {
|
||||
($($B:ident),*) => (
|
||||
#[allow(non_snake_case)]
|
||||
impl<$($B: IntoIterator),*> From<($($B,)*)> for Zip<($($B::IntoIter,)*)> {
|
||||
fn from(t: ($($B,)*)) -> Self {
|
||||
let ($($B,)*) = t;
|
||||
Zip { t: ($($B.into_iter(),)*) }
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
#[allow(unused_assignments)]
|
||||
impl<$($B),*> Iterator for Zip<($($B,)*)>
|
||||
where
|
||||
$(
|
||||
$B: Iterator,
|
||||
)*
|
||||
{
|
||||
type Item = ($($B::Item,)*);
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item>
|
||||
{
|
||||
let ($(ref mut $B,)*) = self.t;
|
||||
|
||||
// NOTE: Just like iter::Zip, we check the iterators
|
||||
// for None in order. We may finish unevenly (some
|
||||
// iterators gave n + 1 elements, some only n).
|
||||
$(
|
||||
let $B = match $B.next() {
|
||||
None => return None,
|
||||
Some(elt) => elt
|
||||
};
|
||||
)*
|
||||
Some(($($B,)*))
|
||||
}
|
||||
|
||||
fn size_hint(&self) -> (usize, Option<usize>)
|
||||
{
|
||||
let sh = (::std::usize::MAX, None);
|
||||
let ($(ref $B,)*) = self.t;
|
||||
$(
|
||||
let sh = size_hint::min($B.size_hint(), sh);
|
||||
)*
|
||||
sh
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
impl<$($B),*> ExactSizeIterator for Zip<($($B,)*)> where
|
||||
$(
|
||||
$B: ExactSizeIterator,
|
||||
)*
|
||||
{ }
|
||||
|
||||
#[allow(non_snake_case)]
|
||||
impl<$($B),*> DoubleEndedIterator for Zip<($($B,)*)> where
|
||||
$(
|
||||
$B: DoubleEndedIterator + ExactSizeIterator,
|
||||
)*
|
||||
{
|
||||
#[inline]
|
||||
fn next_back(&mut self) -> Option<Self::Item> {
|
||||
let ($(ref mut $B,)*) = self.t;
|
||||
let size = *[$( $B.len(), )*].iter().min().unwrap();
|
||||
|
||||
$(
|
||||
if $B.len() != size {
|
||||
for _ in 0..$B.len() - size { $B.next_back(); }
|
||||
}
|
||||
)*
|
||||
|
||||
match ($($B.next_back(),)*) {
|
||||
($(Some($B),)*) => Some(($($B,)*)),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
impl_zip_iter!(A);
|
||||
impl_zip_iter!(A, B);
|
||||
impl_zip_iter!(A, B, C);
|
||||
impl_zip_iter!(A, B, C, D);
|
||||
impl_zip_iter!(A, B, C, D, E);
|
||||
impl_zip_iter!(A, B, C, D, E, F);
|
||||
impl_zip_iter!(A, B, C, D, E, F, G);
|
||||
impl_zip_iter!(A, B, C, D, E, F, G, H);
|
||||
impl_zip_iter!(A, B, C, D, E, F, G, H, I);
|
||||
impl_zip_iter!(A, B, C, D, E, F, G, H, I, J);
|
||||
impl_zip_iter!(A, B, C, D, E, F, G, H, I, J, K);
|
||||
impl_zip_iter!(A, B, C, D, E, F, G, H, I, J, K, L);
|
||||
47
zeroidc/vendor/itertools/tests/adaptors_no_collect.rs
vendored
Normal file
47
zeroidc/vendor/itertools/tests/adaptors_no_collect.rs
vendored
Normal file
@@ -0,0 +1,47 @@
|
||||
use itertools::Itertools;
|
||||
|
||||
struct PanickingCounter {
|
||||
curr: usize,
|
||||
max: usize,
|
||||
}
|
||||
|
||||
impl Iterator for PanickingCounter {
|
||||
type Item = ();
|
||||
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.curr += 1;
|
||||
|
||||
if self.curr == self.max {
|
||||
panic!(
|
||||
"Input iterator reached maximum of {} suggesting collection by adaptor",
|
||||
self.max
|
||||
);
|
||||
}
|
||||
|
||||
Some(())
|
||||
}
|
||||
}
|
||||
|
||||
fn no_collect_test<A, T>(to_adaptor: T)
|
||||
where A: Iterator, T: Fn(PanickingCounter) -> A
|
||||
{
|
||||
let counter = PanickingCounter { curr: 0, max: 10_000 };
|
||||
let adaptor = to_adaptor(counter);
|
||||
|
||||
for _ in adaptor.take(5) {}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn permutations_no_collect() {
|
||||
no_collect_test(|iter| iter.permutations(5))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combinations_no_collect() {
|
||||
no_collect_test(|iter| iter.combinations(5))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn combinations_with_replacement_no_collect() {
|
||||
no_collect_test(|iter| iter.combinations_with_replacement(5))
|
||||
}
|
||||
76
zeroidc/vendor/itertools/tests/flatten_ok.rs
vendored
Normal file
76
zeroidc/vendor/itertools/tests/flatten_ok.rs
vendored
Normal file
@@ -0,0 +1,76 @@
|
||||
use itertools::{assert_equal, Itertools};
|
||||
use std::{ops::Range, vec::IntoIter};
|
||||
|
||||
fn mix_data() -> IntoIter<Result<Range<i32>, bool>> {
|
||||
vec![Ok(0..2), Err(false), Ok(2..4), Err(true), Ok(4..6)].into_iter()
|
||||
}
|
||||
|
||||
fn ok_data() -> IntoIter<Result<Range<i32>, bool>> {
|
||||
vec![Ok(0..2), Ok(2..4), Ok(4..6)].into_iter()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flatten_ok_mixed_expected_forward() {
|
||||
assert_equal(
|
||||
mix_data().flatten_ok(),
|
||||
vec![
|
||||
Ok(0),
|
||||
Ok(1),
|
||||
Err(false),
|
||||
Ok(2),
|
||||
Ok(3),
|
||||
Err(true),
|
||||
Ok(4),
|
||||
Ok(5),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flatten_ok_mixed_expected_reverse() {
|
||||
assert_equal(
|
||||
mix_data().flatten_ok().rev(),
|
||||
vec![
|
||||
Ok(5),
|
||||
Ok(4),
|
||||
Err(true),
|
||||
Ok(3),
|
||||
Ok(2),
|
||||
Err(false),
|
||||
Ok(1),
|
||||
Ok(0),
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flatten_ok_collect_mixed_forward() {
|
||||
assert_eq!(
|
||||
mix_data().flatten_ok().collect::<Result<Vec<_>, _>>(),
|
||||
Err(false)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flatten_ok_collect_mixed_reverse() {
|
||||
assert_eq!(
|
||||
mix_data().flatten_ok().rev().collect::<Result<Vec<_>, _>>(),
|
||||
Err(true)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flatten_ok_collect_ok_forward() {
|
||||
assert_eq!(
|
||||
ok_data().flatten_ok().collect::<Result<Vec<_>, _>>(),
|
||||
Ok((0..6).collect())
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flatten_ok_collect_ok_reverse() {
|
||||
assert_eq!(
|
||||
ok_data().flatten_ok().rev().collect::<Result<Vec<_>, _>>(),
|
||||
Ok((0..6).rev().collect())
|
||||
);
|
||||
}
|
||||
13
zeroidc/vendor/itertools/tests/macros_hygiene.rs
vendored
Normal file
13
zeroidc/vendor/itertools/tests/macros_hygiene.rs
vendored
Normal file
@@ -0,0 +1,13 @@
|
||||
#[test]
|
||||
fn iproduct_hygiene() {
|
||||
let _ = itertools::iproduct!(0..6);
|
||||
let _ = itertools::iproduct!(0..6, 0..9);
|
||||
let _ = itertools::iproduct!(0..6, 0..9, 0..12);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn izip_hygiene() {
|
||||
let _ = itertools::izip!(0..6);
|
||||
let _ = itertools::izip!(0..6, 0..9);
|
||||
let _ = itertools::izip!(0..6, 0..9, 0..12);
|
||||
}
|
||||
108
zeroidc/vendor/itertools/tests/merge_join.rs
vendored
Normal file
108
zeroidc/vendor/itertools/tests/merge_join.rs
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
use itertools::EitherOrBoth;
|
||||
use itertools::free::merge_join_by;
|
||||
|
||||
#[test]
|
||||
fn empty() {
|
||||
let left: Vec<u32> = vec![];
|
||||
let right: Vec<u32> = vec![];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn left_only() {
|
||||
let left: Vec<u32> = vec![1,2,3];
|
||||
let right: Vec<u32> = vec![];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![
|
||||
EitherOrBoth::Left(1),
|
||||
EitherOrBoth::Left(2),
|
||||
EitherOrBoth::Left(3)
|
||||
];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn right_only() {
|
||||
let left: Vec<u32> = vec![];
|
||||
let right: Vec<u32> = vec![1,2,3];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![
|
||||
EitherOrBoth::Right(1),
|
||||
EitherOrBoth::Right(2),
|
||||
EitherOrBoth::Right(3)
|
||||
];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_left_then_right() {
|
||||
let left: Vec<u32> = vec![1,2,3];
|
||||
let right: Vec<u32> = vec![4,5,6];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![
|
||||
EitherOrBoth::Left(1),
|
||||
EitherOrBoth::Left(2),
|
||||
EitherOrBoth::Left(3),
|
||||
EitherOrBoth::Right(4),
|
||||
EitherOrBoth::Right(5),
|
||||
EitherOrBoth::Right(6)
|
||||
];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn first_right_then_left() {
|
||||
let left: Vec<u32> = vec![4,5,6];
|
||||
let right: Vec<u32> = vec![1,2,3];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![
|
||||
EitherOrBoth::Right(1),
|
||||
EitherOrBoth::Right(2),
|
||||
EitherOrBoth::Right(3),
|
||||
EitherOrBoth::Left(4),
|
||||
EitherOrBoth::Left(5),
|
||||
EitherOrBoth::Left(6)
|
||||
];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn interspersed_left_and_right() {
|
||||
let left: Vec<u32> = vec![1,3,5];
|
||||
let right: Vec<u32> = vec![2,4,6];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![
|
||||
EitherOrBoth::Left(1),
|
||||
EitherOrBoth::Right(2),
|
||||
EitherOrBoth::Left(3),
|
||||
EitherOrBoth::Right(4),
|
||||
EitherOrBoth::Left(5),
|
||||
EitherOrBoth::Right(6)
|
||||
];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn overlapping_left_and_right() {
|
||||
let left: Vec<u32> = vec![1,3,4,6];
|
||||
let right: Vec<u32> = vec![2,3,4,5];
|
||||
let expected_result: Vec<EitherOrBoth<u32, u32>> = vec![
|
||||
EitherOrBoth::Left(1),
|
||||
EitherOrBoth::Right(2),
|
||||
EitherOrBoth::Both(3, 3),
|
||||
EitherOrBoth::Both(4, 4),
|
||||
EitherOrBoth::Right(5),
|
||||
EitherOrBoth::Left(6)
|
||||
];
|
||||
let actual_result = merge_join_by(left, right, |l, r| l.cmp(r))
|
||||
.collect::<Vec<_>>();
|
||||
assert_eq!(expected_result, actual_result);
|
||||
}
|
||||
50
zeroidc/vendor/itertools/tests/peeking_take_while.rs
vendored
Normal file
50
zeroidc/vendor/itertools/tests/peeking_take_while.rs
vendored
Normal file
@@ -0,0 +1,50 @@
|
||||
use itertools::Itertools;
|
||||
use itertools::{put_back, put_back_n};
|
||||
|
||||
#[test]
|
||||
fn peeking_take_while_peekable() {
|
||||
let mut r = (0..10).peekable();
|
||||
r.peeking_take_while(|x| *x <= 3).count();
|
||||
assert_eq!(r.next(), Some(4));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peeking_take_while_put_back() {
|
||||
let mut r = put_back(0..10);
|
||||
r.peeking_take_while(|x| *x <= 3).count();
|
||||
assert_eq!(r.next(), Some(4));
|
||||
r.peeking_take_while(|_| true).count();
|
||||
assert_eq!(r.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peeking_take_while_put_back_n() {
|
||||
let mut r = put_back_n(6..10);
|
||||
for elt in (0..6).rev() {
|
||||
r.put_back(elt);
|
||||
}
|
||||
r.peeking_take_while(|x| *x <= 3).count();
|
||||
assert_eq!(r.next(), Some(4));
|
||||
r.peeking_take_while(|_| true).count();
|
||||
assert_eq!(r.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peeking_take_while_slice_iter() {
|
||||
let v = [1, 2, 3, 4, 5, 6];
|
||||
let mut r = v.iter();
|
||||
r.peeking_take_while(|x| **x <= 3).count();
|
||||
assert_eq!(r.next(), Some(&4));
|
||||
r.peeking_take_while(|_| true).count();
|
||||
assert_eq!(r.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn peeking_take_while_slice_iter_rev() {
|
||||
let v = [1, 2, 3, 4, 5, 6];
|
||||
let mut r = v.iter().rev();
|
||||
r.peeking_take_while(|x| **x >= 3).count();
|
||||
assert_eq!(r.next(), Some(&2));
|
||||
r.peeking_take_while(|_| true).count();
|
||||
assert_eq!(r.next(), None);
|
||||
}
|
||||
1695
zeroidc/vendor/itertools/tests/quick.rs
vendored
Normal file
1695
zeroidc/vendor/itertools/tests/quick.rs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
153
zeroidc/vendor/itertools/tests/specializations.rs
vendored
Normal file
153
zeroidc/vendor/itertools/tests/specializations.rs
vendored
Normal file
@@ -0,0 +1,153 @@
|
||||
use itertools::Itertools;
|
||||
use std::fmt::Debug;
|
||||
use quickcheck::quickcheck;
|
||||
|
||||
struct Unspecialized<I>(I);
|
||||
impl<I> Iterator for Unspecialized<I>
|
||||
where
|
||||
I: Iterator,
|
||||
{
|
||||
type Item = I::Item;
|
||||
|
||||
#[inline(always)]
|
||||
fn next(&mut self) -> Option<Self::Item> {
|
||||
self.0.next()
|
||||
}
|
||||
}
|
||||
|
||||
macro_rules! check_specialized {
|
||||
($src:expr, |$it:pat| $closure:expr) => {
|
||||
let $it = $src.clone();
|
||||
let v1 = $closure;
|
||||
|
||||
let $it = Unspecialized($src.clone());
|
||||
let v2 = $closure;
|
||||
|
||||
assert_eq!(v1, v2);
|
||||
}
|
||||
}
|
||||
|
||||
fn test_specializations<IterItem, Iter>(
|
||||
it: &Iter,
|
||||
) where
|
||||
IterItem: Eq + Debug + Clone,
|
||||
Iter: Iterator<Item = IterItem> + Clone,
|
||||
{
|
||||
check_specialized!(it, |i| i.count());
|
||||
check_specialized!(it, |i| i.last());
|
||||
check_specialized!(it, |i| i.collect::<Vec<_>>());
|
||||
check_specialized!(it, |i| {
|
||||
let mut parameters_from_fold = vec![];
|
||||
let fold_result = i.fold(vec![], |mut acc, v: IterItem| {
|
||||
parameters_from_fold.push((acc.clone(), v.clone()));
|
||||
acc.push(v);
|
||||
acc
|
||||
});
|
||||
(parameters_from_fold, fold_result)
|
||||
});
|
||||
check_specialized!(it, |mut i| {
|
||||
let mut parameters_from_all = vec![];
|
||||
let first = i.next();
|
||||
let all_result = i.all(|x| {
|
||||
parameters_from_all.push(x.clone());
|
||||
Some(x)==first
|
||||
});
|
||||
(parameters_from_all, all_result)
|
||||
});
|
||||
let size = it.clone().count();
|
||||
for n in 0..size + 2 {
|
||||
check_specialized!(it, |mut i| i.nth(n));
|
||||
}
|
||||
// size_hint is a bit harder to check
|
||||
let mut it_sh = it.clone();
|
||||
for n in 0..size + 2 {
|
||||
let len = it_sh.clone().count();
|
||||
let (min, max) = it_sh.size_hint();
|
||||
assert_eq!(size - n.min(size), len);
|
||||
assert!(min <= len);
|
||||
if let Some(max) = max {
|
||||
assert!(len <= max);
|
||||
}
|
||||
it_sh.next();
|
||||
}
|
||||
}
|
||||
|
||||
quickcheck! {
|
||||
fn intersperse(v: Vec<u8>) -> () {
|
||||
test_specializations(&v.into_iter().intersperse(0));
|
||||
}
|
||||
}
|
||||
|
||||
quickcheck! {
|
||||
fn put_back_qc(test_vec: Vec<i32>) -> () {
|
||||
test_specializations(&itertools::put_back(test_vec.iter()));
|
||||
let mut pb = itertools::put_back(test_vec.into_iter());
|
||||
pb.put_back(1);
|
||||
test_specializations(&pb);
|
||||
}
|
||||
}
|
||||
|
||||
quickcheck! {
|
||||
fn merge_join_by_qc(i1: Vec<usize>, i2: Vec<usize>) -> () {
|
||||
test_specializations(&i1.into_iter().merge_join_by(i2.into_iter(), std::cmp::Ord::cmp));
|
||||
}
|
||||
}
|
||||
|
||||
quickcheck! {
|
||||
fn map_into(v: Vec<u8>) -> () {
|
||||
test_specializations(&v.into_iter().map_into::<u32>());
|
||||
}
|
||||
}
|
||||
|
||||
quickcheck! {
|
||||
fn map_ok(v: Vec<Result<u8, char>>) -> () {
|
||||
test_specializations(&v.into_iter().map_ok(|u| u.checked_add(1)));
|
||||
}
|
||||
}
|
||||
|
||||
quickcheck! {
|
||||
fn process_results(v: Vec<Result<u8, u8>>) -> () {
|
||||
helper(v.iter().copied());
|
||||
helper(v.iter().copied().filter(Result::is_ok));
|
||||
|
||||
fn helper(it: impl Iterator<Item = Result<u8, u8>> + Clone) {
|
||||
macro_rules! check_results_specialized {
|
||||
($src:expr, |$it:pat| $closure:expr) => {
|
||||
assert_eq!(
|
||||
itertools::process_results($src.clone(), |$it| $closure),
|
||||
itertools::process_results($src.clone(), |i| {
|
||||
let $it = Unspecialized(i);
|
||||
$closure
|
||||
}),
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
check_results_specialized!(it, |i| i.count());
|
||||
check_results_specialized!(it, |i| i.last());
|
||||
check_results_specialized!(it, |i| i.collect::<Vec<_>>());
|
||||
check_results_specialized!(it, |i| {
|
||||
let mut parameters_from_fold = vec![];
|
||||
let fold_result = i.fold(vec![], |mut acc, v| {
|
||||
parameters_from_fold.push((acc.clone(), v.clone()));
|
||||
acc.push(v);
|
||||
acc
|
||||
});
|
||||
(parameters_from_fold, fold_result)
|
||||
});
|
||||
check_results_specialized!(it, |mut i| {
|
||||
let mut parameters_from_all = vec![];
|
||||
let first = i.next();
|
||||
let all_result = i.all(|x| {
|
||||
parameters_from_all.push(x.clone());
|
||||
Some(x)==first
|
||||
});
|
||||
(parameters_from_all, all_result)
|
||||
});
|
||||
let size = it.clone().count();
|
||||
for n in 0..size + 2 {
|
||||
check_results_specialized!(it, |mut i| i.nth(n));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
322
zeroidc/vendor/itertools/tests/test_core.rs
vendored
Normal file
322
zeroidc/vendor/itertools/tests/test_core.rs
vendored
Normal file
@@ -0,0 +1,322 @@
|
||||
//! Licensed under the Apache License, Version 2.0
|
||||
//! https://www.apache.org/licenses/LICENSE-2.0 or the MIT license
|
||||
//! https://opensource.org/licenses/MIT, at your
|
||||
//! option. This file may not be copied, modified, or distributed
|
||||
//! except according to those terms.
|
||||
#![no_std]
|
||||
|
||||
use core::iter;
|
||||
use itertools as it;
|
||||
use crate::it::Itertools;
|
||||
use crate::it::interleave;
|
||||
use crate::it::intersperse;
|
||||
use crate::it::intersperse_with;
|
||||
use crate::it::multizip;
|
||||
use crate::it::free::put_back;
|
||||
use crate::it::iproduct;
|
||||
use crate::it::izip;
|
||||
use crate::it::chain;
|
||||
|
||||
#[test]
|
||||
fn product2() {
|
||||
let s = "αβ";
|
||||
|
||||
let mut prod = iproduct!(s.chars(), 0..2);
|
||||
assert!(prod.next() == Some(('α', 0)));
|
||||
assert!(prod.next() == Some(('α', 1)));
|
||||
assert!(prod.next() == Some(('β', 0)));
|
||||
assert!(prod.next() == Some(('β', 1)));
|
||||
assert!(prod.next() == None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn product_temporary() {
|
||||
for (_x, _y, _z) in iproduct!(
|
||||
[0, 1, 2].iter().cloned(),
|
||||
[0, 1, 2].iter().cloned(),
|
||||
[0, 1, 2].iter().cloned())
|
||||
{
|
||||
// ok
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn izip_macro() {
|
||||
let mut zip = izip!(2..3);
|
||||
assert!(zip.next() == Some(2));
|
||||
assert!(zip.next().is_none());
|
||||
|
||||
let mut zip = izip!(0..3, 0..2, 0..2i8);
|
||||
for i in 0..2 {
|
||||
assert!((i as usize, i, i as i8) == zip.next().unwrap());
|
||||
}
|
||||
assert!(zip.next().is_none());
|
||||
|
||||
let xs: [isize; 0] = [];
|
||||
let mut zip = izip!(0..3, 0..2, 0..2i8, &xs);
|
||||
assert!(zip.next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn izip2() {
|
||||
let _zip1: iter::Zip<_, _> = izip!(1.., 2..);
|
||||
let _zip2: iter::Zip<_, _> = izip!(1.., 2.., );
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn izip3() {
|
||||
let mut zip: iter::Map<iter::Zip<_, _>, _> = izip!(0..3, 0..2, 0..2i8);
|
||||
for i in 0..2 {
|
||||
assert!((i as usize, i, i as i8) == zip.next().unwrap());
|
||||
}
|
||||
assert!(zip.next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multizip3() {
|
||||
let mut zip = multizip((0..3, 0..2, 0..2i8));
|
||||
for i in 0..2 {
|
||||
assert!((i as usize, i, i as i8) == zip.next().unwrap());
|
||||
}
|
||||
assert!(zip.next().is_none());
|
||||
|
||||
let xs: [isize; 0] = [];
|
||||
let mut zip = multizip((0..3, 0..2, 0..2i8, xs.iter()));
|
||||
assert!(zip.next().is_none());
|
||||
|
||||
for (_, _, _, _, _) in multizip((0..3, 0..2, xs.iter(), &xs, xs.to_vec())) {
|
||||
/* test compiles */
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain_macro() {
|
||||
let mut chain = chain!(2..3);
|
||||
assert!(chain.next() == Some(2));
|
||||
assert!(chain.next().is_none());
|
||||
|
||||
let mut chain = chain!(0..2, 2..3, 3..5i8);
|
||||
for i in 0..5i8 {
|
||||
assert_eq!(Some(i), chain.next());
|
||||
}
|
||||
assert!(chain.next().is_none());
|
||||
|
||||
let mut chain = chain!();
|
||||
assert_eq!(chain.next(), Option::<()>::None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn chain2() {
|
||||
let _ = chain!(1.., 2..);
|
||||
let _ = chain!(1.., 2.., );
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn write_to() {
|
||||
let xs = [7, 9, 8];
|
||||
let mut ys = [0; 5];
|
||||
let cnt = ys.iter_mut().set_from(xs.iter().map(|x| *x));
|
||||
assert!(cnt == xs.len());
|
||||
assert!(ys == [7, 9, 8, 0, 0]);
|
||||
|
||||
let cnt = ys.iter_mut().set_from(0..10);
|
||||
assert!(cnt == ys.len());
|
||||
assert!(ys == [0, 1, 2, 3, 4]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_interleave() {
|
||||
let xs: [u8; 0] = [];
|
||||
let ys = [7u8, 9, 8, 10];
|
||||
let zs = [2u8, 77];
|
||||
let it = interleave(xs.iter(), ys.iter());
|
||||
it::assert_equal(it, ys.iter());
|
||||
|
||||
let rs = [7u8, 2, 9, 77, 8, 10];
|
||||
let it = interleave(ys.iter(), zs.iter());
|
||||
it::assert_equal(it, rs.iter());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_intersperse() {
|
||||
let xs = [1u8, 2, 3];
|
||||
let ys = [1u8, 0, 2, 0, 3];
|
||||
let it = intersperse(&xs, &0);
|
||||
it::assert_equal(it, ys.iter());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_intersperse_with() {
|
||||
let xs = [1u8, 2, 3];
|
||||
let ys = [1u8, 10, 2, 10, 3];
|
||||
let i = 10;
|
||||
let it = intersperse_with(&xs, || &i);
|
||||
it::assert_equal(it, ys.iter());
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
#[test]
|
||||
fn foreach() {
|
||||
let xs = [1i32, 2, 3];
|
||||
let mut sum = 0;
|
||||
xs.iter().foreach(|elt| sum += *elt);
|
||||
assert!(sum == 6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn dropping() {
|
||||
let xs = [1, 2, 3];
|
||||
let mut it = xs.iter().dropping(2);
|
||||
assert_eq!(it.next(), Some(&3));
|
||||
assert!(it.next().is_none());
|
||||
let mut it = xs.iter().dropping(5);
|
||||
assert!(it.next().is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batching() {
|
||||
let xs = [0, 1, 2, 1, 3];
|
||||
let ys = [(0, 1), (2, 1)];
|
||||
|
||||
// An iterator that gathers elements up in pairs
|
||||
let pit = xs.iter().cloned().batching(|it| {
|
||||
match it.next() {
|
||||
None => None,
|
||||
Some(x) => match it.next() {
|
||||
None => None,
|
||||
Some(y) => Some((x, y)),
|
||||
}
|
||||
}
|
||||
});
|
||||
it::assert_equal(pit, ys.iter().cloned());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_put_back() {
|
||||
let xs = [0, 1, 1, 1, 2, 1, 3, 3];
|
||||
let mut pb = put_back(xs.iter().cloned());
|
||||
pb.next();
|
||||
pb.put_back(1);
|
||||
pb.put_back(0);
|
||||
it::assert_equal(pb, xs.iter().cloned());
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
#[test]
|
||||
fn step() {
|
||||
it::assert_equal((0..10).step(1), 0..10);
|
||||
it::assert_equal((0..10).step(2), (0..10).filter(|x: &i32| *x % 2 == 0));
|
||||
it::assert_equal((0..10).step(10), 0..1);
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
#[test]
|
||||
fn merge() {
|
||||
it::assert_equal((0..10).step(2).merge((1..10).step(2)), 0..10);
|
||||
}
|
||||
|
||||
|
||||
#[test]
|
||||
fn repeatn() {
|
||||
let s = "α";
|
||||
let mut it = it::repeat_n(s, 3);
|
||||
assert_eq!(it.len(), 3);
|
||||
assert_eq!(it.next(), Some(s));
|
||||
assert_eq!(it.next(), Some(s));
|
||||
assert_eq!(it.next(), Some(s));
|
||||
assert_eq!(it.next(), None);
|
||||
assert_eq!(it.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn count_clones() {
|
||||
// Check that RepeatN only clones N - 1 times.
|
||||
|
||||
use core::cell::Cell;
|
||||
#[derive(PartialEq, Debug)]
|
||||
struct Foo {
|
||||
n: Cell<usize>
|
||||
}
|
||||
|
||||
impl Clone for Foo
|
||||
{
|
||||
fn clone(&self) -> Self
|
||||
{
|
||||
let n = self.n.get();
|
||||
self.n.set(n + 1);
|
||||
Foo { n: Cell::new(n + 1) }
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
for n in 0..10 {
|
||||
let f = Foo{n: Cell::new(0)};
|
||||
let it = it::repeat_n(f, n);
|
||||
// drain it
|
||||
let last = it.last();
|
||||
if n == 0 {
|
||||
assert_eq!(last, None);
|
||||
} else {
|
||||
assert_eq!(last, Some(Foo{n: Cell::new(n - 1)}));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn part() {
|
||||
let mut data = [7, 1, 1, 9, 1, 1, 3];
|
||||
let i = it::partition(&mut data, |elt| *elt >= 3);
|
||||
assert_eq!(i, 3);
|
||||
assert_eq!(data, [7, 3, 9, 1, 1, 1, 1]);
|
||||
|
||||
let i = it::partition(&mut data, |elt| *elt == 1);
|
||||
assert_eq!(i, 4);
|
||||
assert_eq!(data, [1, 1, 1, 1, 9, 3, 7]);
|
||||
|
||||
let mut data = [1, 2, 3, 4, 5, 6, 7, 8, 9];
|
||||
let i = it::partition(&mut data, |elt| *elt % 3 == 0);
|
||||
assert_eq!(i, 3);
|
||||
assert_eq!(data, [9, 6, 3, 4, 5, 2, 7, 8, 1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tree_fold1() {
|
||||
for i in 0..100 {
|
||||
assert_eq!((0..i).tree_fold1(|x, y| x + y), (0..i).fold1(|x, y| x + y));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn exactly_one() {
|
||||
assert_eq!((0..10).filter(|&x| x == 2).exactly_one().unwrap(), 2);
|
||||
assert!((0..10).filter(|&x| x > 1 && x < 4).exactly_one().unwrap_err().eq(2..4));
|
||||
assert!((0..10).filter(|&x| x > 1 && x < 5).exactly_one().unwrap_err().eq(2..5));
|
||||
assert!((0..10).filter(|&_| false).exactly_one().unwrap_err().eq(0..0));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn at_most_one() {
|
||||
assert_eq!((0..10).filter(|&x| x == 2).at_most_one().unwrap(), Some(2));
|
||||
assert!((0..10).filter(|&x| x > 1 && x < 4).at_most_one().unwrap_err().eq(2..4));
|
||||
assert!((0..10).filter(|&x| x > 1 && x < 5).at_most_one().unwrap_err().eq(2..5));
|
||||
assert_eq!((0..10).filter(|&_| false).at_most_one().unwrap(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sum1() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
assert_eq!(v[..0].iter().cloned().sum1::<i32>(), None);
|
||||
assert_eq!(v[1..2].iter().cloned().sum1::<i32>(), Some(1));
|
||||
assert_eq!(v[1..3].iter().cloned().sum1::<i32>(), Some(3));
|
||||
assert_eq!(v.iter().cloned().sum1::<i32>(), Some(55));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn product1() {
|
||||
let v: &[i32] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
||||
assert_eq!(v[..0].iter().cloned().product1::<i32>(), None);
|
||||
assert_eq!(v[..1].iter().cloned().product1::<i32>(), Some(0));
|
||||
assert_eq!(v[1..3].iter().cloned().product1::<i32>(), Some(2));
|
||||
assert_eq!(v[1..5].iter().cloned().product1::<i32>(), Some(24));
|
||||
}
|
||||
1122
zeroidc/vendor/itertools/tests/test_std.rs
vendored
Normal file
1122
zeroidc/vendor/itertools/tests/test_std.rs
vendored
Normal file
File diff suppressed because it is too large
Load Diff
86
zeroidc/vendor/itertools/tests/tuples.rs
vendored
Normal file
86
zeroidc/vendor/itertools/tests/tuples.rs
vendored
Normal file
@@ -0,0 +1,86 @@
|
||||
use itertools::Itertools;
|
||||
|
||||
#[test]
|
||||
fn tuples() {
|
||||
let v = [1, 2, 3, 4, 5];
|
||||
let mut iter = v.iter().cloned().tuples();
|
||||
assert_eq!(Some((1,)), iter.next());
|
||||
assert_eq!(Some((2,)), iter.next());
|
||||
assert_eq!(Some((3,)), iter.next());
|
||||
assert_eq!(Some((4,)), iter.next());
|
||||
assert_eq!(Some((5,)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
assert_eq!(None, iter.into_buffer().next());
|
||||
|
||||
let mut iter = v.iter().cloned().tuples();
|
||||
assert_eq!(Some((1, 2)), iter.next());
|
||||
assert_eq!(Some((3, 4)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
itertools::assert_equal(vec![5], iter.into_buffer());
|
||||
|
||||
let mut iter = v.iter().cloned().tuples();
|
||||
assert_eq!(Some((1, 2, 3)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
itertools::assert_equal(vec![4, 5], iter.into_buffer());
|
||||
|
||||
let mut iter = v.iter().cloned().tuples();
|
||||
assert_eq!(Some((1, 2, 3, 4)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
itertools::assert_equal(vec![5], iter.into_buffer());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tuple_windows() {
|
||||
let v = [1, 2, 3, 4, 5];
|
||||
|
||||
let mut iter = v.iter().cloned().tuple_windows();
|
||||
assert_eq!(Some((1,)), iter.next());
|
||||
assert_eq!(Some((2,)), iter.next());
|
||||
assert_eq!(Some((3,)), iter.next());
|
||||
|
||||
let mut iter = v.iter().cloned().tuple_windows();
|
||||
assert_eq!(Some((1, 2)), iter.next());
|
||||
assert_eq!(Some((2, 3)), iter.next());
|
||||
assert_eq!(Some((3, 4)), iter.next());
|
||||
assert_eq!(Some((4, 5)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
|
||||
let mut iter = v.iter().cloned().tuple_windows();
|
||||
assert_eq!(Some((1, 2, 3)), iter.next());
|
||||
assert_eq!(Some((2, 3, 4)), iter.next());
|
||||
assert_eq!(Some((3, 4, 5)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
|
||||
let mut iter = v.iter().cloned().tuple_windows();
|
||||
assert_eq!(Some((1, 2, 3, 4)), iter.next());
|
||||
assert_eq!(Some((2, 3, 4, 5)), iter.next());
|
||||
assert_eq!(None, iter.next());
|
||||
|
||||
let v = [1, 2, 3];
|
||||
let mut iter = v.iter().cloned().tuple_windows::<(_, _, _, _)>();
|
||||
assert_eq!(None, iter.next());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn next_tuple() {
|
||||
let v = [1, 2, 3, 4, 5];
|
||||
let mut iter = v.iter();
|
||||
assert_eq!(iter.next_tuple().map(|(&x, &y)| (x, y)), Some((1, 2)));
|
||||
assert_eq!(iter.next_tuple().map(|(&x, &y)| (x, y)), Some((3, 4)));
|
||||
assert_eq!(iter.next_tuple::<(_, _)>(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collect_tuple() {
|
||||
let v = [1, 2];
|
||||
let iter = v.iter().cloned();
|
||||
assert_eq!(iter.collect_tuple(), Some((1, 2)));
|
||||
|
||||
let v = [1];
|
||||
let iter = v.iter().cloned();
|
||||
assert_eq!(iter.collect_tuple::<(_, _)>(), None);
|
||||
|
||||
let v = [1, 2, 3];
|
||||
let iter = v.iter().cloned();
|
||||
assert_eq!(iter.collect_tuple::<(_, _)>(), None);
|
||||
}
|
||||
77
zeroidc/vendor/itertools/tests/zip.rs
vendored
Normal file
77
zeroidc/vendor/itertools/tests/zip.rs
vendored
Normal file
@@ -0,0 +1,77 @@
|
||||
use itertools::Itertools;
|
||||
use itertools::EitherOrBoth::{Both, Left, Right};
|
||||
use itertools::free::zip_eq;
|
||||
use itertools::multizip;
|
||||
|
||||
#[test]
|
||||
fn zip_longest_fused() {
|
||||
let a = [Some(1), None, Some(3), Some(4)];
|
||||
let b = [1, 2, 3];
|
||||
|
||||
let unfused = a.iter().batching(|it| *it.next().unwrap())
|
||||
.zip_longest(b.iter().cloned());
|
||||
itertools::assert_equal(unfused,
|
||||
vec![Both(1, 1), Right(2), Right(3)]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_zip_longest_size_hint() {
|
||||
let c = (1..10).cycle();
|
||||
let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
|
||||
let v2 = &[10, 11, 12];
|
||||
|
||||
assert_eq!(c.zip_longest(v.iter()).size_hint(), (std::usize::MAX, None));
|
||||
|
||||
assert_eq!(v.iter().zip_longest(v2.iter()).size_hint(), (10, Some(10)));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_double_ended_zip_longest() {
|
||||
let xs = [1, 2, 3, 4, 5, 6];
|
||||
let ys = [1, 2, 3, 7];
|
||||
let a = xs.iter().map(|&x| x);
|
||||
let b = ys.iter().map(|&x| x);
|
||||
let mut it = a.zip_longest(b);
|
||||
assert_eq!(it.next(), Some(Both(1, 1)));
|
||||
assert_eq!(it.next(), Some(Both(2, 2)));
|
||||
assert_eq!(it.next_back(), Some(Left(6)));
|
||||
assert_eq!(it.next_back(), Some(Left(5)));
|
||||
assert_eq!(it.next_back(), Some(Both(4, 7)));
|
||||
assert_eq!(it.next(), Some(Both(3, 3)));
|
||||
assert_eq!(it.next(), None);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_double_ended_zip() {
|
||||
let xs = [1, 2, 3, 4, 5, 6];
|
||||
let ys = [1, 2, 3, 7];
|
||||
let a = xs.iter().map(|&x| x);
|
||||
let b = ys.iter().map(|&x| x);
|
||||
let mut it = multizip((a, b));
|
||||
assert_eq!(it.next_back(), Some((4, 7)));
|
||||
assert_eq!(it.next_back(), Some((3, 3)));
|
||||
assert_eq!(it.next_back(), Some((2, 2)));
|
||||
assert_eq!(it.next_back(), Some((1, 1)));
|
||||
assert_eq!(it.next_back(), None);
|
||||
}
|
||||
|
||||
|
||||
#[should_panic]
|
||||
#[test]
|
||||
fn zip_eq_panic1()
|
||||
{
|
||||
let a = [1, 2];
|
||||
let b = [1, 2, 3];
|
||||
|
||||
zip_eq(&a, &b).count();
|
||||
}
|
||||
|
||||
#[should_panic]
|
||||
#[test]
|
||||
fn zip_eq_panic2()
|
||||
{
|
||||
let a: [i32; 0] = [];
|
||||
let b = [1, 2, 3];
|
||||
|
||||
zip_eq(&a, &b).count();
|
||||
}
|
||||
Reference in New Issue
Block a user