diff options
Diffstat (limited to 'vendor/im-rc')
48 files changed, 21484 insertions, 0 deletions
diff --git a/vendor/im-rc/.cargo-checksum.json b/vendor/im-rc/.cargo-checksum.json new file mode 100644 index 000000000..098be05eb --- /dev/null +++ b/vendor/im-rc/.cargo-checksum.json @@ -0,0 +1 @@ +{"files":{"CHANGELOG.md":"8dc51178eb616033721246da3a68f58fe4057b892a8360c8b899253efdcc72d1","CODE_OF_CONDUCT.md":"3db9f112c815ffef9a6f51eef2f5f6a3f3c2900510c243f26ad890321b888473","Cargo.toml":"5e1f3a2e1761284562ab23cdb9bb6f9658e8d32344be934106358b5999e6e41c","LICENCE.md":"e6b6566f085df5746515c6d7e2edcaec0d2b77d527ac40d91409d783fb6c8508","README.md":"324883b8da0710ebab5569722ba909dfc734659b11168faf955f1106c5fc400e","build.rs":"0c187f99a0ce4d13fba739f9dc6c92ed1e0f2307984e101556574796c81406cb","proptest-regressions/hash/map.txt":"60c8ddd64ffe9123a8eff434222045f40f24e1261ee9bf07d972e09d46552b1b","proptest-regressions/hash/set.txt":"8952a3432c81fd8f7a89b78b1f6a6f509db8cc606e2a05d7c3ef7d05c3db1b8f","proptest-regressions/ord/map":"087835db5451b9cd5769f1f63a7d73ddef8dfdb4c11855a0fe13be3676ddd967","proptest-regressions/ord/map.txt":"5dc169320ce44ae8ed82173c41856a62f7bee7a2f8f44bf52668e8a2215c3d1c","proptest-regressions/ord/set.txt":"dd5cbfb0cc81817d4093be5094171ace6f7b2b3503099c792e7d5944a234d932","proptest-regressions/ser.txt":"8d7c3b2731be6e56893a0e46bc70a306e68d92c318abe4bf584d743dab3b15ff","proptest-regressions/sort.txt":"1bbe3ff7a20a6ff854fb6061302d6b608cfee46d1140a52dbc8dacd46e093a93","proptest-regressions/tests/ordset.txt":"692dee74e79dee5c5cf28146e64a3571736fdfa941905cd14712038264b5bc18","proptest-regressions/tests/vector.txt":"2f0ff1b033b941062fd255dd49162786d56a0072022c335574010c74e96173e8","proptest-regressions/vector/mod.txt":"953e29432a610e2432d16ba27adfd5259a941d027f93568ee66b20543c584a96","src/arbitrary.rs":"f144751f0b2b1c73a452c760402cf4efc543d4a8c8c5e83aec8bc9a57c7791eb","src/config.rs":"e4416b5b76f6910183e18c2abdc4acc895b88276893caaa00df6c805afd98e36","src/fakepool.rs":"92092d6deca092cf115a926fa1c606db1f14b8ccb736aaaa21d776fb0c5e3cf9","src/hash/map.rs":"94d234ad4af0dc534e642ec2707cb32da5c5ecf06639813e8beeeb4e4311d378","src/hash/mod.rs":"96e9b19b81c59b248c252b9dd085af45a7a45b1f50087aaa2bd94894f2df5706","src/hash/set.rs":"e3c7224a804534905ecb060362f7bdf98866aadfbf300a921f8d35936e88b2a4","src/iter.rs":"dcc1776ba23927feafc9517f488ce506614704e30610ff1f48de61fe7561cee1","src/lib.rs":"16c96265a66a07048cb1029457aacd95ab964bea42a6cc14c1545a5401fe0644","src/nodes/btree.rs":"6971575fd3a21606ff08969c29f75ac3ec4bb632fb0dfc2d53785406c3f83ec1","src/nodes/hamt.rs":"6fcee0007ae99e7b3dc9f920049caee80c819b01055853ec31b8355192cb8386","src/nodes/mod.rs":"0c9bc416bbcea9badef03970e5b6814056da27f0b0fb08d7a3f0ebad7bb396e0","src/nodes/rrb.rs":"eb0c6f451dc65324ec27fb9a51e15d34f5b7379b0c553e2cbe30b2463271717f","src/ord/map.rs":"064bb9367c028cd75f8ff346f1d0759463c0425066640c0aa79153dc37c882a8","src/ord/mod.rs":"96e9b19b81c59b248c252b9dd085af45a7a45b1f50087aaa2bd94894f2df5706","src/ord/set.rs":"4f80912a6e924a5acb7a540f4968cb4eac14ceec1534a664c7cb86750312cbba","src/ord/test-fixtures/issue_124.txt":"b47660b232309abefe3965f168474db05a65bf6d36b0289454aaba6318ffd017","src/proptest.rs":"b7ddb85a996e9a225460c6f649caeab863a04ca19793c20e775b8ac9de86eda8","src/quickcheck.rs":"3998f5fad4bca1de2099e4f684de72bfb3cb258a1585d251566d118a4a79214c","src/ser.rs":"2253cb11a08823c1a09db8a8677818c323bcb1b9483c93d03e8d37a2717a8d24","src/sort.rs":"806b2a3f5f0f5664164d1ef520a596b7eed16e122ded7b881afc4ce5392a12e7","src/sync.rs":"ebe2821cbf12bc7e167f1ea2d7b0726a4dddccecb78e3268f5c69a4d1ba44639","src/test.rs":"a3521b3429bcb3a89e3053294957c6bef76afe0a49f28554d5b1d85405a200de","src/tests/hashset.rs":"dbb867a786f09872c3815baa6a106f44d69d01c4e334ddad237ade0ebb674784","src/tests/mod.rs":"4e195032b38a3296d91b0dfdd32c16eb0e8d880af775c5965826c6402d63eb5f","src/tests/ordset.rs":"9bae1ec767a1c15e3513aa840207948c4bd119be5a66e7359b75198df73188bd","src/tests/vector.rs":"4f25c4a2e6b24fb1c86c06799288205a0036bde212b411a170635eda5e594231","src/util.rs":"b6fd0df67af6db8f1cb414f2d581aa67e1c27cf1eb58b351c3166b94f33b5723","src/vector/focus.rs":"1faf7b178e77b2e0954a3a4a5de9c7714495d16d7af37b11d415305906ffe903","src/vector/mod.rs":"dc753439caa5b4bef8bf696ec11d22d7be75053e41895649e2b29fef865f01e3","src/vector/pool.rs":"343e7697a8a7329a4ea92471650b3eeed8c11bc1550091dba210e2cc6b95a680","src/vector/rayon.rs":"bbf3a94a89dbe8c02962279eea519726830cce3d697d51a9cc0a5e353b54956f"},"package":"af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"}
\ No newline at end of file diff --git a/vendor/im-rc/CHANGELOG.md b/vendor/im-rc/CHANGELOG.md new file mode 100644 index 000000000..edcf429cf --- /dev/null +++ b/vendor/im-rc/CHANGELOG.md @@ -0,0 +1,419 @@ +# Changelog + +All notable changes to this project will be documented in this file. + +The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) and this project +adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html). + +## [15.1.0] - 2022-04-29 + +### Added + +- `HashSet` now implements `From<Vector<A>>` and `From<&Vector<A>> where A: Clone`. + +### Fixed + +- Fixed a long standing crash bug in `OrdMap`/`OrdSet`. (#154, #143, #152, #124) +- The `union` method on maps/sets will now prefer to mutate the larger set (which leads to less + work) rather than the first set. (#163) +- Ensure `TreeFocus` only implements `Send`/`Sync` when the underlying type does. (#157, #158) +- There was an issue where nodes in very large `OrdMap`s could overflow when removing an element + and cause a panic, which has now been fixed. (#141) +- Assorted doc cleanup. (#150, #173, #186, #194) + +## [15.0.0] - 2020-05-15 + +### Changed + +- Map iterators now return `(&K, &V)` and `(&K, &mut V)` respectively, to be consistent with + `std::collections`'s API. `DiffIter` for `OrdMap` has also changed in the same manner. (#121) + +### Removed + +- The `pool` feature flag has been removed from the `im` version of the crate, as `refpool` no + longer supports threadsafe pools. +- `HashSet::iter_mut()` has been removed, because if you modify the hashed values in a hash set, + you break the hash set. + +### Added + +- The `pool` feature flag was missing from the `im-rc` version of the crate, which is the version + where it's actually useful. It's been added now. +- `DiffIter` now has a `Debug` implementation. +- There is now a `Vector::is_inline()` method to determine whether a `Vector` is currently + inlined. (#129) + +### Fixed + +- A smarter implementation of the sorting algorithm for `Vector` has improved the performance of + `Vector::sort` by approximately 2x. (#126) + +## [14.3.0] - 2020-03-03 + +### Changed + +- `proptest` strategies have been moved to `im::proptest`. The previous locations of the + strategies (`im::vector::proptest` etc) are still available, but have been deprecated. + +### Added + +- `OrdSet` and `OrdMap` now have `get_prev` and `get_next` methods (with equivalent `get_prev_mut` + and `get_next_mut` methods for `OrdMap`) which will return the closest key match to the + requested key in the specified direction if the key isn't in the set. (#95) +- The `retain` method, inexplicably missing from `HashMap` but not `HashSet`, has been added. + (#120) +- The `get_mut` method on `OrdMap` was, equally inexplicably, private. It has now been made + public. + +## [14.2.0] - 2020-01-17 + +### Added + +- Both map types now have the `get_key_value()` method, corresponding to the equivalent + [additions](https://doc.rust-lang.org/std/collections/struct.BTreeMap.html#method.get_key_value) + to the standard library. +- The `ptr_eq` method has been added to all data types, allowing you to test whether two values + refer to the same content in memory, by testing for pointer equality. (#117) +- `HashMap` had lost its `Arbitrary` implementation for the `quickcheck` feature flag. It's now + been restored. (#118) +- Implementations for `Arbitrary` from the [`arbitrary`](https://crates.io/crates/arbitrary/) + crate have been added behind the `arbitrary` feature flag. + +### Fixed + +- Fixed a bug when reversing a consuming iterator over a `Vector` by replacing the consuming + iterator with a much simpler and slightly more efficient version. (#116) + +## [14.1.0] - 2019-12-16 + +### Added + +- If you enable the `pool` feature flag, im now supports constructing data types using + [`refpool`](https://crates.io/crates/refpool) to speed up chunk allocation. The performance + boost will vary between use cases and operating systems, but generally at least a 10% speedup + can be expected when constructing a data type from an iterator, and the more complex an + operation is, the more likely it is to benefit from being able to quickly reallocate chunks. + Note that in order to use this feature, you have to construct your data types using the + `with_pool(&pool)` constructor, it's not enough just to enable the feature flag. + +## [14.0.0] - 2019-11-19 + +### Changed + +- As `sized-chunks` now requires a slightly more recent version of `rustc` to compile, + specifically version 1.36.0, so does `im`. This is a breaking change, but will of course only + affect your code if you're using an older `rustc`. + +### Fixed + +- Fixed a quadratic time worst case scenario in the quicksort implementation for `Vector`. (#101) +- Fixed an edge case bug when splitting and joining large `Vector`s. (#105, #107) + +## [13.0.0] - 2019-05-18 + +The minimum supported Rust version is now 1.34.0. + +### Changed + +- `im::iter::unfold` now gives you the owned state value rather than an immutable reference to it, + which makes it a little more useful. + +### Removed + +- The deprecated `singleton` constructors have been removed. Please use `unit` instead. +- The deprecated methods `Vector::chunks` and `Vector::chunks_mut` have been removed in favour of + `Vector::leaves` and `Vector::leaves_mut` respectively. (#50) +- The deprecated reference to [`sized-chunks`](https://crates.io/crates/sized-chunks) has been + removed. If you need it, please use the `sized-chunks` crate directly. +- `im::iter::unfold_mut` has been removed, as there's no meaningful difference between it and + rust-std 1.34.0's `std::iter::from_fn` with a captured state variable. + +### Fixed + +- `Vector` now uses + [`sized_chunks::InlineArray`](https://docs.rs/sized-chunks/0.3.0/sized_chunks/inline_array/struct.InlineArray.html) + instead of an `Empty` enum case to avoid allocation at very small sizes, letting you store a + handful of elements on the stack before needing to grow into a full chunk. This has a beneficial + effect on performance as well, as there's no pointer into the heap to dereference, making it + faster than `std::vec::Vec` in this configuration. +- Some complexity timings have been added and corrected. (#87) +- `OrdSet::is_subset(&self, other)` now returns immediately when `self` is larger than `other` and + thus could not possibly be a subset of it. (#87) + +## [12.3.4] - 2019-04-08 + +### Changed + +- `Clone` constraints have been further relaxed on maps and sets, so that you can now lookup and + iterate over them without requiring a `Clone` constraint (though you do still need `Clone` to + actually insert data into them to lookup or iterate over). (#81) + +### Fixed + +- Enforces the latest bugfix release of sized-chunks. (#78) +- Another edge case bugfix to `Vector`'s size table handling. (#79) + +## [12.3.3] - 2019-03-11 + +### Fixed + +- A number of issues were fixed where `Vector`'s size table would get out of sync with the node + structure if exercised too much and cause erroneous behaviour. (#72, #74) +- Comprehensive generative tests were added to test all data structures through more unexpected + code paths. + +## [12.3.2] - 2019-03-05 + +### Changed + +- `Clone` constraints on all data structures, as well as relevant constraints on maps and sets, + have been relaxed where possible, so that you can now construct empty instances and call most + query methods without requiring values implement `Clone` etc. (#63) + +### Fixed + +- Constructing an empty `Vector` will not allocate any heap memory, instead deferring allocation + until you perform an operation that would increase its length. (#65) +- Some bugs arising when using `Vector::append` repeatedly were fixed. (#67, #70) + +## [12.3.1] - 2019-02-19 + +### Changed + +- Unsafe chunks have been separated out into the `sized-chunks` crate, which is now a dependency + of `im`. + +## [12.3.0] - 2019-01-15 + +### Added + +- `singleton` methods have been deprecated and renamed to `unit`. +- `Vector::chunks` and `Vector::chunks_mut` have been deprecated and renamed to `leaves` and + `leaves_mut` to avoid confusion with `Vec::chunks`. (#50) + +### Fixed + +- Fixed an issue where the `HashMap` draining iterator might access uninitialised memory leading + to undefined behaviour. (#60) +- Fixed multiple issues in `Vector::split_off` and `Vector::append` that would cause lookup errors + and unexpectedly unbalanced trees. (#55). + +## [12.2.0] - 2018-10-12 + +### Added + +- `OrdMap` and `OrdSet` now have a `range()` method which makes an iterator over a bounded subset + of the values. The improved iterator implementation is also considerably more efficient than the + previous (about an order of magnitude faster for nontrivial data sets). `iter()` has been + updated to take advantage of this, and is now just an alias for `range(..)`. (#27) +- `FocusMut` now has an `unmut` method to turn it into an immutable `Focus`, releasing its + exclusive hold on the underlying `Vector`. +- `Focus` now implements `Clone`. + +## [12.1.0] - 2018-09-25 + +### Added + +- Maps and sets now have the `clear` method just like `Vector`. (#46) + +### Changed + +- Single chunk `Vector`s are no longer allocated directly on the stack, meaning that they're now + comparable in performance to `std::vec::Vec` rather than slightly faster, but they also won't + eat up your stack space quite as quickly, and they'll clone without copying and share structure + with clones as you'd expect. + +## [12.0.0] - 2018-08-30 + +Starting with this release, the `arc` flag is gone, in favour of publishing `im` as two separate +crates: `im` (using `Arc`) and `im-rc` (using `Rc`). They're identical (and built from the same +code), except that `im` is thread safe and `im-rc` is a little bit more performant. + +This is a major release as a consequence, but there should be no breaking code changes other than +the new default choice of reference counter. + +### Added + +- The `Chunk` datatype that's used to build `Vector` and `OrdMap` has been exposed and made + generally usable. It's somewhere between a + [`GenericArray`](https://crates.io/crates/generic-array) and a ring buffer, offers O(1)\* push + in either direction, and is generally hyperoptimised for its purpose of serving as nodes for + Bagwell tries, but it's also a powered up version of + [`GenericArray`](https://crates.io/crates/generic-array) that might be useful to others, hence + the public API. +- `Vector` now has `Focus` and `FocusMut` APIs for caching index lookups, yielding huge + performance gains when performing multiple adjacent index lookups. `Vector::iter` has been + reimplemented using this API, and is now much simpler and about twice as fast as a result, and + `Vector::iter_mut` now runs nearly an order of magnitude faster. Likewise, `Vector::sort` and + `Vector::retain` are now using `FocusMut` and run considerably faster as a result. +- `Focus` and `FocusMut` can also be used as stand ins for subslices through the `narrow` and + `split_at` methods. You can also iterate over foci, making this the most efficient way to + iterate over a subset of a `Vector`. +- `Vector` now implements [Rayon](https://crates.io/crates/rayon)'s parallel iterators behind the + `rayon` feature flag. + +### Changed + +- As `std::ops::RangeBounds` is now stabilised in Rust 1.28, the `Vector::slice` method is now + unconditionally available on the stable channel. +- Union/difference/intersection/is_submap methods on `HashMap` and `OrdMap` that take functions + now take `FnMut` instead of `Fn`. This should not affect any existing code. (#34) +- `Vector::split_off` can now take an index equal to the length of the vector, yielding an empty + vector as the split result. (#33) +- `Vector::set` now returns the replaced value. + +### Fixed + +- `Vector` is now represented as a single inline chunk until it grows larger than the chunk size, + making it even faster than `Vec` at small sizes, though `clone` could now be slower if the clone + is expensive (it's still absurdly fast for `A: Copy`). + +## [11.0.1] - 2018-07-23 + +### Fixed + +- Various performance improvements, amounting to a 5-10% speedup for both kinds of map/set. +- Fixed an edge case bug in `sort::quicksort`. + +## [11.0.0] - 2018-07-10 + +### Changed + +This is a major release with many breaking changes, and is intended to stabilise the API more than +to denote that the rewrite is now production ready. You should expect future releases with +significant performance improvements as well as additional APIs, but there should be no further +major release with breaking changes in the immediate future, barring very serious unforeseen issues. + +Specifically, you should expect imminent minor releases with performance improvements for `Vector` +and `OrdMap`, for which I have a number of known optimisations that remain unimplemented. + +#### No More `Arc` + +All data structures have been reworked to take values of `A: Clone` instead of `Arc<A>`, meaning +that there's less performance overhead (as well as mental overhead) when using values that clone +cheaply. The performance gain when values are `A: Copy` is a factor of two or more. It's expected +that users should wrap values in `Arc` themselves when using values which are expensive to clone. + +Data structures still use reference counters internally to reference nodes, but values are stored +directly in the nodes with no further indirection. This is also good for cache locality. + +Data structures now use `Rc` instead of `Arc` by default to do reference counting. If you need a +thread safe version that implements `Send` and `Sync`, you can enable the `arc` feature on the +package to compile with `Arc` instead. + +#### `std::collections` Compatible API + +The API has been reworked to align more closely with `std::collections`, favouring mutable +operations by default, so that operations that were previously suffixed with `_mut` are now the +standard operations, and immutable operations which return a modified copy have been given different +names altogether. In short, all your code using previous versions of this library will no longer +work, and if it was relying heavily on immutable operations, it's recommended that you rewrite it to +be mutable by preference, but you should generally be able to make it work again by using the new +method names for the immutable operations. + +Here is a list of the most notable changed method names for maps and sets: + +| Previous immutable | Current immutable | Previous mutable | Current mutable | +| ------------------ | ----------------- | ---------------- | --------------- | +| `insert` | `update` | `insert_mut` | `insert` | +| `remove` | `without` | `remove_mut` | `remove` | +| `pop` | `extract` | `pop_mut` | `remove` | + +You should expect to be able to rewrite code using `std::collections::HashMap` and +`std::collections::BTreeMap` with minimal or no changes using `im::HashMap` and `im::OrdMap` +respectively. + +`Vector` has been completely rewritten and has an API that aligns closely with +`std::collections::VecDeque`, with very few immutable equivalents. It's expected that you should use +`Vector::clone()` to take a snapshot when you need it rather than cause an implicit clone for each +operation. (It's still O(1) and practically instant.) + +I'm considering adding back some of the immutable operations if I can come up with good names for +them, but for now, just `clone` it if you need it. + +#### RRB Vector + +`Vector` is now implemented as an +[RRB tree](https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf) with +[smart head/tail chunking](http://gallium.inria.fr/~rainey/chunked_seq.pdf), obsoleting the previous +[Hickey trie](https://hypirion.com/musings/understanding-persistent-vector-pt-1) implementation. + +RRB trees have generally similar performance characteristics to the Hickey trie, with the added +benefit of having O(log n) splitting and concatenation. + +| Operation | RRB tree | Hickey trie | Vec | VecDeque | +| --------------- | -------- | ----------- | ------ | -------- | +| Push front | O(1)\* | O(log n) | O(n) | O(1)\* | +| Push back | O(1)\* | O(log n) | O(1)\* | O(1)\* | +| Pop front | O(1)\* | O(log n) | O(n) | O(1)\* | +| Pop back | O(1)\* | O(log n) | O(1) | O(1)\* | +| Lookup by index | O(log n) | O(log n) | O(1) | O(1) | +| Split | O(log n) | O(log n) | O(n) | O(n) | +| Join | O(log n) | O(n) | O(n) | O(n) | + +(Please note that the timings above are for the `im` version of the Hickey trie, based on the +[Immutable.js](https://facebook.github.io/immutable-js/) implementation, which performs better than +the original Clojure version on splits and push/pop front, but worse on push/pop back). + +The RRB tree is the most generally efficient list like data structure currently known, to my +knowledge, but obviously it does not and cannot perform as well as a simple `Vec` on certain +operations. It makes up for that by having no operations you need to worry about the performance +complexity of: nothing you can do to an RRB tree is going to be more expensive than just iterating +over it. For larger data sets, being able to concatenate (and, by extension, insert and remove at +arbitrary locations) several orders of magnitude faster than `Vec` could also be considered a +selling point. + +#### No More `CatList` And `ConsList` + +`CatList` has been superseded by `Vector`, and `ConsList` was generally not very useful except in +the more peculiar edge cases where memory consumption matters more than performance, and keeping it +in line with current API changes wasn't practical. + +#### No More Funny Words + +Though it breaks my heart, words like `cons`, `snoc`, `car`, `cdr` and `uncons` are no longer used +in the `im` API, to facilitiate closer alignment with `std::collections`. Even the `head`/`tail` +pair is gone, though `head` and `last` remain as aliases for `front` and `back`. + +## [10.2.0] - 2018-04-15 + +### Added + +- Map/set methods which accept references to keys will now also take any value that's borrowable + to the key's type, ie. it will take a reference to a type `Borrowable` where the key implements + `Borrow<Borrowable>`. This is particularly handy for types such as `String` because you can now + pass `&str` to key lookups instead of `&String`. So, instead of the incredibly cumbersome + `map.get(&"foo".to_string())` you can just do `map.get("foo")` when looking up a mapping for a + string literal. + +## [10.1.0] - 2018-04-12 + +### Added + +- `Vector`, `OrdMap` and `HashMap` now implement `Index` and `IndexMut`, allowing for syntax like + `map[key] = value`. +- Added `cons`, `snoc`, `uncons` and `unsnoc` aliases where they were missing. +- Everything now implements `Sum` and `Extend` where possible. + +### Changed + +- Generalised `OrdMap`/`OrdSet`'s internal nodes so `OrdSet` now only needs to store pointers to + its values, not pairs of pointers to value and `Unit`. This has caused `OrdMap/Set`'s type + constraints to tighten somewhat - in particular, iteration over maps/sets whose keys don't + implement `Ord` is no longer possible, but as you would only have been able to create empty + instances of these, no sensible code should break because of this. +- `HashMap`/`HashSet` now also cannot be iterated over unless they implement `Hash + Eq`, with the + same note as above. +- Constraints on single operations that take closures on `HashMap` and `OrdMap` have been relaxed + from `Fn` to `FnOnce`. (Fixes #7.) + +### Fixed + +- Hashes are now stored in `HashMap`s along with their associated values, removing the need to + recompute the hash when a value is reordered inside the tree. + +## [10.0.0] - 2018-03-25 + +### Added + +This is the first release to be considered reasonably stable. No changelog has been kept until now. diff --git a/vendor/im-rc/CODE_OF_CONDUCT.md b/vendor/im-rc/CODE_OF_CONDUCT.md new file mode 100644 index 000000000..02a086970 --- /dev/null +++ b/vendor/im-rc/CODE_OF_CONDUCT.md @@ -0,0 +1,73 @@ +# Contributor Covenant Code of Conduct + +## Our Pledge + +In the interest of fostering an open and welcoming environment, we as +contributors and maintainers pledge to making participation in our project and +our community a harassment-free experience for everyone, regardless of age, body +size, disability, ethnicity, gender identity and expression, level of experience, +education, socio-economic status, nationality, personal appearance, race, +religion, or sexual identity and orientation. + +## Our Standards + +Examples of behavior that contributes to creating a positive environment +include: + +* Using welcoming and inclusive language +* Being respectful of differing viewpoints and experiences +* Gracefully accepting constructive criticism +* Focusing on what is best for the community +* Showing empathy towards other community members + +Examples of unacceptable behavior by participants include: + +* The use of sexualized language or imagery and unwelcome sexual attention or + advances +* Trolling, insulting/derogatory comments, and personal or political attacks +* Public or private harassment +* Publishing others' private information, such as a physical or electronic + address, without explicit permission +* Other conduct which could reasonably be considered inappropriate in a + professional setting + +## Our Responsibilities + +Project maintainers are responsible for clarifying the standards of acceptable +behavior and are expected to take appropriate and fair corrective action in +response to any instances of unacceptable behavior. + +Project maintainers have the right and responsibility to remove, edit, or +reject comments, commits, code, wiki edits, issues, and other contributions +that are not aligned to this Code of Conduct, or to ban temporarily or +permanently any contributor for other behaviors that they deem inappropriate, +threatening, offensive, or harmful. + +## Scope + +This Code of Conduct applies both within project spaces and in public spaces +when an individual is representing the project or its community. Examples of +representing a project or community include using an official project e-mail +address, posting via an official social media account, or acting as an appointed +representative at an online or offline event. Representation of a project may be +further defined and clarified by project maintainers. + +## Enforcement + +Instances of abusive, harassing, or otherwise unacceptable behavior may be +reported by contacting the project team at admin@immutable.rs. All +complaints will be reviewed and investigated and will result in a response that +is deemed necessary and appropriate to the circumstances. The project team is +obligated to maintain confidentiality with regard to the reporter of an incident. +Further details of specific enforcement policies may be posted separately. + +Project maintainers who do not follow or enforce the Code of Conduct in good +faith may face temporary or permanent repercussions as determined by other +members of the project's leadership. + +## Attribution + +This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, +available at https://www.contributor-covenant.org/version/1/4/code-of-conduct.html + +[homepage]: https://www.contributor-covenant.org diff --git a/vendor/im-rc/Cargo.toml b/vendor/im-rc/Cargo.toml new file mode 100644 index 000000000..d42771dcd --- /dev/null +++ b/vendor/im-rc/Cargo.toml @@ -0,0 +1,115 @@ +# 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 are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +rust-version = "1.46.0" +name = "im-rc" +version = "15.1.0" +authors = ["Bodil Stokke <bodil@bodil.org>"] +build = "./build.rs" +description = "Immutable collection datatypes (the fast but not thread safe version)" +homepage = "http://immutable.rs/" +documentation = "http://immutable.rs/" +readme = "../../README.md" +keywords = [ + "immutable", + "persistent", + "hamt", + "b-tree", + "rrb-tree", +] +categories = ["data-structures"] +license = "MPL-2.0+" +repository = "https://github.com/bodil/im-rs" + +[package.metadata.docs.rs] +all-features = true + +[lib] +path = "./src/lib.rs" + +[dependencies.arbitrary] +version = "1.1" +optional = true + +[dependencies.bitmaps] +version = "2" + +[dependencies.proptest] +version = "1" +optional = true + +[dependencies.quickcheck] +version = "1" +optional = true + +[dependencies.rand_core] +version = "0.6" + +[dependencies.rand_xoshiro] +version = "0.6" + +[dependencies.rayon] +version = "1" +optional = true + +[dependencies.refpool] +version = "0.4" +optional = true + +[dependencies.serde] +version = "1" +optional = true + +[dependencies.sized-chunks] +version = "0.6.4" + +[dependencies.typenum] +version = "1.12" + +[dev-dependencies.metrohash] +version = "1" + +[dev-dependencies.pretty_assertions] +version = "1" + +[dev-dependencies.proptest] +version = "1" + +[dev-dependencies.proptest-derive] +version = "0.3" + +[dev-dependencies.rand] +version = "0.8" +features = ["small_rng"] + +[dev-dependencies.rayon] +version = "1" + +[dev-dependencies.serde] +version = "1" + +[dev-dependencies.serde_json] +version = "1" + +[build-dependencies.version_check] +version = "0.9" + +[features] +debug = [] +pool = [ + "refpool", + "sized-chunks/refpool", +] + +[badges.travis-ci] +repository = "bodil/im-rs" diff --git a/vendor/im-rc/LICENCE.md b/vendor/im-rc/LICENCE.md new file mode 100644 index 000000000..cd44203cd --- /dev/null +++ b/vendor/im-rc/LICENCE.md @@ -0,0 +1,355 @@ +Mozilla Public License Version 2.0 +================================== + +### 1. Definitions + +**1.1. “Contributor”** + means each individual or legal entity that creates, contributes to + the creation of, or owns Covered Software. + +**1.2. “Contributor Version”** + means the combination of the Contributions of others (if any) used + by a Contributor and that particular Contributor's Contribution. + +**1.3. “Contribution”** + means Covered Software of a particular Contributor. + +**1.4. “Covered Software”** + means Source Code Form to which the initial Contributor has attached + the notice in Exhibit A, the Executable Form of such Source Code + Form, and Modifications of such Source Code Form, in each case + including portions thereof. + +**1.5. “Incompatible With Secondary Licenses”** + means + +* **(a)** that the initial Contributor has attached the notice described + in Exhibit B to the Covered Software; or +* **(b)** that the Covered Software was made available under the terms of + version 1.1 or earlier of the License, but not also under the + terms of a Secondary License. + +**1.6. “Executable Form”** + means any form of the work other than Source Code Form. + +**1.7. “Larger Work”** + means a work that combines Covered Software with other material, in + a separate file or files, that is not Covered Software. + +**1.8. “License”** + means this document. + +**1.9. “Licensable”** + means having the right to grant, to the maximum extent possible, + whether at the time of the initial grant or subsequently, any and + all of the rights conveyed by this License. + +**1.10. “Modifications”** + means any of the following: + +* **(a)** any file in Source Code Form that results from an addition to, + deletion from, or modification of the contents of Covered + Software; or +* **(b)** any new file in Source Code Form that contains any Covered + Software. + +**1.11. “Patent Claims” of a Contributor** + means any patent claim(s), including without limitation, method, + process, and apparatus claims, in any patent Licensable by such + Contributor that would be infringed, but for the grant of the + License, by the making, using, selling, offering for sale, having + made, import, or transfer of either its Contributions or its + Contributor Version. + +**1.12. “Secondary License”** + means either the GNU General Public License, Version 2.0, the GNU + Lesser General Public License, Version 2.1, the GNU Affero General + Public License, Version 3.0, or any later versions of those + licenses. + +**1.13. “Source Code Form”** + means the form of the work preferred for making modifications. + +**1.14. “You” (or “Your”)** + means an individual or a legal entity exercising rights under this + License. For legal entities, “You” includes any entity that + controls, is controlled by, or is under common control with You. For + purposes of this definition, “control” means **(a)** the power, direct + or indirect, to cause the direction or management of such entity, + whether by contract or otherwise, or **(b)** ownership of more than + fifty percent (50%) of the outstanding shares or beneficial + ownership of such entity. + + +### 2. License Grants and Conditions + +#### 2.1. Grants + +Each Contributor hereby grants You a world-wide, royalty-free, +non-exclusive license: + +* **(a)** under intellectual property rights (other than patent or trademark) + Licensable by such Contributor to use, reproduce, make available, + modify, display, perform, distribute, and otherwise exploit its + Contributions, either on an unmodified basis, with Modifications, or + as part of a Larger Work; and +* **(b)** under Patent Claims of such Contributor to make, use, sell, offer + for sale, have made, import, and otherwise transfer either its + Contributions or its Contributor Version. + +#### 2.2. Effective Date + +The licenses granted in Section 2.1 with respect to any Contribution +become effective for each Contribution on the date the Contributor first +distributes such Contribution. + +#### 2.3. Limitations on Grant Scope + +The licenses granted in this Section 2 are the only rights granted under +this License. No additional rights or licenses will be implied from the +distribution or licensing of Covered Software under this License. +Notwithstanding Section 2.1(b) above, no patent license is granted by a +Contributor: + +* **(a)** for any code that a Contributor has removed from Covered Software; + or +* **(b)** for infringements caused by: **(i)** Your and any other third party's + modifications of Covered Software, or **(ii)** the combination of its + Contributions with other software (except as part of its Contributor + Version); or +* **(c)** under Patent Claims infringed by Covered Software in the absence of + its Contributions. + +This License does not grant any rights in the trademarks, service marks, +or logos of any Contributor (except as may be necessary to comply with +the notice requirements in Section 3.4). + +#### 2.4. Subsequent Licenses + +No Contributor makes additional grants as a result of Your choice to +distribute the Covered Software under a subsequent version of this +License (see Section 10.2) or under the terms of a Secondary License (if +permitted under the terms of Section 3.3). + +#### 2.5. Representation + +Each Contributor represents that the Contributor believes its +Contributions are its original creation(s) or it has sufficient rights +to grant the rights to its Contributions conveyed by this License. + +#### 2.6. Fair Use + +This License is not intended to limit any rights You have under +applicable copyright doctrines of fair use, fair dealing, or other +equivalents. + +#### 2.7. Conditions + +Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted +in Section 2.1. + + +### 3. Responsibilities + +#### 3.1. Distribution of Source Form + +All distribution of Covered Software in Source Code Form, including any +Modifications that You create or to which You contribute, must be under +the terms of this License. You must inform recipients that the Source +Code Form of the Covered Software is governed by the terms of this +License, and how they can obtain a copy of this License. You may not +attempt to alter or restrict the recipients' rights in the Source Code +Form. + +#### 3.2. Distribution of Executable Form + +If You distribute Covered Software in Executable Form then: + +* **(a)** such Covered Software must also be made available in Source Code + Form, as described in Section 3.1, and You must inform recipients of + the Executable Form how they can obtain a copy of such Source Code + Form by reasonable means in a timely manner, at a charge no more + than the cost of distribution to the recipient; and + +* **(b)** You may distribute such Executable Form under the terms of this + License, or sublicense it under different terms, provided that the + license for the Executable Form does not attempt to limit or alter + the recipients' rights in the Source Code Form under this License. + +#### 3.3. Distribution of a Larger Work + +You may create and distribute a Larger Work under terms of Your choice, +provided that You also comply with the requirements of this License for +the Covered Software. If the Larger Work is a combination of Covered +Software with a work governed by one or more Secondary Licenses, and the +Covered Software is not Incompatible With Secondary Licenses, this +License permits You to additionally distribute such Covered Software +under the terms of such Secondary License(s), so that the recipient of +the Larger Work may, at their option, further distribute the Covered +Software under the terms of either this License or such Secondary +License(s). + +#### 3.4. Notices + +You may not remove or alter the substance of any license notices +(including copyright notices, patent notices, disclaimers of warranty, +or limitations of liability) contained within the Source Code Form of +the Covered Software, except that You may alter any license notices to +the extent required to remedy known factual inaccuracies. + +#### 3.5. Application of Additional Terms + +You may choose to offer, and to charge a fee for, warranty, support, +indemnity or liability obligations to one or more recipients of Covered +Software. However, You may do so only on Your own behalf, and not on +behalf of any Contributor. You must make it absolutely clear that any +such warranty, support, indemnity, or liability obligation is offered by +You alone, and You hereby agree to indemnify every Contributor for any +liability incurred by such Contributor as a result of warranty, support, +indemnity or liability terms You offer. You may include additional +disclaimers of warranty and limitations of liability specific to any +jurisdiction. + + +### 4. Inability to Comply Due to Statute or Regulation + +If it is impossible for You to comply with any of the terms of this +License with respect to some or all of the Covered Software due to +statute, judicial order, or regulation then You must: **(a)** comply with +the terms of this License to the maximum extent possible; and **(b)** +describe the limitations and the code they affect. Such description must +be placed in a text file included with all distributions of the Covered +Software under this License. Except to the extent prohibited by statute +or regulation, such description must be sufficiently detailed for a +recipient of ordinary skill to be able to understand it. + + +### 5. Termination + +**5.1.** The rights granted under this License will terminate automatically +if You fail to comply with any of its terms. However, if You become +compliant, then the rights granted under this License from a particular +Contributor are reinstated **(a)** provisionally, unless and until such +Contributor explicitly and finally terminates Your grants, and **(b)** on an +ongoing basis, if such Contributor fails to notify You of the +non-compliance by some reasonable means prior to 60 days after You have +come back into compliance. Moreover, Your grants from a particular +Contributor are reinstated on an ongoing basis if such Contributor +notifies You of the non-compliance by some reasonable means, this is the +first time You have received notice of non-compliance with this License +from such Contributor, and You become compliant prior to 30 days after +Your receipt of the notice. + +**5.2.** If You initiate litigation against any entity by asserting a patent +infringement claim (excluding declaratory judgment actions, +counter-claims, and cross-claims) alleging that a Contributor Version +directly or indirectly infringes any patent, then the rights granted to +You by any and all Contributors for the Covered Software under Section +2.1 of this License shall terminate. + +**5.3.** In the event of termination under Sections 5.1 or 5.2 above, all +end user license agreements (excluding distributors and resellers) which +have been validly granted by You or Your distributors under this License +prior to termination shall survive termination. + + +### 6. Disclaimer of Warranty + +> Covered Software is provided under this License on an “as is” +> basis, without warranty of any kind, either expressed, implied, or +> statutory, including, without limitation, warranties that the +> Covered Software is free of defects, merchantable, fit for a +> particular purpose or non-infringing. The entire risk as to the +> quality and performance of the Covered Software is with You. +> Should any Covered Software prove defective in any respect, You +> (not any Contributor) assume the cost of any necessary servicing, +> repair, or correction. This disclaimer of warranty constitutes an +> essential part of this License. No use of any Covered Software is +> authorized under this License except under this disclaimer. + +### 7. Limitation of Liability + +> Under no circumstances and under no legal theory, whether tort +> (including negligence), contract, or otherwise, shall any +> Contributor, or anyone who distributes Covered Software as +> permitted above, be liable to You for any direct, indirect, +> special, incidental, or consequential damages of any character +> including, without limitation, damages for lost profits, loss of +> goodwill, work stoppage, computer failure or malfunction, or any +> and all other commercial damages or losses, even if such party +> shall have been informed of the possibility of such damages. This +> limitation of liability shall not apply to liability for death or +> personal injury resulting from such party's negligence to the +> extent applicable law prohibits such limitation. Some +> jurisdictions do not allow the exclusion or limitation of +> incidental or consequential damages, so this exclusion and +> limitation may not apply to You. + + +### 8. Litigation + +Any litigation relating to this License may be brought only in the +courts of a jurisdiction where the defendant maintains its principal +place of business and such litigation shall be governed by laws of that +jurisdiction, without reference to its conflict-of-law provisions. +Nothing in this Section shall prevent a party's ability to bring +cross-claims or counter-claims. + + +### 9. Miscellaneous + +This License represents the complete agreement concerning the subject +matter hereof. If any provision of this License is held to be +unenforceable, such provision shall be reformed only to the extent +necessary to make it enforceable. Any law or regulation which provides +that the language of a contract shall be construed against the drafter +shall not be used to construe this License against a Contributor. + + +### 10. Versions of the License + +#### 10.1. New Versions + +Mozilla Foundation is the license steward. Except as provided in Section +10.3, no one other than the license steward has the right to modify or +publish new versions of this License. Each version will be given a +distinguishing version number. + +#### 10.2. Effect of New Versions + +You may distribute the Covered Software under the terms of the version +of the License under which You originally received the Covered Software, +or under the terms of any subsequent version published by the license +steward. + +#### 10.3. Modified Versions + +If you create software not governed by this License, and you want to +create a new license for such software, you may create and use a +modified version of this License if you rename the license and remove +any references to the name of the license steward (except to note that +such modified license differs from this License). + +#### 10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses + +If You choose to distribute Source Code Form that is Incompatible With +Secondary Licenses under the terms of this version of the License, the +notice described in Exhibit B of this License must be attached. + +## Exhibit A - Source Code Form License Notice + + This Source Code Form is subject to the terms of the Mozilla Public + License, v. 2.0. If a copy of the MPL was not distributed with this + file, You can obtain one at http://mozilla.org/MPL/2.0/. + +If it is not possible or desirable to put the notice in a particular +file, then You may include the notice in a location (such as a LICENSE +file in a relevant directory) where a recipient would be likely to look +for such a notice. + +You may add additional accurate notices of copyright ownership. + +## Exhibit B - “Incompatible With Secondary Licenses” Notice + + This Source Code Form is "Incompatible With Secondary Licenses", as + defined by the Mozilla Public License, v. 2.0. diff --git a/vendor/im-rc/README.md b/vendor/im-rc/README.md new file mode 100644 index 000000000..d95c071f0 --- /dev/null +++ b/vendor/im-rc/README.md @@ -0,0 +1,28 @@ +# im-rs + +[](https://crates.io/crates/im) + +Blazing fast immutable collection datatypes for Rust. + +Comes in two versions: [`im`](https://crates.io/crates/im) (thread safe) and +[`im-rc`](https://crates.io/crates/im-rc) (fast but not thread safe). + +## Documentation + +* [API docs](https://docs.rs/im/) + +## Licence + +Copyright 2017 Bodil Stokke + +This software is subject to the terms of the Mozilla Public +License, v. 2.0. If a copy of the MPL was not distributed with this +file, You can obtain one at http://mozilla.org/MPL/2.0/. + +## Code of Conduct + +Please note that this project is released with a [Contributor Code of +Conduct][coc]. By participating in this project you agree to abide by its +terms. + +[coc]: https://github.com/bodil/im-rs/blob/master/CODE_OF_CONDUCT.md diff --git a/vendor/im-rc/build.rs b/vendor/im-rc/build.rs new file mode 100644 index 000000000..02d8da393 --- /dev/null +++ b/vendor/im-rc/build.rs @@ -0,0 +1,25 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use std::env; + +fn main() { + println!("cargo:rerun-if-changed=build.rs"); + if let Some(channel) = version_check::Channel::read() { + if channel.supports_features() { + println!("cargo:rustc-cfg=has_specialisation"); + } + } + let pkgname = env::var("CARGO_PKG_NAME").expect("Cargo didn't set the CARGO_PKG_NAME env var!"); + let test_rc = env::var("IM_TEST_RC").is_ok(); + match pkgname.as_str() { + "im" => { + if !test_rc { + println!("cargo:rustc-cfg=threadsafe") + } + } + "im-rc" => {} + _ => panic!("unexpected package name!"), + } +} diff --git a/vendor/im-rc/proptest-regressions/hash/map.txt b/vendor/im-rc/proptest-regressions/hash/map.txt new file mode 100644 index 000000000..698800a72 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/hash/map.txt @@ -0,0 +1,16 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 3591451162 2655640551 804983804 3307909230 # shrinks to ref m = {-13697: 30985, 1338: 29274, -14139: -4092, 673: -19662, -19198: 333, 9155: -4794, -24816: -12851, 14658: -17795, 23662: -25253, -4783: -12972, -31711: -1639, -26495: 16710, -7087: -26434, 18175: -4121, 5045: 8040, -23549: 17012, 6304: -7492, -23305: -28186, 606: 8452, -15872: 2415, 17913: 2306, -20500: 28581} +xs 1457767450 3825624317 1539332905 3279740856 # shrinks to ref m = {7136: -9742, -7547: 13954, -15860: 17017, -31620: -15850, 25480: -13526, 9943: -13939, 1142: 22444, 20378: -26706, -10165: -14641} +xs 2468731224 2159341902 336190467 4018852179 # shrinks to ref m = {22114: -20101, -30886: -4356, 29938: 40, 6256: -29990, 8450: -21821, 30253: 901, -10781: -24620, 22431: 593} +xs 1344206258 166909451 3875523340 3155104601 # shrinks to ref m = {25488: 22186, -4852: 28282, -5097: 4497, 29501: 8087, -29096: -18313, 22286: -17383, 30624: 25063, -2270: -1319, 31014: -28777, 23935: 1507} +xs 2403854785 21349881 2962261870 427550728 # shrinks to ref pairs = [(-17914, 0), (16838, 0)] +xs 1508395022 1122347352 4113209817 3965614759 # shrinks to ref m = {0: 0, 1: 0} +xs 1627474128 2843908894 3937915137 1370561421 # shrinks to ref input = {0: 0}, index_rand = 0 +xs 1863744963 3828268266 3976454353 1279901501 # shrinks to ref m = {1033: ",¦⾘f\u{b}C\u{bae94}}$n\"\u{fc28d}\u{feff}\u{b}-", 2568: "\u{8db77}ꖽ\r\u{7af7f}�7\u{a7bf3}\u{393b9}\u{0}G\u{8}\'%5E\u{cd0dc}?\u{ba311}%\u{ee814}Ѩ\\\u{80aa1}", 3527: "\u{41005}\u{41ff0}$`,L&%\u{1b}~\u{36ada}", 3577: "\u{feff}5\u{109dd9}:\u{8}\u{3}𬃹\u{3c2b6}\\\"5𡂏\'\u{feff}%\u{b8c12}?", 4544: "0*8🕴�\u{33669}\r\"\u{92011}𮡱<\u{0}<\u{1}$\u{1},\u{f1234}{G\u{1b}J\u{ceaa4}\\", 4560: "🕴\r\tѨ@\u{edbda}\u{1b}t�\u{b}\u{2}�ò\u{80090}.\'\u{34690}g%Ѩ\u{0}=\u{1}", 7113: "*", 7944: "¨\u{b6d08}$🕴&{H\rUi\u{feff}\u{0}.¥ô{_*\u{d73fc}:Ѩf`2.*\u{c9c6c}", 8738: "%𬊢*:Ä\u{90}\u{b}\u{48d7b}\"\u{4}"} +xs 1567907912 1646837549 2298759549 1787615177 # shrinks to ref pairs = [(-28601, 0), (2569, 0), (-3384, 0), (5639, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (0, 0), (-30583, 0), (0, 0), (-154, 0), (-27, 0), (105, 0), (-29, 0), (9, 0), (9, 0), (-508, 0), (-478, 0), (-4095, 0), (-2017, 0), (-130, 0), (27145, 0), (2345, 0), (3241, 0), (458, 0), (-6211, 0), (361, 0), (-4772, 0), (-7717, 0), (4265, 0), (-1144, 0)] +xs 2574157460 1821361166 2171243272 102290569 # shrinks to ref pairs = [(0, 0), (7, 0), (7, 0), (2055, 0), (0, 0), (-9530, 0), (0, 0), (6, 0), (6, 0), (0, 0), (6, 0), (0, 0), (0, 0), (0, 0), (0, 0), (-11133, 0), (-161, 0), (-2, 0), (-2051, 0), (-3111, 0), (-2092, 0), (0, 0), (24131, 0), (-5278, 0), (6, 0), (70, 0), (0, 0), (6, 0), (6, 0), (-31, 0), (-3492, 0), (-2373, 0), (8902, 0), (-2438, 0), (3014, 0), (7206, 0), (6854, 0), (15161, 0), (-699, 0)] diff --git a/vendor/im-rc/proptest-regressions/hash/set.txt b/vendor/im-rc/proptest-regressions/hash/set.txt new file mode 100644 index 000000000..a1071568c --- /dev/null +++ b/vendor/im-rc/proptest-regressions/hash/set.txt @@ -0,0 +1,7 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 4213962225 2884706512 1606470227 2259275645 # shrinks to ref s = {"\\\u{4}\u{b}\u{c7afb}Q$x/\u{1a4f0}\u{1}\u{399ac}$.\u{0}=J>\"\u{2}=\t\t*q乣\'?6\u{ca350}\u{a20b5}", "\u{b50f2}$", "\u{de54f}/¥\u{1b}{*\"¥*:\\\u{e77d2}*s`?\u{3}/\u{9daa7}\t\u{1b}\":\'\u{7cf05}G🕴j", "\u{a2848}\u{bf244}.$=d\u{51d0f}¥\u{98d35}\u{3457c}<`𖡒{\"k�\t.$u\u{0}.", "!`", "\u{4}\u{9c2d9}r\u{d33a9}¥쇛\u{cd875}\u{7f}\\\u{37b37}`\u{b}\ruR\r\t\u{8aaa0}\\&`\u{b}\u{feff}\u{b868c}\u{a976e}\u{0}\\X\u{514dd}&k", "\u{feff}🕴M", "\u{b162a}S\u{6}\"\r\u{4b435}🕴 \\\u{b16df}\'\u{3468e}\\", "÷/\\\u{4dfaf}\u{7f}*\u{47f16}\"�aZ\r(Tj\u{1b}记\t;¥*<\u{1b}E\u{8d037}"} diff --git a/vendor/im-rc/proptest-regressions/ord/map b/vendor/im-rc/proptest-regressions/ord/map new file mode 100644 index 000000000..ce47e6b91 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/ord/map @@ -0,0 +1,20 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 1087347487 1450735596 3800950698 1648897824 # shrinks to ref m = {29894: -24214, -22768: -29852, -25204: 19090, -22710: 4694, -27608: 14656, -27740: 29393, 7285: -78, -3041: 77, 20980: 467, 13472: 3518, 2845: -9597, 6987: -29072, -30486: 827, -1022: 15821, 22068: -24552, 6293: -21073, -7161: 10155, 3791: -27929, 6361: 15318, 3190: 30164, 31756: 4331, 11824: 30151, -14319: -451, -17781: -5693, -5991: 372, -27192: -2983, 23456: 21711, -19546: 28578, -9753: 30988, 21193: 22302, 432: 24303, -15110: 26679, -11612: -6722, 12373: -31848, -20837: -16031, 25861: -12660, -23775: 32410, -6760: 25269, 21702: -26852, -17649: 27279, -12789: -28758, -26032: 6316, -16837: -16182, 31817: -24478, -3564: -20084, -5315: 23517, 11955: -29343, 9175: -4003, 20615: -19515, -3453: 24768, -28231: 3065, 10336: -24811, -8978: 17861, 23428: 19571, -450: 14904, -5293: -12205, -15735: -13395, 12747: -25893, 29368: 14652, 16863: -31998, 29612: 2394, 3212: 4512, -2804: 16628, -9070: 2599, -8946: -6150, 22872: -15322, -12672: 22236, 8415: -22569, 18541: -20698, 12395: -11080, -3888: -6244, -4893: 21952, -3595: 16707, 11722: -9301, 23547: 8317, -10052: -5551, -8428: -1168, -6805: 1438, 6185: 27026, 9265: 14429, -7016: -19640, 4739: 28713, 27505: -9101, -21379: 11843, 10141: 26568, -27662: -7672, -5384: -15814, -31927: 23347, 28068: -13380, -3075: 11627, -28778: 26949, 821: 22814, 11572: 16591, -10426: 5726, -14986: 6492, -4472: -12187, -22049: -18715, 3822: -26724, -13821: 24964, 14780: 23541, -26068: -17472, 6419: -16387, -21443: -32036, -27285: -11138, -12544: -22185, -25942: -22158, 8799: 22607, 22203: 23175, -29997: 9170, 18341: -19711, -25162: -29851, 29377: -4845, -4337: -3624, -30764: 13318, 2000: 6862, 13510: 4642, 25068: -1590, 16270: -1390, -23439: 16616, -13611: 30094, 10084: -30492, -6677: 12289, 28032: -21767, 10105: 8774, 627: 24722, 27190: 3954, -26665: -7354, 27566: -8037, 15625: -9453, -30151: -25954, -28349: 30379, -6142: 691, -9262: 24633, 27808: -5306, 11490: -10950, 22022: -705, 7283: -7208, 29941: 6208, -4204: -2121, -9279: 17669, -4498: -4582, -4833: 29055, -22069: 27589, 32004: -31982, 4036: 11622, -5971: 6511, 7362: -31402, 2132: 16965, -17605: 3529, 16899: -16958, 20305: -26766, 18755: 21882, 13064: -29474, 1391: -25296, 9071: -8029, -20305: 30895, 167: 21243, 23450: -32278, -22095: 13405, 12963: 18120, 24666: 28046, 14320: 8050, 30437: -12581, 17277: 15852, -19808: -27963, -23409: 24638, 29401: 15328, -21257: -3018, 28299: 29000, 18823: -8987, 15409: 9114, -2476: -12749, 5807: -25088, -17559: 19530, -3994: 32042, -23994: 11576, 17613: -11312, 24203: 30135, 14421: 29461, -8181: 17641, 6171: -20014, 31027: 1105, 20177: 11742, 28023: 10685, -5413: 22256, -29512: -27827, 26068: -31380, 10750: 9166, -19988: 26137, 6165: -12868, -9662: 15887, 12809: -12054, 25972: 23426, -3522: 11010, -13516: 10518, -20198: 8172, -20051: -21390, 17149: 27954, -25908: -3999, 22600: -21800, -15240: -21275, -12894: -31550, 11168: 6165, 1471: -30312, 25562: 31867, -3575: -5407, 16896: -21901, -31594: -2825, 24966: -2987, 31931: 19139, -671: 16835, -13289: 32113, -7420: -21883, -26225: -29508, 14029: -23627, 13600: 7738, 19823: 22879, -7278: -31931, -18518: -15028, -24285: 15271, 30158: -6041, -7778: -10728, 18967: -9084, 12216: 15282, 7667: -29473, -29079: 5065, 28475: 262, 9873: 455, 14700: 2632, -6257: 15024, 2641: -23165, 25766: -21115, 30853: -8411, 24163: -4764, -30666: 17364, -14056: 31344, -16470: -21166, 7863: -28957, 28281: -15377, 4107: -8950, -9388: -32765, 24227: -9133, -10558: 13655, 23295: 9762, -3019: -27437, 11095: 29763, 10609: 12051, -19079: 16494, -638: -5842, 4362: 27932, 2639: -25626, -3030: -14761, 21408: -18773, -21262: -4491, -5008: 1094, -11589: -2784, 15655: 29651, -19013: -9552, 7540: -28066, 18000: 17054, 29752: 18144, 28226: 27155, -12924: 7241, 22083: 13808, -18448: -3080, 29456: 16400, 53: -12710, -1221: 30244, -16504: 24240, 5545: -27714, -20630: -18870, -21090: 28104, 4959: 12418, -15608: 1794, -23432: -22218} +xs 2470012874 1108569466 2705233914 2105395150 # shrinks to ref m = {-26536: -10140, -31941: 2328, -23547: -9253, -28157: -17639, -2098: -25615, 9417: -4376, 5027: 16722, 17121: -24663, 8128: -25969, 25933: 18490, -25489: 10837, -13402: 29678, 31055: 14092, -3811: 19345, 3565: -15536, 8160: 25591, 21133: -5677, 31382: -12602, -4552: -6140, 23595: 6118, -5496: 2443, 25445: -32364, 1737: -5168, -9077: -15214, 7942: -27346, 503: 29459, 30229: 31798, -21623: -984, -20767: 1391, -20732: -5138, 179: -2480, -30700: 32256, 23991: -29242, 5811: -2677, 8242: -19246, 14001: 121, 23994: 15968, 16850: 22675, 27403: 20078, 28998: 29713, -18285: -28709, 15265: -345, -2024: -7961, -26394: -16075, -15563: -14632, 3611: -4743, -16600: 8421, 9494: 30533, -26355: -7995, -31604: 15030, -28372: -30678, -1460: 4493, 12812: 6867, 3327: 5994, -27683: -25261, -6712: 14346, 20460: 1089, 10960: 1352, 24869: -29446, -8174: 30195, 24471: -27707, 26252: 15759, -17935: 12699, -19327: 31902, 10672: -17255, -3178: -31772, 14367: 13488, 9093: 13209, -20473: -9178, -31120: 3147, -5795: -3982, -24184: 19687, -8033: 16211, -12944: 8417, -9993: 4190, 2100: 30585, -1397: -27306, 68: -17544, 12442: -4284, 7519: -12190, 22795: -29312, -21157: -16782, -32441: -15527, 3210: -4247, 32108: 9123, 24488: 25516, 11162: -10170, -19251: -2295, -28559: -4773, 31985: 172, -227: 30045, -2104: 26418, -3076: 15669, 14672: 12100, 7576: -13667, -5021: -32276, 21621: 29212, 13537: -19166, -2389: 8930, -4556: -31064, -10630: 3433, 29934: 12298, 6640: -32416, 29552: -6676, 2449: 9495, -20587: -24712, -12359: 29691, -26177: -31729, 4421: -9542, -9965: 7463, 28677: 26334, -27845: -6260, 13285: 11380, 32752: -20965, 15706: -17233, 29886: 13339, 17438: -28315, 26609: 30547, 15151: -15429, -2919: -19952, 16934: -32480, 26615: 24385, 233: -32369, -10268: -10139, 29343: -30102, -15885: 30182, 15822: 25778, -26549: -2360, 2001: -4014, -12019: -1196, 731: 29634, -29995: -22547, -15831: -27743, 1976: -14216, 24671: 21678, -10275: -5156, 28289: 17246, 12893: -32150, -16308: 7767, 5729: 11546, 18882: -31578, -4231: 18279, -25379: -31185, -1139: -16861, -18054: -8385, -31606: -23236, 21235: 7426, -6400: -7360, -8606: -2630, -22484: -11090, 15370: -5085, 5679: -17878, -28308: -24539, 9009: -24480, -16109: -19862, -20544: -20765, -6411: -28066, 11890: 21190, 4579: -7721, -22198: -22517, 338: -4143, 12184: -11969, -15946: -24141, -23654: 2485, 9886: -26974, 11733: 28587, -8243: -20115, 13309: 31556, -14397: -19926, 29872: 19550, -4716: -14669, 16769: 14751, 8353: 18931, -22070: -5371, 24224: -26199, 24823: -30739, 9421: -13020, 19874: -2767, -10193: 2881, 6660: 1643, -31321: -16602, -12356: -8592, 7484: 15900, 4220: 7816, 2781: -7331, 17673: 7955, 21734: -2072, -4406: -26944, -2747: 17863, 4584: -2492, 31654: 15772, -10883: 4363, -3737: 3686, -18179: 30440, 18460: 23217, -3702: 15120, 14407: -18596, 7749: -11497, -27197: 12065, 15409: 18406, 1457: 4533, 24941: 24486, 12520: -29147, 9179: 31948, -14078: -21063, -22741: -21277, 29691: 24484, 13093: 30490, 11422: -28999, 19850: 28538, 58: -1946, 26401: -32289, 16997: -26844, -23467: -28453, 24138: -6868, -14289: 2223, -3164: -12604, -24071: -11711, 6645: -19591, 17685: 9616, -29576: 31095, 15812: -19219, -30119: 20657, -9465: -20600, 5077: 19208, -10326: 3699, 27078: -4075, -7152: 28943, 14558: -22676, -10615: 31120, 29487: 29114, -6096: -1001, 5941: -21634, -30352: 30888, 582: -23140, 16391: 7248, 25557: -14944, 21501: 18193, 11316: 11352, 18183: 17500, -18516: 2584, -2107: -32422, -8402: 12344, -17372: 11869, -15723: 2627, -1765: 19581, 2975: 1, -5867: 23341, 25489: -2444, 9809: 21415, 29497: -18101, -25328: 28247, 9621: -3108, 28275: 8915, 6846: 3451, 28008: 18058, 6195: 10677, 12779: 1341, 13248: 30900, -18786: 27113, -26425: 9293, 16195: 8935, -2461: -16811, -31431: 4635, -9480: 779, -22487: 19715, -15600: -8938, 29782: -1315, 8079: -27635, 3322: 10561, -23910: -4240, -10716: 3872, 12155: -11450, -23322: -27745, 3206: 9309, -23080: 1961, 6761: -31058, 28940: -20745, -29586: -5915, -9310: -8874, 23578: -31849, -24336: 2811, -31640: 13432, 17145: 4078, -10857: 25423, -28879: 7602, 8971: -12084, -19239: 2917, -32289: 12788, 10482: -26779, 7196: 18090, 17174: -28319, -16874: -29949, -10772: 15992, -1774: 239, 5296: -15898, -8433: 14050, -12827: 28010, 29685: -21923, -4742: 18358, -9399: 13522, -3136: 23448, 9803: -30280, 4633: 9138, 22129: -3054, -24759: -3027, 13549: -10895, 770: 13115, -22180: -30951, 26425: 26303, 15351: -14655, -2361: 9031, 21063: -15719, 26334: -23261, 1253: 4242, 21284: -31915, -16220: 4816, 957: -25495, -454: 18872, 8183: 8829, -21137: -20303, -6282: 12896, -23187: 23, -32053: 21416, -924: -16666, -30888: 11634, 31358: 22911, -6028: -984, -28864: 9371, 28554: 18962, 13368: -9926, 25395: 11310, -22859: -15920, 24079: 24924, -20238: -29669, -2746: -24651, -21422: 21027, 30773: 9672, -8756: -14597, -11425: 30250, -8475: 3559, 14902: 23939, 32064: 4283, 15572: 18467, -8531: -31074, 26651: -5381, 27619: -17005, -29712: 2868, 16457: 20436, -11057: -2269, 3024: -15357, 15023: -26768, 14212: -26881, -19185: -18690, -4924: 7128, 23174: -20610, -9472: -16907, 17569: -23072, 20118: -14428, 9805: 26597, 6994: -8522, 2040: -32366, 25162: -31175, -1386: 16672, -22403: 26995, 7584: 27458, -17532: -141, 18644: 3005, 24808: 28562, 9341: -5445, -25768: 32689, 16892: 17059, -30689: -12568, 28747: -19363, -2091: 1259, -11643: -20020} +xs 1943497849 4012822781 687301666 4052323690 # shrinks to ref input = {-14552: -9546, -24687: 4553, -5948: -11033, -30216: 31225, -1329: 18654, 25756: 28243, 26320: 32308, 14380: 20303, 30195: -29219, 12769: -13515, 4261: -10098, -15032: 27827, 22373: -30648, -18543: -27064, 20765: -17004, -7193: 29946, 17191: -11212, -9550: 6145, 30413: -3896, 25650: 15492, 6991: -3005, -27117: -18341, -31108: -14720, 2037: -9230, 21209: -17697, -17478: -15083, -7092: -21790, -18620: -19170, 7611: -13546, -10267: -19624, -32677: 26187, 23727: 29533, -3698: -10243, 5300: -3822, 346: -5404, -22233: 16053, 18668: 22996, 2804: 14570, -7140: -914, 29328: 531, 22194: 580, -29271: 32284, -30855: -25589, -24039: 22663, -17584: -7090, 30655: -22419, 6962: 3019, -11388: -29702, 7470: 10191, 12733: -8953, 31781: 29536, -4713: 28624, 29225: 2850, 10639: -17353, 28644: -28651, 27509: 26751, -21653: -3068, -23302: 16505, 23875: -4223, -12294: 8408, 22871: -26300, -11807: -10674, 11617: -20802, -12917: -3942, 12525: 8275, -28360: 25924, -11694: -17660, -8376: -23674, 28022: -11052, 1701: 16466, -10152: 27738, 25396: 3306, 27309: -15176, -24958: 25332, 13257: -9440, 28652: -31476, 28824: -25210, 19544: -26806, -16312: -554, -29314: -25624, -6344: -27482, 12638: 11012, 29993: -5753, -7052: -5445, 6885: -32534, -2710: 15172, 25838: -29888, -4162: 25600, 8274: 3660, 14914: -11250, 18077: 21149, 30865: 29780, 7652: -29810, -27575: -22324, 27190: 13088, -28712: -24931, 32575: 14212, 16100: 2414, 22459: -12558, 12914: 12488, -5756: 26535, -11609: 21588, -23178: 22887, -6623: 10056, 11425: 5119, -24807: 1930, 20747: -2695, 22174: 28280, 26661: -7627, -22429: 26131, 30256: -13483, -23654: -6600, 23857: 20134, -6396: 26307, 27673: -19775, 21325: -20165, 18149: -5624, -16291: 20822, 30797: -19910, -16498: -12698, -28455: -13778, -19937: 16733, 22899: 23440, 20491: -29335, 6724: -14015, 20327: 29236, -13404: 17062, 21857: 21139, -11068: -11817, -24465: -19689, 13258: -20349, -8846: 24655, -14100: -5192, 18797: -4050, 15238: -20885, 21853: -14590, -21265: -5581, 7767: 16287, -29108: -18338, 15365: -10543, -28008: 20715, -27679: 9383, 28946: -32523, -6815: -11660, 25311: -30043, -24259: -32354, -26480: -29813, -4922: -31962, -23235: -14838, -28240: -16289, -20429: -10753, -31466: 4099, 17742: 9919, 22328: -29633, 11484: 5947, -30743: -3454, 27329: -28404, -1440: 16220, -21058: -15381, -7339: 775, 23003: 3428, -29181: -11177, -7918: 18487, 26135: -17235, 31493: -32374, 8674: -29831, 23135: 3319, 22008: 26647, 14087: 926, 9495: 32645, -28424: 4358, -28839: -25000, 12270: 1203, -3843: 24513, 28974: 3537, -11154: 20241, -308: 15509, -1063: 1938, 22352: 16339, 22065: -4794, 25625: 30704, -29994: 25473, -32588: 8066, -19799: -28784, -16369: -7522, 12819: -26116, -10: -12210, 23530: -8239, -8702: 15218, -29559: -6059, 17386: 8272, 9791: 11158, 31268: -23502, 839: -12740, -20953: 30929, -6498: -6179, 18058: 26452, 17715: 21182, -444: 26708, -12166: -10624, -17286: -11707, -5285: 28283, 26686: 28422, -27560: 24488, -9092: -21679, -341: 5249, -1777: -19160, -8798: -18074, 5664: -26770, 8831: 21172, -15630: 10171, 10815: -23739, 10322: -14746, 3683: -28968, -968: -11470, 4300: -21106, 17329: -3943, 919: 15039, 11736: 24420, 18566: 8425, -6499: 17007, 1038: -20933, -1760: 2435, 32364: 17255, -23412: -10508, -20606: -2288, -12261: -24932, 23266: -16759, 29366: -24835, -4536: -26835, 11130: 15321, 9689: -25898, 10497: -8, 8379: -17866, 32503: 1391, -7464: -7476, -10905: 21006, 28934: 27973, -2489: 22253, 18422: -3749, -16897: -26476, 26037: 24177, 25372: -5235, -17793: 5394, -31916: 8290, 2514: 17926, -12681: 10612, -31402: 4216, -21993: 5489, -333: -29732, -7208: 12324, -2259: 7182, -14269: 19700, 7113: -6447, 312: 21681, 16777: -5191, 19799: -22785, -16984: 20498, 13781: -19721, -15005: -27421, -5197: 16418, -26014: 14386, -21116: -29472, 22218: -3249, -12769: 13282, -962: 27871, 323: -26453, -9145: 28365, 20899: 5521, 2983: -28582, 27272: 17304, 14965: 6793, 1119: -8804, 11980: 24389, -27467: 31369, -6059: 22193, 11148: -13064, 28685: 13279, 9266: 23559, 491: 31840, -24358: 20417, -1039: 32656, -8354: 27428, -6823: 13026, 7306: -28986, -29124: -12391, 11358: 19868, 21852: 31747, -354: 17738, -6380: -31076, 6993: -3593, 7749: -26991, -5736: 26845, -23757: -25868, -23018: 21291, -29482: -13037, -28028: -17152, -11500: -2400, 14240: 27368, 8517: -7890, 3318: 26016, 8702: -21694, -15698: -18674, -29992: -16745, 17497: 3921, 17256: 23908, 12994: 16354, -12133: -5976, -9636: -19253, 13662: 26694, -5291: -27961, -19711: -2634, 24676: 200, -21683: -20419, -10755: -20201, 5389: -24265, -18644: 25881, 24013: 26905, -15710: -40, -1078: 24024, 29202: 25073, 7358: 5121, -23181: -31628, 10282: -26184, -20910: -2762, 31789: -11576, -15966: 18578, -14285: 3170, 1448: -13499, -10080: 23097, 9012: -30126, -15463: -12150, 20289: 31453, -23544: -15457, 14694: -5005, 25006: -25213, 20402: -18375, 29679: 20672, -4570: -7111, 22495: -6454, 28869: 31665, 14191: 13852, 16134: 32353, 4529: 8494, 19093: 6864, -794: 18776, 17957: -11241, 25597: -20134, 18037: -1679, 27835: 3288, 22315: -10272, 13032: 9697, -20215: 3797, -12773: -983, 25848: -4873, 19596: 9706, 8030: -28925, 30246: 12946, 7467: -25254, -10731: 6363, 18631: 8976, 1414: -13096, 1779: 15953, -3595: 21321, 339: -8066, -7639: 14039, 20195: 12164, 7156: -11669, 16411: -8927, 13534: -14503, 13577: 17546, -27772: -32545, -6421: -3173, -12316: 16200, -31884: 603, 12395: 3034, 22659: 25898, 30481: -23170, -16623: 20360, -20279: 30762, 3968: -13181, -2313: -4445, -13314: 13183, 17186: -472, -25465: -11926, -12985: 12936, -17260: 21153, 14971: 366, 5035: 29873, 29: 19702, -29547: -10586, -10368: 11518, -13759: -4543, -29208: -4931, 1605: -15282, 22500: 24270, -25324: -150, -24578: -5930, -25949: 21945, -10053: 2314, 19195: 24191, -6760: 32697, -8885: 28695, 12676: -18931, -24963: 5956, -11667: -32632, 3496: -7015, -3422: 24361, 17031: -19643, -21362: 28410, 11868: -24693, 26928: -25916, -8771: -10298, -19434: 29046, 16057: -21815, -28508: -1488, 17240: -23998, 3146: 4003, -8669: 1658, -2885: 3442, 19212: -25066, 8584: -30453, -19749: 25649, 12925: 1864, -7982: -17592, -18312: -6020, 26066: -12698, 10168: 2258, 23411: -27324, 20913: 2058, -17161: -2704, -28674: -8941, 19334: -154, 29314: -18570, -4291: 13987, 27890: -10595, -6139: -19690, -2185: 29099, -19246: -21481, 18345: -7746, 8792: 32374, -12093: -11963, 27898: 28419, -2679: 31973, -6053: -9814, 28750: -1279, 5512: -22468, 24559: 13801, 29152: 10421, -8834: 21875, -11673: 15773, 28602: -9755, -5742: 6786, 13086: 15119, -10716: 23940, -31277: 6551, -12006: 16878, 31399: 15139, -3499: -14162, -7428: -10133, 31533: -4236, -20111: 23374, -13506: -28699, 31291: 27230, -32598: -7092, -5972: 31899, 15397: -8419, 15791: -2952, 24123: 9853, -32197: -7823, 12564: -18593, 16139: 21230, -23524: -28360, 6509: 20623, -8275: 31514, -6607: -5333, 5101: 31408, 23166: 21657, -12672: 8924, 1406: -11027, -24417: -3430, 27934: -17823, -7960: -29901, -20662: 24784, 9478: -22265, -3096: -26803, -5897: 23795, 29566: 26527, -19057: -10328, -22202: 18967, 11290: 32741, 14225: 4804, -31177: 15798, -23514: -7563, 21445: 15844, 14156: 8570, -23968: -24474, 12089: 5498, -14198: -26135, 12664: -23411, 11111: 27354, 15998: 11423, 2891: 21555, -3889: 17061, 32491: -4625, 110: -9137, -20559: -6986, -28721: 3288, 6697: -23898, 8774: -6890, -24838: 20366, 31820: 27280, 14127: 10447, 605: -23336, -28271: -9387, -1486: -28143, 1623: 19882, 30022: -7494, 16398: 31225, -20320: -23582, -23295: -17336, -14291: -775, 3270: 20106, 11662: 16973, 29041: 3377, 7387: -16397, 18767: 32565, 5022: 19191, 16397: -31024, -16106: 13405, -31898: -23690, -25746: 17046, -8847: -29236, 28656: 21644, -11311: -25314, 4515: -19390, -15847: -1245, -5025: 24474, 24302: 28820, -31534: 24028, -14548: -21272, 20722: -27070, -24083: 29927, -27812: 19042, -18194: 5028, -29732: -8181, 20316: 16946, 3176: -32144, -30223: -25654, 202: 22052, -20234: 6669, 18732: 15730, 7127: -27128, -2948: -22493, -21733: 27859, 25166: -31535, -27174: 28732, -14476: 5256, 20346: -27358, 6308: 18033, -10411: 12780, -5469: -28028, 4884: -15738, -12442: -3065, 24311: -21682, 18679: -10632, -13091: 25595, -18882: 31353, 23626: 20687, -17201: 13186, 4270: 16793, -22089: 5358, 4374: -23552, -13011: 5661, -14593: 1052, -10586: -18438, 9093: -3136, -19492: -30355, -5066: 24396, -9852: 13836, 8770: 30757, -18672: -13421, 16224: -10802, 21800: 12639, -213: 28223, 22311: -6756, 7182: 31529, 19224: 16315, 20067: -19940, 10720: -12330, 8384: 14353, 27730: -24075, -18309: 4570, 5808: -32765, 14330: -24746, -19632: -3605, 4228: 25887, 28783: -30008, 16483: -20439, 16655: 26861, -10047: -14259, 30091: 29732, 29182: -13397, -26897: 14659, -17202: 16830, -15265: -16433, 18554: 18464, 3269: -15505, -11054: -20924, -5253: 3749, 14888: -553, 15310: 29010, 3194: 31220, -13770: 21130, 4236: -15365, 13546: -11695, 32688: -16898, 24524: -8344, -2968: 25207, 1449: 26456, 29046: -5209, 12133: -27981, -27130: -21148, -3586: -24606}, index_rand = 6181253659715007859 +xs 3094145122 1848048556 41621330 1587738279 # shrinks to ref input = {25109: 17547, 13167: -24835, 32450: -27886, 28704: 27530, -29237: -31051, 17202: -31179, -22358: 15751, -17715: -2518, 82: -27363, -26280: -12489, -10711: 1113, 28197: -29265, -12233: 15499, 1578: 18570, -10956: 7886, 957: -15131, -26652: -19109, -1698: 7038, -3697: -2352, -18762: 4688, 2143: -17488, -30936: -28216, 26547: 20891, 20001: -10566, 20162: 12139, -15042: 4332, 23226: 835, -1720: 26602, -9048: -19721, -29320: -13680, 30000: -7286, -3693: -16312, -30022: -21864, 29541: 16785, 4006: -20908, -29599: 14040, -17690: 24907, -3766: 16608, 22217: -29766, -29552: -3913, -4046: -20703, -26412: 21205, -15898: 17844, -4553: 32030, 30908: 18124, -1065: 27619, 1642: -19186, 31516: 28398, -22847: 5892, -31043: 21198, -20284: 25965, -27740: 4090, -750: 29603, 29546: -7601, 19831: 16923, -27337: 27061, -5052: -22512, 19028: 22656, -6128: -20716, -5324: -2624, 7273: 5987, 26259: 28589, -5682: 24455, 19425: -13458, -8687: 1837, -29081: -5536, -5126: 19859, -23172: -26061, -17454: -9093, -14495: -19415, 124: 27981, -214: -15589, 17580: 24995, -22303: 227, -2043: -17283, 13309: -29027, -22094: -31943, -1826: 12330, -26959: 19945, 22155: 4915, 16: 1005, -6802: -8951, -29879: 4766, 21350: 7196, -4292: -29428, -17591: 7350, -23475: 20767, 23372: 13739, -16316: -30392, 17391: 5141, -10827: 27764, -11304: 7731, -4247: -21446, 8251: -19738, -568: 8414, 14787: 5321, 2403: -17445, -19412: -16874, 16247: -30651, 11946: -29414, -7725: -10389, -2002: -20578, -12689: -21992, 15800: -451, 32435: 1683, 16805: 11493, -8068: 32206, 27386: 26184, -14311: 21859, 7208: 19308, -13115: 24029, 32222: 19098, -3951: 20703, 10184: 5095, -3235: 29199, 7358: 3163, -9539: 23015, 17802: -31374, -12478: 18169, 21253: 2717, -4126: 30376, 31545: 13768, 14466: 10983, 26903: -7058, -8377: 21868, -15947: 21121, 31358: -30749, -22714: 23423, 17855: 9349, 7118: -3573, 20807: 30872, -19809: 19037, 3084: 622, -13442: -19023, -9314: 14811, 19551: 9175, 13945: -24551, -9482: 14832, 4058: -11363, -29175: 3097, 26866: -6501, -19528: 16419, 13884: -10693, -30894: 18387, 2434: -11471, -29588: 8302, 9537: 26353, 11223: -4669, 32503: -8454, -17566: -12769, 2898: 31182, -19042: 2208, 18941: -22060, -22700: -31888, -11067: -21667, -23130: -13776, 29835: 5369, -15197: -21652, -31889: 23653, 19121: -20925, -4888: 11878, -23301: -32625, -12188: 18858, 7983: -19066, 30772: 18792, 18565: -29423, -30448: -28531, -29781: -27670, -23123: 24404, -8686: -5154, 1956: 28781, -7050: -19514, -21874: -15534, 27434: 2933, 11568: 8591, 8645: -32175, -24288: -32065, 23708: -16804, -102: -20155, -21298: -10486, -5606: 25010, -6095: -10305, -19200: -11318, -2702: -31591, 10484: -30488, 12966: 18734, 19351: -29225, -10379: 28706, -13211: 13219, -30684: -30410, 12809: 3245, -9528: -14612, -13917: 30016, 15751: 14348, -16078: -20918, 21568: 22488, 18004: 30534, -19602: 18121, 13959: 22532, -9411: 17916, -13153: -12283, -16441: 24688, -31877: -25633, -10943: 21681, -12241: 25973, 18048: -16131, -32576: 16074, -23799: 30191, -27572: -4842, -9917: 17632, 28907: 26864, 1029: -8790, -15458: 5122, 617: 31966, 5083: 20195, 26118: -27966, -31719: 261, -30897: 26416, -28104: 25353, -25183: 10371, -25051: -9876, -8676: -2203, -25965: -25244, 14552: -27117, -6195: -9440, 6733: -15895, -16548: 22340, 7795: -7156, -5548: -8170, 1975: 11313, 26002: 13579, -1090: 16028, 3119: -22116, -26790: 3213, -12524: -21450, 19788: -30362, -11778: 7254, -24041: 18664, 10038: 10500, 12731: 10291, 19886: 8630, -13579: 4280, -10199: 16578, -10637: 18165, -3835: 6271, 14929: 24076, 27938: -31473, -14770: 5512, 15441: -3706, -17185: 2295, 15932: 20222, 13258: -18255, 24353: -11049, 24897: -6737, 365: -23551, 23329: 30521, -31648: -13380, -1552: -25692, -5206: -1325, -27419: 31094, -51: -28413, 12361: -29699, 5402: 26930, -27529: 7188, -12050: -7233, -7996: 20657, -18903: -31229, 2184: -27864, -22198: 8189, -14333: -3151, -8819: 32208, -25427: -1465, -13361: 23768, 25140: -13818, -18482: 5019, -9847: -31791, -17654: -16678, -18171: -25938, 24839: -22327, -10299: 17415, -517: -9938, 11604: 19413, -20522: 25880, -16853: 12843, -19711: 6243, -2217: 17848, 31544: -23358, 32481: -20104, 916: -13297, 21632: 27432, -20301: -905, -28748: -18375, -18946: -26872, -27139: 23619, -28341: -2690, -14751: 3261, -31340: -5866, 14129: -1873, -17466: -19221, -27794: -25683, -16132: -26856, -6446: 21798, -26329: -20765, -19511: 31669, -25708: -5275, 10217: 797, -9016: -17110, 7696: 13723, 6083: -19072, 31100: 8435, 8017: 10175, -23973: -199, 25418: 21954, -5106: 15703, -29119: -14678, -23448: -14905, -1334: 27615, -25389: 21402, 5764: -14910, -25059: -20274, 32586: -21603, 27022: 24446, 30370: -23901, -31423: 31764, -21135: -21011, -6284: 14914, -20672: -4657, 3691: 9397, 1305: -26046, -29806: 1663, 11409: -9037, -25440: 12737, -16350: -30111, -15664: 4544, 29290: -19087, -10773: -15820, -1299: 31105, -9945: -24879, 25445: -1393, 17568: -11207, 2868: 11240, -14478: -5443, -29749: 22046, 30402: 18906, -14676: 28148, -12434: 19407, -8904: -31377, 32723: 19548, 26961: -12468, -20695: 24529, -11186: -16253, 17983: -16005, -22681: 29406, -32124: -28864, 4551: -32279, 16423: 21410, -29467: 30297, -32316: -11084, 19168: 13447, 31777: -17253, -20788: 30789, 10397: 26717, -16290: 10403, 3436: -20939, 24973: 21047, -23977: 19143, -21115: 16465, -32140: -27035, 29494: 19758, -31925: 16559, 25544: 14705, 16117: 2902, 16076: 1994, 1259: -4130, 11871: -31322, 31923: -12428, 6485: 16367, -15055: 17454, -32536: -23142, 19287: -30036, 19046: -6360, 30467: -20193, -1352: 19442, -24389: -32203, -25508: 28905, 13432: -28476, 15794: -2020, 7907: 12590, 19319: -31856, -10096: -8759, 9365: 24849, -11559: 25438, 23762: 21598, -7248: 22542, -16926: 12934, -24708: 4222, 2179: 3309, 1855: -8693, 10786: 29825, 18783: 25809, -5169: 5570, -8235: -4664, -20234: 26252, 18273: -26922, -4496: 19147, 4458: -20329, -18952: -31435, 22439: -27690, -3304: -7512, -17425: 6385, 2885: -18520, 2478: -17666, -16036: 22920, -8658: -18048, -7204: -25509, 28983: 4786, -9146: 16439, -26893: -27056, -31037: 17541, 643: 17042, 27085: 11808, 26037: 20956, 4234: 1346, -14815: -6582, 25700: -8577, -10298: -23247, 5728: 10020, -25496: 10378, -27275: 28186, 24689: -21421, 32092: -15135, 17254: -370, 13808: 18349, 19084: -163, 16447: -25693, -22306: 26140, -1695: 3490, 32119: -6821, 25084: 21803, 10922: -26376, 27134: 21743, 30570: 8146, -12987: 6435, -20456: -22516, -31704: 12485, -23916: 4096, -26088: 20130, -19159: -28657, -3808: -29934, 21346: 18600, -17642: 22758, -9589: 9627, -12541: -16450, 3120: -31143, -5758: -4025, -14764: 22952, 26792: -16315, 12268: -8062, -31344: 20767, -10729: 652, 32354: 30556, 10533: 27076, 18563: 31611, -15395: -16343, -7271: 28710, 28693: -28840, 19304: -31194, 4838: -28332, -15421: 18530, 24139: -28363, -31872: 15347, 17464: -17470, 30063: -21708, -6516: -17705, 14553: 20142, 29460: -4329, -9381: -14281, 3286: 26530, -25478: 18858, 8614: 12250, 3087: 21051, -32628: 24370, -15651: -18351, 8024: 4382, 15805: -11203, -1077: 8609, 32285: -11583, -27614: 7211, -10535: 22639, -20099: 16870, 21230: 28095, 612: -23352, -5544: -26504, -25887: 2679, 14181: -26845, -31967: -7583, 26010: -15169, -6467: 12825, 24107: 4381, 3800: -2605, 2010: -21114, -1414: 6971, -12659: -21065, 20831: 9711, 20073: -8964, -24951: -3223, -6740: -32200, -8304: -23492, 27109: -8227, -17744: -25257, -28537: 18637, -18411: -15041, -25173: 928, -25903: -13895, -21831: -3009, -25678: 1895, 30480: 17166, -25850: 16586, 12531: -10102, 19095: -6338, -26672: -9944, 11671: 1505, -13311: 12087, 8454: 19381, -12936: -31002, -17139: 19189, 11596: 20259, -25535: 3542, 20951: -18777, -6500: -18332, 30742: -277, 31676: -30490, -27517: -19880, -25374: 32088, 21483: -10823, -16979: -18696, 14561: 13047, -13368: -16548, 4720: -14672, -29316: -19115, 1395: 9605, -10992: -10275, -21747: 8507, -4734: -6057, -30595: 16035, -24700: 22816, -2210: 19173, 7671: 24589, 27460: 5788, -10899: -21848, -26840: -3095, -28802: -2572, -3431: -5783, -21943: -31626, -22611: 26127, 3213: 396, -15957: 17787, -11959: 17422, 1613: 22455, 32292: -9957, -23718: -32341, 2795: 4614, -15162: 2211, 26391: 18246, 885: -15549, -29735: 26493, -17763: -9509, 832: 15026, -23215: 22609, 28230: 20969, -32629: 28951, 10402: -11520, 26729: 11732, 14065: -4855, -12988: 5456, -24309: -15464, -20942: -11584, -18355: 1571, 16650: -13337, -7873: -13362, 11313: -19130, 20194: -6007, -9755: -26600, -25013: 21165, -14900: 26513, 17728: 17821, -28277: -25003, -14757: 5100, 13577: -9806, -22115: 27298, 14668: -23429, -25174: -28161, 2367: 4067, -23795: 27843, -3780: 5571, 30910: -13600, 11355: -21254, -7086: 2278, -13419: 3221, 22732: 21622, 24582: 15497, -4771: -18262, -705: -24363, -6490: 13550, -3098: -31941, -20378: -12040, 25336: -18191, 21299: 822, -30797: -23895, -17162: 18699, 228: -17254, -12250: -21242, 4730: -2067, 8150: -16241, 15707: -29248, 6042: 32137, -26556: 15175, 14154: -28226, 9935: -23158, -29846: -22516, 9461: -29500, 11475: -19325, 31974: 2561, 1330: 8660, -1271: -17382, 3482: -8519, -25956: 15786, 25713: 3023, -394: -27817, 19478: 32434, -12289: 12678, -2608: 9330, -26485: -7465, -27840: 12092, -31666: 3630, 15748: -11979, 30892: 30006, -21505: -30879, 10340: 14885, 11619: 5575, -7216: -30397, -15140: -11637, 16761: -16433, -21925: 12562, 28429: 18057, -12739: -25584, 13377: -24419, -3752: 22641, 21444: -30136, -27669: 23044, 521: 28473, 9286: 5030, 29721: -14329, 10899: 8578, 9145: 15065, -30537: -15209, -21221: -5525, -16581: -17871, 27355: 23268, 56: 17851, -2659: 22647, -1630: 31617, -30759: -18270, -28584: -4801, 1875: 10171, -8604: -27218, -16634: -19036, -17802: -16413, 13379: -6140, 23704: 6880, 8765: -1719, -21255: -6806, -19546: 23388, -22379: -4391, -17126: -18724, -21340: -9110, 18182: -10221, -2471: 2014, 13850: 25597, 18153: -5252, 13325: -21738, -27130: 19737, 8324: -57, 16162: 17766, 30735: -1934, -13008: 18027, -14177: -26344, -3410: -15352, -22373: 13456, 23820: 30037, -16682: -8556, 2771: 32686, 7700: 2288, -15586: 23950, -23520: -30119, 24085: -27227, 28343: -27847, 11661: 11000, -2690: 6058, -30191: 21458, -10655: -20377, -18377: 8672, 15970: 29352, 13854: -28243, -12566: 12732, -11424: -5467, -13021: 19087, 4285: -20833, 4850: 15552, -28485: -26386, 8290: 259, -11749: 19444, 26075: -905, 30605: -1488, 6438: 27983, 9535: 25448, 10668: -26317, 9228: 2787, -9342: 6996, 3077: 2077, 14575: -17406, -13263: -28914, -16497: -8505, 17807: 29989, 17642: 27683, -7320: 22167, -28413: 23955, -29262: 1610, -7611: 20341, 13742: -22167, 1948: -3978, -26335: -18254, 7765: 4432, 22110: -27003, -3021: -16057, 15606: -23087, 8263: -28114, -28389: 28514, -24292: -3802, 593: -22012, -11632: 18700, -8493: -17690, -24000: 29402, -30405: 18870, 2054: -12353, 6302: 13902, 14627: 20456, -20713: -6796, 59: -27945, 15401: 3763, -31282: 2136, -30080: -21448, 596: 31173, -3777: 10969, -27062: -12955, 10983: -10220, 23508: 7525, 18741: -17043, -2752: -3564, 1045: 29156, -23741: -18438, -20412: -20083, 31569: 5108, -19554: 24719, -31716: -26184, 3254: 30063, -23755: -474, -10974: 24808, 32587: 24856, 13274: -13294, -23140: -5331, -1612: -8780, -12950: 16875, -7602: -1367, -8407: 24480, -18043: -18814, 5557: -14426, 23239: -32629, 12839: 10100, -23881: -9397, 9000: 1367, -16739: 24959, 27731: -23120, 1404: 16785, 26722: 2067, 13575: 21126, -4894: 14658, 13344: -7459, -3522: 8125, 10021: -14961, -10653: -5225, -23802: 25545, -6938: -12602, 3949: -14698, 29660: 11675, -2952: -7008, -30398: 12733, 24591: -27470, -8108: -1693, 8378: 6293, 19409: 107, -24293: 13979, -26643: 24382, -8928: 14933, -15145: -3845, -22551: 10211, 425: -15224, 16478: 7707, 2338: 16763, -23791: 31613, -8916: 7382, -5384: -31297, 10300: -1373, -27891: 1916, 2999: -30008, 1165: 24301, -397: -18055, -4201: -8619, -23959: -1718, 16219: -26007, -15100: -24529, -32527: -12160, 19770: -292, -10008: 22619, -26772: 3604, 236: 105, -7879: 31666, 19242: 10567, -6348: 14664, 5832: 13312, 1492: 10163, 8927: 21565, -26318: -18183, -10174: -25158, 9807: -26056, 26076: 17814, -15366: -19761, 2621: 12814, 30193: -31344, 4206: -18921, 7126: 22715, 16128: -10023, 25936: -31820}, index_rand = 5224467844040644997 +xs 361304641 2604218693 3136857884 1914902562 # shrinks to ref input = {-19354: 24819, -16292: -12090, -14434: -17000, 7065: 3299, -18458: 22292, 19194: 12574, 1: 18507, 32098: 548, 3309: 3711, 30631: 31499, -9540: -31601, 29472: 15053, 28278: 16574, 10805: -6409, 1937: -29445, -27617: -19598, 14618: -13991, -31216: -14546, -8002: -19976, 24690: -11392, 19023: 6532, -4475: -15383, -3276: 3043, -22021: -831, 7566: 28669, 7414: 7538, 3289: 1498, 32294: 11245, 27957: -24717, 394: -5551, -25550: 7578, -10781: 17801, -15265: 22301, -22600: -27228, 18049: 28811, -5680: -4765, 6393: -26312, -3763: 19239, 12387: -7834, -17270: 15102, -849: -18294, -11185: -8909, 5848: 28816, 4822: -1284, 9283: 17434, 5749: 13204, 11282: 18054, -30054: -1590, -5733: -8222, 27256: -17099, 25828: 27982, -26680: -20087, -31170: -3715, -27215: 20014, -3297: -27491, -4237: -9165, -3803: 6289, -13220: -7922, -31962: 28987, 15542: 18604, -17133: -25302, 13426: -25405, 2685: 15869, 5642: -8384, -8618: -21494, 696: -6333, 30169: 22735, -31498: -2698, -16350: -30346, 23455: -30868, 24880: 8411, 12752: -26951, 807: 5479, -31915: -6948, -6797: 32084, -27450: -5011, 12562: -16186, 16308: 9586, 8802: -8309, 22958: 1367, 5967: -7809, 7342: 9794, -21809: -30257, 22051: -8714, 11489: 27098, 9636: -24412, -22926: 4643, 16522: 3404, -13679: 20161, -20645: -4604, -27194: 2276, -1203: -23043, 15177: -16488, 17368: 19938, 18129: 13518, 29506: 13683, 30487: 29314, 22806: 20773, -1727: -29216, 8206: -19496, 7127: -23074, -2964: 1656, -8043: -15180, 31783: -24797, -14997: -8251, -9625: -985, -3485: -1572, 3259: 1018, 4124: 31363, -6871: 11567, -15128: -13650, -30770: 9112, -2638: 21963, -19057: 16043, 20685: 214, 17778: 6821, 27947: 8329, -13235: -3670, -15954: -21158, 12517: 13054, 23898: 16751, 16216: -18722, 15237: -7624, -31732: 21365, 30822: -28157, -17438: -30023, -26596: 3301, -13414: 5061, 17372: -8376, 30362: 28469, -20309: 143, 24393: 10508, -6411: 32337, -18972: 19110, 30365: 10104, -5140: 19909, 11898: 18406, -14442: -15467, -32552: 22492, -11355: 5350, -8307: -18294, 17475: 7093, 22597: 1992, 20469: 30777, -32614: -6165, 32573: 8339, 1514: 25969, 10701: -20617, -3021: -12256, 6587: 18950, -25402: 12031, -9936: 16285, -29946: 22912, -14064: -10944, 671: 13716, 5073: 7865, 5197: -26128, 19416: 9507, -30681: 8287, -21677: 28198, 3770: -21258, 14103: -8796, 21840: 6932, -14302: -3120, 18835: -21353, -19863: -30682, 30904: -24579, 23767: -2876, 14140: -7923, 23444: -8002, 20015: 24236, -8959: -10261, 19803: 10542, 13739: 29511, -28569: -14754, -3714: -30519, -14450: 8383, -11394: -30165, -32079: -13880, 13248: -30479, 11781: 9474, -10436: -2853, 6759: 27954, 25845: 29391, -31738: -26454, 30132: -23278, -18345: -23422, -25979: 16664, 9607: 29137, 8336: 22464, 20324: -23583, 15078: 31805, -28529: -17128, -12412: 9041, 5972: -27525, 10224: -32042, -6332: 7448, 26995: 20876, -12473: -28199, -23999: -23159, -18299: 21242, -14408: -31328, -29246: -10044, -10164: -28095, -27052: -5400, 10173: -25267, 23822: -17900, -23953: -13219, 28791: -8090, -21909: 21407, 17530: 26269, 29655: 29973, -16374: -16957, 13982: -24366, 11639: -20136, -18021: -4470, -28776: -14271, -19637: 20591, 17096: -6224, 19899: -7035, 10911: -124, 5706: -16549, 2364: -24950, -10944: 31678, 31723: 11433, 6413: 4440, 32675: 19466, 27096: -13819, -10806: 6633, -4937: 28751, -27140: -13550, -12557: 13547, 8629: 3152, 3413: 2565, -25866: 10729, -15566: -15218, -3621: -23194, 7527: -27521, -24127: -29997, 12909: -25868, 31772: 4680, 31014: 29821, 18678: -16508, 30298: 9039, 14505: -3668, 22669: -10595, 26152: -16178, 24944: -8114, 16694: -19338, -14047: 24498, -30270: 26317, -16665: -26461, -30656: 20249, 25517: -20809, -23571: 1882, 23007: 17866, -25659: 8076, -23717: -5810, 6904: 2115, 11784: -31335, 30197: 18033, 12572: -30508, 17268: -18072, 10674: -22655, 29365: 24132, -17185: 10599, 8749: -31736, -3334: 32668, 21915: -2453, 17556: -26978, -9373: 26250, 22616: 30289, 2165: 15435, 10766: 1818, 13715: -20952, 2935: -9271, 25227: 15051, 13045: 23934, 13260: 30812, 10690: -10114, 824: 8266, -14298: -13127, 11000: -14100, -18008: 21650, -8299: 6540, 3128: -12265, -7224: -8911, 19209: 14023, -8038: 24840, -26622: -26079, 14895: 22828, 31625: 20961, -2636: 19675, -17021: -28086, -5946: 15939, -32313: -153, -14012: 30196, 31144: 31395, 7996: 24091, 28923: -29327, -9247: 15709, -26391: -9285, -14883: 27089, -15544: -12422, 1374: 28261, -22870: -12032, 26286: -20763, 4080: 2040, -14599: 9484, 32660: -3226, -22977: 5487, 18067: 3363, -6489: -21852, -10804: -13137, 27933: 20036, 15275: -12004, -13892: -676, 16130: 22039, -24538: 21841, 24641: -3642, 21784: -26054, -20651: -27826, 5295: 32093, -24305: -3414, -18446: 10556, 4517: 526, 24294: 10881, 24194: 26364, -13901: 18395, -12783: -27360, -713: -29957, 8644: 14950, -6324: 9260, 9506: -30362, -29129: 6181, -3784: 18178, -28466: -21361, -18659: 3987, -10595: -19837, 7499: 30194, -12558: 7406, 28463: 12837, 27107: -2298, -6932: 4389, -32374: 25500, 23110: -23112, 8747: -22926, 4097: -2613, 3462: 30698, 3398: 31612, 30467: 23139, -1641: -3740, 3293: -19082, -20228: 31473, 20793: -17194, 17724: -25522, 8074: 32013, 23712: 19733, 31907: 8354, 12744: 28197, -24606: -11268, 23637: 3704, -3436: -24423, -2739: 10852, -4260: 18850, 12969: 6263, -26425: -6431, -28020: 25049, 31644: -1993, -20327: -6272, 22470: 17788, -28205: 31716, -21534: 32498, -4889: 19628, -825: 16644, -30248: -31584, -26932: -3743, -28597: 27796, 10641: 29403, 18736: 11379, 17445: 4741, 15954: -22253, 28955: 3994, -18758: -20179, -16666: -22951, -23409: 7546, 28441: 28286, -6600: 29204, 245: 5060, 21723: -31646, 13693: -28832, 17526: 19157, -3421: -30798, -12920: 25702, -13396: 4699, 25125: -17956, -378: 30900, -29352: 13943, 21551: -27295, -31207: 316, -5104: -20171, 10981: -14599, 13127: 7748, 12536: 20062, 15315: -493, 10111: 24216, 3207: -31216, 18499: -20515, 4815: 26753, 24865: -18658, 28562: -27549, -14256: -3818, 22292: 9007, 9550: -22562, -18174: -5902, 18354: -4282, -14416: 6361, -20722: -24289, 31715: 29227, 29704: 15935, -5533: -8673, 10845: -30941, 14160: 12144, 1992: 1318, -11404: 28138, -5428: 18711, -1624: 3223, -20437: 19171, -13983: -15469, 29721: -11600, -32689: 14340, -12675: 7713, -21501: 21229, -3729: 27686, 13580: -5131, -17708: 16700, 20809: 25221, -28564: -3272, 29509: 26850, -9889: -9564, 938: 25880, -17223: 18566, -20452: -799, -4292: -17811, -19061: -11617, 25764: -11388, -3347: -14170, 29220: -7185, -21149: -4187, -8341: -13996, -9012: -22916, 5303: -18306, 14513: 21706, -4815: 9868, 4316: 3968, 28688: -1524, -19338: 14733, -13386: -14098, 18253: 3130, -1221: -5690, 5093: 24217, -12424: -8733, 25791: 31206, 6697: 29204, 31192: 12158, 31407: 749, 17618: -3504, -3199: -3206, -11293: -20357, -16165: -3563, -27497: -25700, -27297: -3825, -23521: -23715, 4652: -29245, -17313: 10246, 22202: 28783, 12621: 7793, -25616: -9539, -8209: 11244, 2018: -23988, -29161: 7278, -17743: 748, 6678: -15931, -31969: -10178, 11253: -18267, 9135: -23204, -31002: 27729, 22133: 28453, -31372: 16243, 29200: -18504, 27344: -7996}, index_rand = 12865908526723545602 +xs 2514330554 4021224636 4249159765 809946243 # shrinks to ref input = {22983: 25567, -21524: 12652, -31419: -14369, 24781: -3215, -6098: -3626, -4344: 6615, 11513: -5995, -32129: -25765, 19648: -32475, 5272: 26666, 6416: 22836, 27222: -3403, -4042: 3636, 13253: -27848, 27331: -4442, 666: -14459, 13044: -27108, 2407: -18269, -11769: -23455, 6186: 23587, 3702: 7914, 29676: -21600, 12424: 12219, 27941: -5207, 15122: -12497, -11158: -27362, -8282: 26473, 3415: 26408, 12831: 17512, 5795: 28896, 21721: -11462, 20429: 9497, -12438: 9683, -3959: -13001, -25293: -23380, 5700: 24227, -21071: 9692, -18808: -24549, -27808: -4112, 14687: -13091, -14445: 10864, 8680: 29230, 28793: 2289, 572: 22804, -12907: -22882, 19549: 29926, -24247: -3077, -96: 16251, 8929: 32524, 18444: -31578, 24622: 19896, -20594: 13891, -22943: 19132, 31425: -2940, -12580: 30389, -526: 2891, -10880: -20465, -20861: -9108, -1990: -1706, -14673: -3333, -12415: 12446, 1711: -3619, 2889: 26166, 5135: -9934, 9761: 7314, -13727: -30121, 23167: -14068, 7972: -16912, 792: -2110, -23816: -11162, -14613: -11944, 2276: 16327, -1710: -513, 14501: 12803, -14424: 12359, 8166: 23242, 7132: -5033, 2661: 18395, -29564: -10169, -24378: -28753, -6535: -12561, 8864: 16922, 5509: 24075, 6948: -31451, 9166: -16562, -15552: -22739, -23577: -11089, -23262: 15724, 7935: -226, -15831: 22789, 19431: 12267, -32692: 13439, 8190: -27259, 5177: 21511, -25935: -29614, -23804: -9779, -5144: -13329, 13090: -1785, -24277: 11514, 23943: -7920, -5978: -7247, -10397: -26707, 25026: -2168, 16104: 8686, 1807: -29851, -24649: -22813, -19629: 11095, 22893: -20902, -23916: 17574, 1476: -25217, -24340: -19076, 28100: 15570, -22175: 22320, -6586: 6492, -18649: 11816, 16251: -21463, 17368: 3798, -20189: 3235, 16961: -6580, -8404: 20372, 16047: -15304, 29490: -3055, -24776: 15119, 27563: 16145, -22311: -2158, -15739: -32392, 2484: 14964, 21250: 7246, -9967: -28930, 31387: 5103, 14859: -2042, 16259: 31622, 29267: 26762, 6688: -2894, -25600: -27724, -22795: -11228, 2779: -25135, 3592: -29746, 2684: 25084, -14032: -6792, 16004: -29800, 10914: 6250, -15582: -26248, 21285: 13207, 22458: 2337, -13517: 14340, -29653: -16328, -9174: 8207, 6822: -22380, -13230: -5805, -24662: -20758, 23527: 6218, 21957: -1144, -29983: -14789, -25776: -10625, 29489: -29112, -634: -1687, 16362: -5095, 24103: 17173, -28568: 4122, -27366: -2615, -3220: 25064, 990: -31755, -14609: 23575, 31478: -24182, -15842: 9193, 7823: -20861, 32558: 23623, 28629: 20621, -27884: 26432, -14903: -17295, -20813: -25646, -14902: -25559, -13309: -1218, -12300: -17285, 31853: -3859, 1399: -7893, -26296: -29878, 19179: 13265, 15479: 17728, -25448: -8456, 13588: 27559, -24783: -7128, -32103: 29322, -1758: -3572, 13728: 31962, -17236: 5243, -21230: 27588, 20742: -27977, -20661: 4578, 9198: -15494, 5045: 25517, 29565: 31629, 20558: -6873, 24626: -30679, -7805: -9759, -3591: -19001, 28566: 18547, -13063: -28236, -19655: -4068, -9420: -16081, 25403: 23876, -17448: 2581, -26642: 1171, -24759: -17468, 20219: 24202, -30341: 13934, 27839: -18353, -545: -28904, 381: 6631, -14539: 19857, -2539: 19520, 31691: -3655, 1385: -507, 30959: -12761, -16041: 8706, 21997: -15520, -11702: 28136, -19969: -15001, -575: -19615, 15183: 2436, 5198: -26540, -18493: 24520, -17505: -5183, -2493: -30253, -25067: -4479, -1283: -3796, 31471: 3428, 25734: 30828, -12627: -6061, 11155: -26067, -26923: 20405, -24052: 21789, -435: -23207, 30135: -13145, -15985: 11367, 16307: 15640, 28752: -18459, 22594: 7750, 22206: -269, 12789: 803, 5691: -26452, 31114: 1532, -15192: -30273, 23101: 3141, 6407: 15910, -1158: -18687, -25606: 29881, 17713: 19127, -1122: -12940, -6489: -9054, 15743: 3691, 21427: -22498, 10898: 19136, -15369: 8230, 30219: 3776, 1353: 27070, 31264: 29339, 31831: -20760, -9233: -18316, 24841: -26176, -12699: 3016, -22370: -9549, -6545: -22728, -8574: -14535, -31864: -12833, 768: 15313, -19955: -22453, -30880: 9396, 29543: 755, -9778: -32702, -22077: -25372, -2605: 16746, -30839: 29080, 32699: 16318, 2417: -12052, -31380: 12651, 24376: -19710, -32686: 761, 5677: 30160, 12035: 12228, 32125: -20315, -20314: 5439, 11493: -17794, -26680: 11610, -28132: -20467, 16900: -25287, 25461: -31865, 24573: -32602, 9200: -1505, 27518: -25693, 12990: -27271, -9397: -803, 14105: 1387, 2651: 8640, 17112: 30678, -969: 19205, 19710: 31993, 1893: 5361, -17816: 24812, 2765: 16979, 1966: -21769, -26954: -1952, 29816: -1928, 26782: -29372, 18567: -22726, -10111: 5989, 14917: 22916, -14570: -2257, 1263: -4715, 18190: 30641, 11528: 12151, 4035: 20675, 20933: 20327, 20055: -30733, -14881: 6272, -26276: -44, 10879: -30096, -9294: -16413, 2817: 13299, 643: 15982, -7677: 4313, -20647: 31903, 3668: 29744, -895: 14661, -17897: -17401, -11844: -19818, -10186: 29763, -32372: 29925, -28816: 10622, 31355: 10910, -17637: -27328, 9535: -27794, 12855: 2934, -3109: 3109, -6427: -16454, -15442: 8398, -23169: 31026, 12834: -25030, 10930: -16079, -12447: 9572, 398: -5332, -11374: 27256, -12183: 32336, -14535: 14519, 12753: -3875, 8795: -11151, -3712: -16993, -26508: 14252, 20375: -14368, -13681: -745, -30307: -5112, 13277: 25773, -7944: -31433, -28425: -12788, 20210: 15294, 17797: -5799, -19999: -7498, 31427: -21005, 11063: 16683, -12187: -11576, 25180: 1372, 12244: -7444, 27900: 20262, 28587: 7083, 18724: 8161, -20180: 25818, 15692: -31648, -28303: 17209, -720: 21874, -16321: 31013, -454: 5366, 31803: 29349, 13754: 24292, 21162: -20849, -23732: -27863, 25477: -6654, -26061: -12152, 20032: -20593, -12006: 28036, 6291: -26468, 14737: 5272, 32728: 5626, -1731: -29345, 24503: 19404, -24868: -21379, -6468: -22831, 22287: 10296, 2631: -26020, 14590: 19330, -9565: 26433, -15283: 5147, 6630: 31769, -17396: -21499, -25553: -10823, 13619: -10207, 23182: -25363, -23069: -32662, 19477: 15524, -1868: 5359, 7929: 27049, -12723: 9380, -16172: -20285, -10286: -10075, -9506: 31490, -25795: 13824, -17148: -32529, -21164: -9272, 20979: 9504, -18600: -2080, 27700: -20006, 9823: 31533, -6997: -19415, 28861: 17091, 26758: -15191, 24983: -24729, -28254: -1130, 25914: -26157, -24819: 405, 20339: 9923, 30368: 1691, -21613: -748, 1453: -19462, 3731: 13394, -32452: 3223, 24913: -6930, -21912: 19356, -24594: 21413, -4422: -29373, -15940: -23075, 27267: 7024, 2732: -24160, -28400: 18241, -24538: 1422, -426: 12283, -10915: -11143, -22114: 31517, 28357: 14424, 19009: 15527, -11167: -4468, 22854: -18910, -23106: 19639, 10382: 23860, 6220: -23926, -26385: -10089, -7503: -5631, 22781: -1889, 16878: -26298, 18982: 21243, 31681: 22201, -7993: 27285, -7299: 25550, 610: 16890, 8167: 21304, -16920: -617, -22339: 30620, 11333: -26987, -26992: -20496, -7985: -22986, 10141: -7469, 372: -21212, 17081: -17544, -11618: -922, 27971: 8305, -28364: -29445, 15932: 3403, 20712: -21072, 14139: 24028, -1589: -1905, 32372: -17183, -21555: 12537, 31409: 17560, 3035: -19927, -5300: 22560, -4845: 21856, 15699: -25855, 7642: 27579, 30284: -15949, -30974: -30226, 15786: 8546, -5179: 30950, 5765: 5052, 1410: -23757, -2705: -31393, 4012: 30468, -1359: -31879, -24808: 31414, 7542: 20843, -26533: -25712, 16975: 8303, -3145: -28727, 30626: -4547, 7331: -22347, -229: -15652, 26743: 8164, -28242: -12747, -13570: 28103, -31635: -32305, 25882: -22303, 392: -21213, -3910: -419, -24637: -4685, 15423: -4564, 16842: -5323, 2530: -6191, -28954: -20857, 12709: -1223, -29605: -31941, -15037: 9147, -2441: -9869, -30549: -24089, -2045: -24975, -6257: 5642, 19458: -26673, -11026: -32379, 11073: -2714, -16340: 29939, 22558: -389, -282: -29137, -8915: 10668, 13276: -26492, -6567: 15209, 18167: 6255, 18833: 9305, 23382: 9685, 22344: -6270, -5200: -17657, -27124: -17742, -19079: -568, 31073: -16882, 28075: 23525, -27683: -6870, -4980: 20988, 15716: -12047, -17167: -27903, 14047: 1751, 18332: 17369, -4584: -13960, -19312: -7004, 24390: -26226, -31358: -20950, 2846: 8574, 23256: -28403, -12965: -970, -10968: 6290, 31485: 3696, -14595: -24510, 8331: -24508, 16660: -6434, -21947: -11573, -13276: 18857, -11196: 13858, 20146: 29787, 26780: 16229, 22109: -21982, 3218: 12243, 20958: -15577, -25637: -8935, -29695: -30458, -27502: -9512, 6608: -10482, 260: -12910, 7060: 3640, 20729: -5920, 9177: 17672, 23669: 9673, -4719: -23531, 12804: -12848, -29031: -3714, 17216: -27527, -23101: 8400, -6250: 26869, -26842: -26986, -21952: 31092, 14811: 3573, -6081: 2717, -10912: -16202, -24595: 20431, -11358: -22184, 21588: -21605, -6061: 3518, 18275: -24618, 24224: 28119, -32273: 6717, -25485: -19967, -21076: -16695, -16947: -17173, 6350: -31349, 21046: 2696, 16207: -13750, -6710: 6770, 24774: -11316, -26121: -7976, 24586: -1831, -28350: -32385, -28591: 6607, 19897: 5582, 10787: -15060, 10497: -6872, -10294: 17802, -8472: 16304, -25702: 1771, 24559: 25237, -22562: 12409, 5848: 32381, 6698: 29851, -29088: -2362, -25758: -7282, 13364: 9287, 9286: -21108, -5875: 7021, 10384: -19100, -14947: -31087, 9224: -30160, 10825: 11627, 15906: 24744, -2491: 14682, 25078: -8675, -1487: 9277, 20301: -16262, -16721: 3749, 12876: 2719, -17183: 4920, -7383: -20989, 587: -29137, 1359: -18302, -31714: 5165, -10671: 13375, -1014: 25286, -5237: 14127, -20162: -15366, -17597: -27172, -16427: 24301, 21080: 29359, -16296: 21156, -27123: 17636, -14475: -17380, 3677: 3071, -13795: -14542, 25583: 2939, -18388: 26695, -30563: -10031, -19535: 16570, 22004: 14784, 4240: 16012, -26396: -7757, 1009: -24215, 10291: 31948, 31730: 31672, -27181: 4692, -7558: 15578, 8628: 18466, 15093: -25146, 15115: -23111, -25498: 19694, -29510: -6893, 10810: -20013, -7953: 24646, 17484: -6921, -22020: 317, 6794: 31084, 3107: 30850, 31725: 21696, -27069: -15468, 20231: -10374, 13074: -27686, -5761: 4056, 6032: 974, -515: -19247, -21834: -21830, 12853: -24945, -12244: 15573, 22762: -30055, 21333: 27246, 17857: -18844, 7569: -30916, 2863: 30220, 24301: -32097, -26608: -8747, -32337: -4850, 27215: 16975, -28845: 5184, 29948: 16776, -8096: -19809, 28922: 1579, -22399: -10320, 23633: 9402, 25594: -10014, -19789: 21539, 7783: -5857, 6413: 28988, 18148: 24286, 16425: -21685, -2117: 24914, 22809: -2465, -4052: 29220, -17437: -20536, 1701: -13236, 3559: -26792, 13260: 28650, 24280: 28935, -31390: 4155, -27444: 448, -15557: -22317, -26261: 14775, 8621: -19065, 854: -24623, -13346: -13154, 28008: 7670, 8308: -26926, -15207: -30554, -4728: -30539, 19116: -14938, -31105: 13428, -17085: 28001, 640: 29984, -30694: -21836, 31336: 29388, -23090: 26134, -22064: -8217, 23023: 25281, 28377: 3055, -826: 32149, -10250: 30089, -21073: -18570, -18476: -26801, -26910: -26764, -23220: -30649, 11262: 14325, 3587: 12688, -20447: -11553, -14604: -1133, 3267: 12700, -30988: -604, 31066: -5487, 4192: 1516, -9863: 26649, -12142: 839, -5180: -23733, 4771: 18192, -30173: 21726, 5816: -6256, -332: -23918, 9971: 21833, 368: 10035, 7709: 315, 18131: 27655, -12214: -2422, 8036: -21700, -12127: 30496, -17331: 23521, -5948: -28752, 9996: -22175, -12256: -9599, 12127: -14043, 8773: 23434, -24251: 31338, -30890: 4170, 796: 22060, -9480: -23318, 30137: -12439, -11200: -14846, -20960: -6630, -11449: -12059, 1710: -25246, 27339: -29509, 23266: -11878, 11424: 13957, -31513: -6604, 29223: 6248, 18427: 26701, -12933: -29661, -22958: 17397, -20885: -7075, -12532: 11832, -11207: -31040, -25413: -32634, -24423: 1136, 27748: -23097, 6865: -20862, 18880: -20717, -10317: -13842, -13186: -15707, 26939: -25776, 28970: 10404, -5636: 14068, -20214: 17872, 24853: 30283, 9956: 8484, 9398: -6284, -16839: 21664, 22800: -14869, 6033: 9989, -4795: -32223, 7279: -20473, 1275: -11857, 22338: 29810, 27015: -1704, -19258: 30646, 29954: 8034, -25853: 14141, 3311: -18597, -23320: -20940, -29480: 24564, 10547: 5534, -242: -13465, 24209: -1327, 10490: -5572, 7640: -20006, -8432: 5032, -11149: -24754, -4663: -23686, -10592: -7167, -25371: 22450, 4522: 7837, 6151: 19181, -18379: -20567, -31877: -18894, 17881: 7374, 24203: -4232, -15566: 16796, 5510: -31735, 15169: -20736, -29601: -27463, 7747: -430, 25280: -6754, -15509: 2251, -3086: -2933, 5884: 27703, -11157: -24312, 14484: -912, -3230: -9668, 16082: -25169, -137: 14744, -2665: -8726, 32412: 31615, -7276: -27566, 6279: 1989, -25300: -15901, 2440: 7619, 31956: 264, -5369: 16171, 14418: 1610, 18599: 4848, 20977: -22077, -6321: -4946, -8343: -22193, 1775: -19058, 26761: -28761, -12920: 27027, 4448: -11253, 25002: 4314, -22369: 23526, -12022: -7474, 32105: -12895, 1455: -4159, 15674: -28876, 11387: 18072, -27516: -8671, -10452: 32061, -29518: 28392, 29722: -20187, 15094: -22775, -31173: 17747, 28936: -12104, -19139: -6836, 10489: -818, -19250: 2431, -24391: 29686, 5886: 4259, 11123: 7634, 14067: 14441}, index_rand = 8788646705830835008 +xs 1144700111 3351133221 1701312047 4140849688 # shrinks to ref input = {-995: -18367, -30184: -27030, 4338: -17464, -26495: 18470, -23875: 6714, 11043: 22383, -7998: 11935, 16847: 5368, -9936: 1676, 469: -14105, -25789: -439, 2949: -19822, -13219: -11532, -13024: 24096, 7755: -32141, 5267: 20461, 13213: 5297, -7746: 31930, -24638: 20376, 11502: 161, 28692: -9359, -5352: 788, 17858: 16574, -4832: 26375, 3089: 1666, -27646: -21448, -29415: 27692, 5699: -11459, 9914: -14535, 10779: 11740, -29883: 790, 1921: -17804, -2606: 26661, 355: 10341, -9220: -21783, 10130: 2847, -28778: -8331, -26138: 21104, 19481: -11787, 23407: -22704, -13780: 6006, 7248: 6188, 9583: -27582, -19931: 21871, 7757: 32217, 7030: 24321, 13903: -28335, -6040: -8746, -16956: 3084, -27320: 10074, -11931: 23573, -14684: -2347, 25890: 13771, 770: -22088, 3703: -21750, -20005: -1416, -7260: -3308, -13212: 5663, 11568: -1211, -31546: -12571, 1625: -28634, 29510: -27517, -14067: -32392, -6952: -15279, 32194: -28535, 22530: -9153, 23590: -10792, -24830: 4545, -1413: 4698, 13676: -29216, -22119: 20809, 11493: -23219, 30324: -19957, -19740: 9364, -28332: 23760, 7598: -15700, 5250: 5262, 8892: -11149, 512: 21208, -26713: -22645, 15901: -16244, -11774: 25184, -27782: 31736, 1932: 28625, -19899: -15534, -14500: 28168, -31943: -10376, 5096: -6393, -12529: -28083, 15871: -31782, 24491: 9705, -13197: -2280, 20267: 26985, -2805: -7895, -12439: -25986, -1013: 18461, 1975: 32395, 22412: 8807, 18620: -21921, 18836: -11655, 20099: 15576, -15176: -556, -16690: 10393, -20701: -25137, 16023: 6541, 6323: 30693, 22672: 4962, 6262: -6543, 16070: 8710, 16145: 28518, -1209: -18693, -28389: -24853, 17412: -24261, 3497: 10996, 9187: -19998, -32168: 10884, 3560: 7346, 22807: 23444, -23068: 18732, -26136: -17299, 4558: -4291, 16805: 25070, 23084: 30635, -25411: 22895, -2902: 31559, -7150: -27951, -20232: 1338, 6838: 27765, -31069: -28409, 11606: -29065, -13760: 30312, -2036: -14916, 25218: 18519, -10854: -7745, 27820: 15149, 102: 7496, 804: 9488, 30201: -8547, 32678: 20708, -25202: 31329, -5584: -22884, -5108: 30003, 25093: -865, 27335: 6724, -10328: 15249, 5215: -12859, 25426: -6436, 4131: 8277, -19570: 7708, 20395: 7626, 3155: 12890, 19644: 581, -19031: -9366, -7803: 24805, 6673: -15061, -10892: -20442, -28410: 17433, -18136: 18606, 16432: 31698, -9848: 7414, 10831: 4060, -19606: -19806, -26041: -14198, 7826: 18579, -12900: -19535, -21442: 30662, -9253: -13676, 4185: -25497, -32472: -11113, -20772: -21936, 30731: 247, -17401: -28973, -11698: -26755, -17077: -5017, 22536: -3777, 13939: 16609, -8959: -24782, 29183: 15322, 28738: -31932, 12914: -31447, 27024: 19561, -6230: -2767, -18069: 12291, -3808: -532, 8699: -30308, -13072: 26305, -24174: -1772, 5083: -26578, 32374: -29090, -32055: 12554, 8496: -6213, 3295: 7339, 13897: 31817, -32448: -28910, 16533: 26195, 16795: -8295, 23292: -32385, 15102: 2439, 9462: 19663, 24237: 21643, 5357: 20413, 2361: 5794, 25247: -17229, -4187: 5207, -21262: 19783, -24684: -4240, -24679: -18791, 2368: -8363, 12208: -20319, 23264: 16664, -13617: 1275, -19198: -25513, 5092: 16212, 15124: 28714, 21439: -1196, -4432: 30044, 9557: -4855, -22916: 1046, -26280: 25826, -27674: -20014, -13633: 27408, -10975: -4991, 26520: -9235, -6589: 27583, -31631: -21487, 31832: 8595, -18451: -12811, -10412: -24981, 17602: -10428, -25014: 15888, 21325: 14946, 7746: 2626, -29626: -22668, 29538: -5978, 21901: 5842, 13851: 31830, -11034: 29385, -3586: 7536, -6063: 32614, -11727: 16659, 29320: -1367, -21326: 9220, 3205: -1974, -4787: 12852, 30793: 2568, 25796: 9433, 19016: -13799, -9621: -14129, 20136: 20434, -18060: -13251, -634: 18285, 15435: 22675, 29971: 5174, 31997: -29557, 18450: 7875, 22519: -12860, -10973: -20277, -26809: 31348, 6220: 11504, -178: 22232, 9592: -1419, -13548: 27708, 6172: 20899, 27648: 15593, -12157: 24765, -3131: 27366, -1827: -2958, 18365: 18538, -17861: -8596, -25217: -20668, -4257: -9796, -27958: -17570, -11603: -23589, -17591: -21385, 23905: 22546, -6098: 13776, -26132: 18512, 8204: 14798, 29533: 4545, 62: 22711, -9020: -8280, 11140: -8181, 1781: 10516, -1334: 15284, -7224: 7160, -28987: 22020, -4891: 8434, -4403: 19578, -20394: 14965, 29827: -30255, -560: 29091, -23917: -11862, -13868: -21175, -10219: 16295, 2577: 3128, 9484: -11742, 8668: 21789, -25813: -8178, -21404: 29342, -21751: 13687, 18052: 7524, -19144: -30345, 24903: -25167, 30700: 1834, -28266: 27752, -30375: 954, -11219: -5836, 28011: 8806, 20451: -23577, 10616: -15512, 6848: 4786, -5701: -16618, 10552: -612, 14323: -30855, 25785: -3039, -423: -22087, 20028: 21248, -31919: 15338, -19884: 15952, -22678: -176}, index_rand = 4536586039788573449 +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 888006417 2608449019 3789353629 478040202 # shrinks to ref m = {0: 0} diff --git a/vendor/im-rc/proptest-regressions/ord/map.txt b/vendor/im-rc/proptest-regressions/ord/map.txt new file mode 100644 index 000000000..9111b32b6 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/ord/map.txt @@ -0,0 +1,8 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 888006417 2608449019 3789353629 478040202 # shrinks to ref m = {0: 0} +cc 1cc795607ade8b03fded509b229a329cf489559bf1ffd51710469db6532ef3c3 # shrinks to ref orig = {13654: -29485, -24329: 12447, 28073: 17462, -11155: 3551, 11565: -26208, -15232: 7608, 29759: 20320, 438: -16354, 571: -10462, 7614: -10288, 23780: -23920, -6563: 29101, 26479: 3890, 26520: -11140, -17636: -22688, -9506: 1900, -30037: -31504, -26114: 12976, 22103: 27666, -16535: 28839, -16809: -30920, 20788: 18978, -20423: 26728, -31348: -22678, -9794: -21451, 16178: -20708, 31232: 29025, -30976: 4474, -29215: -26793, 852: -11649, -4772: -14366, -19460: -5289, -5325: 24856, 45: -20269, -23801: -29271, 27724: -17783, -23212: -18476, 30206: -16727, 435: -2093, 15924: 4857, -25633: 29368, -20962: -9007, -7339: 27158, -30115: -25527, 14804: -18380, -14522: 29035, 15562: 23077, -20118: 17616, 28098: 8432, -27495: 12350, 14609: -13814, -9145: 29859, -31933: 16305, 19469: -825, 2409: -19471, 20578: 22502, 7884: -12550, 11389: -14638, -21015: -16375, 9053: 16535, 4588: -7460, 9046: -8592, 9482: -10249, -30236: 32067, -5302: 27299, 30181: -6167, -29843: 7210, 16374: -32301, -25407: 20496, 2749: -11107, -5975: 27109, -27089: 2177, 8897: -31616, -29271: 2162, -31613: 20560, 31507: -14262, 21540: -25321, 24744: -7423, 26657: -26369, -12605: -22618, -27512: -21723, 291: -9951, -12495: -32742, 7539: 30444, -27269: -12562, 29899: 26866, -587: 20631, -31271: -32202, -15662: -21784, 28126: -31732, -9749: -6578, -13352: -5663, -5080: 21203, -31106: -8714, 29841: -16964, -11827: -13788, -24678: 4958, 6499: 17700, -5695: 1260, 12631: 29706, 21390: 794, 5009: -5889, -32578: -14971, -26389: -8078, 26546: 17151, -22373: 15689, 27572: 568, -5244: -1643, 23163: 11329, -28715: -15929, -25818: 12223, -4427: 28582, 26061: -32554, -14351: 5137, 3017: -15529, -23194: -19328, 30499: 5974, 16990: -31204, 28136: 23024, -13986: 5556, 12355: -10820, 2837: -15764, -8318: -22640, 19390: -32081, 5443: -11767, 14269: 4778, 12880: -8658, 23857: 15963, 29819: 14185, -28642: -14213, 1092: -1891, 3065: 7306, 5667: -16519, 13195: 30960, 30981: 3805, -18227: 17519, 26714: -10844, 1867: 3065, -21164: -23958, -27908: 23652, -3016: -25807, 21021: -24516, 601: 6650, 10464: -30444, -25383: 21397, 16149: -20990, -23678: 19268, 13651: -30926, -30193: 4015, -20550: -3813, 8984: 23024, 8529: 12538, 13423: 3073, 24037: -11619, -20993: -31582, -7056: -2892, -12795: 10504, -16197: 1330, -20748: -17973, -31199: 22341, 31286: -22643, 9674: -18049, -29206: -15460, -25215: -15832, 28334: 11339, 14680: 15220, -25943: 24920, 32275: -6093, 13259: 30579, -29041: -17489, 15886: 7941, 15683: 9359, -1635: 54, -30492: -21635, 10271: 18315, 13384: -5318, 31595: -23502, 14243: 5855, 10461: -11363, -3155: -29668, -5835: -8232, -28140: 19386, -761: 30096, -2515: 27267, -17737: -31871, 31096: -26754, -24336: 13642, -14011: -8588, -14996: 25507, 28759: 9825, -14214: 9160, -14712: -24558, 19038: -18469, -30816: -20086, 4334: -10671, -17006: 1184, -3730: 13058, 31026: -16485, 9580: -17771, -21186: 18345, -9664: -11262, -8480: 7648, 22920: -14965, -21022: -28133, -8744: -11234, -30252: -16231, -26305: 12363, -28149: -24604, -26462: 3796, 3057: -18784, 16634: 13983, 6987: -20371, 7469: 11214, 1205: -21956, -29086: 28404, 12269: 16334, 32493: -11094, 18386: -27104, -25066: -26762, -8850: 27225, -21958: -12209, -13409: -10100, -14283: -27726, -339: -26813, -25875: -8615, -9605: 8712, 10133: 21989, 9858: -12796, -19094: 32285, 32169: -26413, 2531: 30679, 15476: -23974, 14526: 26173, 32030: -8035, -32658: -23894, 32452: 31750, 8858: 3008, -22939: -30641, -570: 27228, -21127: -27648, 24710: 19973, 1390: 4422, 26123: 30745, -1229: -11664, -14679: 21300, -23645: -21514, -19979: -21143, 187: 26447, 1962: 103, -22968: 29896, 15464: 15061, 21532: 12811, -22803: -28425, 13579: -3285, -20628: -1077, -1080: 1008, 15835: -683, 29901: -2994, 8479: -3328, 21105: -27495, -3175: 19378, -30585: -24530, 17220: -24097, 30652: -32638, -21764: -4829, 24103: 19016, -21401: -27015, -31558: 18025, 30591: 11391, -22504: -23421, 5082: 27279, -2537: 27017, -12136: -749, 1815: -31786, -9416: -175, -12810: 30806, -9899: -2793, -32007: 30752, 20930: 30725, -28783: 8969, 29565: 2902, 18834: 2903, 31282: 30845, -10893: 28071, -20454: 1174, 27915: 5772, 29383: -1684, -5885: -19780, -9746: 17492, 8958: -7053, -1675: 24931, -20548: 29629, 10029: 19670, 372: 251, -22290: 1847, -22754: -8267, 15349: 14893, 6565: -16252, 5100: 31913, -21771: 247, 3407: -27092, 31264: 8619, -31498: 30586, -26457: -15280, 13900: -6472, 20237: 23494, -9435: -20123, 6560: 684, 6684: 13629, -19962: 31911, 7387: 22300, -16475: -211, 18073: -14359, 9010: -16589, -8927: 28464, -20438: -14947, 29302: -13068, 5174: -12114, -2684: 8886, 22145: -17371, -11264: -13950, -25938: -12728, -28145: -25911, -2871: -16462, -9775: -19757, 18920: 21013, 22571: 13793, -7253: 614, 1353: -19656, 22230: 14776, -25153: 4229, -26295: 15362, -25138: -16289, -26420: 21238, 32553: 2348, -17295: -15555, -18560: -30281, 25786: -5042, -10591: 10906, 17986: -1866, -32187: 14848, -8185: -18226, 28767: -25694, 15864: 740, -13565: -5281, 16351: -17855, 20798: 32488, 30621: 17130, -605: -12389, 11190: 6647, -5191: -7463, -17293: 21338, -1894: -29073, 10118: 15281, -24187: 12088, -13829: 32655, 19616: -29201, 32331: 26134, -22497: 12542, 2780: 29682, -8061: 20915, -15085: 21858, -2284: 1496, 12256: 14729, -12669: 8208, 12081: -20514, -19564: 21060, -5230: -3232, -47: 12452, -23297: 25490, 15469: 19166, -31330: -1486, 22627: 6048, 2274: 14307, -32613: -17602, 31993: -20703, 14408: -24288, -1425: 2191, -27528: 12719, -13137: -19771, -10087: -15533, 23123: 13133, -310: 28795, -17066: -28238, -323: -28130, 30008: -23016, 29855: 9227, -11934: -24563, -16278: -19539, 3943: -23354, 13038: 8483, -1376: -15228, 7177: -28754, 5920: -21813, 1028: -27574, -27086: -11996, -2451: 31603, -22198: 32494, 20534: 11352, -6499: 17474, -17125: -9124, 30067: 29674, -12170: -27056, 987: 10245, 20189: 7215, -17598: -31297, 20584: 32174, -27159: -25146, 15669: 14996, 22287: 32183, -17952: -27435, -20978: 29156, 17502: 23504, -2148: -3829, 14096: 8068, -25471: -11783, -10066: 25659, 14854: 17031, -16055: 30964, -24705: 9847, -21845: 27718, 30004: 14241, -2415: -3601, -23396: -26488, 27072: 4241, -25740: -23800, -32283: -6378, -20149: -2325, -29938: -25721, 26132: -5055, 4443: -8672, -4050: 19873, -936: -11208, -17559: 20749, 14497: 11691, 16966: 20137, -29672: 686, -11408: -10767, -2153: 29746, -31040: 2878, 2624: 10124, 7960: -27203, 17944: 18886, 5964: -30909, -6166: 25605, 13164: 10691, -27151: -18494, 6796: 10814, -9287: 8912, -27917: -2697, 21533: 22935, -27712: -24484, 8240: 27279, -10392: 24267, -5470: -32174, 18400: -29304, 6357: 9981, -10733: -30914, -20535: -266, -26868: -11399, -157: -13150, -7205: 6723, 23256: -6764, -786: 31308, -10664: 1606, -20685: -882, -24938: -1889, -7206: -3509, -25250: 31979, 30426: 128, 23897: -24001, -2859: -19488, -32217: 31472, 2593: 8890, 4407: 30506, 22878: 31925, -7560: -2864, -2411: -26849, 22106: -6447, 24278: 28527, 27516: -9012, 5476: -6024, 9147: 13764, 24213: -24869, -1759: -16068, -5603: -30129, 31029: -2919, -14714: 19182, -1590: 12635, -28358: 3872, -2090: -12305, -20911: -2417, 20313: 18181, -12831: -31538, 10130: 12759, -15468: 14679, 12923: 22142, 18271: -29174, -30962: 23155, 27775: -4512, -26395: -2421, -17588: 16263, 7453: 31385, 8023: 2389, -12214: 21076, 18059: 27701, -8734: 21859, 12513: -5333, 25322: -8656, 12712: 23597, 25917: -21636, -19326: -24361, 4360: -11045, -22272: 31718, -20938: -18069, 13566: -7383, -23839: -21705, -24263: 21476, -24653: 13628, -23521: 15327, -7348: -27475, -19318: -806, -8248: 14683, -29376: -8615, 24517: 4415, 19604: 19484, -32302: 22802, -24795: -13299, -12528: 32372, 13871: 5985, -8162: -19078, -22665: -32732, 9803: -4532, 27376: -14806, 15809: -23444, 16523: -6943, -25262: -4067, 12042: 6032, -13822: 21798, 11271: 16788, -6415: 783, 8921: -12257, -10523: 11184, 13024: 26551, -8164: -15301, 26059: 21139, -19775: -15038, 28467: 13920, 24798: 27943, 23346: 24954, 22060: -14719, 4525: -7210, -27468: -30621, 25871: -1553} diff --git a/vendor/im-rc/proptest-regressions/ord/set.txt b/vendor/im-rc/proptest-regressions/ord/set.txt new file mode 100644 index 000000000..9380d494a --- /dev/null +++ b/vendor/im-rc/proptest-regressions/ord/set.txt @@ -0,0 +1,7 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +cc d2977c225bfd8d461dea19c554cae04a48f9155854b53118264fb27b2dab49cb # shrinks to max = 1 diff --git a/vendor/im-rc/proptest-regressions/ser.txt b/vendor/im-rc/proptest-regressions/ser.txt new file mode 100644 index 000000000..d5c25a33f --- /dev/null +++ b/vendor/im-rc/proptest-regressions/ser.txt @@ -0,0 +1,10 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 3983395997 40281418 114824171 2339847213 # shrinks to ref v = {1285771567, -841112960, -2090277076, 1080385872, 900828884, 615148720, -333870035, -1551786909, -1167746969, -1453736382, -1747821313, 367596715, 1982056530, -1495713558} +xs 2832291072 3367532499 2480853836 1445020057 # shrinks to ref v = {-1006265241: 1190299023, -874470135: -656918271, -747552887: -119701798, -446035143: 289470610, -38617499: -70412299, -28555422: 742423513, 549345238: -1218765301, 1006459863: 373426025, 1730586809: 1217890615, 1741069766: 1330906833} +xs 497222929 1550339526 1868828736 2852494662 # shrinks to ref v = {-33, -32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21, -20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, 0} +xs 3367619631 4093181880 814513877 3641392342 # shrinks to ref v = {-33: 0, -32: 0, -31: 0, -30: 0, -29: 0, -28: 0, -27: 0, -26: 0, -25: 0, -24: 0, -23: 0, -22: 0, -21: 0, -20: 0, -19: 0, -18: 0, -17: 0, -16: 0, -15: 0, -14: 0, -13: 0, -12: 0, -11: 0, -10: 0, -9: 0, -8: 0, -7: 0, -6: 0, -5: 0, -4: 0, -3: 0, -2: 0, 0: 0} diff --git a/vendor/im-rc/proptest-regressions/sort.txt b/vendor/im-rc/proptest-regressions/sort.txt new file mode 100644 index 000000000..a6b62f5d4 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/sort.txt @@ -0,0 +1,7 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 1397459766 1987461941 1386942626 306293423 # shrinks to ref input = [0, 777418683, 1143505337, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1422499358, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1143505337, 0, -275943289, -1, 0, 0, 0, 777418684, 0, 777418684] diff --git a/vendor/im-rc/proptest-regressions/tests/ordset.txt b/vendor/im-rc/proptest-regressions/tests/ordset.txt new file mode 100644 index 000000000..9f4a7cbf8 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/tests/ordset.txt @@ -0,0 +1,7 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +cc ad212dea44eb83bbfd86396a2e0f9460ecb93f6b1a2644bc700ffc317638a37a # shrinks to actions = let mut set = OrdSet::new(); set.insert(0); let expected = vec![0]; assert_eq!(OrdSet::from(expected), set); diff --git a/vendor/im-rc/proptest-regressions/tests/vector.txt b/vendor/im-rc/proptest-regressions/tests/vector.txt new file mode 100644 index 000000000..1fa3f5210 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/tests/vector.txt @@ -0,0 +1,9 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +cc a81c870198d194d869b85a541fca54b5a3f3ea4e84705bfdede6212ad7451789 # shrinks to actions = [PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), SplitLeft(0), PushFront(0), PushFront(0), PushFront(0), Remove(0), PopFront, PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), PushFront(0), SplitLeft(1026178654884686841), PushFront(0), PushFront(0), SplitLeft(2673257349917114567), PushFront(0), PushFront(0), PushFront(0), PushFront(0), JoinLeft([0, 0, 0, 0, 0, 0, 0]), PushFront(0), PushFront(0), SplitRight(6380212717721778205), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PopFront, Insert(0, 0), PushFront(0), PushFront(0), SplitRight(12236220624414400388), Insert(0, 0), PushFront(0), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), SplitLeft(13848748256934322935), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinLeft([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), SplitLeft(13115524110820767241), Insert(0, 0), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PushFront(0), PopFront, PopFront, Remove(0), Insert(0, 0), PopFront, JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PopFront, PushFront(0), PopFront, PushFront(0), PushFront(0), Remove(0), SplitLeft(9383655485369749481), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), PopBack, PushFront(0), Insert(455053961473158936, 0), SplitRight(676041696221001931), PushBack(0), PopFront, JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]), JoinRight([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]), PushFront(0), PushFront(0), PushFront(0), JoinLeft([0])] +cc bae4a6aa243531a345cb36883fda4aebc84848fffe12d051df4e24ff22af3689 # shrinks to actions = let mut vec = Vector::new(); let mut vec_new = Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); vec_new.append(vec); vec = vec_new; vec = vec.split_off(6); vec.pop_front(); vec.pop_front(); vec.push_front(0); vec.pop_front(); vec.push_front(0); vec.append(Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])); vec.split_off(141); let mut vec_new = Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); vec_new.append(vec); vec = vec_new; vec.insert(41, 0); vec.pop_front(); vec.pop_front(); vec = vec.split_off(5); vec.pop_front(); vec.append(Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])); vec.append(Vector::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])); vec.push_front(0); vec.push_front(0); let mut vec_new = Vector::from([0]); vec_new.append(vec); vec = vec_new; +cc 2c8368d1e6fe86c9b944a688cc167d961767ffb028ca724bb3c12e2716cbfbf9 # shrinks to actions = let mut vec = Vector::new(); let mut vec_new = Vector::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]); // size 70 vec_new.append(vec); vec = vec_new; // len = 70 vec.append(Vector::from(vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 53, 59, 108, 189, 95, 24, 92, 116, 211, 64, 195, 2, 58, 198, 130, 44, 163, 180, 50, 176, 78, 24, 2, 180, 91, 132, 176, 205, 155, 65, 228, 182, 175, 100, 204, 222])); // size 61 // len = 131 vec.insert(8, 88); // len = 132 vec.push_back(252); // len = 133 vec.insert(1, 65); // len = 134 let mut vec_new = Vector::from(vec![57, 103, 160, 147, 241, 248, 112, 54, 152, 245, 195, 156, 245, 143, 175, 51, 27, 183, 236, 77, 126, 27, 160, 172, 73, 179]); // size 26 vec_new.append(vec); vec = vec_new; // len = 160 vec.insert(0, 112); // len = 161 let mut vec_new = Vector::from(vec![191, 78, 196, 239, 181, 187, 82, 160]); // size 8 vec_new.append(vec); vec = vec_new; // len = 169 vec.pop_front(); // len = 168 vec.pop_back(); // len = 167 vec.insert(153, 32); // len = 168 vec.split_off(10); // len = 10 vec.insert(6, 131); // len = 11 vec.pop_front(); // len = 10 vec.insert(4, 235); // len = 11 vec.remove(8) // len = 10 vec.insert(6, 48); // len = 11 vec.insert(3, 194); // len = 12 vec.push_back(31); // len = 13 vec.pop_front(); // len = 12 vec.push_front(96); // len = 13 vec.push_back(77); // len = 14 vec.append(Vector::from(vec![70, 240, 146, 141, 164, 160, 150, 102, 163, 137, 14, 197, 249, 2, 249, 52, 9, 203, 50, 161, 148, 209, 86, 161, 34, 32, 189, 39, 208, 106, 47, 100, 194, 160, 147, 69, 4, 249, 250, 77, 73, 181, 49, 228, 141, 195, 210, 102, 73, 75, 167, 106, 233, 141, 182, 243, 42, 102, 166, 184, 248, 127, 120, 88, 246, 204, 127, 214, 30, 201, 205, 115, 28, 204, 26, 17, 67, 228, 44, 158, 15, 79, 141, 86, 101, 148, 76, 44, 216, 65])); // size 90 // len = 104 let mut vec_new = Vector::from(vec![123, 94, 60, 147, 41, 173, 214, 101, 145, 201, 69, 78, 61, 38, 60, 170, 56, 33, 65, 151, 28, 93, 16, 187, 49, 103, 52, 133, 253, 244, 125, 66, 56, 190, 17, 235, 117, 101, 212, 129, 170, 112, 203, 78, 217, 49, 176, 252, 8, 153, 178, 205, 211, 165, 197, 32, 171, 224, 17, 127, 56, 45, 36, 248, 66, 126, 110, 109, 94, 116, 189, 185, 24, 215, 87, 239, 248, 98, 134, 0, 249, 147, 197, 237, 6, 150, 30, 51, 149, 12, 31, 93, 95, 158, 229]); // size 95 vec_new.append(vec); vec = vec_new; // len = 199 vec.append(Vector::from(vec![127, 142, 241, 16, 254, 11, 153, 252, 3, 104, 61, 225, 73, 56, 149, 247, 142, 67, 4, 24, 96, 169, 234, 215, 227, 30, 84, 45, 209])); // size 29 // len = 228 vec.append(Vector::from(vec![194, 101, 202, 247, 108, 248, 86, 224, 255, 187, 50, 123, 93, 110, 63, 83, 122, 101, 48, 38])); // size 20 // len = 248 vec.push_front(80); // len = 249 vec.append(Vector::from(vec![228, 25, 146, 89, 230, 224, 101])); // size 7 // len = 256 let mut vec_new = Vector::from(vec![89, 252, 187, 201, 31, 229, 16, 211, 172, 223, 209, 123, 120, 100, 91, 241, 223, 42, 71, 212, 42, 113, 211, 128, 54, 142]); // size 26 vec_new.append(vec); vec = vec_new; // len = 282 vec = vec.split_off(188); // len = 94 let expected = vec![233, 141, 182, 243, 42, 102, 166, 184, 248, 127, 120, 88, 246, 204, 127, 214, 30, 201, 205, 115, 28, 204, 26, 17, 67, 228, 44, 158, 15, 79, 141, 86, 101, 148, 76, 44, 216, 65, 127, 142, 241, 16, 254, 11, 153, 252, 3, 104, 61, 225, 73, 56, 149, 247, 142, 67, 4, 24, 96, 169, 234, 215, 227, 30, 84, 45, 209, 194, 101, 202, 247, 108, 248, 86, 224, 255, 187, 50, 123, 93, 110, 63, 83, 122, 101, 48, 38, 228, 25, 146, 89, 230, 224, 101]; assert_eq!(Vector::from(expected), vec); diff --git a/vendor/im-rc/proptest-regressions/vector/mod.txt b/vendor/im-rc/proptest-regressions/vector/mod.txt new file mode 100644 index 000000000..6ac612271 --- /dev/null +++ b/vendor/im-rc/proptest-regressions/vector/mod.txt @@ -0,0 +1,16 @@ +# Seeds for failure cases proptest has generated in the past. It is +# automatically read and these particular cases re-run before any +# novel cases are generated. +# +# It is recommended to check this file in to source control so that +# everyone who runs the test benefits from these saved cases. +xs 781088174 2402437932 46071810 3445483747 # shrinks to ref vec = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +xs 1236163365 497060525 1875560600 3785939576 +xs 2440477773 3871129562 3025797391 1057174199 # shrinks to ref vec1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ref vec2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +xs 3956050500 706730731 3245945489 2502775722 # shrinks to ref vec1 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], ref vec2 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +cc cf2875f6f7c5648d87ffcab4ccac7f8a8f720c93ee377e89f8c86e542cc643bc +cc 3f8ab4d20e0696c9811622b868e9e2e11df5e6195ffd427aa305e4c6b36937f0 # shrinks to ref input = [2074036082, -13825946, 1485618086, 938025892, 1634050283, 343602973, -606035941, 2086123502, 756455726, 1967901285, 417064296, 912931675, -48362083, -439614021, -192545534, 353571790, -1804858855, 908622705, 1183010347, -2019732894, 474300008, -1087280630, 1989024406, -1862412421, 1817688323, 1779903690, 645225408, 1290443907, 739077543, 1459983883, -19629421, 921340531, 1254057305, -1854941617, 339275035, 1177377681, -107461978, 1556951107, 1142459430, 418860714, -1711737411, 1787159709, -316274917, 1302348247, 181570291, -2076292901, -1093494155, 1763629984, -1195124258, 490574341, -681065204, 1238632378, 853854507, 42089611, 1831408714, -1041889085, -421564140, -1913933099, 926289166, 279182650, -2127045141, 1738196395, 2053843176, -2017898141, -399808861, 457054821, 1398259288, 560215405, 538259370, -1037968371, -737896076, 341049037, -1211866783, -1843247477, 602815427, -1981792594, -932949201, 1730346408, 173892487, -118710082, -993398654, -852952873, -1368077643, 321394671, 2093514113, 1831301356, 2104751555, -183869811, -1503190860, 1135803650, -25841157, 1218834281, -479227795, -1808365999, -1532913102, -1328086922, 1318622180, -1280127583, -802930281, -508955020, -1574788467, -1982208682, -563261649, -418424840, 2029013774, -1362803987, -638036545, -947262269, 1950557609, 1187410224, -1464584417, 1384726544, 413235774, 1436482752, 1395432848, 1656858203, 147231077, 1946166606, -701896304, 410570040, -1905606977, -1122557347, 2122591018, 567266348, -943154118, -1971951936, 590807013, 1967462062, 255252417, 2073823043, 1541319971, 1453203803, 1421341138, 132882974, -1352759657, 538478979, -140652930, -1307846641, -221794328, 584699783, 51954554, -1851000469, 400639112, -1849914695, -608123546, -1897558717, -938554976, -1021874582, -1619777886, 2098079695, -188166053, -654806278, -1089147663, 1364112441, -2080156329, 485140329, 1867162848, -1435377175, 1281905818, 464841556, 1285796301, 1233354604, 1251770836, 972787149, 194394838, -408637346, 297940676, -764140760, -535189066, -1222082930, 1999659587, -1466965620, -545915560, -33381613, -3391831, -1726247123, 1541843291, 618382071, 1692204756, -556631887, -1010281118, 547567742, 262071110, 1315561258, 1041276450, -200019451, 155953937, -1918010523, -2034646338, 179308692, -1851545907, 518204726, -1644852449, -930708052, -1533983680, 174298704, -1142603020, 400835696, -1032416568, -143748802, 89618872, 1498511740, -1964329731, 1985385121, 1338534044, 63395119, -2024486383, -1608930868, -2132981855, -1724578322, -1192711882, 1794405014, -1875127241, 220328451, -914341018, 1456640965, 1592862117, 1416491276, 457921478, 694438266, 1597638181, -1033179164, 1392568444, 1320710298, -1026116152, -1107223499, 2046373754, -802840884, 167120902, 2132541214, -1939037919, 376672960, -809965082, -629582607, -1849899910, -49034754, 814355126, 1904252470, -1995358474, -1535123866, 1964249876, 1541812798, 1216319781, 1448772690, -1676360707, -593183425, 367191330, -1015415169, -209835596, 973923323, -1379232452, -1678253796, -504812765, -2093303787, 1352940938, 1298454946, 1581876111, -1223031747, 2069730200, -1460608552, -1737622339, 1109644043, 2026556453, 1759367532, 1086741250, -167537825, 1616204085, -326437736, 955819637, 1295445215, 336028006, -1727534730, -968937744, -553518261, 1670053153, -1349953260, -2120024551, 1980134547, -1068452794, 1219491483, -390297250, -1475253674, 415787435, 1873218319, -964316540, 221387283, 1591083275, 1444258216, -1881949415, 776917485, -1456154045, -1552934014, 2084443571, -1120296261, -1579431939, -1519754301, -1709430045, -303381422, 129976350, 254373149, 1407938652, -334266500, 24715971, -1489003805, -344545827, -30707531, -1037864976, -1932107944, -1947334424, -450501819, -717436421, 555717916, 341387118, 369635675, 1599459501, -1778790486, -1104209594, -2118365426, -2054102940, -1118790563, 850092741, 2031700649, -2032648691, 209452659, 1033303173, -2138994429, 747531727, -1564008984, 479576488, -1210763963, -147017823, -78176051, -894576638, -1997663736, 414627089, -460407928, 242360038, -521406219, -1628996761, -744872182, -1441232914, 1846502295, -943262183, -1393886050, -2018639700, 145134549, 187913768, 69737401, -1313998467, 1510329953, -621473150, -982308299, 1043016699, -1651933122, -1244551793, -289264939, 1877434840, -885867921, -1455488637, 1208421381, -195139456, -507382900, -1417009162, -801223255, 913934347, 1483498591, 313323757, 684949109, -2138586829, -2071891390, -812202386, 1737302175, 1076518260, -526641190, -2049254033, 112548900, 323995436, -791419496, -1225118760, 642320913, 383365901, 1380650886, -339607804, 2033605956, 1103328389, -914762689, 1158292416, 1643458103, 139201662, -565020354, -1313785974, -863936467, 897894968, -1312998944, 1790634237, -752758530, 439608095, 1681084131, 233508147, 2013294518, 1823519587, 1660588466, 1812760899, 508524059, 1184818398, 213279538, -1222991812, -1978978464, 971476813, 1841261427, 2132433812, 1958231930, -117862732, 1650837593, 1029355018, 779022208, -1419168200, -340738059, -467041175, 329912954, 2132095988, -1585519098, 1323577018, -810116712, -1865039613, 1617692461, -1807759080, 344751862, 1450322400, -248458668, 237856838, 934330482, -649300467, -1895742412, -68722199, 288157201, -1819800236, 636713948, 1350627276, 86963139, 707515305, 1637864209, -951128924, 1833027683, -660390999, 727450477, -178917142, -1756743187, 153010136, 1146380330, 1149200284, -112449880, -1722382195, -1105256026, -562353456, 735928455, 1980254150, 166745367, 1589677843, 239612358, -1375912249, -232347030, -513829568, -715230968, -951636353, 35308988, 1058861976, -939881777, 389606025, -1455012972, 1789973526, 819109054, 2072323170, -1718042069, 415141655, 91908874, -375749327, 1622668705, 575657694, -1904593276, -67784013, -172853454, -484633603, -93271368, -1345817662, -1137764517, -1270761846, 726587010, 473120028, 178775245, -1701651765, 1526034877, -959144121, -183434587, -1617575041, 638251420, -1667918115, -829628671, 2035538892, 1670451796, 1392586407, -496019207, 903216680, 2100415815, -1980994623, -1052104848, 1457997902, 135859152, -108183568, -1097707977, -1374810787, 1180961208, -1307964614, -655644955, 1068486096, 581472280, 479947778, 136787664, -1476233191, -771095637, -1946363681, -21954842, -1629269370, 398541279, -1381636972, 456435952, 549611143, 1226758538, -665527736, 921771361, 1732495943, 857537416, -1311210307, 259851132, 54363142, -1872821125, -1558611717, -1561079726, -2050987563, 1820207889, 428187339, -1822780242, 676403468, -1654516077, 1731138284, -459002904, -2110845122, -621879519, 957958995, 1265282103, 243944836, -1271620168, 212486812, 1544089397, 1225721531, 1373272554, -1146075901, -31903557, -2122165744, 716785949, 773898185, -1697590745, 1139026087, -1128365692, -625874054, 1620393856, 2049458344, -638108114, 1006443422, 244013891, -959077606, 590687801, 1457741822, -836587639, 1164800185, 715176364, -1990226498, 1876286734, 1104112736, -1019905535, 1546003147, -1944204741, -1441042435, -1003488031, 1193976065, 454296507, 88091747, -1241971921, -372366427, -1131355056, -1993192868, 612679547, -1014555561, -2072304807, -181217339, -1230739815, 144971487, 636393978, -571012714, -1037687907, -1159249903, -656360123, -752128517, -616386904, 1621018842, 2120187290, 840041366, 1046715186, -213798416, 1220245598, -672389981, 963148331, -1445841173, -1758726199, 1919633920, -2120029560, -1217985998, 1161564327, -185318835, -1236360705, -956544035, -2144416202, -613210283, 1670320117, 828779231, 1146210465, 2096904410, -896703053, -1793409666, 484239052, 1374451134, -170334499, -1298101602, -1884559050, 120611217, 561196767, 825646390, -379512545, -1181612672, 1725080453, 894394587, -344082758, 736879648, 674694083, 1619268347, -496023195, -102002782, -842294653, 1841077684, -1510106855, 182713856, -202141272, -1506286097, -745352139, -1623254497, 1993580158, -1458213604, -1063096945, 1838489414, -1507167817, -1800227771, -1597408579, -786176532, 652248741, 369542434, 1568176235, 2131816918, 1675019550, -35228538, -626903300, 925830026, -2112784346, 417584189, -1057780140, 338713052, 825189157, -541098859, 795314319, 834369951, 1813578641, 1853897695, -508754162, 1131302557, 1842805572, -1386265126, -105109281, 1929191619, 365363316, 30848530, 1648738008, -5477858, -128018202, -1616404752, -706096224, -669233949, 1470778925, -818029978, -1123804154, -1801848224, -128380870, 1979870858, -2034279195, 24763756, 146178405, -87107679, -1276578948, -931079626, -19523975, -352157139, -2089700377, 878963733, -933252824, 177118516, 2007822342, 369516438, -223358742, 1555386773, 172477838, 696822368, 1734455136, -1691821089, -1710391517, -852385941, 985649133, -990853305, 2132107158, 1027224135, 1243623279, 1140262391, -680877276, -487308262, -2012563745, -158258209, -776719120, -280474401, -2089800633, 1110970379, 2042227416, 1822232534, 434874365, -1708107889, 564960608, 603651451, 670259206, 496003746, 1781379733, 263720034, 1348487686, -500344248, -47605549, 1083823409, -2112131381, 1360946561, 1032611909, 722713543, 631919140, -2020465896, -1425404176, -1057926350, 2016005948, 1500712949, -572195007, 1705736830, -607815961, -1110944216, 1521417863, -1845376244, 1600750078, 726936858, 1057595290, 621086544, -1389672811, 605472649, 1332661070, -906674643, -1110321279, -1411856682, -1152283803, 1551997284, -1920544851, -923902286, -1158501532, -183191214, -1440914774, 2039809837, 708032355, -783129450, 1757226306, -1934942490, -387201262, 954917910, 2047838574, 1011062626, 2013368665, -785120726, 2110535812, 1784304612, -1463847791, 1144411860, -245946308, -80365437, 1567197443, 1327272314, -140150720, 149507793, 1159202773, 1002514003, -1744390956, -1782985230, 1673971410, -777733567, -129088441, -79017303, 52585550, -334069958, 1154008540, -430846671, 1438426004, 1802651992, -1130101106, -1840626986, 436239024, -1031507775, 1338703766, -1672638532, -185408152, 2138867350, 1455179070, 495841734, 243789940, 119847865, 1584300320, -967618123, 450392156, -333159947, -658236010, 985332812, -828567444, -703879489, 810152232, 1362837274, 538318967, 1493290149, -795241024, -329956784, 1555841105, 1288467661, -712740577, -1555985260, -1096322447, -587003901, -1969396615, 1262483995, -745308685, 1415894777, -927442975, -1119406446, -841365439, 1590961822, -1137095817, -471430773, -1724561514, 1632082470, 1452194693, 1573724207, -1056390572, 1409850492, 1986869003, -1338889943, 1028065063, 852777652, -1970303190, -162211687, 191430130, 73303236, 1248707160, 1147073730, 1963985187, 85123011, 943234918, -589830911, 1615305226, 877377745, 413476354, -1485535096, 292861396, 587319220, -1093011335, -1323555037, -1357193160, 164263022, -972519902, 279224127, 711182294, -1995243735, -1793989650, 1352628071, -866818457, -77298747, 425992637, -1595732809, -700857521, 94834560, -351790881, -1648488658, -450350491, -2086521426, 125456589, 1699220019, 2068296684, -710274617, 646836800, 1804572376, 1258920542, -1787200449, -1903274259, 1206277195, 772958010, 303500230, -15790904, -1612308290, 1658129395, -395132767, -176780729, 701517154, -1141166097, -506094904, 419452540, -447817973, -1944275095, -587149278, 440910705, -1954163668, 284196487, 110272837, 1383525792, -1590873999, -2046627948, 1609135967, 1576362735, 1351579814, 1215558731, -1571835272, 1164889714, -1687222223, -308301954, 548400081, -1603661876, -1492992204, -1069693438, -146086196, 1654865162, -1744673963, -1916511304, 1156765219, 705280294, -1351994050, -1457658843, -1643654416, 1939831051, 592724212, -77904168, -841119817, -1916382996, 332785278, -523144810, -1937360372, -1783779649, -1296361371, -1334714400, -340608540, -557600043, -2121148923, 336729750, 70670973, 1700104880, 1211975311, -2065301796, 1350766899, 1008664094, 914213634, 1451337520, 72519135, 1621122800, -880167527, -1996260667, 1543405835, 19988, -1006109465, 1022821761, 1920504508, 1853584207, -1219874606, 818730373, -389483600, 1126720754, 1200031245, 90176802, 400890505, -632493449, 2126131937, 81577335, -831586672, -1557362007, 1624430684, -97733102, -874664357, 1859678361, -2058068798, 810835444, -797049033, 1588534622, 722602759, 587748230, -306983628, 2112257232, 222045709, 1806043771, -1995279884, 708369281, 1593214010, -594305532, -835696452, -261598470, 1700209807, 2132552449, 1134259195, -557873538, 666199347, -1370860865, -1291669929, -1982793775, -964359611, 1411523767, 874684473, 280843736, -772863939, -1760910534, 1834571177, -113850263, 964555207, 1700093129, -1291386198, -453641221, 1575423428, 1737962346, -1205243353, -1815954346, 69474747, 923104036, 1181772263, -1954223897, 1640227821, -2032732182, 741984480, 695783719, -1075712461, -451815548, 2088922812, -1074740902, 1530562045, 1991403690, 784239790, 840688915, -1065420476, -1783096063, 729574579, -721908166, -806317184, 804801148, 990212065, 166291018, -1286443454, -667451876, -308501055, -194874181, -1871320761, -1358248959, 2057411783, -1382427531, -710083396, 1875533947, -57075992, -1381920306, 511702421, 1053171309, -1989916206, 1155691146, 1768712079, -579366500, -1487994331, 1109105390, -448084072, -1316657967, 23535972, -610752518, 920167859, -685935559, -361038175, 614940771, -1835683232, -1464216722, 1567931048, -1994985293, -1575541261, -250001784, 1659320670, -1129013935, 1227172121, 1021763464, 1360636903, -1009013211, -658125530, -1375782121, 1240924938, 587120020, 251840472, 1919062628, 326163621, -1388285489, 1216631946, 95329632, -1263592868, 1431874243, 475640951, -1885419865, 138624677, -231681197, 1594004410, -114908843, -126965190, -897916266, -646374849, 2140471964, -42192764, -1136579062, -960331802, -1914310317, -161196491, -887650349, 1751087483, 1695100819, 910614545, 2031160212, 1827844249, 1184629796, -143447496, -1098200504, 189279679, 1324510949, -1446474674, 374348185, 814073640, 1059475157, 2106225596, -1353443328, 1489890147, -1710764596, -1784900998, -251447273, 2054477315, 1585596197, -961315036, -826391659, 910636006, 1693044605, 1064368829, 1494075395, 1316546601, -1915811198, -1968971680, 917565630, -911293726, 527747479, 1226513819, -1194618477, -1066559495, 615261865, 109378971, 1985712025, -2121477532, -710315708, 462546122, 244402885, -1169605677, -239741560, -1389817631, -2074550579, 426106154, -1406477206, -1611764701, 1220612586, -169469038, 1633206125, 703871587, 653033018, -1812149862, -143687434, 1563767746, -2029373357, 1133913077, -1365421112, 1830895650, -1241992896, -526096394, -1504042041, 2034202791, -116306895, -105403378, 1320613411, 914735204, -603131075, -1337211362, -709897527, -398529917, 864272188, 745999546, 65547189, 1861061706, 1212542882, 1333816648, -66085575, 746272134, -1975437052, 309057506, 1861395667, -1621979177, 1634029512, 1155954467, -967116681, -1160188235, 2144749944, 612130365, -1694063490, 1188913513, 1817673964, 1581379395, 850453154, -1821257251, 314169881, -586612280, 704538858, -550049394, -209614563, 662701873, -311754096, 1377384853, -2115678459, 838659047, 1425206620, 265309427, -1769712716, 794796500, 1776676236, 180574163, 1731804946, -1245564323, 124720676, 1536773954, -460052747, 1697871505, 1131379069, -230355481, -375495423, 649038466, -2053993612, 1646267153, 1066665731, 66317061, -357886827, -1529226434, -1720347572, 1374808084, -1683348431, -657294744, -1648480561, -142156380, 804824504, -393825521, 808709041, -666437984, -217705813, -2137435184, 1878510110, -1106819282, 801244361, -1643847311, -2000588465, 1420335452, -377832648, -1181104589, 710498099, 1776638075, 823288316, 1610711184, -1652544835, 132984139, -296219092, -114074886, -302097585, 1314050769, 1841154579, -1644619138, 528246600, -1276685666, -245772515, 507798437, -373604894, -1594177389, 53530042, 651204691, -2047265000, -311902066, 880688919, -1613610621, -400217694, 82248699, 642273308, -962271244, 762202930, 1377472172, -55275715, 1724616384, 487093745, -437663694, 168541739, -1812211398, -1672271840, 881873677, 1114714497, -904275714, 980093336, 540542544, 365158655, -916121916, -1187305107, 534011775, 782554968, 1163745042, 2035150524, -1512225129, -651081570, 362911732, -358329340, 1150492243, 182748386, 625114055, 882334292, 1098022965, 661677805, 1546581972, -514109477, 1643063823, -316855599, -442291463, 314094648, 1406436485, 767663595, 332893275, 1988709222, -1693267882, 474960718, -1711721184, 342144578, -1863678194, 2081877579, 2089996190, -471238875, -1097388511, 152530052, -993210765, -1805356187, -937869973, 112616890, -1650110162, -1948553974, 1610043089, -324810425, 1153590211, -2120221729, 1747016685, 1048445071, -200354549, -186862725, -815791749, -1319742901, -1672326416, 154887756, 600989314, 1621636945, -1511044851, -1989762847, 1244663259, -1972206082, -971692935, 159648606, 1886894019, 1256820220, -305051454, -1992313537, -1614655295, 2062970258, -732510151, -327269492, -972065271, 314883827, -804361736, -1802664745, -1393097923, 841119789, 1306073353, -1268939377, -1212140202, -5727530, -1219272851, -1944932538, -1284292025, 1613138533, -1566829015, -2124065514, -890344075, -1725254559, -340276035, 1888494158, 670809273, 490260198, -450901623, 1062109421, 1212084769, -1501158577, -1298993648, 1911739572, 1772401749, 1740321100, -114970408, 1894338453, -485024171, -997653831, -1343152304, -1902325295, 2020326338, -2021698673, -1714917529, -558328846, -1898519224, 1269234258, -1911896692, 1184951814, -724811169, -145504403, -593702511, 1898191072, -1480726052, 953055855, -1821482370, -1887272472, -546961180, -1304957288, -531926924, 823439575, 724449411, -1271201114, 927202475, -1535450500, -2147175631, -1112598415, 866322046, -1564446585, 29633599, -825456558, 150100279, -2101568583, 359203977, -1237656177, -1816457309, 1642157330, 1610350540, 765556957, 1631810071, -233161011, 1845036552, -1946832639, -720202126, 1238716982, -111929575, -61735137, 460862103, -964499783, -1719796295, 1431908922, -2021835794, 534546885, 606442281, 1595336494, 207703461, 1994438784, -896480284, 1985525729, -1708393804, 1394205953, -271754554, -563841883, -819961696, -1646837392, 343169754, -182200579, 1202996831, -1078270387, 1345234359, 393601534, -434470623, -1593472207, 1842910383, -1801179439, -1099448595, -823573945, -356217029, 1217853059, 420981607, 1454030672, 403134304, 867996715, 1600236310, -1419419307, -1419962415, 1305298669, 2020494006, -2109351160, 1650520625, -825913866, 1069743846, -1862232186, 606928841, 1158621547, 2104404684, -485894381, 1851371246, -50298200, -853066598, 985824221, 1004369806, 1102935179, 1510783885, 1656067979, 927075135, 1170380815, 1774084327, -481903018, 47851310, 44620135, 1330599795, 1350266355, -1554545431, 1064732618, 66409816, 65526106, 21165577, 427740885, 483723017, 35454706, -7354557, 1047226914, -945721408, 345991533, 1571094729, -1971201628, -1894897988, 1447332988, -1233870505, 603392934, 1072266402, 514282162, -1642540303, 1762619187, -832224359, 2077531767, -1517254591, -1712552797, -819974299, -1875907532, -1661342398, -990812716, -1240965349, 1607455043, -1377916738, -963550263, -1211027112, -1628311755, 1463570154, -1672122427, 894733706, 544168552, 606117200, -2026249981, -1974738484, -1158307622, -1365243007, -1562950578, 2079141243, -235622301, 614947263, 611227439, 85917271, -1177848821, -664696881, 1488438760, 1177956309, 59705022, 711345438, 923223046, 1203371455, -549647450, -35023964, -1505117893, 710465445, -1296368867, 1630729548, 1557945985, 844231014, 2005708325, -1290199164, 1304486157, -217612581, -1931913813, -970249370, 473025451, -200709418, 184538323, 1213312738, -2013039594, -1639401940, 525613809, 1245902519, 1706341080, 650706587, -1773352619, -1179651170, -575729581, -1730951972, -260659192, 1468639200, 1162190522, 1682825499, -878374032, 771849933, 240576651, 155325731, -960977566, -992840686, 2056114509, 1738055400, 294977645, 1264418031, -958333813, -1380453956, 499832797, 817392330, -1247263376, -777045122, -836124598, 899690640, 1527550217, 1305253225, 1044413882, 1814223024, 931157089, -1723631238, -817502582, -829951866, 2087626889, -1947546236, 971164418, 1939629075, 952567194, 1967395635, 1289866873, -1744342751, -13909708, -1681951265, -73308599, -1335323714, 337521938, 898485675, -961252002, -904441097, -829430518, 1647349729, 859110940, 1009996690, 1175364, -1731015109, -82089215, -1874190134, -1582759345, -595698798, -1796552845, 639185195, -2059403318, -637567169, -635726071, 1506201648, 971714982, -1001821939, 572478864, 186545027, -1574180302, -32768479, -576949254, 2052783601, -151628868, -2036643463, 1778894281, -1197478516, 1753628928, -946610274, 882925391, -1256849931, -222651507, -906735335, 1938435700, 345182693, 1104965399, -1649155143, 435000686, -1909422785, 1216166408, -1692256880, -888695288, -1768507878, -2063241053, 1828957201, -46194893, -489710286, -410395703, -2103572352, 988971566, -2101803910, -1895006133, -1195331642, -1252662530, 1707417472, -967229313, 1792762625, -1102087985, 387508985, 1231080158, 630489021, 880641861, 159427921, -516227521, -1630783764, 1115924174, 1425792795, -566104154, -1150501290, 1969777362, -1230136655, 684335591, -1027332760, 915071942, 838375480, 1507691727, 28096794, -1619278869, 1961812843, 1596475991, 1386509383, -1225479197, 1220206769, -1381497381, 1291039841, -803224587, -895608024, -1364075382, 958971519, 864821661, 243797844, 342931602, -164939684, -411568688, -618750496, -708408003, -1872778333, -1002871277, -584030075, -1666646320, -1808942452, -1981790540, -913956051, -60986585, -1792184994, -1238634575, 570040290, -1753449480, -1592475740, 749966826, -1880520928, -272864035, 1936731130, -773985737, -544732237, -1698904105, 2129148869, -2035046528, 829219482, 905659495, 1582796391, -192820708, -2001536680, 1701433266, 773507903, -766695198, 445972053, 1953498627, 2130699149, 1082788801, -818872630, -346828415, -1325716989, 1744486675, -1565767710, -1835163165, -867656874, 1335135691, 1793823082, -658815696, -689290922, -309120621, -1955820388, 93013624, 1486938108, -284530947, 1524825754, 1733900812, 1457593653, -1355871840, 648014650, 1755325084, -709076667, -764763066, 1739307655, 257954771, 2047109644, -156656991, 558478547, 1258135392, -656024989, 1024959894, -1512664685, -378250925, -1949903037, -139772205, 641075170, -1036173394, 881333798, -82300171, -974627005, 475862077, -1911663845, -1599081849, 23810813, 1957974322, 1503233714, -1722056665, -1378688795, 302037199, 826208596, -141706235, -1206737332, 669753363, 1982305051, -749055015, 1039516909, -498251521, 24230781, -866890024, 1905972132, 2121969063, 1568323848, 1982848987, -1672235500, -63968325, -325701882, 661605179, 1812026469, -399265824, 719541907, 1410608334, 1777006498, -1049031294, -1420572565, 1750207842, -329757753, -1457069586, 1420911533, 2141384494, 574688220, -535474851, 1817098927, 1745079322, -1397130927, 673154800, 1128049219, -9664779, -117030017, 1215158711, 609783724, -964683549, -354644958, 892408159, -1015147858, 1688871110, 786905015, -807927458, -1426313497, 738749954, 432699143, 2034921165, -1200485975, -1413453463, 1937157348, -362092578, 1356874957, -1709834974, 594752720, 946796298, 1854767205, -776650823, 213518265, -37832322, 377817837, -1549358859, 1865874275, -675793518, -853299874, 408852684, -2101382816, 2106904971, 641549702, 872639835, -1625781499, 1578043569, -1869099544, -1520434438, -5792783, -1501624842, 1591670846, -1679808201, 307611723, -1669856920, -1732370715, -1435788919, 1349286702, 1762122722, 444504859, 434118061, 1531872154, -1921635151, 461501365, 171995757, -787029246, 1450608733, -965916943, 2109390499, -968905926, -555935451, 197622877, -1273797603, -1146425472, 1025007550, -2044487715, -1766399309, 1444621382, -1366310202, -1920916880, -1555651494, -1535193099, -644504916, 1008757743, 2114227944, 2146670725, 1615083220, -375991599, 169656183, 347162435, 832769616, -1215247623, 714458165, -444110872, -310018744, 1499610027, 1464902845, -748242684, 863157776, 1156691939, -876228300, 1914798725, -716881422, -34404712, -1073518267, -1842831631, -1827986121, 1149347194, 1108742924, -1812776801, -1347072639, 703653852, -1664322579, -1516110764, 960302225, -2037192203, 152564419, 1172752504, -458652203, -416139558, 1395448680, -1562149933, 846592421, 1478024746, 1382685158, -1212006349, 62959140, -1052743695, 431591648, -1456232854, -144177870, -655319813, -1525278474, -872244779, -721521788, 45166108, 1095986725, -1077614150, -1456137894, 1438074383, -217036601, 958421168, -231776335, 1741860394, 242567606, -20690983, -804748349, -409173917, 22481376, 686480262, 2127592680, 89614444, 1684548825, -984033810, 244142203, -1819765814, -5864415, -1621233543, -1063410560, -986930256, -130908238, 508599121, 1318739213, 896055054, -90612498, -317988103, -264654415, -1329221037, 1470575530, 1164650924, -1071623508, -1437421278, 2135634422, -1240821586, 1076346272, -1266511203, 1250699414, -928392746, -1177069029, 1318782928, 843470750, -248021515, 1187937926, 1443419921, 878529241, -1118633192, 1947534301, 1494772836, 779692278, 253098856, 658362515, 84661694, 400271970, 1523996720, -1712995981, -267561915, 480800796, 1922989838, -460091455, -1832061899, -2047758766, -1864498316, 1124875090, 1574530078, 626652963, -1541103034, 674196527, 1569962865, -1372652113, 1385927992, 340709540, 171708628, 619839443, -348877606, 2027369285, -843916036, 1637078240, -814551079, 164779239, -485665085, -1588076105, 755263840, -115516048, -46400229, 1238897345, -395198949, -1800028195, 1773904467, 870834333, 1729827340, -661543153, 1964144948, -455531520, 1137110697, -281908104, -800939374, 1841735580, -1945155635, -1078994053, -1727806263, -2114522102, -694243633, 121866799, -2019364398, -1776580513, 266209479, 1672380585, -946581043, -815000738, -782944163, 2109990170, 514632370, -1636390124, -1146493658, 1808746770, 271495095, -1730754553, -2031292872, 1782264703, -1085845477, 45845271, -61199851, -1452794038, 766525656, 465624801, 564578530, -1536401328, -1350960158, -822844540, -1675533314, 1463564272, -858456464, 830256249, -1402020590, 1061822244, 2056427231, -818237356, 532810618, -135657641, -495351699, -1523926091, -1264935009, -864112343, -1121277765, -1387523599, 339045071, 696066596, 796576915, -368902456, 687860556, 1598519608, 455454634, -432810106, -1782184913, -1134133295, 1815259154, 248760036, 714170821, -66177395, -1543284772, -781067614, 1488997215, 1189488805, 74603448, 1015125628, -1352920507, -1585448216, -1565182640, 478156282, 1179041562, 1820827756, -1157795129, -1802276672, 209807979, -1309984341, 1129463870, -1886483323, 1281556385, 537249359, -1462568933, 1408903083, 2002922014, -1599364601, -1954412043, 364995218, 2130230766, -45339351, 1809174838, -597555785, -1694863938, 1590113653, -1515483817, -697800002, -856001429, 235165263, 507560979, 2127875549, -851572918, -1675427211, 1750307663, -614113733, -214111301, 1775363940, 1935997873, 821649232, 205051377, 1511250329, 298712720, -462817078, -1611814691, 1585121429, 612069516, -210320298, -925801814, -980440069, -2107723588, 117209888, 983127763, 1317541730, -717236993, -1876759792, -1316138379, -256985663, 1497690548, 1536687898, 266189925, 1992605358, 1062600270, -663324143, -975208133, 389924880, 1274310235, 170158308, -1384484254, -1831200218, 1898972867, -492853557, 61806028, 1273757991, -1160788979, -424235333, 437862120, -1059353567, 1853494041, 72071260, -1109873047, 167168738, 1520669889, 1180353142, -1481132995, -357402117, -369109703, 1291650654, -1600486499, -1082549661, -1749813781, 2105194217, 1032420477, 262986466, 194821755, 951729698, -275962403, 171767054, -674920470, 959584790, -679108067, -536711441, 887066445, -86563567, 1212841687, -421100963, -214630196, -1543529359, 937281409, -74279649, 963974934, -1990658056, 503440542, 2109210720, -232706253, 1009908221, -1854072025, -882006402, 712057373, -2109350230, 913223831, -161622508, -1964288122, 431926902, -401951225, -921597038, 711616884, 443179653, 806599158, -1633467433, -1651928717, -1227985736, -692216005, -2043662074, 1657634295, -279432510, 1688185410, 1329733075, 1925894026, -361652441, -2100044059, 614627571, -1988406558, -1093670315, -225607928, 1040892877, -551764273, 258020151, 1764708688, 1379025933, -1301742585, 193852539, -1049683994, 2096234346, 1441367841, -169123979, 1790047960, 1718395001, 1916251528, -823831239, 2028778371, -1263190013, 1773093197, 1464745833, 1557101023, 1171095454, -1305732503, -57688736, 534714168, 1336831841, 577399491, -1694162936, -688985713, -957445079, 1479776685, 1009735413, -1481884552, -2118003710, -107595726, 453231361, -1278085937, -1371933214, -1326750180, -1509814098, 104964229, -2124793331, -726494051, -1405813182, -569417804, 1350247623, -1893729588, -526892997, -523092364, -119332878, 690575897, 1356673196, 1240271248, 1336359033, -1424078190, 777312073, -698621368, -1265466655, -913875957, 414763056, -2024757661, 150811391, 1985421865, -276870421, -734979648, -1159784487, 1908805935, -1412188802, 3707295, -803678155, 1353282903, 1092966435, -519856726, 688511683, -1315285217, 1754532099, 731675915, 2036642622, -490675351, 702933419, 2054538165, -1605673030, 530137404, 631630234, -396828210, -457910645, 328936322, 1459368517, -626717242, -1493160930, -2024598588, 1185915275, 696036597, -761221335, -1456523719, 1046970154, -138840183, -1141389775, -1082707957, -1190849711, 1056337011, -522959331, 1010405190, -382694875, -1964500446, 1247583659, 1038167337, -1978296836, 1266009218, -1296473165, -1145916624, -899275827, 1193825143, 1413595896, -634764006, -878342348, 1542505892, 875211556, -166409244, 502753504, 1213055506, -603568940, 76615997, -1421135218, -213490441, -1168059769, -231967227, 1978211993, -1960258751, -1930974314, 360249920, -1919900572, -2062200627, -268952584, -1153432068, 627820224, -2130086132, -1868552892, -1909712430, 959778829, 1212057528, 258670222, -840166096, 1943036424, 116014457, -1384564186, 1184824951, 908074466, 1585254178, 98466435, -168240947, -863531830, -1427312059, 1284229190, 507098737, 941402140, -219402260, 1346622990, 1231522110, 507733839, -1610263475, 144940486, -1736219543, -1985784682, -1736477148, 603323115, -1129349621, 1089272848, 992075028, 36696481, -657430524, -1705217716, 327007641, 492791025, -1259407248, -1251063263, -111142734, 1450262749, -1220553021, 477158174, -70417219, -1694169983, -876747649, -523121266, 541922519, 1767514138, -149436036, 742074375, 467226103, -1645352866, 1463142293, -1079931863, -2079781743, 1248229926, 1321418176, 2048066386, -1608973805, 1544685842, -443485137, 690831677, 1640492515, 513242750, -1755983918, -672226322, 1549624163, 816639186, 646205565, -2142323173, -905952197, 703777055, -361653501, 44826984, -1379377990, 820248537, -1473766197, -2072259218, -388366794, -744795441, 873255125, -696641358, 433712478, 207213832, -1560365070, 2127711832, -1451704177, -1565862607, -893138308, 1456692780, 1348910332, -2121013998, 980276993, -1843061248, 604634047, -1232571302, -1165472835, 1156164852, -24630408, 1150613935, -203576330, 1286773721, 1977554936, -2039880063, -896639261, 381035347, -100644266, 219587978, 554988181, -393548497, -127309584, 909855725, -729457340, 1244918128, 337717193, 1722032001, 993989177, -898880404, 592326961, 1243729511, -465647747, -175536179, 777125268, -1471335967, -665574837, 1685142415, 1597001581, 840231777, -882099121, -316303168, 498831327, -662886359, -204322356, -41289200, 1585296337, 686025290, -169769641, 1003321996, -655288081, 1005986195, 814550702, 65769638, 2077078909, -1542497868, -2146482548, 379744626, -1963950020, -1557933593, 360176856, -121386100, -2078743455, 720428054, -119841489, 1154785840, 1515275690, -314559824, 1875610627, -1076311913, -1082989363, -181445483, -935200241, -61787913, 2135864170, 341352098, -159713250, -215695069, -397899140, -512684949, -12334642, -827156706, 740332051, -1763474847, 1204803845, -266555084, 895305683, 41473725, 1628813578, -112444784, -2111837439, -2108547200, -73161153, -702781657, 515297797, 1235614775, 10629611, -530023308, -548143140, 28726025, 449800942, 823846666, -714581681, 148920007, -54038626, -1051920081, -476868902, -1703879247, -938905943, -844892171, -1723049906, -933077256, -405211328, 66095241, -911785435, -1304378355, -1959897308, 952937046, 2123136523, 1205958787, 491498347, -1479208316, -1539225545, 1892839403, 2022346914, -268091380, -1868316126, -1040787542, -980745392, 1331153007, 386141789, 905136649, 1684659822, 162135379, 414483581, 701005460, 1480201692, -1378734756, -26663830, 2123027811, 2137781510, 1787376948, 1402927997, 527423640, 658729620, 1365138809, -18518360, -1230600230, 1013529188, 62224866, -477888403, -1253825556, 446687634, 941525323, 303729260, 1847788660, -1922037783, -477693880, 2017702746, -756743447, -244660715, 614705266, 255273660, -1393183902, 1670522150, -1560879023, 987843854, -166329927, 333448683, 804001381, 2067859291, -1199315134, -2078029009, 153842, 701127658, -1531549608, -1683478668, 1987577619, -1640582263, -2009199526, -412380532, 98749849, -1622982931, -149553096, 1542882428, -115820399, -1850379151, 4360834, -1533034354, -60836772, 655035911, -112587015, -1014416375, -734618575, 228765388, 356365259, -1720978146, 1710607987, -1789263947, 357197964, 410350068, -376736347, -501374844, -452867016, 1282014807, -11985927, 866210915, -1115431305, 1513930489, -1008652725, -551342155, 1941015218, 737178471, 1243940774, -1015983675, -53098971, 1175052126, -706117912, 517538224, -41378405, 1045433289, -1523129539, -1747847230, 638526342, 1915722861, -1698342417, -690431884, -955134729, -931915076, 328490030, -493518972, 984960214, -1886902365, 847353486, 798836730, -1054139840, -225804666, 407385152, -2147014033, -817638518, 1392445506, -961976157, -1421291746, -969326438, 1854942995, -484593744, -178727688, -1445470311, 1053803562, 1738927941, -1664962209, -899079492, 407751969, -1398488508, -973290192, 920431027, 1856922128, 2096160299, 1969255694, 203478216, -1338364749, -1652169167, -1533707229, -50510061, -1523764991, -691586996, -53824577, -737226924, -1426166019, 1281653039, -53358504, -1929518512, -529993360, -651674151, 1498810198, 1031393196, -1652135346, -51111247, 2091523585, 463536701, 1071500444, 540748347, -1795803951, -1915732026, -1661419024, 1029114990, -943529072, 1191387116, -548955746, -1234894541, 597527317, 276199807, 1534347243, -1314792800, 1431327081, 219153107, 972023687, 1901811873, 208388106, -125631310, -349149337, -1584150966, 1886912642, 910816749, -1929990238, -944824810, -1512832057, 763956042, -147358629, -803941828, 2051946990, -1094453475, -1929845707, 1147677932, 1509703282, -2023367159, 433193027, -1576664844, 467784813, 22707195, -1306487477, 1816452998, -1689783528, -1325463290, -1730861539, -1305484409, 921663692, 1095739859, -1693175328, -282877545, -2057324113, 692037929, 1371996733, 1523501989, 122700143, -1091200891, -1829463609, -535515134, -1275135525, 2082791475, -520777512, -1776275494, -720306156, 1033873346, 285927881, -231741121, 1128723274, -956072348, 1439571541, 400465914, -1709917383, 1521453111, 497485965, 1761977252, 957916923, 1519928337, -1868347828, 2058859760, -358080945, -735750927, -373871869, -1397041945, 766223779, 1953031959, -174605878, -550189113, -578254936, 2082017934, 2146629123, 652233524, 1695194840, 514322181, 306067373, 955171379, 1754955550, -648275577, -1536160045, 1152150347, 604002190, 751839298, -1689626970, 929055119, 13379357, -1571319025, -641498014, -215056514, 244571851, -1704294277, -1630617596, 281545329, 274608783, -1734503580, -748864779, 516015612, 1080659711, -2100788843, -1808091194, 1583937858, 999838812, -80396371, 1696942708, 972384977, 813845578, -1619818522, -827535035, 738564182, 1534735370, 1178084327, 1062099304, 649971853, -700047417, -1924569531, -1071445519, -1211292415, -1593959669, -612844096, -1489226422, 507356064, 2053936928, 1017591240, 1266532126, 1431797905, 1587222715, 412743829, -1337081654, -545271364, 145199956, -808302537, -1199919563, -633947214, 167847619, 1807643435, 1346678288, 1355332320, -1666549008, 1632904986, -1427036767, 1670652838, -1479994595, 2089300643, -1047712382, 1391799561, 75631797, 948338528, 1312184720, 1023391218, -1195405238, 1015022648, 235798234, 350656348, 1568644988, 1297496858, -449555341, -515678563, -1864857293, -975601193, -787245172, -1490952641, -1279827921, -1156382894, -646116073, 858316145, -769950195, -39710393, 88536925, -2001591585, 218665428, 917160146, -1814524748, -1137967214, -879059513, -1790020379, 324738303, 1766102514, 1542662684, -924069648, 849207790, -491346181, -536819925, -132727520, 1857712941, 16245144, -866306331, -1419882343, 107014671, 1621166321, -68371792, -2071733847, -1658684180, -440067934, -1950770570, 1094581455, 1213349283, 764120071, -1166648492, 1488933296, -1773499402, -1703199123, 591044452, -1960323109, -33062195, -1165353733, 1213061246, 1415146231, 503178368, -446015207, -1495681265, 1604961090, -293643754, -153737604, -1984907329, 1733363335, -224751819, 796487852, 291842267, -1523522304, -1999692197, 1585224455, -1947336254, 652171247, 2125622736, -1729122005, 1630500369, -1033340691, -1573825480, -1425784021, 643475951, 642365324, -410417441, -1117474800, -909065953, 1194559962, 219654505, 63902071, 1290842847, -152761154, -510349809, -1924129042, 876929856, -1542946447, -475627974, 639979112, -252277489, 1919595738, -1727027988, -927128707, 1089814321, -491152785, 1638330106, -171769176, -1916941547, 1184844161, -1432066173, -1846428288, 220569594, 2140975619, 1452208905, 545709105, 194454757, 1372868620, 976549084, -1111806262, 1888253043, 579383590, -122749484, 168602881, -843792615, 1156474714, 427561130, -491579788, -154084101, 281990897, -2145365970, -1736855559, -438031098, -461649071, -306375756, -1541604875, 457219811, -1582055094, 1071799174, 192394806, -1766023671, 29265591, 2016019049, -611312914, 1318164059, 182883028, 673515689, 183005279, 1973182098, -738598558, 1649146052, -1011477718, -674883198, -1440025384, 1485943453, -1540612093, 1751645316, -2023346810, 1172217580, -1979057075, -736452510, 2134957890, -1701950844, 899095091, 1714720890, -1332274654, 65951221, -810976604, 1157241557, -1165276632, -1542772984, 1812399258, -1829440226, 152305708, 1670513630, 305284046, 696737278, 1933663867, 861576708, 1839383951, -278897829, -79305507, 441656324, -2008503123, 1621004839, -870578638, -1730208427, 1957759346, 1103575856, 292047568, -1604654269, -1510607322, -994649786, 853450133, 763234175, 770708060, 207245487, -1652224543, -490118797, 809015561, 882514568, -389634273, -1607640505, -1569563654, -1682730374, -754592188, 809697056, -1630238741, -1059853554, 280545453, -1176206795, -1620359007, -540935421, 391335261, 2057639650, -498384398, 1717509668, -466886631, 2099709458, -1010958427, 237492257, -873659995, -863100008, -423916400, 889325355, -237567456, -1363946305, -1830059701, 1851239243, 1894589071, 2008064337, 987008987, -219902400, 1323847226, -779715482, -1308702154, -1072433298, -769712548, -2012197226, 353818730, 690469944, 1063129068, -699150855, -752626518, -1173024120, 782754308, -899165002, -2137234434, -891176536, -405501175, 1333656964, -1256821647, -1077501077, 901009235, 378761437, 599284084, 666828278, 55874734, 377787807, 1798946341, 1194014376, 1876826962, 1608228205, -1076408145, 1398475380, 301348623, -2054022313, 432707081, 708175639, 323240415, 60633891, -973452200, -1689748893, -2977077, 1113338446, 1416515366, 1349334298, 1360506403, -838025730, -1952999649, 892626520, 603370344, -1348924970, -1514831615, 1621780120, 1904091156, -376542737, -172218436, 2018768947, -907105355, -1188075675, 1648932414, -899254596, 1109814078, -1793918913, -1548947405, -603102396, 2133289174, 890080233, -2113689655, -1146758468, 1489026587, -743563222, -861689370, 884389758, 449661587, 1077338769, 1897813232, 328663778, -1130090121, 1275118235, 1366341604, -1532401782, -422522473, -349218791, 2140373727, 1873900768, 1876051608, 1766397489, -1767224732, 131722965, 982727640, -752126908, -805647151, 638454515, 1374318748, -1561916119, 561587896, -2064139410, -1281816449, 240506899, -513360137, 1282074327, 1296125714, 625818120, 1199136890, -506723482, 1891863429, -82757734, -1416947287, 1445796244, -413901900, 1937555621, 2107091689, 117504348, 508323586, -1186024288, 1899017606, -1440021746, 521842459, -545367972, -612927121, 1955002522, -1881853770, -552571106, 797659330, 1065526245, -612345780, -41590496, 674019778, -1001718101, -1160268420, -454980785, 854171887, -1245143394, -1791015528, 438117783, 307914154, 337432457, -1090078396, -876162814, -1289713183, 327803597, 1697976843, -558907482, -1321389478, 2044641609, -411540004, 1823501589, 864101340, -1834526660, 1373944591, -1470872387, -226948560, 1372901370, -343459744, -371903978, -1312661143, 2079977874, 742408150, -1499057941, 148641425, 930992199, 544815673, 721621148, -115765913, 973369083, 424415980, -1549216758, -618597574, 1958625024, 1409447570, -603057203, -1527975650, 2104993273, -1785576485, 1908566458, -1018595235, -1710853318, -2085488267, 1281240065, 2113803374, 13943608, -1602197456, 2118886771, 173527948, 1826580684, 1240872132, 1756539355, 2087896242, 922143479, -191504695, -647281978, -171958154, -1255476289, 294425289, 927598937, 21643811, 752692611, -1216529539, -1822079014, 727835201, -577227146, 1165470644, 1786365507, -1813710101, -427640263, -47602469, 53783715, 1730451702, -987636326, -466143974, -1589553810, -1546085501, -1579856642, -899045269, 1505340166, -1164671405, 1072451860, -270630959, 1127407499, -540868162, -619655340, -2126409526, 938216901, -919985099, -1495017247, -1669832294, -151931637, 1839544242, 322354554, 1162744525, 2020189868, -287543513, -483345027, 1446638495, 325228959, -81595817, 1256944124, -1335443082, 1174488134, 364886827, -432665666, -272256721, 400759525, 473083836, -76586090, 244784110, 1188380885, 47224998, -68517340, -237020813, 225843503, 809268006, 41025352, 246789768, 1562386753, 617286531, 1324190717, -1506349386, -816060755, -1047085903, -1256320331, -1689755530, -509368697, -1252406445, -493635213, -2068517664, 899953449, 1581255537, -1617441226, 566665114, -1418703509, -668728976, 1805297953, -1529964729, -834572918, 1689145568, 948831972, 1271117184, -1687381788, 869449980, 1442881835, 197891807, 1621361190, 763601265, 970005330, -816032339, -1241430961, 1117056540, -877805313, 1778383552, -159774267, 1240555093, 933104706, -361664214, -1811290450, 894792515, -1974847711, -1011138336, -572652545, -1707302102, 1140169109, -1335453049, -754708933, -1798188869, -1754444925, 1609153383, 1462870019, -741108495, -1724820016, -1169570857, -1084569577, 166777230, 479334092, 434596987, -1160735569, -1683063484, -1881199759, 1722044665, -1020537872, 1439400109, -370373873, 1753098600, 119497153, 1576101051, -2115202912, 435633137, 1306599882, 2144034428, -943895489, 1197688145, -1690081745, 1966957071, -348851055, -1361463887, -1888382666, -706634846, 972485267, -891440476, -1427508609, 941311775, -204585274, -1584501749, 886272286, 1571755314, 2043848673, 311817685, -408680502, -1862166670, 1635880377, 1527572249, -1278096467, 1377118958, 1262652294, -1091118984, 2086516397, 329263994, 1552769867, -1527200486, -288433628, -563095458, -1584940289, 1334024223, 84739785, -259323643, 1100044557, -1708124818, -1646970400, -1936117242, 2072709245, -1091407826, -1108277230, -373676421, -67633340, 657604325, 1041026038, -1028341463, 1679570632, 1239226158, 1795718869, -1488333441, 670992852, 1251054416, -1773451308, 1508564948, -1108870741, 1848096751, 1893161372, 2042195526, -362483196, -189831198, -285495841, 2043709061, 549374138, -111287294, 478916407, -643916159, 2142122101, 1137203221, 205551013, -1758558588, -1189008453, -451701807, 355995071, 330062930, 310199126, 224784831, 1892658682, -120385839, 1178968057, 1566699717, 798371275, -101779713, -941844963, -564997779, 2069034392, 1798122540, 85386757, -784717221, 788256701, -1179078391, 1135154351, 445136728, 1500872790, 1491120999, -1018865227, 199051662, 1631248559, 1766760035, -1782879050, 308670372, 97810757, 1899550948, -2115836087, -696785835, -1049465052, -1289485631, 444214640, 2073806889, -1021030787, 1894878195, -382280428, -1643933612, 844385613, 1415378315, 821275460, 2102153981, -1064533629, 1944293771, -1998418297, 1242240229, 1699066528, 2040562092, -637924728, -771300786, -169991445, 778433373, 840770087, 1838070208, 1752717773, 1618897921, 1875774154, -373420583, 414868140, -493259749, 494145806, 1231826404, -1989016460, 1203203125, -1135260036, 1977748055, -1283449017, 950247212, 555052392, -488604066, 98995573, 985206533, 607174138, 1924737373, -1737859837, 1869378340, -1977557385, -1858853390, -714707441, -84622775, 802100375, 1434368049, -92901442, 1296808709, 1044407033, -258855319, -1814197593, -1180528805, -1869160359, 2100941288, 812234670, 1274094733, -277835, 228226215, 232912929, -1647043102, 183688632, 1136157093, -268463502, -1739267292, -888602788, -1385421084, -731134281, -1986935102, 459189529, -2015786464, 1342661868, 1240237828, -1293099296, -1094483741, 734711780, -1319809365, 1216592081, 1827537819, -179100428, -329093053, -577009030, -164967258, -1454796743, 1971805902, -323992780, 411470479, -27745064, 1579764247, 770766563, 553750912, 647003888, 1967845144, 1545891632, -595124049, 332495090, 1036458285, 974929185, 784439635, -298652921, 573884910, -349289444, 2064444653, -1621191130, 1255429289, 1369286628, -1433326243, -36551775, -106999787, 451044656, -87845812, -1083898758, -1546608651, 959535292, 1139314193, 276523676, 1541728863, -141361712, 2012223166, 805615487, 1648293994, -1323439451, -186640956, 1373899813, 1796657697, -17274317, 1173436414, -2061081665, -104692029, 552834229, 427672444, -40957158, -598521306, 78868621, -1010455675, -1536817788, -1612736110, 1248796439, -248308003, 1572783690, -670686989, 673543969, 11031149, -1864475537, -1453479741, -1969593833, 273071032, 1189603735, -89223578, 735883119, -1514604429, 1725576379, 1994560422, 1775114857, 896871317, 243717529, 1105336340, -1479198180, 931758820, -1344797382, -777718000, -937648208, -1633310533, -1898865004, -885327079, -694800286, -1859490843, -1212249688, 1240546906, -748514324, -1394103798, 2073669105, -1980277407, -590188717, -1109104871, 1684070352, -2069414525, -1660187001, -2111825961, -201318458, -498248281, -1902567486, 1423117527, -1031737099, -983508297, -823424708, 2069553657, -335142975, -1326063098, 1486359973, -733643559, -786761187, 1697038670, -1091436486, -1928944452, -1695442241, -401154532, 1209432056, 1098530933, 1885489601, 1179541608, 331935293, 176913743, 3081219, -1434190816, -1505383146, 1803905797, -457572185, -1071534803, 11571048, 1131962527, -1771869382, 241183795, 37823486, 1217427161, 1987203666, -568735427, -306617172, 1161643530, 590564904, 1400167229, 1701097954, -952201977, -1129228133, 2095430190, -1000081087, -1923201529, -1761301594, 1927547539, -2123161595, -880460130, -1753228718, -1319847666, -90424752, -1833724758, -1161370626, 1746396178, 1152137535, 1297624921, 693033342, 1235425011, -808117992, -1844322023, 1203230081, 1792834707, -859528231, -1033081524, -572373380, 1990195773, -162570317, 1714745520, -1990949916, 1329926727, -776376214, -2114245141, 2135487702, -1416937561, 286296009, -304241500, 1576212335, 1259961504, -1889004976, -738773038, -1234269522, 1336373882, -382861588, -1933786274, 1993284879, -778592344, 1673217994, 734054451, 1265958727, 470887463, -1136611770, -797826828, -845643334, -464718680, 1264641961, -1214830467, 492726206, 251812049, 746694449, 1899336026, -51762697, -759125365, 1637988900, 673749776, 1473515398, -693266942, -1732826881, 157760323, -23029609, -2113927790, -1190920987, 1646600475, 310793168, -367260854, -1915046107, -1004175641, 1490227158, -1287766122, -1770297209, 2097838891, 1335129038, 408269560, 296936593, -1718727486, -487059993, -662017890, -1309116197, 426018789, 152263385, 719152480, -144526094, -126083625, -1731173609, -468284909, -554786558, 60877782, -1525879147, 1781464866, 151185691, 343636334, 1860584536, 1196616106, -1184296278, 620772008, 1769090949, -1944954026, 1901058524, 738333538, 754721325, -1476349118, 1745185259, 425188529, 1286989520, 402033204, 857854440, 145004339, -737493166, 2043189171, -858248635, 197383432, -358487916, -101346052, 828719427, 1163463215, 513712662, -86911793, -1238467517, 1703799957, -1003879642, -509271454, -1810329514, -2138156127, -950637028, 953540266, -785952983, 517116806, 1146919570, 1884706964, -2043708214, 233153451, 1858488921, 2081122223, 182807755, 1017136123, -1227998082, 569102866, 971760511, -1337926428, -967396970, 714451755, 936890372, 1657304674, 159246135, 1737453408, 889274779, 1093705692, 1902009733, -37633448, -1234081166, -473867125, 1219066117, 829674752, -44923731, -934855099, -878942314, -472397992, -1768482520, 1692918869, 1500983525, -1048871130, 349234751, -1950738688, 44237037, -958358960, -146976346, -2036028016, 1586327603, -167209353, 1899496947, 1738501276, 878188643, -426972254, -864406208, -1551660693, -2088937598, -2061053943, -1931753692, -1583219289, 176444714, 1743454252, -305535081, -1216351997, 1814870305, -237628264, 653602890, -616896896, -778803951, -959013264, -772004972, 1483984089, -793023314, -1254258183, -1070184181, -286779787, 556508486, -1765271586, -1510248020, 892731305, -1095823761, -1145760983, 1279293536, -1258762364, 1174533003, -434460605, -1643499501, -694465319, 1249839444, 1769811645, 469526682, -363913390, 1669258944, 1398157972, 642493446, 239282979, 1756119045, -880464279, 54315273, 862358681, 1151159196, -447772998, -238614009, 1624173119, -49335278, -1898197275, 421288608, 1263513648, -1952853509, -1204312840, 1007760506, -1631468313, 1662367972, -116668764, -537632551, -1094572564, -1262550033, 1104729134, -1779658610, 451398948, -512984257, 1579936149, 1168918838, 1844776551, 1424824056, 119232521, 838131160, 576387104, -1952740534, 2139630082, -1404800115, 440431011, -1020708846, -1476487036, -761323034, -1760043890, -586163271, -1066091016, 1491215679, -2028304454, -744471179, 1823203439, 1858757912, -2102915996, 1398459514, 886637164, 1839257546, -7107191, 1275403245, 1810290977, -542075957, 700835203, 1429066447, 676759135, -834382466, -953039724, -1749087564, 120317812, 17072646, -1942125795, 972240712, 148020674, -1591316233, -910449245, 1426073050, 1147534318, -936550476, -2081241319, -208748296, -960267372, -994110123, -613427933, -201595969, -205196827, 1647051338, 1800255508, -228058846, 70624346, -1842306369, 444655177, 1519873942, 198743973, 2123434816, -522298181, 1694721492, 1747571840, 852083982, 1546848600, -924944917, 356821868, 1709189508, 1668557110, -546818375, -1952199112, 989863762, 877136595, 992412062, 468931108, -463588557, -1022299235, -1046424340, 1420079433, 1548862723, 2137388235, 215317625, -271630187, -615775243, 190807702, -405769929, -1576130825, 1496142733, -1816684069, 135144401, -27072909, -981631974, -111025619, -692242667, -299529448, -1687847043, -392941988, 971233702, 600794222, -1051683690, -1122250514, 2111564991, -1602199506, -1701950254, 823121359, 1547122641, 1467659883, 133498611, 1065266807, 736412120, -1535887524, 449203580, 861102027, 1402576846, 328245414, 1153931228, 679875697, 1131167819, 596755769, 1338750611, -1730948388, -601796230, 670851701, 1563967767, 1992741842, 1659260503, 85445763, -533428286, 360259523, 1891477125, 1855743279, -652463979, 2088965943, 2079231939, -832482670, 1463180761, -801182039, -1160588152, 1630924181, 1733681719, 1859897246, -1218870190, -178910436, 2128076427, -1696546617, -692249829, -1995884661, 2107745556, 1827043533, 2038838233, -1448254580, -538119379, -372960911, -99879391, 1062853129, -1203762349, -1132583315, 623474890, 2118341926, -1549691210, -186827350, -594591207, -679962823, -68245454, -367434618, 426495, 586318770, -591370912, 2092805730, -100148441, 1709716404, 571477958, -185568072, 1046582057, -1047478805, 1831440204, 465849328, -350939875, 210582224, -1729745183, 75244795, -396883531, -243319899, -1969436122, 1314731936, -1918753892, -830896817, 684447648, -1544392575, 619529880, -330622431, -994511347, 2045003157, 1702070421, 490862419, 748577944, 291389637, -935634362, 1872525645, -1919864962, 1972665458, -35727230, -1716530400, 1168047645, -1064624250, 726532814, -1797857541, 394949659, 700463859, -379501333, -307664985, 1315401226, 1326569301, 1803528155, 2101958569, 1601695987, -1287374120, -1092751566, -1039584456, -2038173482, 1218511439, 1087579784, 588280399, 1309035880, -1852388772, -1257814555, -530773262, 1071041812, -1964545898, 1056903014, -1324831597, -859705221, 157302000, 481765849, 878480411, -1742504093, -1335975804, 1523860378, 731675379, 655850775, 1464113121, 1229879349, -251011086, 127432841, 280181141, 100193492, -109082009, 70498174, -1222911310, 779119011, -154051694, 1457747732, 937304362, -1018489071, -109525563, -885944448, -700534214, 929194314, -24302403, 19252334, 1605221340, 110622696, 1145782755, 1532085456, 692870428, -876682148, -1217491345, -1859580331, 1200856996, 156936207, -78999386, -202473350, 1957494031, 1217258624, -840951573, 446690427, -1554112269, -1474023399, 1159667145, -1373856588, -956707787, -300758204, -1079712574, -908623770, -552043928, -2125205393, -17902291, -1576782502, 1861074752, -1735575563, 570152198, 1043235675, 2114020604, 113362085, -675038828, -1701644914, 1294456644, 2002826066, 656766203, -1860683636, 1666227457, 1350539743, -1158617354, -764264913, 1232908095, -1043903274, -355073201, -934926572, 357353202, -1133796212, -118483349, 343744975, 1480665850, -235339094, -890930135, 703181016, 1593901304, -2116499641, -2136025892, 1886250291, -1421351409, 1995789030, 2011021743, -97709252, -529744802, -977079763, 1461719437, -263098075, -1631477150, 1732390911, -1473074318, -1386450233, -1527641596, -556198416, 1554454189, 913242433, -442030097, 750757981, -464848653, -560135963, 1463283303, -575727544, -2101442342, 1111285145, -1802737985, -1647880052, 310516965, 1321872843, 31232586, -1082359948, 1305288621, 101976628, -106800635, 905762446, 1405925544, -975354904, -1911913665, -1262258650, -2096778152, -397839680, 707372112, -2100946576, -1649095945, -1937463837, -1326087674, 780088137, -289955576, -1991644442, -1424190086, 791103730, 696238544, -1200068271, 176051935, -2085488814, -1522879659, -1386910667, -741143752, -1044807339, 1833100441, -1388385218, 243186997, -47865005, -1762318004, 789749490, 1371176934, -1263914852, -369045848, 481876275, 1372926182, -2012472678, -1853824242, -1896567703, -1089943017, -1667761452, -264180301, 228157639, -1916780821, 1985867650, 897451767, 153917328, -905842727, -1220592946, -631629644, -716032020, 2025552307, 1562522355, -1010334971, -927267644, 754628258, 1272622097, 1104384221, -1191154385, 302129978, 1429817251, -960492749, 1644424133, -432607704, 976364174, -1684542904, 1041548268, 606620247, 1864262959, 1486820202, -1829132864, 526926870, 1691389284, -2143249599, -1240381542, -1236473569, -1825200060, -499895390, -1637535245, -902454684, -829107044, 528212553, 107198702, -1012973430, -990199684, -1965130567, -676513468, -1620543935, 470941096, -1654856265, -2048023307, 1204292631, -285460060, -1041645981, 309005246, -838590854, -794658927, 1570231794, -479573069, -154676931, -849990516, 905343764, -499132333, 467057758, 1969418208, -445207676, 2118601161, 718466116, 1324001445, -760912398, -1290246249, 182358651, -1019630363, 129483290, -274190333, -1651993714, -801670429, 43806078, 1935129416, 833913418, 756357517, -1178262913, -806416792, 333729519, 1345590262, -675687454, -1241029615, -971185697, -2033122062, -150126464, 752197541, 1257262996, -1559877980, -1113563444, -1471836203, -2007241830, 1187672164, -986901908, 1445846479, -2114639958, -544630187, 1091212071, -1624183497, -2004556494, -166279234, 798117463, -1670153399, -1432361867, 258628212, -2004477786, -304798408, -1148921742, -1091694152, 1244634716, -1802075338, 399011352, 1776825991, -1819251867, -2122786300, 366608225, 57505644, 1203759938, 1952010824, -1277074148, -875778267, -269726540, -1779917729, -172824242, 1450740065, 571533550, 1018399355, -917165589, -1537685861, -468413845, -112354081, 356053472, 986848556, 1045826577, 531034714, -494638766, 282530995, -648991207, 952087813, -1350575928, -85554593, -1433724313, -1106876537, -92355303, -19732342, 1279456531, -511004989, 2090995347, -194068701, -931731999, -1538206530, -1552383898, 1963519743, -1262967083, 1533354297, 1360187660, -635195693, -1460496431, 39935695, -443925678, -1258451114, 1896558763, -1043378822, -497425755, 1591810520, -135620511, -1635599941, 394692628, -330139562, 1543271410, -1087167487, 1833490804, 2145519002, -1849664784, 1966398456, 245189112, 1504568730, 469359097, -1794286574, 795164740, 154462290, -1132404487, -770876585, 2067624732, 1732871411, -1099848450, -2128319171, 210355300, -566289010, -1875910766, -480568172, 759449271, 637007572, 1220173900, 707230374, -1881577458, -1805267881, -1440820388, -326639744, -498089825, -1219644263, -2114438404, 937098841, -1644360943, 1149071621, 13711491, 645592525, 1857886503, 1276685503, -666910404, -266525754, -1669889761, 264234806, 1942278121, -1720574312, -643229384, 2000722726, -1573775580, 424751713, 1675835969, -1507691437, 1341007072, 1461057880, 89175645, 1284879519, -289397664, 829547553, 810368094, -1499886709, 1527321152, 589356112, -1055023562, -1809562043, 630704973, -1198396920, 1959028384, 51047183, -301144489, 632190403, 2081882212, -724580298, 2960323, 1737756651, -296986722, -71500043, 428711865, 520330322, -913649778, -360470309, -229840389, 17668127, 1836815800, -204069960, 439927126, -1231647731, 1803185177, 979344492, -1811730920, 389991226, -428787354, 648547699, 1604400083, 610540386, -284111845, -409677162, 1827323956, 1066890655, -2036376927, 1625912905, 33644313, -654908008, 711866787, 1166450727, -1854177502, -1672411081, -2136266252, 256114931, -766448457, 1486804296, -687045679, 1141973195, 348013692, 1719141639, 151815235, -515836906, -1973594612, -1336567005, -1786283799, -255995280, -1697254859, -197079406, -355509594, -775387994, 242346369, 1320772486, -355027753, 669325257, -1915807227, -1563840374, 1591832013, -864114483, 1771449603, -1358512000, -1696431172, 396663951, 1980618706, -1797636647, -1318072264, -2100252126, 1676268892, -2041332538, 949691227, -1396800636, -1501010902, -264804697, 605240005, -2018431252, -1823549506, 466310182, -599408057, 2061867463, -1955295038, 167063533, -1117278095, 1046514742, 1317399331, -1487521166, 1708600723, -1532741043, 524638800, 539771184, -1567346127, -1902421047, 1327690622, -399452625, 1978419839, -629061309, 517688324, -437534223, -1848642769, -1139690349, 1678750513, 2079880294, -154610982, -1206647349, 1026064888, -1563666412, -1019699737, -165240022, -1257386366, 16302777, -262978839, -972882478, -1596255938, -1007073849, -1693791556, -1740592051, 1920877952, 571275343, -1913072584, -112346533, 140687899, 142746125, 1539887879, 1124219102, -2042017316, 1159369026, -325843437, -1548040643, 437748400, -945663933, 133028676, -602009872, 1021336736, -233900216, 2145278193, -1685176493, 848377624, 713661621, -1603239815, 1253527041, -785278329, -2086268247, -99491729, 441078542, 2089559025, -1736814327, -2050507416, -1941490914, -512316064, -334217179, 940238206, 1399465411, -181039888, -572169948, 51555859, 675967667, -1980359596, -1723433772, -1886919738, 635420604, -583742593, -1634534623, 1290419560, -171286316, -817731524, 1312434906, -1759898785, -597641420, -544637197, -786446916, 841976872, -1791656634, -1569334239, -398713270, -1059294103, -1867585648, -734953327, -880867153, -837556602, -279074386, -473751100, 425227347, -727733420, 445990327, 635489545, -171288146, 626570935, -811611765, -2129693076, 1815181583, 2125699706, 1040368352, -1500182902, -827534427, -383495021, 1789798837, -2010095577, 2113181078, -1661360834, -1572673619, -156940158, 795771145, 1163588952, -1802413131, 1401931213, 91226831, 2133220100, 935639448, -794624944, -1207195477, -1907460372, 1017424463, -680334818, 537568387, 230845850, -1921146749, -107784639, 1448104587, 175526440, -827678372, -565172898, 892702235, 696460198, -523011714, -336228181, -53616394, 1484216828, 265473548, -811628463, -1426021115, 563112684, -728445080, -2108323126, 1770008742, 598117421, 289095112, -998266551, -991483720, 1012931207, 862005234, 1157773152, -856461279, 718081425, 890695050, -740010500, -1927331273, 732297547, -1060523192, -1610911492, -890318860, -2017287250, -1120743580, -203363363, -1043762290, -22037002, -264942164, -2021176334, -1800389354, -1504514478, -2063684746, 507745979, 811594422, 92249453, -839707683, 507943321, 550798292, -949118789, 932689129, -1483738191, 1759552051, -576389545, 1762152188, 1834491834, -701055718, 883658446, -1901711315, -22631475, 1904271650, -2135132253, 1461801992, -1523997509, 1816037203, 222963140, -463417628, -1086614918, -586342172, -1296250552, 1889492219, -1044343908, -1078371457, 1417179645, 1346055525, -1338333065, 240401292, 898463601, 2028103463, 1377471906, -1836081296, 476069707, 1776633981, -530452195, 968288932, 890819322, -1721041526, 881436101, -716205717, 1255670978, -698960771, 186221364, -1901368678, 13181266, -2021821419, 460530331, -1429362158, 1697726533, 1670115754, -1966795588, -168772316, -1214244161, 1209299080, 1476610933, -1445477393, -1336885137, -1458416740, -710253153, 717281492, -756110181, 1841549480, -1755847037, 1332182527, 955341156, 609214889, -811914714, 1628590942, -93174401, -1388811628, -516356831, -439546673, -1893975994, 1663021042, 1221883868, 239980858, -1466840556, -1619368065, 322640641, -951835123, -1038985615, -683118049, -670282787, -690866931, -449847012, -2061995824, -1388102853, 1516477368, 640253607, -1294087941, 309512468, -1611487107, -1909178758, 1235324156, -1017876933, 1118500709, 1110078562, -1170032855, 2051276038, -2022107000, -723906642, -1101379734, 1864642487, 632483563, -791748618, -986341006, -1908799289, 1305123120, 1726845770, 1850076284, 10511938, -867482539, 306639099, 1716648769, 202374649, -349524953, 1892990254, 1358814887, 1316030237, -577592670, -307946206, 1001830832, -528012684, 5525052, 243506457, -1323434124, 1375456664, -1165563580, -1343647460, 2085752549, 2102600358, -1043876060, 688338850, -667790744, 863013870, 723589796, -2068797193, -192827102, -2091522913, -1125941991, 40717391, -980112913, 1531854866, 1378300095, -865037397, 492844750, -1072377504, -1366962286, -569487310, 442014001, 2007878499, 1922820830, 926929369, 1093596960, 1736700104, -1370953907, -1084090578, 1974542370, -835520428, 515532608, 560437430, -813446277, -832587750, -1658872626, 588658049, 983262531, -1138021283, -915679804, -1808842116, -1732775241, -37732711, -139382643, -198280124, -753073922, -1661346037, 2026396101, 1432382120, -373896278, -1924437090, 730209528, -1593592886, -1259921071, 1366064174, 1343817041, -1974113258, -2104197288, -463028945, -2003101712, -1158200293, -482546759, -1202123214, 1106144636, -1048992621, -1716920381, -1983708276, -872999994, 1658308024, -161843086, -1104434361, -1810553563, 1586629286, 1943507021, 1239585779, 1497381990, 23941066, -1511485983, -1292172121, -525319595, 881872134, -537970334, -1261921096, -1481128204, -181565511, -908995954, 1261259922, -289729113, 908906986, 827560189, -744583768, -1774545524, 1641401552, 1479675189, 2094110052, -1660646617, -467649449, 1176466223, -1971337345, -142127535, 16936052, 92032033, 588921646, 430204899, 1450378766, -1294295346, 953133127, 2109622255, -44060504, -1628122187, -1965740641, -1291543529, -595254331, 751934582, -14179300, 1903705376, -282027011, -626177449, 1787407780, -1606210013, 202969546, -569436844, 1802381428, 1214079296, 1979721392, -474518336, 888014255, 947457302, -1629617301, -750493122, -582516055, -1556977732, -1156580924, -386127641, -1474706510, 1043354379, 779865585, 1492331480, -907328017, 1712098283, -1560289910, 446047665, 1828028329, -829261274, -89699967, 743025664, -1689810597, 1383953176, 155486689, -714590538, 944445991, -757630916, 1258251027, 901437248, -1666374860, -278797100, -1588249212, 60265301, -888566258, -975212770, -1050667488, 1132897368, -568759879, 1778024782, 1265136, 432500843, -395613238, -481388386, -1295348292, -1063206471, 1182932192, 763997125, -1668438736, 1147987730, -1299591081, 1798711578, -1431081630, -995701160, -1937413884, -271552178, -1138524257, -1167464766, -1346163499, 1232997848, 79055216, 731065700, -135452621, 2142188485, -1696629842, 1291212111, -1256697752, 2107450363, -1532556144, 1594302050, -32439309, 671974139, 1184833140, 116018108, 1134849256, 1278619505, -1266026451, 649868591, -1293351797, -869726441, 1154499396, 1306229413, -334065883, -102088072, -1722293900, -397427540, -1264896145, -1265834122, -1158632899, 1727689690, 1394681036, 846314537, 22693533, -1473756825, -1168173184, 1566834549, 205766209, -188916286, 2018032159, 657159513, -1353289563, 950448763, -824578740, -1330551497, 1131370037, 2104825653, -1815931767, 1010327410, -429692101, 1889839321, 1390735967, -805901740, -1812076627, 2117839183, -1332543379, 1488558198, -984084432, -1212941465, 1919241598, -481513581, 495416308, 1678145196, 164935808, 62940067, -445100256, 636973430, -2109503989, -740546976, 1325287205, 269595300, -127163463, -485030574, 1757518990, 1525841992, 786502900, 34685337, -1827246441, -637214929, -2132456108, -2145068466, 482366670, 136455404, -1189251634, 1193571702, 1399591423, -605412824, 456959856, -240983508, 1101790475, 406309509, 1450379739, 1138603224, -1610604815, 1474957962, 737892750, -1863352403, 782239378, -96244599, 1166826194, 1430597679, -1414842655, -67896559, -1714244320, 1876213576, -141594411, 743227148, 1326103887, -2123741245, 1920795101, -1113100821, 1065934167, 1941371950, -1827742881, -1220891549, 384687433, 537505044, -1590238063, 1594202044, -825511470, -1928316518, -668030363, -97323434, -876701055, -1998473144, -1778352483, -1352806925, -1758641284, -553100970, -211681906, 387257811, 1507039009, 1804193901, 1058651819, 1161575196, 674709347, -319546981, -779538207, -1056611535, 251256344, 693404186, 437194922, -1658713950, -1801288432, 1018113721, 1338780308, -1216670331, -177752440, -761877877, -2089265100, -1613587474, -2056412345, 1869809804, -1135095829, 1896739193, -1652210165, -1381792955, 1347460579, 412548609, -1064099555, -222860994, 963497213, 534582273, -2145645948, -1695619591, -1053984336, 949046371, -1798042468, 1382981640, 914975224, 1977758142, -115912768, -927854003, -1888101238, 759311622, -1150381132, -635242601, 1702378448, 656920190, 330170442, -165869015, 786177024, -591730421, 1612998781, -1899126271, 765249873, 2087512946, 619979470, 2052306960, 1949077802, 725654678, 1809778443, -1222211418, 317127039, 1010145479, 2061683757, -28032099, 542650206, 1414017883, -2121220796, 1201370668, -1533701885, 1673507780, 1459625516, 1550957424, 562508126, -1439791928, -1008327214, -112005967, 163783558, -1608877525, 838637880, 1477659230, 830635822, -1080878017, 272070669, 1273867620, 180955359, 1457347688, -1933934457, 345622681, -2050107879, 517258659, 1585272397, 994567680, 1218919543, 673055822, 1771297071, 1827698889, -1982687164, 1076111895, 493057230, -1345851163, -843715648, 1444793790, -1680572085, 626572748, -797425747, 1736137105, 30668615, 615715417, 1386133100, 1844470421, -706966327, 1649859039, -853695528, -1699075962, 705101023, -1927867404, -210990334, 285119545, -63456911, 885527086, 1225888133, -1438597758, 1482202891, 1115394917, -1813462066, -325271838, -917557262, -1485034469, -2071964070, 1967708471, -308957317, 779168177, 680869515, 868021049, 1179897975, 885986630, -1201125406, 1007672284, -1995778044, 1669237647, 1102775073, -479698377, 112012052, 677407472, -2008228544, 1520295092, 1323540059, 1470520212, 247201932, -951322631, 1532334039, 2063700344, 1444835377, -1035289057, 1410714078, -1083505963, -1379420174, 1013396002, 1190436573, -1582951442, -821151101, -1942151161, -1380163371, 330171520, -2130715659, -28583501, -459995767, 973667761, -100453177, 307008783, 1345216289, 1524951312, 406465274, -28206299, 974183900, 536799226, 1630672756, 1129990123, 1353618907, 1089668189, 1904850333, 761952938, -871029652, -1822050367, -688586504, 272640830, 369035972, -1950878186, 1506509752, -998795898, -204219768, -1297629703, -899589825, -670683472, 1787960576, 1644016105, 338201866, 2116326931, -1899970629, 1642768842, -1131482762, -2112417422, 1778001898, -751926370, -459737543, -1847863240, 1624309077, 371959479, -306346411, 57355273, 1848838224, -453576818, -403673626, 157858522, 259945674, -2040696480, -1270438547, 959821219, 1235621123, -1200623479, 1865048288, -1413993835, 2095560907, -756457302, 1513341614, -1894743885, 465802130, 259217706, -1371355875, -825134093, -37760439, 1982607371, 982100976, -251461770, -109420740, -135303870, 1728254082, -1008755595, 1322635974, -1707814277, 1875502416, -606219798, 1414767934, 814026842, 260673651, 1060717532, -284469926, 603652165, -1926380281, -1480763498, -466085677, 1196938735, 1933902021, -1796760197, 1706198895, -366050591, 910643691, 97056506, -1141503023, 1588567766, 1279567070, -2028703996, 942925896, 243771320, -1111380510, -636551777, 1116350337, -858479096, 243543472, 1086819327, 986580791, 2007861973, 1031384023, -1143022022, 1912414163, 2142694296, 1007376573, 1311167569, 213499779, -740458032, -625478066, 1842838241, -593960214, 2128229231, -1955287224, -145847355, -1458464530, 87155307, -1040275014, -158823132, 1513561869, 913385656, 73953344, -1452911678, -777397744, 340137327, -370994148, 1573194720, -1663087073, -1990978380, 795522786, -83650937, -146455910, 483609360, 1585855387, -1943097118, -333323737, -1624074792, 667889848, -856114419, -1697745416, 1003506487, -1243529990, 607591537, -1811621020, -830991550, -1991348671, 1654977098, -1438865202, 1533704444, 1922463110, -1736638706, 1669981662, -345829244, -145942950, -625932037, -483179218, -221123135, -239959610, 282543504, -1599203680, -1742006890, 2012300773, -1105430060, -488277845, 1250922319, 838863466, -602547084, -1270174970, -797094148, -1801674023, -756778832, -941754326, -1189116397, -804409462, 1961039732, 74719705, 1030593184, -525977012, 1976015107, -1909474899, -1438007205, 943751455, 1598647373, -1126223250, 708225303, -1118695985, 536789188, 907843596, -607290504, 1439638712, -1198673677, 1300488445, 954212379, -1287227424, -2038595461, -1700445824, 1660525456, 1542921516, 1081759101, 1019408725, -129931464, 885268106, 1827191247, 329526872, 798939352, 900885749, 2090204093, 473854029, 6695964, -1571885698, -110882082, 1360464789, -1764692592, 624152982, 2090893717, 1282083699, 1890283721, -1713072328, 2101004478, 1907251765, 2068308684, -1149940849, 158125327, -306262136, -878617842, 1189970943, 2021037619, 477519483, 573804935, -93298682, 131138697, -1686110965, 1996378147, 1218292861, -1065325500, 1153402104, 999429539, -825020119, -946863686, -546491620, 792965663, -1478230982, 1434355582, -1694587107, -1249998648, -1855177361, -165161591, 1900361506, 1150385829, -1133265106, -1185711560, -1601032693, 437639327, -762564174, 639983304, -2138540512, -145096692, 1615100466, -467352404, -158476663, 452435267, -450434914, 195998539, -1259992039, 795224178, -661157535, 841030443, -403277952, -1768037422, -1335240071, -550512051, -397812846, 1018278885, -232161122, 1269834741, 634632086, 1926132132, 41228271, 487936248, -1508845369, 917116262, 1281813022, 1704212280, 2111810946, 148202946, -1653513101, 405820496, 812478127, -952723355, -1462311828, 1261885727, 1355900418, 39907862, -1911695180, -1559337887, 1815492105, 1292313827, 1132464543, -1269081408, 1898988954, 1193860859, 874988722, -1821956494, -621347948, 584514376, -1702834466, -465070338, 608773666, 474381651, -1245585111, -895717575, 644848640, -1881777820, 143635668, -1709756281, -1386888345, 1190555952, 714512230, -1973957462, -1499364946, -1511587839, 896202, 1290661604, -402237274, 1428127237, 579764631, 529519317, 979321212, -1892940262, 1779521679, -398148027, 934598603, -749246543, -1100967958, 508803829, -1630055310, 360609136, 158452743, 1211077932, 2103255460, 56670632, -909447983, -1342511656, 1930148350, -435514010, -770012698, 1039873800, 60907859, -718848142, -1506054984, -1686872750, 1908002704, -1955072156, 973271765, -307695281, 271730751, 1954004650, -2089919630, -846140224, -2131570169, -1572407944, 1375770961, 1147452128, 1896431281, -373818574, 235371173, -1779227785, 198950782, -658496693, -1926918750, 1869666309, -699287279, -856560017, 1963282157, 1680103846, -326458250, -1110867595, -1560846156, 535507168, -1129704981, -1297440470, 1215457189, 850033624, -1543009727, 1280572133, -675991366, 109180501, -1797046838, 462655578, -529046673, -1965948407, -90951162, -380177492, -1745766119, 470634811, -1988136729, -1181484889, 2043371297, -201899802, -2051985861, 773608572, 1298870683, 510816179, 2024816508, 1390836454, -1965452238, 1573743511, 2101971164, -557058113, 2047008705, -572878059, -2082464174, 2045885280, -1618586685, 1493452403, 315480741, -67987897, 1223469625, -211714735, 1149868853, -935657783, 1466493203, 2017301009, -363746981, -1409286889, -1604842239, -1721593741, -537192233, -601988941, -1205793450, -1967814592, 1809022425, 1932153337, -1357861460, 1123475538, 1147013933, 1007919760, -699694192, -1621215384, 2066906763, 1593585584, -475179165, 1143779301, -586129542, 581667142, 1492996665, -134971460, -235503615, 1688906035, 1609196744, 804863894, -1108706764, -646274671, -1069027098, 311553694, -1470507906, -1491583483, -844554526, -1171833315, 528747721, -1553568712, -1214535735, 1833189196, 2038088431, 392821632, -763421480, 181827223, 1913070046, -138432946, -304292182, 788965993, 1363804715, 369791559, -790756598, -1515406361, 1410804574, 1418922680, -441340813, -815009575, -1319477066, -728139288, -1449300487, 825291269, -924837484, 1542189515, -270906537, 1400435540, -358233852, -569487515, -99471149, -1444933215, 1522524067, 1446272080, 1487929120, 1943218273, 658282521, 7347755, 961561183, 228439552, 1137293755, 363938864, -930460368, -1262721440, -869797469, 195520033, 1856208903, -1381644842, -592305889, 1757003289, 1106835980, -1025502300, 1224396970, 2030538064, 1003485845, -1144370309, -1414702345, -228124146, -1074354608, 858772232, -2021953086, 1064276939, 1069010619, 1723806992, -1007188432, 1223648261, -32515918, -623447269, -1448072414, 413259913, 1310414793, 1980915107, 493570171, -638293668, -1896394894, 166398873, 1409785101, 1913979640, -1369339660, -144931303, 1398112338, 60412969, -1943421350, -1259699187, 860635849, -703617878, 912943583, -68782392, -1462452538, 1048712056, 2125593372, -1041579446, 1055064102, -262831341, -390597151, -1886237962, -876353887, -1915419926, -739741206, 670877982, -887505070, -736496554, -1482640793, -1289390476, -1860099076, 913978138, 2073436184, -697867410, -892805022, 1207152920, 1501257191, 615876472, -1651410936, 873983899, -902943686, 1156004525, 1832528959, -70970686, 1700299358, -876801647, -1957871498, -1568919510, -1048671770, -1289317034, 134106918, -1505588421, -1849118863, 1199316838, -2035170223, 747626921, 1116667945, 1985054427, -1498370169, -1471611405, -2080774379, -1278151647, -1584771942, 1495636961, -1873481907, 999261603, -883260509, -1723319277, 1082082621, 2112267517, 256910441, 1997830435, 1388706801, -1269559003, -1378663323, 631109243, -1147447055, -498407177, -503070464, -80867569, 587142723, -1530994870, -1895948844, 879602891, -2146732507, 1539449883, 696223252, -774555031, -1632124035, -819276009, -1958336108, -1315318305, 1399945276, -1438713330, 333027049, 785191597, -1133532244, -544335033, -1583465980, 1044996113, -801383905, -1882042242, -1767000104, -81361628, 711688180, -1179435524, -1637699251, 1038689704, 2082705598, -440781644, -880896018, -1880945319, 746337773, -1962866863, 1607533296, 1414422096, -216229277, 1491338910, 1268751922, 868522498, 1949357131, 150085240, -823049178, 519874998, 906136211, 1880165097, -296882572, 240315750, -219188289, -1271262921, 1386352457, 954316131, 1773419711, -1676181866, 1692695249, 1162872812, -796950845, -454589314, 1363666157, -368936427, 1913907725, -2037447971, -1255659661, 487915960, 1125865361, -2072867838, 1895727173, -1926421755, 1909077464, -297156218, 1141419492, 445083635, 1903099022, 1578252925, 1615689799, 9784283, 945365131, 1869253655, 1363070015, 1415617857, -1374773332, -24053714, 1925912383, -1151725608, 1963254455, -115511523, 685088653, 1994257752, -2072935340, -1763247037, 738357279, 1788765089, 599689465, 299419577, -1338585751, -870923977, 1106427347, 1046307483, -1722366216, -1562445700, 1349834553, -1900560798, -1002876056, 1410932156, 206008985, 1932581636, 1120415175, -1107515363, 2122814359, 2115419589, 677032854, -960179552, -1032597134, 1306093785, 250598985, 1399346257, 1263885409, -1359723772, 127748795, -1507208801, -345316697, -319755401, 1817741375, -846437971, -200035232, 2032312812, 1229335204, -1083031187, -608035888, 1709684861, 1758175813, 1578717725, 731742106, 388472928, -1640530790, -424153774, -1226394775, -1185515317, 1467306038, 1804681745, 1774559423, -850048234, 2040572450, -1304240389, -1311073416, -288264857, 894150318, 433611492, 1942311868, -1264482697, 1651399709, 1494322772, 1145757174, -92428104, -180343351, -87504189, 1500850477, 1794815867, 1110876534, -82490581, -46497552, -564501467, 1463635859, 1190109641, -784415639, -2142848349, 350761483, 1814798667, -934644213, 187100501, 1579970904, -586308816, -935549978, 1257543356, 767611618, 99787424, -342521857, -1961608285, 109480681, -1436127526, 322671461, 551301944, 2019301372, 693391259, -569069231, -786187815, 1479195472, 522160502, -376816829, -231805591, -739346990, -1235881491, -132802300, -236315866, -1649160848, 612730780, -100952179, -592361085, 342552280, -1816075130, 673167457, 1317780803, 2063807754, -132379254, -1418234343, 1499984473, -1409360615, -728707861, -1974335171, -1313137885, -1609282390, 1430499621, 1523677325, 124994091, -707775005, 2087940175, 1642400182, 1855929786, 1622443457, -1778512979, -1634604238, 1154697200, -1803419191, 1748161442, -1651637928, 2036482523, 392144337, 1033708636, -1016121353, -1987713610, -754978281, -1628297382, -71273841, -1198093568, 256920147, 1166332723, 142219233, 1523109504, 1627351811, -835890113, -259316639, -122400349, -760823620, -1666156910, 1482428045, -1206379991, -749673126, -312537401, -1540369943, 1355015623, -1833521536, -590564618, 1736424678, -361506754, -511774703, 1447411201, 1232222002, 1918963668, -413877214, 1262435748, -490948743, 1408161504, -233871369, 1936684741, -865381569, -215528641, 970074732, 1621153848, -59102633, -179431796, -720491220, 1719189073, 1498905059, -514838544, -615472888, -1274722182, -1891936203, -1721272720, -363118408, -1044558805, 1242905928, 1436161059, -1600558211, -1692503435, -1061188758, -634857415, -1663890429, 897194027, 1212571456, -673313552, -1225956934, 479241108, -1931596749, 1293948144, -482554295, -869657421, -1514249432, 477405933, 2145290478, -757286371, 277994965, -1261504661, 139991951, 1887011790, -456366895, 1406093317, -886402325, 252494506, 689950503, 1356598053, -1004137644, -1192753277, 670062665, 1083906569, -1329649859, 1488888513, -969685318, 459043016, 1161313952, -1129497754, 1324467055, -1099019764, -203704355, -1069029839, 1278937085, 1073181115, 226875896, -264842983, 1980864560, -656047475, 1323231642, -601401053, -1946802418, -253790903, 119956763, -44364644, -1995613000, 1610683387, -1699262499, -2103180928, -63167324, -1300352141, -1009321940, -1044929750, -1800105049, -1979944148, 14222471, -1432640628, 1688235742, 424114623, 30308972, 1462966850, -359476729, 1488377264, -527220589, 1186931100, 1101973752, -1472579895, 1914931104, 283107098, -1931279151, -1718200491, 1792738082, 1667244170, -114658266, -1224265059, 351047092, -1605815820, 1516659109, 1462102522, 681751559, -807956376, -786865187, -1693372931, -673156580, 1309653081, 446052025, -186550220, -642009792, -2134745073, -449421949, -237043221, 1975064865, -1652125684, 382056507, 1942350801, 1154312036, -1127994577, -1260892858, -70777083, 594868445, -447760497, -1329308630, 1024084550, 766358247, 1827325386, 2144728345, -1298174473, 231860022, -418919919, -2085785440, 2141510387, 1462173083, -661695332, -1156528440, -1959187193, 807454502, -1248709382, 37646812, 1920730334, -661832103, -1190920655, -1881837225, -1201869824, -1208235575, -113727977, -1764793855, -1550797371, -1204731695, 186747613, -1218435074, 1957746366, 454163363, -65971481, -1304482776, 1544857664, 930738730, 1678677373, -1003320057, 1265725736, 1956891693, -417894949, 517277694, 891796487, 1228794427, -176209, 141634552, -439467150, 38106221, -1495901082, 2127996072, -1503461118, 1809040108, 1627496104, -333002288, 2137185931, -1073007113, 1720941082, -1271215886, -1127754397, -1851449345, -1880413021, 353079556, 1459902589, -1921484492, -1510958623, 751470763, -1833747000, -721794635, 2049922754, -291520455, -267044280, 1179388024, 155806298, 1307439864, -709701511, -1081407653, 428855877, -1835958873, -831847952, 2136018861, 1024638104, -1881292992, 936646378, -180466400, 126984382, -1639949024, -444567803, 1091572596, 492144947, -1486723177, 510355722, 33891022, 1803350302, 660921310, 638050765, 874880528, -1986177967, -993906518, 1593021621, -1452112927, -506004895, 437341923, 2119609533, -355668060, -1687323724, -1900041588, 704316977, -1283123831, -709142656, 1680380685, 1343855333, 844516429, -418250255, -656024350, 1228458056, -148191680, -1114556213, 260694258, -441056449, -536921038, -1942265700, -2125229175, -1696362218, -701065156, 560077529, 1036623286, -340511558, 553174342, -737076946, 247187933, -1843075350, -2014538342, -286725762, -830648809, 1006640706, 814528877, -1562137403, -1383810808, 936725162, -1832046635, -595664406, 235633427, 1215009721, -1330003543, 643602705, 9070321, -2122985511, -180874289, -434075224, 1320572600, 448007596, -355760708, -2139522265, 726143704, -558263286, 1711644270, 277293540, -1745861874, -238194849, -1650157982, 891602958, 202684487, -1288519012, 779269420, 716011377, -1529774751, 1115632997, -1246420280, -628585597, 605344052, 1095918929, 1991661933, 83529150, -734389870, 1180932781, -277376191, -872980168, -206171015, -2004269296, -1265516718, -496598906, -1999564102, -1393244179, -1186931866, 915367475, 1194803503, -1462110844, 1340433009, 106022459, 894231254, -494012522, 891382372, -1595168117, -718710097, -868678737, -1876520821, 1350247070, -256081870, -1126707659, 219836420, 607227376, -410259630, -298324977, 141330521, 898675034, 927792137, 1290363279, -595199101, 741850881, -584294764, -836313982, 847360395, 453335563, -1201739726, -286110583, -1890611187, 2950286, 643569779, 1497722778, 1897060465, 677554663, -982550542, -914478017, -992895552, -447444064, 1548929412, -116532649, -578468620, -275364510, -230633369, 1343574242, -1094772458, 84301202, -469969878, 406646030, 2124798447, -1890016752, 758405837, 1651791103, 391191697, -1928726777, -861867533, 4741298, 1816363658, -1473740502, 1922521014, 342230988, -121510671, 1164335844, 256081002, -567311466, 561087273, 1025637901, -613306517, 737542525, 1639112109, 1541340586, -1681025335, 95351556, 1885451465, -1128416918, -1699479660, 198419038, -1666750215, 604793566, 111605059, 683781445, 58947048, 38197788, 1131261318, 964566156, 651980285, -150493665, 1238783127, -1490740101, -73516038, 2066122730, -292995522, -204470899, 349527483, 2059205508, 1492966785, -271090742, 650255319, 178177003, -848926172, -14606861, 912695250, -459254434, 117523430, -545965159, 66550492, 1282668264, -1961586127, 55097911, -360396794, -1918077941, 1377716475, 1988039182, -38646403, -1326950323, 200257735, -1258891143, 375803543, 958470486, 194595748, -1260178113, 1714164163, -1315669042, -492111163, 892128870, 1704553781, 1558430931, -479396028, -728478785, 750924349, 355414235, 478559711, -1434394503, -1008211010, -1717713405, 189750720, -1264975434, 896427939, 978847597, -362686550, -1228966901, 677635207, -1512285449, -1461241351, 1666783574, 824410920, -1417763943, -603173782, -1141448292, -490432104, 1276321843, -12875786, 703613299, -515699362, 1191568619, 1549121985, -2057741765, -1223897867, -1156575124, -1335888653, -1074885462, 435418687, -1577552900, -166211098, -1705461745, 114134930, -1397417735, 2138784264, -1634583703, -2006347946, -909630394, -1965144503, -484300210, 1856096070, -723413990, 1793185962, 1614055343, 810913952, 1662972360, 1182830722, -1471719274, -1546129270, -307483904, 1968956976, -799070156, 1050658604, -1144697434, 89460728, -941428410, -122161052, -1350549960, 1607351415, 1932091470, 1523524394, -1823383970, 960590694, 847249804, -1149243035, -695583853, 686459825, -1343363100, -367498297, 2015530271, 16136716, 1958929914, 1503526383, 296919109, 814553155, 723033123, 580496578, -51354493, 1643839467, -617817823, 1224027864, -1236233218, 765971743, -1224816592, -1208290440, -913761583, -1770804960, -382906420, 1718065547, -429735563, 1912746017, -185128900, -1100384588, 1876289588, -300747725, -1227196825, 1835371648, 1076813716, -2006649175, -673100686, -215048223, -391801397, 123246221, 1158190854, -929001098, -817005448, 1781589109, -274468116, -1995063986, 1742686779, -1201077001, -213531050, 1284583888, -2041131732, -1496569734, -282273172, 183531725, -491997656, -447879478, -1265834145, 1583500155, -1210291916, -878092245, 1607261760, -1666100980, 1120309729, 1002218188, -1531157653, 1393530317, -2008773159, 1415749472, 972906647, -1758198483, -208300303, 1892302216, 494033915, -358341674, 840060403, -1966814599, -1287829260, -1459539048, -772357942, 59900265, -1506353715, -1319659359, -1663555389, 252836352, -656883971, 428100479, 151423145, 1418181703, 1694553898, 1858314111, -1262057723, -545181481, 788235257, 1044460438, 177740558, -1921328030, -322923173, -613090052, -512763215, -669801844, 1722324584, -463603493, 2146427480, 698414532, -1233859098, -1412257772, 120379379, 105339858, -1070572887, 2060852360, -1515083037, 2004731835, 118263430, 1141114334, -413524875, -501302207, -1490521176, 811346316, 884835676, 225107240, 1061444245, -829676748, 426127849, -941093591, 1129629822, -81832228, -1317037345, -1964677234, 275235138, 1502488877, -1554352636, 640613906, -1437798555, 196702482, 1902902971, -472103645, -1670986930, -1688408456, -278506322, -1782195120, -1393346494, -1349310538, 2042497814, 748168186, -444671224, 1338156424, -2145383314, -1514258676, 96996643, -1011442041, -1872055867, 152290864, 322225395, 570061937, -1124117913, -1033305006, -470630024, -81960967, 1464901700, 197750318, -164270934, 1271742859, 463512555, 776858483, 811851213, 1313823641, 1068864647, 905285845, -1067114775, 680811370, -656530561, -1325429453, 2080653677, -1595711403, -567009045, 322923102, 1502953872, 903482515, 1864192536, -757924707, -952190312, -1661511502, -1510483862, -330091202, -652277362, 468740797, -1760350751, -1897316850, -1667560635, 843087663, -2036900525, 1706138183, 1692755666, 409461481, 612918398, -981637914, -478080458, 672151357, 1620269160, -2003279943, 1425552948, -996267201, 71811080, 1689541523, -298179555, -1991497825, 2063037353, 354490008, 1304739678, -684427893, 1314608828, -2074732138, -1318288178, 446712634, -535533431, 1868742830, 1307429836, -1110701257, -752103582, -594250510, -1075350152, -124476854, -1044009920, 684010993, 767483345, -421437497, 2128934646, 1554106672, -1210282217, 1317462638, 1119098170, -489689085, 1242501075, 1474438679, 802577422, -1562705469, -1044966662, 348889038, -1638823850, -1457837203, 1441466964, 1208555157, -711054124, -1231243915, -1150925993, -1220754411, 1307470481, 622936937, -30094442, 1289118, -388114648, 754635617, 856727668, -291283758, 831410314, -1808557882, 87182148, 600411597, 1059398288, -1007267185, -615660547, -1669061323, 1476538285, 2048353399, 468484099, 1420871458, -101588779, -649442911, -97163154, -1613496541, -140285139, -1884559249, -1112984573, -1686654756, 1025522180, 184813412, 2141097723, -1257367414, 553224438, 25301844, -2142562813, 1755485472, 1839193418, -173533633, 371190304, 2018089405, -959463330, -18054443, 102729411, 1838998089, -1269614741, -824599975, -575373865, 1498056256, -678046591, 1553189018, -2018672366, -1793538382, 1462846791, -776054819, -1289769222, -525822720, 2109700966, -1358503882, 1667924983, 1269108284, 1175706598, 1626798475, 2129561451, -887248608, 1513759056, -1931683412, 1952942399, -1889093829, 1913030140, 1106814650, 315507327, -1184354610, -845267304, 86200420, -587958390, 970371571, -495246149, 1087212814, -929663949, -1988622590, -1087217094, -1294581982, -2002943521, -1511705422, -33438, 306070164, -794474068, -607379400, 995075290, -1947574462, 291138661, -1862026425, -284994431, 1981331325, -295095652, -1640664050, -502391647, -298147006, -759845877, -57850817, 62687211, -867523503, -2045788990, -1888838589, -429975345, -1618629335, -61416479, -1120648789, 258517897, -1270073923, 660994092, -1429166385, -840504072, -1435140398, -1341126539, -395745828, -811500847, -1160710657, 940755305, 270032119, -493228936, 796034185, -596653897, -1821200654, 1355130577, 1063640085, -462968182, 2128283302, -1913776328, 359717262, -1152333962, -998979542, 1975954391, -557806346, -463622556, 1216253080, -635822680, 718622920, 2013281180, -2004887289, 1829369658, 666403036, -349103516, 1527813962, -1135439226, -1161633003, -443906754, -1923472597, 1815774854, 1568116969, 2136400151, -827712414, 119489899, -2091704143, 1578039823, -204310972, 1639073175, 1973581756, -1405492023, 464695482, -574900055, 986315757, 1743760258, -132155111, 950211624, -570553748, -1038810430, 778193004, -1468229997, 234884206, -372299627, -751441573, 1425166080, 317414273, 1358862764, 1949216581, 1862852961, 1400729205, 416699274, -2023791725, -556950324, -1276507218, 1367038669, 810158340, -1253834255, 1547203648, 1712426469, -2040438668, -942745551, 1914533793, -1937965113, 1800509634, 2029585463, 1384292693, 1181618494, -413404740, 1561115879, 297314112, 229917094, -1978493305, 1214251529, -837122023, -833015636, 1954960522, 1006169068, -1531846893, 333842166, -1012672929, -469850904, 637048029, -395312868, -1380943487, -1892576823, 442180993, -1646482639, 1446446226, -1682016398, -1007453652, 888411462, 331116203, -629682089, -1718482518, 265043760, -1019221259, 1869846781, 936747089, -1517311213, 372562696, 906859232, -1425676017, 48975252, -1341854859, -2089180612, -1068076055, 1874892782, 1652169965, 1157943384, -773225543, -323996276, -818862632, 156005302, 2000519514, 1427820008, -1021442831, 1804302941, -1609750249, 1228352825, -1290885767, -1899483953, -1272003119, -1035472828, 2001303805, 1279880126, -1972758673, -860699977, -895677, 1553908866, -256889456, -54349105, 1935563167, 1959654550, 1342306927, -463860350, 2018212448, -1976136873, -1321789709, 519290351, -878196271, 1416391706, 1997808027, -741508841, -647346054, 646400542, -1106467688, 1468263050, -1425279304, 1170563435, -1841378329, 1184969864, 1914824652, -1325456412, 988552147, 884565065, 415800418, -453574918, 275834609, 48207744, 2135467314, 702477650, 102965566, -763968440, 471224482, -1279720951, 739300156, 2136013176, -2115946465, 823955913, -1847689566, -859494013, -1717723340, 421442946, -775469653, -1602093703, 628061442, -1156466954, 2146056167, 1163863080, 613966968, -268941904, 1130830948, -1580207712, -1766534996, 385727357, 320405604, -2144049214, 1276259991, 1344448621, 489194245, -1847841712, 756151600, -151969326, 164358178, 697709449, -370308967, 2093670590, -665704333, -134953266, 759941983, 672239619, 279015781, 1395133283, -842458038, -1524105337, 182288246, 1431853343, 78700095, 1433355670, -24593159, 527405240, 1406613517, -764183089, 686495640, 2053356436, 1543473442, 1665227150, -16894973, 1892440712, 1791400383, -1510847956, -1214782850, 916872379, -1086841580, -1084208313, 416347580, -268161060, -594948841, -1010051534, -54545220, 22879806, 22079373, 260808346, 1499853288, 752706288, -1446555783, -1508906906, -142572826, 2085624580, -1694570799, 1322533584, -1634778380, 1720243426, -446724573, -966715585, -1060769188, -303942680, 101162157, -478783329, -2024114681, -254341969, 979137120, -303649029, 808347593, 321882488, 1493080090, 1691499643, -418789643, -1064499066, -1102944414, 879990377, 1588432383, 1150856295, -1680509849, 1970957530, -797026769, -73327919, 748785685, 1215011973, 585217952, -886677309, 1766904120, 365332543, -1482001054, -326119897, -1445345695, 1456094038, 1027199429, 1010128020, -1080582474, 2023702212, 1350470435, 390289859, -165678955, 1391872715, -2036012256, 583114991, -1027988504, -872534637, -980212881, -1929975011, -327092927, 734121734, 1585555479, 550659297, 1974120794, -923753061, 2043915994, 1159226886, -1806512234, -1828935780, -1530965616, 873171067, -1789687415, -1872307293, -417901750, 1741334968, -360712375, -1022301158, 1865882568, 1200151331, 2145666141, -2027655890, 687151700, 1410594918, 974900322, -1519354448, -156678080, -226110093, -1047772447, -1719525872] +cc e62da794bbaf569bec601c6ce85d8ca80d85b726d10347a487524807c76e9e9a # shrinks to ref input = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +cc 6bb8dfa5f2a1b8c2e7cbd18e81b31724ea1e121e84061ee6fa6a8ad7ed62fbe2 # shrinks to ref input = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +cc a2ce9c3a2234cbda6bcf2e0d84a3c3e607d730def32a5dfff59b9c680a18b5af # shrinks to ref mut input_src = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] +cc bc29377410935c0e4cd1d3a56cb6e5ccc8bb23ca1fc7e11dae15e57066482739 # shrinks to ref input = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] diff --git a/vendor/im-rc/src/arbitrary.rs b/vendor/im-rc/src/arbitrary.rs new file mode 100644 index 000000000..777a3b36f --- /dev/null +++ b/vendor/im-rc/src/arbitrary.rs @@ -0,0 +1,98 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use std::hash::{BuildHasher, Hash}; + +use ::arbitrary::{size_hint, Arbitrary, Result, Unstructured}; + +use crate::{HashMap, HashSet, OrdMap, OrdSet, Vector}; + +impl<'a, A: Arbitrary<'a> + Clone> Arbitrary<'a> for Vector<A> { + fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> { + u.arbitrary_iter()?.collect() + } + + fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> { + u.arbitrary_take_rest_iter()?.collect() + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + size_hint::recursion_guard(depth, |depth| { + size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None)) + }) + } +} + +impl<'a, K: Arbitrary<'a> + Ord + Clone, V: Arbitrary<'a> + Clone> Arbitrary<'a> for OrdMap<K, V> { + fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> { + u.arbitrary_iter()?.collect() + } + + fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> { + u.arbitrary_take_rest_iter()?.collect() + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + size_hint::recursion_guard(depth, |depth| { + size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None)) + }) + } +} + +impl<'a, A: Arbitrary<'a> + Ord + Clone> Arbitrary<'a> for OrdSet<A> { + fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> { + u.arbitrary_iter()?.collect() + } + + fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> { + u.arbitrary_take_rest_iter()?.collect() + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + size_hint::recursion_guard(depth, |depth| { + size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None)) + }) + } +} + +impl<'a, K, V, S> Arbitrary<'a> for HashMap<K, V, S> +where + K: Arbitrary<'a> + Hash + Eq + Clone, + V: Arbitrary<'a> + Clone, + S: BuildHasher + Default + 'static, +{ + fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> { + u.arbitrary_iter()?.collect() + } + + fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> { + u.arbitrary_take_rest_iter()?.collect() + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + size_hint::recursion_guard(depth, |depth| { + size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None)) + }) + } +} + +impl<'a, A, S> Arbitrary<'a> for HashSet<A, S> +where + A: Arbitrary<'a> + Hash + Eq + Clone, + S: BuildHasher + Default + 'static, +{ + fn arbitrary(u: &mut Unstructured<'a>) -> Result<Self> { + u.arbitrary_iter()?.collect() + } + + fn arbitrary_take_rest(u: Unstructured<'a>) -> Result<Self> { + u.arbitrary_take_rest_iter()?.collect() + } + + fn size_hint(depth: usize) -> (usize, Option<usize>) { + size_hint::recursion_guard(depth, |depth| { + size_hint::and(<usize as Arbitrary>::size_hint(depth), (0, None)) + }) + } +} diff --git a/vendor/im-rc/src/config.rs b/vendor/im-rc/src/config.rs new file mode 100644 index 000000000..f8611396c --- /dev/null +++ b/vendor/im-rc/src/config.rs @@ -0,0 +1,20 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use typenum::*; + +/// The branching factor of RRB-trees +pub(crate) type VectorChunkSize = U64; + +/// The branching factor of B-trees +pub(crate) type OrdChunkSize = U64; // Must be an even number! + +/// The level size of HAMTs, in bits +/// Branching factor is 2 ^ HashLevelSize. +pub(crate) type HashLevelSize = U5; + +/// The size of per-instance memory pools if the `pool` feature is enabled. +/// This is set to 0, meaning you have to opt in to using a pool by constructing +/// with eg. `Vector::with_pool(pool)` even if the `pool` feature is enabled. +pub(crate) const POOL_SIZE: usize = 0; diff --git a/vendor/im-rc/src/fakepool.rs b/vendor/im-rc/src/fakepool.rs new file mode 100644 index 000000000..5ff36f7e5 --- /dev/null +++ b/vendor/im-rc/src/fakepool.rs @@ -0,0 +1,208 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#![allow(dead_code)] + +use std::marker::PhantomData; +use std::ops::Deref; +use std::rc::Rc as RRc; +use std::sync::Arc as RArc; + +use crate::nodes::chunk::Chunk; + +pub(crate) trait PoolDefault: Default {} +pub(crate) trait PoolClone: Clone {} + +impl<A> PoolDefault for Chunk<A> {} +impl<A> PoolClone for Chunk<A> where A: Clone {} + +pub(crate) struct Pool<A>(PhantomData<A>); + +impl<A> Pool<A> { + pub(crate) fn new(_size: usize) -> Self { + Pool(PhantomData) + } + + pub(crate) fn get_pool_size(&self) -> usize { + 0 + } + + pub(crate) fn fill(&self) {} +} + +impl<A> Clone for Pool<A> { + fn clone(&self) -> Self { + Self::new(0) + } +} + +// Rc + +#[derive(Default)] +pub(crate) struct Rc<A>(RRc<A>); + +impl<A> Rc<A> { + #[inline(always)] + pub(crate) fn default(_pool: &Pool<A>) -> Self + where + A: PoolDefault, + { + Self(Default::default()) + } + + #[inline(always)] + pub(crate) fn new(_pool: &Pool<A>, value: A) -> Self { + Rc(RRc::new(value)) + } + + #[inline(always)] + pub(crate) fn clone_from(_pool: &Pool<A>, value: &A) -> Self + where + A: PoolClone, + { + Rc(RRc::new(value.clone())) + } + + #[inline(always)] + pub(crate) fn make_mut<'a>(_pool: &Pool<A>, this: &'a mut Self) -> &'a mut A + where + A: PoolClone, + { + RRc::make_mut(&mut this.0) + } + + #[inline(always)] + pub(crate) fn ptr_eq(left: &Self, right: &Self) -> bool { + RRc::ptr_eq(&left.0, &right.0) + } + + pub(crate) fn unwrap_or_clone(this: Self) -> A + where + A: PoolClone, + { + RRc::try_unwrap(this.0).unwrap_or_else(|r| (*r).clone()) + } +} + +impl<A> Clone for Rc<A> { + #[inline(always)] + fn clone(&self) -> Self { + Rc(self.0.clone()) + } +} + +impl<A> Deref for Rc<A> { + type Target = A; + #[inline(always)] + fn deref(&self) -> &Self::Target { + self.0.deref() + } +} + +impl<A> PartialEq for Rc<A> +where + A: PartialEq, +{ + #[inline(always)] + fn eq(&self, other: &Self) -> bool { + **self == **other + } +} + +impl<A> Eq for Rc<A> where A: Eq {} + +impl<A> std::fmt::Debug for Rc<A> +where + A: std::fmt::Debug, +{ + #[inline(always)] + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { + self.0.fmt(f) + } +} + +// Arc + +#[derive(Default)] +pub(crate) struct Arc<A>(RArc<A>); + +impl<A> Arc<A> { + #[inline(always)] + pub(crate) fn default(_pool: &Pool<A>) -> Self + where + A: PoolDefault, + { + Self(Default::default()) + } + + #[inline(always)] + pub(crate) fn new(_pool: &Pool<A>, value: A) -> Self { + Self(RArc::new(value)) + } + + #[inline(always)] + pub(crate) fn clone_from(_pool: &Pool<A>, value: &A) -> Self + where + A: PoolClone, + { + Self(RArc::new(value.clone())) + } + + #[inline(always)] + pub(crate) fn make_mut<'a>(_pool: &Pool<A>, this: &'a mut Self) -> &'a mut A + where + A: PoolClone, + { + RArc::make_mut(&mut this.0) + } + + #[inline(always)] + pub(crate) fn ptr_eq(left: &Self, right: &Self) -> bool { + RArc::ptr_eq(&left.0, &right.0) + } + + pub(crate) fn unwrap_or_clone(this: Self) -> A + where + A: PoolClone, + { + RArc::try_unwrap(this.0).unwrap_or_else(|r| (*r).clone()) + } +} + +impl<A> Clone for Arc<A> { + #[inline(always)] + fn clone(&self) -> Self { + Self(self.0.clone()) + } +} + +impl<A> Deref for Arc<A> { + type Target = A; + #[inline(always)] + fn deref(&self) -> &Self::Target { + self.0.deref() + } +} + +impl<A> PartialEq for Arc<A> +where + A: PartialEq, +{ + #[inline(always)] + fn eq(&self, other: &Self) -> bool { + **self == **other + } +} + +impl<A> Eq for Arc<A> where A: Eq {} + +impl<A> std::fmt::Debug for Arc<A> +where + A: std::fmt::Debug, +{ + #[inline(always)] + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> { + self.0.fmt(f) + } +} diff --git a/vendor/im-rc/src/hash/map.rs b/vendor/im-rc/src/hash/map.rs new file mode 100644 index 000000000..2c2761b0e --- /dev/null +++ b/vendor/im-rc/src/hash/map.rs @@ -0,0 +1,2379 @@ +// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+//! An unordered map.
+//!
+//! An immutable hash map using [hash array mapped tries][1].
+//!
+//! Most operations on this map are O(log<sub>x</sub> n) for a
+//! suitably high *x* that it should be nearly O(1) for most maps.
+//! Because of this, it's a great choice for a generic map as long as
+//! you don't mind that keys will need to implement
+//! [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq].
+//!
+//! Map entries will have a predictable order based on the hasher
+//! being used. Unless otherwise specified, this will be the standard
+//! [`RandomState`][std::collections::hash_map::RandomState] hasher.
+//!
+//! [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+//! [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+//! [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+//! [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html
+
+use std::borrow::Borrow;
+use std::cmp::Ordering;
+use std::collections;
+use std::collections::hash_map::RandomState;
+use std::fmt::{Debug, Error, Formatter};
+use std::hash::{BuildHasher, Hash, Hasher};
+use std::iter::{FromIterator, FusedIterator, Sum};
+use std::mem;
+use std::ops::{Add, Index, IndexMut};
+
+use crate::nodes::hamt::{
+ hash_key, Drain as NodeDrain, HashBits, HashValue, Iter as NodeIter, IterMut as NodeIterMut,
+ Node,
+};
+use crate::util::{Pool, PoolRef, Ref};
+
+/// Construct a hash map from a sequence of key/value pairs.
+///
+/// # Examples
+///
+/// ```
+/// # #[macro_use] extern crate im_rc as im;
+/// # use im::hashmap::HashMap;
+/// # fn main() {
+/// assert_eq!(
+/// hashmap!{
+/// 1 => 11,
+/// 2 => 22,
+/// 3 => 33
+/// },
+/// HashMap::from(vec![(1, 11), (2, 22), (3, 33)])
+/// );
+/// # }
+/// ```
+#[macro_export]
+macro_rules! hashmap {
+ () => { $crate::hashmap::HashMap::new() };
+
+ ( $( $key:expr => $value:expr ),* ) => {{
+ let mut map = $crate::hashmap::HashMap::new();
+ $({
+ map.insert($key, $value);
+ })*;
+ map
+ }};
+
+ ( $( $key:expr => $value:expr ,)* ) => {{
+ let mut map = $crate::hashmap::HashMap::new();
+ $({
+ map.insert($key, $value);
+ })*;
+ map
+ }};
+}
+
+def_pool!(HashMapPool<K,V>, Node<(K,V)>);
+
+/// An unordered map.
+///
+/// An immutable hash map using [hash array mapped tries] [1].
+///
+/// Most operations on this map are O(log<sub>x</sub> n) for a
+/// suitably high *x* that it should be nearly O(1) for most maps.
+/// Because of this, it's a great choice for a generic map as long as
+/// you don't mind that keys will need to implement
+/// [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq].
+///
+/// Map entries will have a predictable order based on the hasher
+/// being used. Unless otherwise specified, this will be the standard
+/// [`RandomState`][std::collections::hash_map::RandomState] hasher.
+///
+/// [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie
+/// [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html
+/// [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html
+/// [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html
+
+pub struct HashMap<K, V, S = RandomState> {
+ size: usize,
+ pool: HashMapPool<K, V>,
+ root: PoolRef<Node<(K, V)>>,
+ hasher: Ref<S>,
+}
+
+impl<K, V> HashValue for (K, V)
+where
+ K: Eq,
+{
+ type Key = K;
+
+ fn extract_key(&self) -> &Self::Key {
+ &self.0
+ }
+
+ fn ptr_eq(&self, _other: &Self) -> bool {
+ false
+ }
+}
+
+impl<K, V> HashMap<K, V, RandomState> {
+ /// Construct an empty hash map.
+ #[inline]
+ #[must_use]
+ pub fn new() -> Self {
+ Self::default()
+ }
+
+ /// Construct an empty hash map using a specific memory pool.
+ #[cfg(feature = "pool")]
+ #[must_use]
+ pub fn with_pool(pool: &HashMapPool<K, V>) -> Self {
+ let root = PoolRef::default(&pool.0);
+ Self {
+ size: 0,
+ hasher: Default::default(),
+ pool: pool.clone(),
+ root,
+ }
+ }
+}
+
+impl<K, V> HashMap<K, V, RandomState>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+{
+ /// Construct a hash map with a single mapping.
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map = HashMap::unit(123, "onetwothree");
+ /// assert_eq!(
+ /// map.get(&123),
+ /// Some(&"onetwothree")
+ /// );
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn unit(k: K, v: V) -> HashMap<K, V> {
+ HashMap::new().update(k, v)
+ }
+}
+
+impl<K, V, S> HashMap<K, V, S> {
+ /// Test whether a hash map is empty.
+ ///
+ /// Time: O(1)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// assert!(
+ /// !hashmap!{1 => 2}.is_empty()
+ /// );
+ /// assert!(
+ /// HashMap::<i32, i32>::new().is_empty()
+ /// );
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }
+
+ /// Get the size of a hash map.
+ ///
+ /// Time: O(1)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// assert_eq!(3, hashmap!{
+ /// 1 => 11,
+ /// 2 => 22,
+ /// 3 => 33
+ /// }.len());
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn len(&self) -> usize {
+ self.size
+ }
+
+ /// Test whether two maps refer to the same content in memory.
+ ///
+ /// This is true if the two sides are references to the same map,
+ /// or if the two maps refer to the same root node.
+ ///
+ /// This would return true if you're comparing a map to itself, or
+ /// if you're comparing a map to a fresh clone of itself.
+ ///
+ /// Time: O(1)
+ pub fn ptr_eq(&self, other: &Self) -> bool {
+ std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root)
+ }
+
+ /// Get a reference to the memory pool used by this map.
+ ///
+ /// Note that if you didn't specifically construct it with a pool, you'll
+ /// get back a reference to a pool of size 0.
+ #[cfg(feature = "pool")]
+ pub fn pool(&self) -> &HashMapPool<K, V> {
+ &self.pool
+ }
+
+ /// Construct an empty hash map using the provided hasher.
+ #[inline]
+ #[must_use]
+ pub fn with_hasher<RS>(hasher: RS) -> Self
+ where
+ Ref<S>: From<RS>,
+ {
+ let pool = HashMapPool::default();
+ let root = PoolRef::default(&pool.0);
+ HashMap {
+ size: 0,
+ hasher: hasher.into(),
+ pool,
+ root,
+ }
+ }
+
+ /// Construct an empty hash map using a specific memory pool and hasher.
+ #[cfg(feature = "pool")]
+ #[must_use]
+ pub fn with_pool_hasher<RS>(pool: &HashMapPool<K, V>, hasher: RS) -> Self
+ where
+ Ref<S>: From<RS>,
+ {
+ let root = PoolRef::default(&pool.0);
+ Self {
+ size: 0,
+ hasher: hasher.into(),
+ pool: pool.clone(),
+ root,
+ }
+ }
+
+ /// Get a reference to the map's [`BuildHasher`][BuildHasher].
+ ///
+ /// [BuildHasher]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html
+ #[must_use]
+ pub fn hasher(&self) -> &Ref<S> {
+ &self.hasher
+ }
+
+ /// Construct an empty hash map using the same hasher as the
+ /// current hash map.
+ #[inline]
+ #[must_use]
+ pub fn new_from<K1, V1>(&self) -> HashMap<K1, V1, S>
+ where
+ K1: Hash + Eq + Clone,
+ V1: Clone,
+ {
+ let pool = HashMapPool::default();
+ let root = PoolRef::default(&pool.0);
+ HashMap {
+ size: 0,
+ pool,
+ root,
+ hasher: self.hasher.clone(),
+ }
+ }
+
+ /// Get an iterator over the key/value pairs of a hash map.
+ ///
+ /// Please note that the order is consistent between maps using
+ /// the same hasher, but no other ordering guarantee is offered.
+ /// Items will not come out in insertion order or sort order.
+ /// They will, however, come out in the same order every time for
+ /// the same map.
+ #[inline]
+ #[must_use]
+ pub fn iter(&self) -> Iter<'_, K, V> {
+ Iter {
+ it: NodeIter::new(&self.root, self.size),
+ }
+ }
+
+ /// Get an iterator over a hash map's keys.
+ ///
+ /// Please note that the order is consistent between maps using
+ /// the same hasher, but no other ordering guarantee is offered.
+ /// Items will not come out in insertion order or sort order.
+ /// They will, however, come out in the same order every time for
+ /// the same map.
+ #[inline]
+ #[must_use]
+ pub fn keys(&self) -> Keys<'_, K, V> {
+ Keys {
+ it: NodeIter::new(&self.root, self.size),
+ }
+ }
+
+ /// Get an iterator over a hash map's values.
+ ///
+ /// Please note that the order is consistent between maps using
+ /// the same hasher, but no other ordering guarantee is offered.
+ /// Items will not come out in insertion order or sort order.
+ /// They will, however, come out in the same order every time for
+ /// the same map.
+ #[inline]
+ #[must_use]
+ pub fn values(&self) -> Values<'_, K, V> {
+ Values {
+ it: NodeIter::new(&self.root, self.size),
+ }
+ }
+
+ /// Discard all elements from the map.
+ ///
+ /// This leaves you with an empty map, and all elements that
+ /// were previously inside it are dropped.
+ ///
+ /// Time: O(n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::HashMap;
+ /// let mut map = hashmap![1=>1, 2=>2, 3=>3];
+ /// map.clear();
+ /// assert!(map.is_empty());
+ /// ```
+ pub fn clear(&mut self) {
+ if !self.is_empty() {
+ self.root = PoolRef::default(&self.pool.0);
+ self.size = 0;
+ }
+ }
+}
+
+impl<K, V, S> HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ fn test_eq(&self, other: &Self) -> bool
+ where
+ K: Hash + Eq,
+ V: PartialEq,
+ {
+ if self.len() != other.len() {
+ return false;
+ }
+ let mut seen = collections::HashSet::new();
+ for (key, value) in self.iter() {
+ if Some(value) != other.get(key) {
+ return false;
+ }
+ seen.insert(key);
+ }
+ for key in other.keys() {
+ if !seen.contains(&key) {
+ return false;
+ }
+ }
+ true
+ }
+
+ /// Get the value for a key from a hash map.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map = hashmap!{123 => "lol"};
+ /// assert_eq!(
+ /// map.get(&123),
+ /// Some(&"lol")
+ /// );
+ /// ```
+ #[must_use]
+ pub fn get<BK>(&self, key: &BK) -> Option<&V>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ self.root
+ .get(hash_key(&*self.hasher, key), 0, key)
+ .map(|&(_, ref v)| v)
+ }
+
+ /// Get the key/value pair for a key from a hash map.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map = hashmap!{123 => "lol"};
+ /// assert_eq!(
+ /// map.get_key_value(&123),
+ /// Some((&123, &"lol"))
+ /// );
+ /// ```
+ #[must_use]
+ pub fn get_key_value<BK>(&self, key: &BK) -> Option<(&K, &V)>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ self.root
+ .get(hash_key(&*self.hasher, key), 0, key)
+ .map(|&(ref k, ref v)| (k, v))
+ }
+
+ /// Test for the presence of a key in a hash map.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map = hashmap!{123 => "lol"};
+ /// assert!(
+ /// map.contains_key(&123)
+ /// );
+ /// assert!(
+ /// !map.contains_key(&321)
+ /// );
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn contains_key<BK>(&self, k: &BK) -> bool
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ self.get(k).is_some()
+ }
+
+ /// Test whether a map is a submap of another map, meaning that
+ /// all keys in our map must also be in the other map, with the
+ /// same values.
+ ///
+ /// Use the provided function to decide whether values are equal.
+ ///
+ /// Time: O(n log n)
+ #[must_use]
+ pub fn is_submap_by<B, RM, F>(&self, other: RM, mut cmp: F) -> bool
+ where
+ F: FnMut(&V, &B) -> bool,
+ RM: Borrow<HashMap<K, B, S>>,
+ {
+ self.iter()
+ .all(|(k, v)| other.borrow().get(k).map(|ov| cmp(v, ov)).unwrap_or(false))
+ }
+
+ /// Test whether a map is a proper submap of another map, meaning
+ /// that all keys in our map must also be in the other map, with
+ /// the same values. To be a proper submap, ours must also contain
+ /// fewer keys than the other map.
+ ///
+ /// Use the provided function to decide whether values are equal.
+ ///
+ /// Time: O(n log n)
+ #[must_use]
+ pub fn is_proper_submap_by<B, RM, F>(&self, other: RM, cmp: F) -> bool
+ where
+ F: FnMut(&V, &B) -> bool,
+ RM: Borrow<HashMap<K, B, S>>,
+ {
+ self.len() != other.borrow().len() && self.is_submap_by(other, cmp)
+ }
+
+ /// Test whether a map is a submap of another map, meaning that
+ /// all keys in our map must also be in the other map, with the
+ /// same values.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 2 => 2};
+ /// let map2 = hashmap!{1 => 1, 2 => 2, 3 => 3};
+ /// assert!(map1.is_submap(map2));
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn is_submap<RM>(&self, other: RM) -> bool
+ where
+ V: PartialEq,
+ RM: Borrow<Self>,
+ {
+ self.is_submap_by(other.borrow(), PartialEq::eq)
+ }
+
+ /// Test whether a map is a proper submap of another map, meaning
+ /// that all keys in our map must also be in the other map, with
+ /// the same values. To be a proper submap, ours must also contain
+ /// fewer keys than the other map.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 2 => 2};
+ /// let map2 = hashmap!{1 => 1, 2 => 2, 3 => 3};
+ /// assert!(map1.is_proper_submap(map2));
+ ///
+ /// let map3 = hashmap!{1 => 1, 2 => 2};
+ /// let map4 = hashmap!{1 => 1, 2 => 2};
+ /// assert!(!map3.is_proper_submap(map4));
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn is_proper_submap<RM>(&self, other: RM) -> bool
+ where
+ V: PartialEq,
+ RM: Borrow<Self>,
+ {
+ self.is_proper_submap_by(other.borrow(), PartialEq::eq)
+ }
+}
+
+impl<K, V, S> HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ /// Get a mutable iterator over the values of a hash map.
+ ///
+ /// Please note that the order is consistent between maps using
+ /// the same hasher, but no other ordering guarantee is offered.
+ /// Items will not come out in insertion order or sort order.
+ /// They will, however, come out in the same order every time for
+ /// the same map.
+ #[inline]
+ #[must_use]
+ pub fn iter_mut(&mut self) -> IterMut<'_, K, V> {
+ let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+ IterMut {
+ it: NodeIterMut::new(&self.pool.0, root, self.size),
+ }
+ }
+
+ /// Get a mutable reference to the value for a key from a hash
+ /// map.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let mut map = hashmap!{123 => "lol"};
+ /// if let Some(value) = map.get_mut(&123) {
+ /// *value = "omg";
+ /// }
+ /// assert_eq!(
+ /// map.get(&123),
+ /// Some(&"omg")
+ /// );
+ /// ```
+ #[must_use]
+ pub fn get_mut<BK>(&mut self, key: &BK) -> Option<&mut V>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+ match root.get_mut(&self.pool.0, hash_key(&*self.hasher, key), 0, key) {
+ None => None,
+ Some(&mut (_, ref mut value)) => Some(value),
+ }
+ }
+
+ /// Insert a key/value mapping into a map.
+ ///
+ /// If the map already has a mapping for the given key, the
+ /// previous value is overwritten.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let mut map = hashmap!{};
+ /// map.insert(123, "123");
+ /// map.insert(456, "456");
+ /// assert_eq!(
+ /// map,
+ /// hashmap!{123 => "123", 456 => "456"}
+ /// );
+ /// ```
+ #[inline]
+ pub fn insert(&mut self, k: K, v: V) -> Option<V> {
+ let hash = hash_key(&*self.hasher, &k);
+ let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+ let result = root.insert(&self.pool.0, hash, 0, (k, v));
+ if result.is_none() {
+ self.size += 1;
+ }
+ result.map(|(_, v)| v)
+ }
+
+ /// Remove a key/value pair from a map, if it exists, and return
+ /// the removed value.
+ ///
+ /// This is a copy-on-write operation, so that the parts of the
+ /// set's structure which are shared with other sets will be
+ /// safely copied before mutating.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let mut map = hashmap!{123 => "123", 456 => "456"};
+ /// assert_eq!(Some("123"), map.remove(&123));
+ /// assert_eq!(Some("456"), map.remove(&456));
+ /// assert_eq!(None, map.remove(&789));
+ /// assert!(map.is_empty());
+ /// ```
+ pub fn remove<BK>(&mut self, k: &BK) -> Option<V>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ self.remove_with_key(k).map(|(_, v)| v)
+ }
+
+ /// Remove a key/value pair from a map, if it exists, and return
+ /// the removed key and value.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let mut map = hashmap!{123 => "123", 456 => "456"};
+ /// assert_eq!(Some((123, "123")), map.remove_with_key(&123));
+ /// assert_eq!(Some((456, "456")), map.remove_with_key(&456));
+ /// assert_eq!(None, map.remove_with_key(&789));
+ /// assert!(map.is_empty());
+ /// ```
+ pub fn remove_with_key<BK>(&mut self, k: &BK) -> Option<(K, V)>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+ let result = root.remove(&self.pool.0, hash_key(&*self.hasher, k), 0, k);
+ if result.is_some() {
+ self.size -= 1;
+ }
+ result
+ }
+
+ /// Get the [`Entry`][Entry] for a key in the map for in-place manipulation.
+ ///
+ /// Time: O(log n)
+ ///
+ /// [Entry]: enum.Entry.html
+ #[must_use]
+ pub fn entry(&mut self, key: K) -> Entry<'_, K, V, S> {
+ let hash = hash_key(&*self.hasher, &key);
+ if self.root.get(hash, 0, &key).is_some() {
+ Entry::Occupied(OccupiedEntry {
+ map: self,
+ hash,
+ key,
+ })
+ } else {
+ Entry::Vacant(VacantEntry {
+ map: self,
+ hash,
+ key,
+ })
+ }
+ }
+
+ /// Construct a new hash map by inserting a key/value mapping into a map.
+ ///
+ /// If the map already has a mapping for the given key, the previous value
+ /// is overwritten.
+ ///
+ /// Time: O(log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map = hashmap!{};
+ /// assert_eq!(
+ /// map.update(123, "123"),
+ /// hashmap!{123 => "123"}
+ /// );
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn update(&self, k: K, v: V) -> Self {
+ let mut out = self.clone();
+ out.insert(k, v);
+ out
+ }
+
+ /// Construct a new hash map by inserting a key/value mapping into
+ /// a map.
+ ///
+ /// If the map already has a mapping for the given key, we call
+ /// the provided function with the old value and the new value,
+ /// and insert the result as the new value.
+ ///
+ /// Time: O(log n)
+ #[must_use]
+ pub fn update_with<F>(&self, k: K, v: V, f: F) -> Self
+ where
+ F: FnOnce(V, V) -> V,
+ {
+ match self.extract_with_key(&k) {
+ None => self.update(k, v),
+ Some((_, v2, m)) => m.update(k, f(v2, v)),
+ }
+ }
+
+ /// Construct a new map by inserting a key/value mapping into a
+ /// map.
+ ///
+ /// If the map already has a mapping for the given key, we call
+ /// the provided function with the key, the old value and the new
+ /// value, and insert the result as the new value.
+ ///
+ /// Time: O(log n)
+ #[must_use]
+ pub fn update_with_key<F>(&self, k: K, v: V, f: F) -> Self
+ where
+ F: FnOnce(&K, V, V) -> V,
+ {
+ match self.extract_with_key(&k) {
+ None => self.update(k, v),
+ Some((_, v2, m)) => {
+ let out_v = f(&k, v2, v);
+ m.update(k, out_v)
+ }
+ }
+ }
+
+ /// Construct a new map by inserting a key/value mapping into a
+ /// map, returning the old value for the key as well as the new
+ /// map.
+ ///
+ /// If the map already has a mapping for the given key, we call
+ /// the provided function with the key, the old value and the new
+ /// value, and insert the result as the new value.
+ ///
+ /// Time: O(log n)
+ #[must_use]
+ pub fn update_lookup_with_key<F>(&self, k: K, v: V, f: F) -> (Option<V>, Self)
+ where
+ F: FnOnce(&K, &V, V) -> V,
+ {
+ match self.extract_with_key(&k) {
+ None => (None, self.update(k, v)),
+ Some((_, v2, m)) => {
+ let out_v = f(&k, &v2, v);
+ (Some(v2), m.update(k, out_v))
+ }
+ }
+ }
+
+ /// Update the value for a given key by calling a function with
+ /// the current value and overwriting it with the function's
+ /// return value.
+ ///
+ /// The function gets an [`Option<V>`][std::option::Option] and
+ /// returns the same, so that it can decide to delete a mapping
+ /// instead of updating the value, and decide what to do if the
+ /// key isn't in the map.
+ ///
+ /// Time: O(log n)
+ ///
+ /// [std::option::Option]: https://doc.rust-lang.org/std/option/enum.Option.html
+ #[must_use]
+ pub fn alter<F>(&self, f: F, k: K) -> Self
+ where
+ F: FnOnce(Option<V>) -> Option<V>,
+ {
+ let pop = self.extract_with_key(&k);
+ match (f(pop.as_ref().map(|&(_, ref v, _)| v.clone())), pop) {
+ (None, None) => self.clone(),
+ (Some(v), None) => self.update(k, v),
+ (None, Some((_, _, m))) => m,
+ (Some(v), Some((_, _, m))) => m.update(k, v),
+ }
+ }
+
+ /// Construct a new map without the given key.
+ ///
+ /// Construct a map that's a copy of the current map, absent the
+ /// mapping for `key` if it's present.
+ ///
+ /// Time: O(log n)
+ #[must_use]
+ pub fn without<BK>(&self, k: &BK) -> Self
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ match self.extract_with_key(k) {
+ None => self.clone(),
+ Some((_, _, map)) => map,
+ }
+ }
+
+ /// Filter out values from a map which don't satisfy a predicate.
+ ///
+ /// This is slightly more efficient than filtering using an
+ /// iterator, in that it doesn't need to rehash the retained
+ /// values, but it still needs to reconstruct the entire tree
+ /// structure of the map.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::HashMap;
+ /// let mut map = hashmap!{1 => 1, 2 => 2, 3 => 3};
+ /// map.retain(|k, v| *k > 1);
+ /// let expected = hashmap!{2 => 2, 3 => 3};
+ /// assert_eq!(expected, map);
+ /// ```
+ pub fn retain<F>(&mut self, mut f: F)
+ where
+ F: FnMut(&K, &V) -> bool,
+ {
+ let old_root = self.root.clone();
+ let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+ for ((key, value), hash) in NodeIter::new(&old_root, self.size) {
+ if !f(key, value) && root.remove(&self.pool.0, hash, 0, key).is_some() {
+ self.size -= 1;
+ }
+ }
+ }
+
+ /// Remove a key/value pair from a map, if it exists, and return
+ /// the removed value as well as the updated map.
+ ///
+ /// Time: O(log n)
+ #[must_use]
+ pub fn extract<BK>(&self, k: &BK) -> Option<(V, Self)>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ self.extract_with_key(k).map(|(_, v, m)| (v, m))
+ }
+
+ /// Remove a key/value pair from a map, if it exists, and return
+ /// the removed key and value as well as the updated list.
+ ///
+ /// Time: O(log n)
+ #[must_use]
+ pub fn extract_with_key<BK>(&self, k: &BK) -> Option<(K, V, Self)>
+ where
+ BK: Hash + Eq + ?Sized,
+ K: Borrow<BK>,
+ {
+ let mut out = self.clone();
+ out.remove_with_key(k).map(|(k, v)| (k, v, out))
+ }
+
+ /// Construct the union of two maps, keeping the values in the
+ /// current map when keys exist in both maps.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 3};
+ /// let map2 = hashmap!{2 => 2, 3 => 4};
+ /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 3};
+ /// assert_eq!(expected, map1.union(map2));
+ /// ```
+ #[must_use]
+ pub fn union(self, other: Self) -> Self {
+ let (mut to_mutate, to_consume) = if self.len() >= other.len() {
+ (self, other)
+ } else {
+ (other, self)
+ };
+ for (k, v) in to_consume {
+ to_mutate.entry(k).or_insert(v);
+ }
+ to_mutate
+ }
+
+ /// Construct the union of two maps, using a function to decide
+ /// what to do with the value when a key is in both maps.
+ ///
+ /// The function is called when a value exists in both maps, and
+ /// receives the value from the current map as its first argument,
+ /// and the value from the other map as the second. It should
+ /// return the value to be inserted in the resulting map.
+ ///
+ /// Time: O(n log n)
+ #[inline]
+ #[must_use]
+ pub fn union_with<F>(self, other: Self, mut f: F) -> Self
+ where
+ F: FnMut(V, V) -> V,
+ {
+ self.union_with_key(other, |_, v1, v2| f(v1, v2))
+ }
+
+ /// Construct the union of two maps, using a function to decide
+ /// what to do with the value when a key is in both maps.
+ ///
+ /// The function is called when a value exists in both maps, and
+ /// receives a reference to the key as its first argument, the
+ /// value from the current map as the second argument, and the
+ /// value from the other map as the third argument. It should
+ /// return the value to be inserted in the resulting map.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 4};
+ /// let map2 = hashmap!{2 => 2, 3 => 5};
+ /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 9};
+ /// assert_eq!(expected, map1.union_with_key(
+ /// map2,
+ /// |key, left, right| left + right
+ /// ));
+ /// ```
+ #[must_use]
+ pub fn union_with_key<F>(self, other: Self, mut f: F) -> Self
+ where
+ F: FnMut(&K, V, V) -> V,
+ {
+ if self.len() >= other.len() {
+ self.union_with_key_inner(other, f)
+ } else {
+ other.union_with_key_inner(self, |key, other_value, self_value| {
+ f(key, self_value, other_value)
+ })
+ }
+ }
+
+ fn union_with_key_inner<F>(mut self, other: Self, mut f: F) -> Self
+ where
+ F: FnMut(&K, V, V) -> V,
+ {
+ for (key, right_value) in other {
+ match self.remove(&key) {
+ None => {
+ self.insert(key, right_value);
+ }
+ Some(left_value) => {
+ let final_value = f(&key, left_value, right_value);
+ self.insert(key, final_value);
+ }
+ }
+ }
+ self
+ }
+
+ /// Construct the union of a sequence of maps, selecting the value
+ /// of the leftmost when a key appears in more than one map.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 3};
+ /// let map2 = hashmap!{2 => 2};
+ /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 3};
+ /// assert_eq!(expected, HashMap::unions(vec![map1, map2]));
+ /// ```
+ #[must_use]
+ pub fn unions<I>(i: I) -> Self
+ where
+ S: Default,
+ I: IntoIterator<Item = Self>,
+ {
+ i.into_iter().fold(Self::default(), Self::union)
+ }
+
+ /// Construct the union of a sequence of maps, using a function to
+ /// decide what to do with the value when a key is in more than
+ /// one map.
+ ///
+ /// The function is called when a value exists in multiple maps,
+ /// and receives the value from the current map as its first
+ /// argument, and the value from the next map as the second. It
+ /// should return the value to be inserted in the resulting map.
+ ///
+ /// Time: O(n log n)
+ #[must_use]
+ pub fn unions_with<I, F>(i: I, f: F) -> Self
+ where
+ S: Default,
+ I: IntoIterator<Item = Self>,
+ F: Fn(V, V) -> V,
+ {
+ i.into_iter()
+ .fold(Self::default(), |a, b| a.union_with(b, &f))
+ }
+
+ /// Construct the union of a sequence of maps, using a function to
+ /// decide what to do with the value when a key is in more than
+ /// one map.
+ ///
+ /// The function is called when a value exists in multiple maps,
+ /// and receives a reference to the key as its first argument, the
+ /// value from the current map as the second argument, and the
+ /// value from the next map as the third argument. It should
+ /// return the value to be inserted in the resulting map.
+ ///
+ /// Time: O(n log n)
+ #[must_use]
+ pub fn unions_with_key<I, F>(i: I, f: F) -> Self
+ where
+ S: Default,
+ I: IntoIterator<Item = Self>,
+ F: Fn(&K, V, V) -> V,
+ {
+ i.into_iter()
+ .fold(Self::default(), |a, b| a.union_with_key(b, &f))
+ }
+
+ /// Construct the symmetric difference between two maps by discarding keys
+ /// which occur in both maps.
+ ///
+ /// This is an alias for the
+ /// [`symmetric_difference`][symmetric_difference] method.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 4};
+ /// let map2 = hashmap!{2 => 2, 3 => 5};
+ /// let expected = hashmap!{1 => 1, 2 => 2};
+ /// assert_eq!(expected, map1.difference(map2));
+ /// ```
+ ///
+ /// [symmetric_difference]: #method.symmetric_difference
+ #[inline]
+ #[must_use]
+ pub fn difference(self, other: Self) -> Self {
+ self.symmetric_difference(other)
+ }
+
+ /// Construct the symmetric difference between two maps by discarding keys
+ /// which occur in both maps.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 4};
+ /// let map2 = hashmap!{2 => 2, 3 => 5};
+ /// let expected = hashmap!{1 => 1, 2 => 2};
+ /// assert_eq!(expected, map1.symmetric_difference(map2));
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn symmetric_difference(self, other: Self) -> Self {
+ self.symmetric_difference_with_key(other, |_, _, _| None)
+ }
+
+ /// Construct the symmetric difference between two maps by using a function
+ /// to decide what to do if a key occurs in both.
+ ///
+ /// This is an alias for the
+ /// [`symmetric_difference_with`][symmetric_difference_with] method.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// [symmetric_difference_with]: #method.symmetric_difference_with
+ #[inline]
+ #[must_use]
+ pub fn difference_with<F>(self, other: Self, f: F) -> Self
+ where
+ F: FnMut(V, V) -> Option<V>,
+ {
+ self.symmetric_difference_with(other, f)
+ }
+
+ /// Construct the symmetric difference between two maps by using a function
+ /// to decide what to do if a key occurs in both.
+ ///
+ /// Time: O(n log n)
+ #[inline]
+ #[must_use]
+ pub fn symmetric_difference_with<F>(self, other: Self, mut f: F) -> Self
+ where
+ F: FnMut(V, V) -> Option<V>,
+ {
+ self.symmetric_difference_with_key(other, |_, a, b| f(a, b))
+ }
+
+ /// Construct the symmetric difference between two maps by using a function
+ /// to decide what to do if a key occurs in both. The function
+ /// receives the key as well as both values.
+ ///
+ /// This is an alias for the
+ /// [`symmetric_difference_with`_key][symmetric_difference_with_key]
+ /// method.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 4};
+ /// let map2 = hashmap!{2 => 2, 3 => 5};
+ /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 9};
+ /// assert_eq!(expected, map1.difference_with_key(
+ /// map2,
+ /// |key, left, right| Some(left + right)
+ /// ));
+ /// ```
+ ///
+ /// [symmetric_difference_with_key]: #method.symmetric_difference_with_key
+ #[must_use]
+ pub fn difference_with_key<F>(self, other: Self, f: F) -> Self
+ where
+ F: FnMut(&K, V, V) -> Option<V>,
+ {
+ self.symmetric_difference_with_key(other, f)
+ }
+
+ /// Construct the symmetric difference between two maps by using a function
+ /// to decide what to do if a key occurs in both. The function
+ /// receives the key as well as both values.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 3 => 4};
+ /// let map2 = hashmap!{2 => 2, 3 => 5};
+ /// let expected = hashmap!{1 => 1, 2 => 2, 3 => 9};
+ /// assert_eq!(expected, map1.symmetric_difference_with_key(
+ /// map2,
+ /// |key, left, right| Some(left + right)
+ /// ));
+ /// ```
+ #[must_use]
+ pub fn symmetric_difference_with_key<F>(mut self, other: Self, mut f: F) -> Self
+ where
+ F: FnMut(&K, V, V) -> Option<V>,
+ {
+ let mut out = self.new_from();
+ for (key, right_value) in other {
+ match self.remove(&key) {
+ None => {
+ out.insert(key, right_value);
+ }
+ Some(left_value) => {
+ if let Some(final_value) = f(&key, left_value, right_value) {
+ out.insert(key, final_value);
+ }
+ }
+ }
+ }
+ out.union(self)
+ }
+
+ /// Construct the relative complement between two maps by discarding keys
+ /// which occur in `other`.
+ ///
+ /// Time: O(m log n) where m is the size of the other map
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::ordmap::OrdMap;
+ /// let map1 = ordmap!{1 => 1, 3 => 4};
+ /// let map2 = ordmap!{2 => 2, 3 => 5};
+ /// let expected = ordmap!{1 => 1};
+ /// assert_eq!(expected, map1.relative_complement(map2));
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn relative_complement(mut self, other: Self) -> Self {
+ for (key, _) in other {
+ let _ = self.remove(&key);
+ }
+ self
+ }
+
+ /// Construct the intersection of two maps, keeping the values
+ /// from the current map.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 2 => 2};
+ /// let map2 = hashmap!{2 => 3, 3 => 4};
+ /// let expected = hashmap!{2 => 2};
+ /// assert_eq!(expected, map1.intersection(map2));
+ /// ```
+ #[inline]
+ #[must_use]
+ pub fn intersection(self, other: Self) -> Self {
+ self.intersection_with_key(other, |_, v, _| v)
+ }
+
+ /// Construct the intersection of two maps, calling a function
+ /// with both values for each key and using the result as the
+ /// value for the key.
+ ///
+ /// Time: O(n log n)
+ #[inline]
+ #[must_use]
+ pub fn intersection_with<B, C, F>(self, other: HashMap<K, B, S>, mut f: F) -> HashMap<K, C, S>
+ where
+ B: Clone,
+ C: Clone,
+ F: FnMut(V, B) -> C,
+ {
+ self.intersection_with_key(other, |_, v1, v2| f(v1, v2))
+ }
+
+ /// Construct the intersection of two maps, calling a function
+ /// with the key and both values for each key and using the result
+ /// as the value for the key.
+ ///
+ /// Time: O(n log n)
+ ///
+ /// # Examples
+ ///
+ /// ```
+ /// # #[macro_use] extern crate im_rc as im;
+ /// # use im::hashmap::HashMap;
+ /// let map1 = hashmap!{1 => 1, 2 => 2};
+ /// let map2 = hashmap!{2 => 3, 3 => 4};
+ /// let expected = hashmap!{2 => 5};
+ /// assert_eq!(expected, map1.intersection_with_key(
+ /// map2,
+ /// |key, left, right| left + right
+ /// ));
+ /// ```
+ #[must_use]
+ pub fn intersection_with_key<B, C, F>(
+ mut self,
+ other: HashMap<K, B, S>,
+ mut f: F,
+ ) -> HashMap<K, C, S>
+ where
+ B: Clone,
+ C: Clone,
+ F: FnMut(&K, V, B) -> C,
+ {
+ let mut out = self.new_from();
+ for (key, right_value) in other {
+ match self.remove(&key) {
+ None => (),
+ Some(left_value) => {
+ let result = f(&key, left_value, right_value);
+ out.insert(key, result);
+ }
+ }
+ }
+ out
+ }
+}
+
+// Entries
+
+/// A handle for a key and its associated value.
+///
+/// ## Performance Note
+///
+/// When using an `Entry`, the key is only ever hashed once, when you
+/// create the `Entry`. Operations on an `Entry` will never trigger a
+/// rehash, where eg. a `contains_key(key)` followed by an
+/// `insert(key, default_value)` (the equivalent of
+/// `Entry::or_insert()`) would need to hash the key once for the
+/// `contains_key` and again for the `insert`. The operations
+/// generally perform similarly otherwise.
+pub enum Entry<'a, K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ /// An entry which exists in the map.
+ Occupied(OccupiedEntry<'a, K, V, S>),
+ /// An entry which doesn't exist in the map.
+ Vacant(VacantEntry<'a, K, V, S>),
+}
+
+impl<'a, K, V, S> Entry<'a, K, V, S>
+where
+ K: 'a + Hash + Eq + Clone,
+ V: 'a + Clone,
+ S: 'a + BuildHasher,
+{
+ /// Insert the default value provided if there was no value
+ /// already, and return a mutable reference to the value.
+ pub fn or_insert(self, default: V) -> &'a mut V {
+ self.or_insert_with(|| default)
+ }
+
+ /// Insert the default value from the provided function if there
+ /// was no value already, and return a mutable reference to the
+ /// value.
+ pub fn or_insert_with<F>(self, default: F) -> &'a mut V
+ where
+ F: FnOnce() -> V,
+ {
+ match self {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => entry.insert(default()),
+ }
+ }
+
+ /// Insert a default value if there was no value already, and
+ /// return a mutable reference to the value.
+ pub fn or_default(self) -> &'a mut V
+ where
+ V: Default,
+ {
+ self.or_insert_with(Default::default)
+ }
+
+ /// Get the key for this entry.
+ #[must_use]
+ pub fn key(&self) -> &K {
+ match self {
+ Entry::Occupied(entry) => entry.key(),
+ Entry::Vacant(entry) => entry.key(),
+ }
+ }
+
+ /// Call the provided function to modify the value if the value
+ /// exists.
+ pub fn and_modify<F>(mut self, f: F) -> Self
+ where
+ F: FnOnce(&mut V),
+ {
+ match &mut self {
+ Entry::Occupied(ref mut entry) => f(entry.get_mut()),
+ Entry::Vacant(_) => (),
+ }
+ self
+ }
+}
+
+/// An entry for a mapping that already exists in the map.
+pub struct OccupiedEntry<'a, K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ map: &'a mut HashMap<K, V, S>,
+ hash: HashBits,
+ key: K,
+}
+
+impl<'a, K, V, S> OccupiedEntry<'a, K, V, S>
+where
+ K: 'a + Hash + Eq + Clone,
+ V: 'a + Clone,
+ S: 'a + BuildHasher,
+{
+ /// Get the key for this entry.
+ #[must_use]
+ pub fn key(&self) -> &K {
+ &self.key
+ }
+
+ /// Remove this entry from the map and return the removed mapping.
+ pub fn remove_entry(self) -> (K, V) {
+ let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+ let result = root.remove(&self.map.pool.0, self.hash, 0, &self.key);
+ self.map.size -= 1;
+ result.unwrap()
+ }
+
+ /// Get the current value.
+ #[must_use]
+ pub fn get(&self) -> &V {
+ &self.map.root.get(self.hash, 0, &self.key).unwrap().1
+ }
+
+ /// Get a mutable reference to the current value.
+ #[must_use]
+ pub fn get_mut(&mut self) -> &mut V {
+ let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+ &mut root
+ .get_mut(&self.map.pool.0, self.hash, 0, &self.key)
+ .unwrap()
+ .1
+ }
+
+ /// Convert this entry into a mutable reference.
+ #[must_use]
+ pub fn into_mut(self) -> &'a mut V {
+ let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+ &mut root
+ .get_mut(&self.map.pool.0, self.hash, 0, &self.key)
+ .unwrap()
+ .1
+ }
+
+ /// Overwrite the current value.
+ pub fn insert(&mut self, value: V) -> V {
+ mem::replace(self.get_mut(), value)
+ }
+
+ /// Remove this entry from the map and return the removed value.
+ pub fn remove(self) -> V {
+ self.remove_entry().1
+ }
+}
+
+/// An entry for a mapping that does not already exist in the map.
+pub struct VacantEntry<'a, K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ map: &'a mut HashMap<K, V, S>,
+ hash: HashBits,
+ key: K,
+}
+
+impl<'a, K, V, S> VacantEntry<'a, K, V, S>
+where
+ K: 'a + Hash + Eq + Clone,
+ V: 'a + Clone,
+ S: 'a + BuildHasher,
+{
+ /// Get the key for this entry.
+ #[must_use]
+ pub fn key(&self) -> &K {
+ &self.key
+ }
+
+ /// Convert this entry into its key.
+ #[must_use]
+ pub fn into_key(self) -> K {
+ self.key
+ }
+
+ /// Insert a value into this entry.
+ pub fn insert(self, value: V) -> &'a mut V {
+ let root = PoolRef::make_mut(&self.map.pool.0, &mut self.map.root);
+ if root
+ .insert(&self.map.pool.0, self.hash, 0, (self.key.clone(), value))
+ .is_none()
+ {
+ self.map.size += 1;
+ }
+ // TODO it's unfortunate that we need to look up the key again
+ // here to get the mut ref.
+ &mut root
+ .get_mut(&self.map.pool.0, self.hash, 0, &self.key)
+ .unwrap()
+ .1
+ }
+}
+
+// Core traits
+
+impl<K, V, S> Clone for HashMap<K, V, S>
+where
+ K: Clone,
+ V: Clone,
+{
+ /// Clone a map.
+ ///
+ /// Time: O(1)
+ #[inline]
+ fn clone(&self) -> Self {
+ HashMap {
+ root: self.root.clone(),
+ pool: self.pool.clone(),
+ size: self.size,
+ hasher: self.hasher.clone(),
+ }
+ }
+}
+
+#[cfg(not(has_specialisation))]
+impl<K, V, S> PartialEq for HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ V: PartialEq,
+ S: BuildHasher,
+{
+ fn eq(&self, other: &Self) -> bool {
+ self.test_eq(other)
+ }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> PartialEq for HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ V: PartialEq,
+ S: BuildHasher,
+{
+ default fn eq(&self, other: &Self) -> bool {
+ self.test_eq(other)
+ }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> PartialEq for HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ V: Eq,
+ S: BuildHasher,
+{
+ fn eq(&self, other: &Self) -> bool {
+ if PoolRef::ptr_eq(&self.root, &other.root) {
+ return true;
+ }
+ self.test_eq(other)
+ }
+}
+
+impl<K, V, S> Eq for HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ V: Eq,
+ S: BuildHasher,
+{
+}
+
+impl<K, V, S> PartialOrd for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone + PartialOrd,
+ V: PartialOrd + Clone,
+ S: BuildHasher,
+{
+ fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+ if Ref::ptr_eq(&self.hasher, &other.hasher) {
+ return self.iter().partial_cmp(other.iter());
+ }
+ self.iter().partial_cmp(other.iter())
+ }
+}
+
+impl<K, V, S> Ord for HashMap<K, V, S>
+where
+ K: Hash + Eq + Ord + Clone,
+ V: Ord + Clone,
+ S: BuildHasher,
+{
+ fn cmp(&self, other: &Self) -> Ordering {
+ if Ref::ptr_eq(&self.hasher, &other.hasher) {
+ return self.iter().cmp(other.iter());
+ }
+ self.iter().cmp(other.iter())
+ }
+}
+
+impl<K, V, S> Hash for HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ V: Hash,
+ S: BuildHasher,
+{
+ fn hash<H>(&self, state: &mut H)
+ where
+ H: Hasher,
+ {
+ for i in self.iter() {
+ i.hash(state);
+ }
+ }
+}
+
+impl<K, V, S> Default for HashMap<K, V, S>
+where
+ S: BuildHasher + Default,
+{
+ #[inline]
+ fn default() -> Self {
+ let pool = HashMapPool::default();
+ let root = PoolRef::default(&pool.0);
+ HashMap {
+ size: 0,
+ pool,
+ root,
+ hasher: Ref::<S>::default(),
+ }
+ }
+}
+
+impl<K, V, S> Add for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ type Output = HashMap<K, V, S>;
+
+ fn add(self, other: Self) -> Self::Output {
+ self.union(other)
+ }
+}
+
+impl<'a, K, V, S> Add for &'a HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ type Output = HashMap<K, V, S>;
+
+ fn add(self, other: Self) -> Self::Output {
+ self.clone().union(other.clone())
+ }
+}
+
+impl<K, V, S> Sum for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn sum<I>(it: I) -> Self
+ where
+ I: Iterator<Item = Self>,
+ {
+ it.fold(Self::default(), |a, b| a + b)
+ }
+}
+
+impl<K, V, S, RK, RV> Extend<(RK, RV)> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone + From<RK>,
+ V: Clone + From<RV>,
+ S: BuildHasher,
+{
+ fn extend<I>(&mut self, iter: I)
+ where
+ I: IntoIterator<Item = (RK, RV)>,
+ {
+ for (key, value) in iter {
+ self.insert(From::from(key), From::from(value));
+ }
+ }
+}
+
+impl<'a, BK, K, V, S> Index<&'a BK> for HashMap<K, V, S>
+where
+ BK: Hash + Eq + ?Sized,
+ K: Hash + Eq + Borrow<BK>,
+ S: BuildHasher,
+{
+ type Output = V;
+
+ fn index(&self, key: &BK) -> &Self::Output {
+ match self.root.get(hash_key(&*self.hasher, key), 0, key) {
+ None => panic!("HashMap::index: invalid key"),
+ Some(&(_, ref value)) => value,
+ }
+ }
+}
+
+impl<'a, BK, K, V, S> IndexMut<&'a BK> for HashMap<K, V, S>
+where
+ BK: Hash + Eq + ?Sized,
+ K: Hash + Eq + Clone + Borrow<BK>,
+ V: Clone,
+ S: BuildHasher,
+{
+ fn index_mut(&mut self, key: &BK) -> &mut Self::Output {
+ let root = PoolRef::make_mut(&self.pool.0, &mut self.root);
+ match root.get_mut(&self.pool.0, hash_key(&*self.hasher, key), 0, key) {
+ None => panic!("HashMap::index_mut: invalid key"),
+ Some(&mut (_, ref mut value)) => value,
+ }
+ }
+}
+
+#[cfg(not(has_specialisation))]
+impl<K, V, S> Debug for HashMap<K, V, S>
+where
+ K: Hash + Eq + Debug,
+ V: Debug,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+ let mut d = f.debug_map();
+ for (k, v) in self {
+ d.entry(k, v);
+ }
+ d.finish()
+ }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> Debug for HashMap<K, V, S>
+where
+ K: Hash + Eq + Debug,
+ V: Debug,
+ S: BuildHasher,
+{
+ default fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+ let mut d = f.debug_map();
+ for (k, v) in self {
+ d.entry(k, v);
+ }
+ d.finish()
+ }
+}
+
+#[cfg(has_specialisation)]
+impl<K, V, S> Debug for HashMap<K, V, S>
+where
+ K: Hash + Eq + Ord + Debug,
+ V: Debug,
+ S: BuildHasher,
+{
+ fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
+ let mut keys = collections::BTreeSet::new();
+ keys.extend(self.keys());
+ let mut d = f.debug_map();
+ for key in keys {
+ d.entry(key, &self[key]);
+ }
+ d.finish()
+ }
+}
+
+// // Iterators
+
+/// An iterator over the elements of a map.
+pub struct Iter<'a, K, V> {
+ it: NodeIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Iter<'a, K, V> {
+ type Item = (&'a K, &'a V);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.it.next().map(|((k, v), _)| (k, v))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.it.size_hint()
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Iter<'a, K, V> {}
+
+/// A mutable iterator over the elements of a map.
+pub struct IterMut<'a, K, V>
+where
+ K: Clone,
+ V: Clone,
+{
+ it: NodeIterMut<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for IterMut<'a, K, V>
+where
+ K: Clone,
+ V: Clone,
+{
+ type Item = (&'a K, &'a mut V);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.it.next().map(|((k, v), _)| (&*k, v))
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.it.size_hint()
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for IterMut<'a, K, V>
+where
+ K: Clone,
+ V: Clone,
+{
+}
+
+impl<'a, K, V> FusedIterator for IterMut<'a, K, V>
+where
+ K: Clone,
+ V: Clone,
+{
+}
+
+/// A consuming iterator over the elements of a map.
+pub struct ConsumingIter<A: HashValue> {
+ it: NodeDrain<A>,
+}
+
+impl<A> Iterator for ConsumingIter<A>
+where
+ A: HashValue + Clone,
+{
+ type Item = A;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.it.next().map(|(p, _)| p)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.it.size_hint()
+ }
+}
+
+impl<A> ExactSizeIterator for ConsumingIter<A> where A: HashValue + Clone {}
+
+impl<A> FusedIterator for ConsumingIter<A> where A: HashValue + Clone {}
+
+/// An iterator over the keys of a map.
+pub struct Keys<'a, K, V> {
+ it: NodeIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Keys<'a, K, V> {
+ type Item = &'a K;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.it.next().map(|((k, _), _)| k)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.it.size_hint()
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
+
+/// An iterator over the values of a map.
+pub struct Values<'a, K, V> {
+ it: NodeIter<'a, (K, V)>,
+}
+
+impl<'a, K, V> Iterator for Values<'a, K, V> {
+ type Item = &'a V;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.it.next().map(|((_, v), _)| v)
+ }
+
+ fn size_hint(&self) -> (usize, Option<usize>) {
+ self.it.size_hint()
+ }
+}
+
+impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {}
+
+impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
+
+impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S>
+where
+ K: Hash + Eq,
+ S: BuildHasher,
+{
+ type Item = (&'a K, &'a V);
+ type IntoIter = Iter<'a, K, V>;
+
+ #[inline]
+ fn into_iter(self) -> Self::IntoIter {
+ self.iter()
+ }
+}
+
+impl<K, V, S> IntoIterator for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher,
+{
+ type Item = (K, V);
+ type IntoIter = ConsumingIter<(K, V)>;
+
+ #[inline]
+ fn into_iter(self) -> Self::IntoIter {
+ ConsumingIter {
+ it: NodeDrain::new(&self.pool.0, self.root, self.size),
+ }
+ }
+}
+
+// Conversions
+
+impl<K, V, S> FromIterator<(K, V)> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from_iter<T>(i: T) -> Self
+ where
+ T: IntoIterator<Item = (K, V)>,
+ {
+ let mut map = Self::default();
+ for (k, v) in i {
+ map.insert(k, v);
+ }
+ map
+ }
+}
+
+impl<K, V, S> AsRef<HashMap<K, V, S>> for HashMap<K, V, S> {
+ #[inline]
+ fn as_ref(&self) -> &Self {
+ self
+ }
+}
+
+impl<'m, 'k, 'v, K, V, OK, OV, SA, SB> From<&'m HashMap<&'k K, &'v V, SA>> for HashMap<OK, OV, SB>
+where
+ K: Hash + Eq + ToOwned<Owned = OK> + ?Sized,
+ V: ToOwned<Owned = OV> + ?Sized,
+ OK: Hash + Eq + Clone + Borrow<K>,
+ OV: Borrow<V> + Clone,
+ SA: BuildHasher,
+ SB: BuildHasher + Default,
+{
+ fn from(m: &HashMap<&K, &V, SA>) -> Self {
+ m.iter()
+ .map(|(k, v)| ((*k).to_owned(), (*v).to_owned()))
+ .collect()
+ }
+}
+
+impl<'a, K, V, S> From<&'a [(K, V)]> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: &'a [(K, V)]) -> Self {
+ m.iter().cloned().collect()
+ }
+}
+
+impl<K, V, S> From<Vec<(K, V)>> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: Vec<(K, V)>) -> Self {
+ m.into_iter().collect()
+ }
+}
+
+impl<'a, K, V, S> From<&'a Vec<(K, V)>> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: &'a Vec<(K, V)>) -> Self {
+ m.iter().cloned().collect()
+ }
+}
+
+impl<K, V, S> From<collections::HashMap<K, V>> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: collections::HashMap<K, V>) -> Self {
+ m.into_iter().collect()
+ }
+}
+
+impl<'a, K, V, S> From<&'a collections::HashMap<K, V>> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: &'a collections::HashMap<K, V>) -> Self {
+ m.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+ }
+}
+
+impl<K, V, S> From<collections::BTreeMap<K, V>> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: collections::BTreeMap<K, V>) -> Self {
+ m.into_iter().collect()
+ }
+}
+
+impl<'a, K, V, S> From<&'a collections::BTreeMap<K, V>> for HashMap<K, V, S>
+where
+ K: Hash + Eq + Clone,
+ V: Clone,
+ S: BuildHasher + Default,
+{
+ fn from(m: &'a collections::BTreeMap<K, V>) -> Self {
+ m.iter().map(|(k, v)| (k.clone(), v.clone())).collect()
+ }
+}
+
+// impl<K: Ord + Hash + Eq, V, S> From<OrdMap<K, V>> for HashMap<K, V, S>
+// where
+// S: BuildHasher + Default,
+// {
+// fn from(m: OrdMap<K, V>) -> Self {
+// m.into_iter().collect()
+// }
+// }
+
+// impl<'a, K: Ord + Hash + Eq, V, S> From<&'a OrdMap<K, V>> for HashMap<K, V, S>
+// where
+// S: BuildHasher + Default,
+// {
+// fn from(m: &'a OrdMap<K, V>) -> Self {
+// m.into_iter().collect()
+// }
+// }
+
+// Proptest
+#[cfg(any(test, feature = "proptest"))]
+#[doc(hidden)]
+pub mod proptest {
+ #[deprecated(
+ since = "14.3.0",
+ note = "proptest strategies have moved to im::proptest"
+ )]
+ pub use crate::proptest::hash_map;
+}
+
+// Tests
+
+#[cfg(test)]
+mod test {
+ use super::*;
+ use crate::test::LolHasher;
+ use ::proptest::num::{i16, usize};
+ use ::proptest::{collection, proptest};
+ use std::hash::BuildHasherDefault;
+
+ #[test]
+ fn safe_mutation() {
+ let v1: HashMap<usize, usize> = (0..131_072).map(|i| (i, i)).collect::<HashMap<_, _>>();
+ let mut v2 = v1.clone();
+ v2.insert(131_000, 23);
+ assert_eq!(Some(&23), v2.get(&131_000));
+ assert_eq!(Some(&131_000), v1.get(&131_000));
+ }
+
+ #[test]
+ fn index_operator() {
+ let mut map = hashmap![1 => 2, 3 => 4, 5 => 6];
+ assert_eq!(4, map[&3]);
+ map[&3] = 8;
+ assert_eq!(hashmap![1 => 2, 3 => 8, 5 => 6], map);
+ }
+
+ #[test]
+ fn proper_formatting() {
+ let map = hashmap![1 => 2];
+ assert_eq!("{1: 2}", format!("{:?}", map));
+
+ assert_eq!("{}", format!("{:?}", HashMap::<(), ()>::new()));
+ }
+
+ #[test]
+ fn remove_failing() {
+ let pairs = [(1469, 0), (-67, 0)];
+ let mut m: collections::HashMap<i16, i16, _> =
+ collections::HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+ for &(ref k, ref v) in &pairs {
+ m.insert(*k, *v);
+ }
+ let mut map: HashMap<i16, i16, _> =
+ HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+ for (k, v) in &m {
+ map = map.update(*k, *v);
+ }
+ for k in m.keys() {
+ let l = map.len();
+ assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+ map = map.without(k);
+ assert_eq!(None, map.get(k));
+ assert_eq!(l - 1, map.len());
+ }
+ }
+
+ #[test]
+ fn match_string_keys_with_string_slices() {
+ let mut map: HashMap<String, i32> =
+ From::from(&hashmap! { "foo" => &1, "bar" => &2, "baz" => &3 });
+ assert_eq!(Some(&1), map.get("foo"));
+ map = map.without("foo");
+ assert_eq!(Some(3), map.remove("baz"));
+ map["bar"] = 8;
+ assert_eq!(8, map["bar"]);
+ }
+
+ #[test]
+ fn macro_allows_trailing_comma() {
+ let map1 = hashmap! {"x" => 1, "y" => 2};
+ let map2 = hashmap! {
+ "x" => 1,
+ "y" => 2,
+ };
+ assert_eq!(map1, map2);
+ }
+
+ #[test]
+ fn remove_top_level_collisions() {
+ let pairs = vec![9, 2569, 27145];
+ let mut map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+ for k in pairs.clone() {
+ map.insert(k, k);
+ }
+ assert_eq!(pairs.len(), map.len());
+ let keys: Vec<_> = map.keys().cloned().collect();
+ for k in keys {
+ let l = map.len();
+ assert_eq!(Some(&k), map.get(&k));
+ map.remove(&k);
+ assert_eq!(None, map.get(&k));
+ assert_eq!(l - 1, map.len());
+ }
+ }
+
+ #[test]
+ fn entry_api() {
+ let mut map = hashmap! {"bar" => 5};
+ map.entry("foo").and_modify(|v| *v += 5).or_insert(1);
+ assert_eq!(1, map[&"foo"]);
+ map.entry("foo").and_modify(|v| *v += 5).or_insert(1);
+ assert_eq!(6, map[&"foo"]);
+ map.entry("bar").and_modify(|v| *v += 5).or_insert(1);
+ assert_eq!(10, map[&"bar"]);
+ assert_eq!(
+ 10,
+ match map.entry("bar") {
+ Entry::Occupied(entry) => entry.remove(),
+ _ => panic!(),
+ }
+ );
+ assert!(!map.contains_key(&"bar"));
+ }
+
+ #[test]
+ fn refpool_crash() {
+ let _map = HashMap::<u128, usize>::new();
+ }
+
+ #[test]
+ fn large_map() {
+ let mut map = HashMap::new();
+ let size = 32769;
+ for i in 0..size {
+ map.insert(i, i);
+ }
+ assert_eq!(size, map.len());
+ for i in 0..size {
+ assert_eq!(Some(&i), map.get(&i));
+ }
+ }
+
+ proptest! {
+ #[test]
+ fn update_and_length(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let mut map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+ for (index, (k, v)) in m.iter().enumerate() {
+ map = map.update(*k, *v);
+ assert_eq!(Some(v), map.get(k));
+ assert_eq!(index + 1, map.len());
+ }
+ }
+
+ #[test]
+ fn from_iterator(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let map: HashMap<i16, i16> =
+ FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+ assert_eq!(m.len(), map.len());
+ }
+
+ #[test]
+ fn iterate_over(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let map: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+ assert_eq!(m.len(), map.iter().count());
+ }
+
+ #[test]
+ fn equality(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let map1: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+ let map2: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+ assert_eq!(map1, map2);
+ }
+
+ #[test]
+ fn lookup(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let map: HashMap<i16, i16> = FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v)));
+ for (k, v) in m {
+ assert_eq!(Some(*v), map.get(k).cloned());
+ }
+ }
+
+ #[test]
+ fn without(ref pairs in collection::vec((i16::ANY, i16::ANY), 0..100)) {
+ let mut m: collections::HashMap<i16, i16, _> =
+ collections::HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+ for &(ref k, ref v) in pairs {
+ m.insert(*k, *v);
+ }
+ let mut map: HashMap<i16, i16, _> = HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+ for (k, v) in &m {
+ map = map.update(*k, *v);
+ }
+ for k in m.keys() {
+ let l = map.len();
+ assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+ map = map.without(k);
+ assert_eq!(None, map.get(k));
+ assert_eq!(l - 1, map.len());
+ }
+ }
+
+ #[test]
+ fn insert(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let mut mut_map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+ let mut map: HashMap<i16, i16, BuildHasherDefault<LolHasher>> = Default::default();
+ for (count, (k, v)) in m.iter().enumerate() {
+ map = map.update(*k, *v);
+ mut_map.insert(*k, *v);
+ assert_eq!(count + 1, map.len());
+ assert_eq!(count + 1, mut_map.len());
+ }
+ assert_eq!(map, mut_map);
+ }
+
+ #[test]
+ fn remove(ref pairs in collection::vec((i16::ANY, i16::ANY), 0..100)) {
+ let mut m: collections::HashMap<i16, i16, _> =
+ collections::HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+ for &(ref k, ref v) in pairs {
+ m.insert(*k, *v);
+ }
+ let mut map: HashMap<i16, i16, _> = HashMap::with_hasher(BuildHasherDefault::<LolHasher>::default());
+ for (k, v) in &m {
+ map.insert(*k, *v);
+ }
+ for k in m.keys() {
+ let l = map.len();
+ assert_eq!(m.get(k).cloned(), map.get(k).cloned());
+ map.remove(k);
+ assert_eq!(None, map.get(k));
+ assert_eq!(l - 1, map.len());
+ }
+ }
+
+ #[test]
+ fn delete_and_reinsert(
+ ref input in collection::hash_map(i16::ANY, i16::ANY, 1..100),
+ index_rand in usize::ANY
+ ) {
+ let index = *input.keys().nth(index_rand % input.len()).unwrap();
+ let map1: HashMap<_, _> = HashMap::from_iter(input.clone());
+ let (val, map2) = map1.extract(&index).unwrap();
+ let map3 = map2.update(index, val);
+ for key in map2.keys() {
+ assert!(*key != index);
+ }
+ assert_eq!(map1.len(), map2.len() + 1);
+ assert_eq!(map1, map3);
+ }
+
+ #[test]
+ fn proptest_works(ref m in proptest::hash_map(0..9999, ".*", 10..100)) {
+ assert!(m.len() < 100);
+ assert!(m.len() >= 10);
+ }
+
+ #[test]
+ fn exact_size_iterator(ref m in proptest::hash_map(i16::ANY, i16::ANY, 0..100)) {
+ let mut should_be = m.len();
+ let mut it = m.iter();
+ loop {
+ assert_eq!(should_be, it.len());
+ match it.next() {
+ None => break,
+ Some(_) => should_be -= 1,
+ }
+ }
+ assert_eq!(0, it.len());
+ }
+ }
+}
diff --git a/vendor/im-rc/src/hash/mod.rs b/vendor/im-rc/src/hash/mod.rs new file mode 100644 index 000000000..27a56a5e2 --- /dev/null +++ b/vendor/im-rc/src/hash/mod.rs @@ -0,0 +1,8 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#[macro_use] +pub mod map; +#[macro_use] +pub mod set; diff --git a/vendor/im-rc/src/hash/set.rs b/vendor/im-rc/src/hash/set.rs new file mode 100644 index 000000000..edc4ad60c --- /dev/null +++ b/vendor/im-rc/src/hash/set.rs @@ -0,0 +1,1134 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +//! An unordered set. +//! +//! An immutable hash set using [hash array mapped tries] [1]. +//! +//! Most operations on this set are O(log<sub>x</sub> n) for a +//! suitably high *x* that it should be nearly O(1) for most sets. +//! Because of this, it's a great choice for a generic set as long as +//! you don't mind that values will need to implement +//! [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq]. +//! +//! Values will have a predictable order based on the hasher +//! being used. Unless otherwise specified, this will be the standard +//! [`RandomState`][std::collections::hash_map::RandomState] hasher. +//! +//! [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie +//! [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html +//! [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html +//! [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html + +use std::borrow::Borrow; +use std::cmp::Ordering; +use std::collections::hash_map::RandomState; +use std::collections::{self, BTreeSet}; +use std::fmt::{Debug, Error, Formatter}; +use std::hash::{BuildHasher, Hash, Hasher}; +use std::iter::FusedIterator; +use std::iter::{FromIterator, IntoIterator, Sum}; +use std::ops::{Add, Deref, Mul}; + +use crate::nodes::hamt::{hash_key, Drain as NodeDrain, HashValue, Iter as NodeIter, Node}; +use crate::ordset::OrdSet; +use crate::util::{Pool, PoolRef, Ref}; +use crate::Vector; + +/// Construct a set from a sequence of values. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use im::hashset::HashSet; +/// # fn main() { +/// assert_eq!( +/// hashset![1, 2, 3], +/// HashSet::from(vec![1, 2, 3]) +/// ); +/// # } +/// ``` +#[macro_export] +macro_rules! hashset { + () => { $crate::hashset::HashSet::new() }; + + ( $($x:expr),* ) => {{ + let mut l = $crate::hashset::HashSet::new(); + $( + l.insert($x); + )* + l + }}; + + ( $($x:expr ,)* ) => {{ + let mut l = $crate::hashset::HashSet::new(); + $( + l.insert($x); + )* + l + }}; +} + +def_pool!(HashSetPool<A>, Node<Value<A>>); + +/// An unordered set. +/// +/// An immutable hash set using [hash array mapped tries] [1]. +/// +/// Most operations on this set are O(log<sub>x</sub> n) for a +/// suitably high *x* that it should be nearly O(1) for most sets. +/// Because of this, it's a great choice for a generic set as long as +/// you don't mind that values will need to implement +/// [`Hash`][std::hash::Hash] and [`Eq`][std::cmp::Eq]. +/// +/// Values will have a predictable order based on the hasher +/// being used. Unless otherwise specified, this will be the standard +/// [`RandomState`][std::collections::hash_map::RandomState] hasher. +/// +/// [1]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie +/// [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html +/// [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html +/// [std::collections::hash_map::RandomState]: https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html +pub struct HashSet<A, S = RandomState> { + hasher: Ref<S>, + pool: HashSetPool<A>, + root: PoolRef<Node<Value<A>>>, + size: usize, +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)] +struct Value<A>(A); + +impl<A> Deref for Value<A> { + type Target = A; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +// FIXME lacking specialisation, we can't simply implement `HashValue` +// for `A`, we have to use the `Value<A>` indirection. +impl<A> HashValue for Value<A> +where + A: Hash + Eq, +{ + type Key = A; + + fn extract_key(&self) -> &Self::Key { + &self.0 + } + + fn ptr_eq(&self, _other: &Self) -> bool { + false + } +} + +impl<A> HashSet<A, RandomState> { + /// Construct an empty set. + #[must_use] + pub fn new() -> Self { + Self::default() + } + + /// Construct an empty set using a specific memory pool. + #[cfg(feature = "pool")] + #[must_use] + pub fn with_pool(pool: &HashSetPool<A>) -> Self { + Self { + pool: pool.clone(), + hasher: Default::default(), + size: 0, + root: PoolRef::default(&pool.0), + } + } +} + +impl<A> HashSet<A, RandomState> +where + A: Hash + Eq + Clone, +{ + /// Construct a set with a single value. + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// # use std::sync::Arc; + /// let set = HashSet::unit(123); + /// assert!(set.contains(&123)); + /// ``` + #[inline] + #[must_use] + pub fn unit(a: A) -> Self { + HashSet::new().update(a) + } +} + +impl<A, S> HashSet<A, S> { + /// Test whether a set is empty. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// assert!( + /// !hashset![1, 2, 3].is_empty() + /// ); + /// assert!( + /// HashSet::<i32>::new().is_empty() + /// ); + /// ``` + #[inline] + #[must_use] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Get the size of a set. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// assert_eq!(3, hashset![1, 2, 3].len()); + /// ``` + #[inline] + #[must_use] + pub fn len(&self) -> usize { + self.size + } + + /// Test whether two sets refer to the same content in memory. + /// + /// This is true if the two sides are references to the same set, + /// or if the two sets refer to the same root node. + /// + /// This would return true if you're comparing a set to itself, or + /// if you're comparing a set to a fresh clone of itself. + /// + /// Time: O(1) + pub fn ptr_eq(&self, other: &Self) -> bool { + std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root) + } + + /// Get a reference to the memory pool used by this set. + /// + /// Note that if you didn't specifically construct it with a pool, you'll + /// get back a reference to a pool of size 0. + #[cfg(feature = "pool")] + pub fn pool(&self) -> &HashSetPool<A> { + &self.pool + } + + /// Construct an empty hash set using the provided hasher. + #[inline] + #[must_use] + pub fn with_hasher<RS>(hasher: RS) -> Self + where + Ref<S>: From<RS>, + { + let pool = HashSetPool::default(); + let root = PoolRef::default(&pool.0); + HashSet { + size: 0, + pool, + root, + hasher: From::from(hasher), + } + } + + /// Construct an empty hash set using the provided memory pool and hasher. + #[cfg(feature = "pool")] + #[inline] + #[must_use] + pub fn with_pool_hasher<RS>(pool: &HashSetPool<A>, hasher: RS) -> Self + where + Ref<S>: From<RS>, + { + let root = PoolRef::default(&pool.0); + HashSet { + size: 0, + pool: pool.clone(), + root, + hasher: From::from(hasher), + } + } + + /// Get a reference to the set's [`BuildHasher`][BuildHasher]. + /// + /// [BuildHasher]: https://doc.rust-lang.org/std/hash/trait.BuildHasher.html + #[must_use] + pub fn hasher(&self) -> &Ref<S> { + &self.hasher + } + + /// Construct an empty hash set using the same hasher as the current hash set. + #[inline] + #[must_use] + pub fn new_from<A1>(&self) -> HashSet<A1, S> + where + A1: Hash + Eq + Clone, + { + let pool = HashSetPool::default(); + let root = PoolRef::default(&pool.0); + HashSet { + size: 0, + pool, + root, + hasher: self.hasher.clone(), + } + } + + /// Discard all elements from the set. + /// + /// This leaves you with an empty set, and all elements that + /// were previously inside it are dropped. + /// + /// Time: O(n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::HashSet; + /// let mut set = hashset![1, 2, 3]; + /// set.clear(); + /// assert!(set.is_empty()); + /// ``` + pub fn clear(&mut self) { + if !self.is_empty() { + self.root = PoolRef::default(&self.pool.0); + self.size = 0; + } + } + + /// Get an iterator over the values in a hash set. + /// + /// Please note that the order is consistent between sets using + /// the same hasher, but no other ordering guarantee is offered. + /// Items will not come out in insertion order or sort order. + /// They will, however, come out in the same order every time for + /// the same set. + #[must_use] + pub fn iter(&self) -> Iter<'_, A> { + Iter { + it: NodeIter::new(&self.root, self.size), + } + } +} + +impl<A, S> HashSet<A, S> +where + A: Hash + Eq, + S: BuildHasher, +{ + fn test_eq(&self, other: &Self) -> bool { + if self.len() != other.len() { + return false; + } + let mut seen = collections::HashSet::new(); + for value in self.iter() { + if !other.contains(value) { + return false; + } + seen.insert(value); + } + for value in other.iter() { + if !seen.contains(&value) { + return false; + } + } + true + } + + /// Test if a value is part of a set. + /// + /// Time: O(log n) + #[must_use] + pub fn contains<BA>(&self, a: &BA) -> bool + where + BA: Hash + Eq + ?Sized, + A: Borrow<BA>, + { + self.root.get(hash_key(&*self.hasher, a), 0, a).is_some() + } + + /// Test whether a set is a subset of another set, meaning that + /// all values in our set must also be in the other set. + /// + /// Time: O(n log n) + #[must_use] + pub fn is_subset<RS>(&self, other: RS) -> bool + where + RS: Borrow<Self>, + { + let o = other.borrow(); + self.iter().all(|a| o.contains(a)) + } + + /// Test whether a set is a proper subset of another set, meaning + /// that all values in our set must also be in the other set. A + /// proper subset must also be smaller than the other set. + /// + /// Time: O(n log n) + #[must_use] + pub fn is_proper_subset<RS>(&self, other: RS) -> bool + where + RS: Borrow<Self>, + { + self.len() != other.borrow().len() && self.is_subset(other) + } +} + +impl<A, S> HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher, +{ + /// Insert a value into a set. + /// + /// Time: O(log n) + #[inline] + pub fn insert(&mut self, a: A) -> Option<A> { + let hash = hash_key(&*self.hasher, &a); + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + match root.insert(&self.pool.0, hash, 0, Value(a)) { + None => { + self.size += 1; + None + } + Some(Value(old_value)) => Some(old_value), + } + } + + /// Remove a value from a set if it exists. + /// + /// Time: O(log n) + pub fn remove<BA>(&mut self, a: &BA) -> Option<A> + where + BA: Hash + Eq + ?Sized, + A: Borrow<BA>, + { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + let result = root.remove(&self.pool.0, hash_key(&*self.hasher, a), 0, a); + if result.is_some() { + self.size -= 1; + } + result.map(|v| v.0) + } + + /// Construct a new set from the current set with the given value + /// added. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// # use std::sync::Arc; + /// let set = hashset![123]; + /// assert_eq!( + /// set.update(456), + /// hashset![123, 456] + /// ); + /// ``` + #[must_use] + pub fn update(&self, a: A) -> Self { + let mut out = self.clone(); + out.insert(a); + out + } + + /// Construct a new set with the given value removed if it's in + /// the set. + /// + /// Time: O(log n) + #[must_use] + pub fn without<BA>(&self, a: &BA) -> Self + where + BA: Hash + Eq + ?Sized, + A: Borrow<BA>, + { + let mut out = self.clone(); + out.remove(a); + out + } + + /// Filter out values from a set which don't satisfy a predicate. + /// + /// This is slightly more efficient than filtering using an + /// iterator, in that it doesn't need to rehash the retained + /// values, but it still needs to reconstruct the entire tree + /// structure of the set. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::HashSet; + /// let mut set = hashset![1, 2, 3]; + /// set.retain(|v| *v > 1); + /// let expected = hashset![2, 3]; + /// assert_eq!(expected, set); + /// ``` + pub fn retain<F>(&mut self, mut f: F) + where + F: FnMut(&A) -> bool, + { + let old_root = self.root.clone(); + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + for (value, hash) in NodeIter::new(&old_root, self.size) { + if !f(value) && root.remove(&self.pool.0, hash, 0, value).is_some() { + self.size -= 1; + } + } + } + + /// Construct the union of two sets. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// let set1 = hashset!{1, 2}; + /// let set2 = hashset!{2, 3}; + /// let expected = hashset!{1, 2, 3}; + /// assert_eq!(expected, set1.union(set2)); + /// ``` + #[must_use] + pub fn union(self, other: Self) -> Self { + let (mut to_mutate, to_consume) = if self.len() >= other.len() { + (self, other) + } else { + (other, self) + }; + for value in to_consume { + to_mutate.insert(value); + } + to_mutate + } + + /// Construct the union of multiple sets. + /// + /// Time: O(n log n) + #[must_use] + pub fn unions<I>(i: I) -> Self + where + I: IntoIterator<Item = Self>, + S: Default, + { + i.into_iter().fold(Self::default(), Self::union) + } + + /// Construct the symmetric difference between two sets. + /// + /// This is an alias for the + /// [`symmetric_difference`][symmetric_difference] method. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// let set1 = hashset!{1, 2}; + /// let set2 = hashset!{2, 3}; + /// let expected = hashset!{1, 3}; + /// assert_eq!(expected, set1.difference(set2)); + /// ``` + /// + /// [symmetric_difference]: #method.symmetric_difference + #[must_use] + pub fn difference(self, other: Self) -> Self { + self.symmetric_difference(other) + } + + /// Construct the symmetric difference between two sets. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// let set1 = hashset!{1, 2}; + /// let set2 = hashset!{2, 3}; + /// let expected = hashset!{1, 3}; + /// assert_eq!(expected, set1.symmetric_difference(set2)); + /// ``` + #[must_use] + pub fn symmetric_difference(mut self, other: Self) -> Self { + for value in other { + if self.remove(&value).is_none() { + self.insert(value); + } + } + self + } + + /// Construct the relative complement between two sets, that is the set + /// of values in `self` that do not occur in `other`. + /// + /// Time: O(m log n) where m is the size of the other set + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set1 = ordset!{1, 2}; + /// let set2 = ordset!{2, 3}; + /// let expected = ordset!{1}; + /// assert_eq!(expected, set1.relative_complement(set2)); + /// ``` + #[must_use] + pub fn relative_complement(mut self, other: Self) -> Self { + for value in other { + let _ = self.remove(&value); + } + self + } + + /// Construct the intersection of two sets. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::hashset::HashSet; + /// let set1 = hashset!{1, 2}; + /// let set2 = hashset!{2, 3}; + /// let expected = hashset!{2}; + /// assert_eq!(expected, set1.intersection(set2)); + /// ``` + #[must_use] + pub fn intersection(self, other: Self) -> Self { + let mut out = self.new_from(); + for value in other { + if self.contains(&value) { + out.insert(value); + } + } + out + } +} + +// Core traits + +impl<A, S> Clone for HashSet<A, S> +where + A: Clone, +{ + /// Clone a set. + /// + /// Time: O(1) + #[inline] + fn clone(&self) -> Self { + HashSet { + hasher: self.hasher.clone(), + pool: self.pool.clone(), + root: self.root.clone(), + size: self.size, + } + } +} + +impl<A, S> PartialEq for HashSet<A, S> +where + A: Hash + Eq, + S: BuildHasher + Default, +{ + fn eq(&self, other: &Self) -> bool { + self.test_eq(other) + } +} + +impl<A, S> Eq for HashSet<A, S> +where + A: Hash + Eq, + S: BuildHasher + Default, +{ +} + +impl<A, S> PartialOrd for HashSet<A, S> +where + A: Hash + Eq + Clone + PartialOrd, + S: BuildHasher + Default, +{ + fn partial_cmp(&self, other: &Self) -> Option<Ordering> { + if Ref::ptr_eq(&self.hasher, &other.hasher) { + return self.iter().partial_cmp(other.iter()); + } + self.iter().partial_cmp(other.iter()) + } +} + +impl<A, S> Ord for HashSet<A, S> +where + A: Hash + Eq + Clone + Ord, + S: BuildHasher + Default, +{ + fn cmp(&self, other: &Self) -> Ordering { + if Ref::ptr_eq(&self.hasher, &other.hasher) { + return self.iter().cmp(other.iter()); + } + self.iter().cmp(other.iter()) + } +} + +impl<A, S> Hash for HashSet<A, S> +where + A: Hash + Eq, + S: BuildHasher + Default, +{ + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + for i in self.iter() { + i.hash(state); + } + } +} + +impl<A, S> Default for HashSet<A, S> +where + S: BuildHasher + Default, +{ + fn default() -> Self { + let pool = HashSetPool::default(); + let root = PoolRef::default(&pool.0); + HashSet { + hasher: Ref::<S>::default(), + pool, + root, + size: 0, + } + } +} + +impl<A, S> Add for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher, +{ + type Output = HashSet<A, S>; + + fn add(self, other: Self) -> Self::Output { + self.union(other) + } +} + +impl<A, S> Mul for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher, +{ + type Output = HashSet<A, S>; + + fn mul(self, other: Self) -> Self::Output { + self.intersection(other) + } +} + +impl<'a, A, S> Add for &'a HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher, +{ + type Output = HashSet<A, S>; + + fn add(self, other: Self) -> Self::Output { + self.clone().union(other.clone()) + } +} + +impl<'a, A, S> Mul for &'a HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher, +{ + type Output = HashSet<A, S>; + + fn mul(self, other: Self) -> Self::Output { + self.clone().intersection(other.clone()) + } +} + +impl<A, S> Sum for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn sum<I>(it: I) -> Self + where + I: Iterator<Item = Self>, + { + it.fold(Self::default(), |a, b| a + b) + } +} + +impl<A, S, R> Extend<R> for HashSet<A, S> +where + A: Hash + Eq + Clone + From<R>, + S: BuildHasher, +{ + fn extend<I>(&mut self, iter: I) + where + I: IntoIterator<Item = R>, + { + for value in iter { + self.insert(From::from(value)); + } + } +} + +#[cfg(not(has_specialisation))] +impl<A, S> Debug for HashSet<A, S> +where + A: Hash + Eq + Debug, + S: BuildHasher, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + f.debug_set().entries(self.iter()).finish() + } +} + +#[cfg(has_specialisation)] +impl<A, S> Debug for HashSet<A, S> +where + A: Hash + Eq + Debug, + S: BuildHasher, +{ + default fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + f.debug_set().entries(self.iter()).finish() + } +} + +#[cfg(has_specialisation)] +impl<A, S> Debug for HashSet<A, S> +where + A: Hash + Eq + Debug + Ord, + S: BuildHasher, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + f.debug_set().entries(self.iter()).finish() + } +} + +// Iterators + +/// An iterator over the elements of a set. +pub struct Iter<'a, A> { + it: NodeIter<'a, Value<A>>, +} + +impl<'a, A> Iterator for Iter<'a, A> +where + A: 'a, +{ + type Item = &'a A; + + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|(v, _)| &v.0) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + self.it.size_hint() + } +} + +impl<'a, A> ExactSizeIterator for Iter<'a, A> {} + +impl<'a, A> FusedIterator for Iter<'a, A> {} + +/// A consuming iterator over the elements of a set. +pub struct ConsumingIter<A> +where + A: Hash + Eq + Clone, +{ + it: NodeDrain<Value<A>>, +} + +impl<A> Iterator for ConsumingIter<A> +where + A: Hash + Eq + Clone, +{ + type Item = A; + + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|(v, _)| v.0) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + self.it.size_hint() + } +} + +impl<A> ExactSizeIterator for ConsumingIter<A> where A: Hash + Eq + Clone {} + +impl<A> FusedIterator for ConsumingIter<A> where A: Hash + Eq + Clone {} + +// Iterator conversions + +impl<A, RA, S> FromIterator<RA> for HashSet<A, S> +where + A: Hash + Eq + Clone + From<RA>, + S: BuildHasher + Default, +{ + fn from_iter<T>(i: T) -> Self + where + T: IntoIterator<Item = RA>, + { + let mut set = Self::default(); + for value in i { + set.insert(From::from(value)); + } + set + } +} + +impl<'a, A, S> IntoIterator for &'a HashSet<A, S> +where + A: Hash + Eq, + S: BuildHasher, +{ + type Item = &'a A; + type IntoIter = Iter<'a, A>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<A, S> IntoIterator for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher, +{ + type Item = A; + type IntoIter = ConsumingIter<Self::Item>; + + fn into_iter(self) -> Self::IntoIter { + ConsumingIter { + it: NodeDrain::new(&self.pool.0, self.root, self.size), + } + } +} + +// Conversions + +impl<'s, 'a, A, OA, SA, SB> From<&'s HashSet<&'a A, SA>> for HashSet<OA, SB> +where + A: ToOwned<Owned = OA> + Hash + Eq + ?Sized, + OA: Borrow<A> + Hash + Eq + Clone, + SA: BuildHasher, + SB: BuildHasher + Default, +{ + fn from(set: &HashSet<&A, SA>) -> Self { + set.iter().map(|a| (*a).to_owned()).collect() + } +} + +impl<'a, A, S> From<&'a [A]> for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(slice: &'a [A]) -> Self { + slice.iter().cloned().collect() + } +} + +impl<A, S> From<Vec<A>> for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(vec: Vec<A>) -> Self { + vec.into_iter().collect() + } +} + +impl<'a, A, S> From<&'a Vec<A>> for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(vec: &Vec<A>) -> Self { + vec.iter().cloned().collect() + } +} + +impl<A, S> From<Vector<A>> for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(vector: Vector<A>) -> Self { + vector.into_iter().collect() + } +} + +impl<'a, A, S> From<&'a Vector<A>> for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(vector: &Vector<A>) -> Self { + vector.iter().cloned().collect() + } +} + +impl<A, S> From<collections::HashSet<A>> for HashSet<A, S> +where + A: Eq + Hash + Clone, + S: BuildHasher + Default, +{ + fn from(hash_set: collections::HashSet<A>) -> Self { + hash_set.into_iter().collect() + } +} + +impl<'a, A, S> From<&'a collections::HashSet<A>> for HashSet<A, S> +where + A: Eq + Hash + Clone, + S: BuildHasher + Default, +{ + fn from(hash_set: &collections::HashSet<A>) -> Self { + hash_set.iter().cloned().collect() + } +} + +impl<'a, A, S> From<&'a BTreeSet<A>> for HashSet<A, S> +where + A: Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(btree_set: &BTreeSet<A>) -> Self { + btree_set.iter().cloned().collect() + } +} + +impl<A, S> From<OrdSet<A>> for HashSet<A, S> +where + A: Ord + Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(ordset: OrdSet<A>) -> Self { + ordset.into_iter().collect() + } +} + +impl<'a, A, S> From<&'a OrdSet<A>> for HashSet<A, S> +where + A: Ord + Hash + Eq + Clone, + S: BuildHasher + Default, +{ + fn from(ordset: &OrdSet<A>) -> Self { + ordset.into_iter().cloned().collect() + } +} + +// Proptest +#[cfg(any(test, feature = "proptest"))] +#[doc(hidden)] +pub mod proptest { + #[deprecated( + since = "14.3.0", + note = "proptest strategies have moved to im::proptest" + )] + pub use crate::proptest::hash_set; +} + +#[cfg(test)] +mod test { + use super::proptest::*; + use super::*; + use crate::test::LolHasher; + use ::proptest::num::i16; + use ::proptest::proptest; + use std::hash::BuildHasherDefault; + + #[test] + fn insert_failing() { + let mut set: HashSet<i16, BuildHasherDefault<LolHasher>> = Default::default(); + set.insert(14658); + assert_eq!(1, set.len()); + set.insert(-19198); + assert_eq!(2, set.len()); + } + + #[test] + fn match_strings_with_string_slices() { + let mut set: HashSet<String> = From::from(&hashset!["foo", "bar"]); + set = set.without("bar"); + assert!(!set.contains("bar")); + set.remove("foo"); + assert!(!set.contains("foo")); + } + + #[test] + fn macro_allows_trailing_comma() { + let set1 = hashset! {"foo", "bar"}; + let set2 = hashset! { + "foo", + "bar", + }; + assert_eq!(set1, set2); + } + + #[test] + fn issue_60_drain_iterator_memory_corruption() { + use crate::test::MetroHashBuilder; + for i in 0..1000 { + let mut lhs = vec![0, 1, 2]; + lhs.sort_unstable(); + + let hasher = Ref::from(MetroHashBuilder::new(i)); + let mut iset: HashSet<_, MetroHashBuilder> = HashSet::with_hasher(hasher.clone()); + for &i in &lhs { + iset.insert(i); + } + + let mut rhs: Vec<_> = iset.clone().into_iter().collect(); + rhs.sort_unstable(); + + if lhs != rhs { + println!("iteration: {}", i); + println!("seed: {}", hasher.seed()); + println!("lhs: {}: {:?}", lhs.len(), &lhs); + println!("rhs: {}: {:?}", rhs.len(), &rhs); + panic!(); + } + } + } + + proptest! { + #[test] + fn proptest_a_set(ref s in hash_set(".*", 10..100)) { + assert!(s.len() < 100); + assert!(s.len() >= 10); + } + } +} diff --git a/vendor/im-rc/src/iter.rs b/vendor/im-rc/src/iter.rs new file mode 100644 index 000000000..2327b8dd5 --- /dev/null +++ b/vendor/im-rc/src/iter.rs @@ -0,0 +1,42 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +//! Iterators over immutable data. + +/// Create an iterator of values using a function to update an owned state +/// value. +/// +/// The function is called with the current state as its argument, and should +/// return an [`Option`][std::option::Option] of a tuple of the next value to +/// yield from the iterator and the updated state. If the function returns +/// [`None`][std::option::Option::None], the iterator ends. +/// +/// # Examples +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use im::iter::unfold; +/// # use im::vector::Vector; +/// # use std::iter::FromIterator; +/// // Create an infinite stream of numbers, starting at 0. +/// let mut it = unfold(0, |i| Some((i, i + 1))); +/// +/// // Make a list out of its first five elements. +/// let numbers = Vector::from_iter(it.take(5)); +/// assert_eq!(numbers, vector![0, 1, 2, 3, 4]); +/// ``` +/// +/// [std::option::Option]: https://doc.rust-lang.org/std/option/enum.Option.html +/// [std::option::Option::None]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.None +pub fn unfold<F, S, A>(value: S, f: F) -> impl Iterator<Item = A> +where + F: Fn(S) -> Option<(A, S)>, +{ + let mut value = Some(value); + std::iter::from_fn(move || { + f(value.take().unwrap()).map(|(next, state)| { + value = Some(state); + next + }) + }) +} diff --git a/vendor/im-rc/src/lib.rs b/vendor/im-rc/src/lib.rs new file mode 100644 index 000000000..fa7a0a9eb --- /dev/null +++ b/vendor/im-rc/src/lib.rs @@ -0,0 +1,507 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +//! # Immutable Data Structures for Rust +//! +//! This library implements several of the more commonly useful immutable data +//! structures for Rust. +//! +//! ## What are immutable data structures? +//! +//! Immutable data structures are data structures which can be copied and +//! modified efficiently without altering the original. The most uncomplicated +//! example of this is the venerable [cons list][cons-list]. This crate offers a +//! selection of more modern and flexible data structures with similar +//! properties, tuned for the needs of Rust developers. +//! +//! Briefly, the following data structures are provided: +//! +//! * [Vectors][vector::Vector] based on [RRB trees][rrb-tree] +//! * [Hash maps][hashmap::HashMap]/[sets][hashset::HashSet] based on [hash +//! array mapped tries][hamt] +//! * [Ordered maps][ordmap::OrdMap]/[sets][ordset::OrdSet] based on +//! [B-trees][b-tree] +//! +//! ## Why Would I Want This? +//! +//! While immutable data structures can be a game changer for other +//! programming languages, the most obvious benefit - avoiding the +//! accidental mutation of data - is already handled so well by Rust's +//! type system that it's just not something a Rust programmer needs +//! to worry about even when using data structures that would send a +//! conscientious Clojure programmer into a panic. +//! +//! Immutable data structures offer other benefits, though, some of +//! which are useful even in a language like Rust. The most prominent +//! is *structural sharing*, which means that if two data structures +//! are mostly copies of each other, most of the memory they take up +//! will be shared between them. This implies that making copies of an +//! immutable data structure is cheap: it's really only a matter of +//! copying a pointer and increasing a reference counter, where in the +//! case of [`Vec`][std::vec::Vec] you have to allocate the same +//! amount of memory all over again and make a copy of every element +//! it contains. For immutable data structures, extra memory isn't +//! allocated until you modify either the copy or the original, and +//! then only the memory needed to record the difference. +//! +//! Another goal of this library has been the idea that you shouldn't +//! even have to think about what data structure to use in any given +//! situation, until the point where you need to start worrying about +//! optimisation - which, in practice, often never comes. Beyond the +//! shape of your data (ie. whether to use a list or a map), it should +//! be fine not to think too carefully about data structures - you can +//! just pick the one that has the right shape and it should have +//! acceptable performance characteristics for every operation you +//! might need. Specialised data structures will always be faster at +//! what they've been specialised for, but `im` aims to provide the +//! data structures which deliver the least chance of accidentally +//! using them for the wrong thing. +//! +//! For instance, [`Vec`][std::vec::Vec] beats everything at memory +//! usage, indexing and operations that happen at the back of the +//! list, but is terrible at insertion and removal, and gets worse the +//! closer to the front of the list you get. +//! [`VecDeque`][std::collections::VecDeque] adds a little bit of +//! complexity in order to make operations at the front as efficient +//! as operations at the back, but is still bad at insertion and +//! especially concatenation. [`Vector`][vector::Vector] adds another +//! bit of complexity, and could never match [`Vec`][std::vec::Vec] at +//! what it's best at, but in return every operation you can throw at +//! it can be completed in a reasonable amount of time - even normally +//! expensive operations like copying and especially concatenation are +//! reasonably cheap when using a [`Vector`][vector::Vector]. +//! +//! It should be noted, however, that because of its simplicity, +//! [`Vec`][std::vec::Vec] actually beats [`Vector`][vector::Vector] even at its +//! strongest operations at small sizes, just because modern CPUs are +//! hyperoptimised for things like copying small chunks of contiguous memory - +//! you actually need to go past a certain size (usually in the vicinity of +//! several hundred elements) before you get to the point where +//! [`Vec`][std::vec::Vec] isn't always going to be the fastest choice. +//! [`Vector`][vector::Vector] attempts to overcome this by actually just being +//! an array at very small sizes, and being able to switch efficiently to the +//! full data structure when it grows large enough. Thus, +//! [`Vector`][vector::Vector] will actually be equivalent to +//! [Vec][std::vec::Vec] until it grows past the size of a single chunk. +//! +//! The maps - [`HashMap`][hashmap::HashMap] and +//! [`OrdMap`][ordmap::OrdMap] - generally perform similarly to their +//! equivalents in the standard library, but tend to run a bit slower +//! on the basic operations ([`HashMap`][hashmap::HashMap] is almost +//! neck and neck with its counterpart, while +//! [`OrdMap`][ordmap::OrdMap] currently tends to run 2-3x slower). On +//! the other hand, they offer the cheap copy and structural sharing +//! between copies that you'd expect from immutable data structures. +//! +//! In conclusion, the aim of this library is to provide a safe +//! default choice for the most common kinds of data structures, +//! allowing you to defer careful thinking about the right data +//! structure for the job until you need to start looking for +//! optimisations - and you may find, especially for larger data sets, +//! that immutable data structures are still the right choice. +//! +//! ## Values +//! +//! Because we need to make copies of shared nodes in these data structures +//! before updating them, the values you store in them must implement +//! [`Clone`][std::clone::Clone]. For primitive values that implement +//! [`Copy`][std::marker::Copy], such as numbers, everything is fine: this is +//! the case for which the data structures are optimised, and performance is +//! going to be great. +//! +//! On the other hand, if you want to store values for which cloning is +//! expensive, or values that don't implement [`Clone`][std::clone::Clone], you +//! need to wrap them in [`Rc`][std::rc::Rc] or [`Arc`][std::sync::Arc]. Thus, +//! if you have a complex structure `BigBlobOfData` and you want to store a list +//! of them as a `Vector<BigBlobOfData>`, you should instead use a +//! `Vector<Rc<BigBlobOfData>>`, which is going to save you not only the time +//! spent cloning the big blobs of data, but also the memory spent keeping +//! multiple copies of it around, as [`Rc`][std::rc::Rc] keeps a single +//! reference counted copy around instead. +//! +//! If you're storing smaller values that aren't +//! [`Copy`][std::marker::Copy]able, you'll need to exercise judgement: if your +//! values are going to be very cheap to clone, as would be the case for short +//! [`String`][std::string::String]s or small [`Vec`][std::vec::Vec]s, you're +//! probably better off storing them directly without wrapping them in an +//! [`Rc`][std::rc::Rc], because, like the [`Rc`][std::rc::Rc], they're just +//! pointers to some data on the heap, and that data isn't expensive to clone - +//! you might actually lose more performance from the extra redirection of +//! wrapping them in an [`Rc`][std::rc::Rc] than you would from occasionally +//! cloning them. +//! +//! ### When does cloning happen? +//! +//! So when will your values actually be cloned? The easy answer is only if you +//! [`clone`][std::clone::Clone::clone] the data structure itself, and then only +//! lazily as you change it. Values are stored in tree nodes inside the data +//! structure, each node of which contains up to 64 values. When you +//! [`clone`][std::clone::Clone::clone] a data structure, nothing is actually +//! copied - it's just the reference count on the root node that's incremented, +//! to indicate that it's shared between two data structures. It's only when you +//! actually modify one of the shared data structures that nodes are cloned: +//! when you make a change somewhere in the tree, the node containing the change +//! needs to be cloned, and then its parent nodes need to be updated to contain +//! the new child node instead of the old version, and so they're cloned as +//! well. +//! +//! We can call this "lazy" cloning - if you make two copies of a data structure +//! and you never change either of them, there's never any need to clone the +//! data they contain. It's only when you start making changes that cloning +//! starts to happen, and then only on the specific tree nodes that are part of +//! the change. Note that the implications of lazily cloning the data structure +//! extend to memory usage as well as the CPU workload of copying the data +//! around - cloning an immutable data structure means both copies share the +//! same allocated memory, until you start making changes. +//! +//! Most crucially, if you never clone the data structure, the data inside it is +//! also never cloned, and in this case it acts just like a mutable data +//! structure, with minimal performance differences (but still non-zero, as we +//! still have to check for shared nodes). +//! +//! ## Data Structures +//! +//! We'll attempt to provide a comprehensive guide to the available +//! data structures below. +//! +//! ### Performance Notes +//! +//! "Big O notation" is the standard way of talking about the time +//! complexity of data structure operations. If you're not familiar +//! with big O notation, here's a quick cheat sheet: +//! +//! *O(1)* means an operation runs in constant time: it will take the +//! same time to complete regardless of the size of the data +//! structure. +//! +//! *O(n)* means an operation runs in linear time: if you double the +//! size of your data structure, the operation will take twice as long +//! to complete; if you quadruple the size, it will take four times as +//! long, etc. +//! +//! *O(log n)* means an operation runs in logarithmic time: for +//! *log<sub>2</sub>*, if you double the size of your data structure, +//! the operation will take one step longer to complete; if you +//! quadruple the size, it will need two steps more; and so on. +//! However, the data structures in this library generally run in +//! *log<sub>64</sub>* time, meaning you have to make your data +//! structure 64 times bigger to need one extra step, and 4096 times +//! bigger to need two steps. This means that, while they still count +//! as O(log n), operations on all but really large data sets will run +//! at near enough to O(1) that you won't usually notice. +//! +//! *O(n log n)* is the most expensive operation you'll see in this +//! library: it means that for every one of the *n* elements in your +//! data structure, you have to perform *log n* operations. In our +//! case, as noted above, this is often close enough to O(n) that it's +//! not usually as bad as it sounds, but even O(n) isn't cheap and the +//! cost still increases logarithmically, if slowly, as the size of +//! your data increases. O(n log n) basically means "are you sure you +//! need to do this?" +//! +//! *O(1)** means 'amortised O(1),' which means that an operation +//! usually runs in constant time but will occasionally be more +//! expensive: for instance, +//! [`Vector::push_back`][vector::Vector::push_back], if called in +//! sequence, will be O(1) most of the time but every 64th time it +//! will be O(log n), as it fills up its tail chunk and needs to +//! insert it into the tree. Please note that the O(1) with the +//! asterisk attached is not a common notation; it's just a convention +//! I've used in these docs to save myself from having to type +//! 'amortised' everywhere. +//! +//! ### Lists +//! +//! Lists are sequences of single elements which maintain the order in +//! which you inserted them. The only list in this library is +//! [`Vector`][vector::Vector], which offers the best all round +//! performance characteristics: it's pretty good at everything, even +//! if there's always another kind of list that's better at something. +//! +//! | Type | Algorithm | Constraints | Order | Push | Pop | Split | Append | Lookup | +//! | --- | --- | --- | --- | --- | --- | --- | --- | --- | +//! | [`Vector<A>`][vector::Vector] | [RRB tree][rrb-tree] | [`Clone`][std::clone::Clone] | insertion | O(1)\* | O(1)\* | O(log n) | O(log n) | O(log n) | +//! +//! ### Maps +//! +//! Maps are mappings of keys to values, where the most common read +//! operation is to find the value associated with a given key. Maps +//! may or may not have a defined order. Any given key can only occur +//! once inside a map, and setting a key to a different value will +//! overwrite the previous value. +//! +//! | Type | Algorithm | Key Constraints | Order | Insert | Remove | Lookup | +//! | --- | --- | --- | --- | --- | --- | --- | +//! | [`HashMap<K, V>`][hashmap::HashMap] | [HAMT][hamt] | [`Clone`][std::clone::Clone] + [`Hash`][std::hash::Hash] + [`Eq`][std::cmp::Eq] | undefined | O(log n) | O(log n) | O(log n) | +//! | [`OrdMap<K, V>`][ordmap::OrdMap] | [B-tree][b-tree] | [`Clone`][std::clone::Clone] + [`Ord`][std::cmp::Ord] | sorted | O(log n) | O(log n) | O(log n) | +//! +//! ### Sets +//! +//! Sets are collections of unique values, and may or may not have a +//! defined order. Their crucial property is that any given value can +//! only exist once in a given set. +//! +//! | Type | Algorithm | Constraints | Order | Insert | Remove | Lookup | +//! | --- | --- | --- | --- | --- | --- | --- | +//! | [`HashSet<A>`][hashset::HashSet] | [HAMT][hamt] | [`Clone`][std::clone::Clone] + [`Hash`][std::hash::Hash] + [`Eq`][std::cmp::Eq] | undefined | O(log n) | O(log n) | O(log n) | +//! | [`OrdSet<A>`][ordset::OrdSet] | [B-tree][b-tree] | [`Clone`][std::clone::Clone] + [`Ord`][std::cmp::Ord] | sorted | O(log n) | O(log n) | O(log n) | +//! +//! ## In-place Mutation +//! +//! All of these data structures support in-place copy-on-write +//! mutation, which means that if you're the sole user of a data +//! structure, you can update it in place without taking the +//! performance hit of making a copy of the data structure before +//! modifying it (this is about an order of magnitude faster than +//! immutable operations, almost as fast as +//! [`std::collections`][std::collections]'s mutable data structures). +//! +//! Thanks to [`Rc`][std::rc::Rc]'s reference counting, we are able to +//! determine whether a node in a data structure is being shared with +//! other data structures, or whether it's safe to mutate it in place. +//! When it's shared, we'll automatically make a copy of the node +//! before modifying it. The consequence of this is that cloning a +//! data structure becomes a lazy operation: the initial clone is +//! instant, and as you modify the cloned data structure it will clone +//! chunks only where you change them, so that if you change the +//! entire thing you will eventually have performed a full clone. +//! +//! This also gives us a couple of other optimisations for free: +//! implementations of immutable data structures in other languages +//! often have the idea of local mutation, like Clojure's transients +//! or Haskell's `ST` monad - a managed scope where you can treat an +//! immutable data structure like a mutable one, gaining a +//! considerable amount of performance because you no longer need to +//! copy your changed nodes for every operation, just the first time +//! you hit a node that's sharing structure. In Rust, we don't need to +//! think about this kind of managed scope, it's all taken care of +//! behind the scenes because of our low level access to the garbage +//! collector (which, in our case, is just a simple +//! [`Rc`][std::rc::Rc]). +//! +//! ## Thread Safety +//! +//! The data structures in the `im` crate are thread safe, through +//! [`Arc`][std::sync::Arc]. This comes with a slight performance impact, so +//! that if you prioritise speed over thread safety, you may want to use the +//! `im-rc` crate instead, which is identical to `im` except that it uses +//! [`Rc`][std::rc::Rc] instead of [`Arc`][std::sync::Arc], implying that the +//! data structures in `im-rc` do not implement [`Send`][std::marker::Send] and +//! [`Sync`][std::marker::Sync]. This yields approximately a 20-25% increase in +//! general performance. +//! +//! ## Feature Flags +//! +//! `im` comes with optional support for the following crates through Cargo +//! feature flags. You can enable them in your `Cargo.toml` file like this: +//! +//! ```no_compile +//! [dependencies] +//! im = { version = "*", features = ["proptest", "serde"] } +//! ``` +//! +//! | Feature | Description | +//! | ------- | ----------- | +//! | [`pool`](https://crates.io/crates/refpool) | Constructors and pool types for [`refpool`](https://crates.io/crates/refpool) memory pools (only available in `im-rc`) | +//! | [`proptest`](https://crates.io/crates/proptest) | Strategies for all `im` datatypes under a `proptest` namespace, eg. `im::vector::proptest::vector()` | +//! | [`quickcheck`](https://crates.io/crates/quickcheck) | [`quickcheck::Arbitrary`](https://docs.rs/quickcheck/latest/quickcheck/trait.Arbitrary.html) implementations for all `im` datatypes (not available in `im-rc`) | +//! | [`rayon`](https://crates.io/crates/rayon) | parallel iterator implementations for [`Vector`][vector::Vector] (not available in `im-rc`) | +//! | [`serde`](https://crates.io/crates/serde) | [`Serialize`](https://docs.rs/serde/latest/serde/trait.Serialize.html) and [`Deserialize`](https://docs.rs/serde/latest/serde/trait.Deserialize.html) implementations for all `im` datatypes | +//! | [`arbitrary`](https://crates.io/crates/arbitrary/) | [`arbitrary::Arbitrary`](https://docs.rs/arbitrary/latest/arbitrary/trait.Arbitrary.html) implementations for all `im` datatypes | +//! +//! [std::collections]: https://doc.rust-lang.org/std/collections/index.html +//! [std::collections::VecDeque]: https://doc.rust-lang.org/std/collections/struct.VecDeque.html +//! [std::vec::Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html +//! [std::string::String]: https://doc.rust-lang.org/std/string/struct.String.html +//! [std::rc::Rc]: https://doc.rust-lang.org/std/rc/struct.Rc.html +//! [std::sync::Arc]: https://doc.rust-lang.org/std/sync/struct.Arc.html +//! [std::cmp::Eq]: https://doc.rust-lang.org/std/cmp/trait.Eq.html +//! [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html +//! [std::clone::Clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html +//! [std::clone::Clone::clone]: https://doc.rust-lang.org/std/clone/trait.Clone.html#tymethod.clone +//! [std::marker::Copy]: https://doc.rust-lang.org/std/marker/trait.Copy.html +//! [std::hash::Hash]: https://doc.rust-lang.org/std/hash/trait.Hash.html +//! [std::marker::Send]: https://doc.rust-lang.org/std/marker/trait.Send.html +//! [std::marker::Sync]: https://doc.rust-lang.org/std/marker/trait.Sync.html +//! [hashmap::HashMap]: ./struct.HashMap.html +//! [hashset::HashSet]: ./struct.HashSet.html +//! [ordmap::OrdMap]: ./struct.OrdMap.html +//! [ordset::OrdSet]: ./struct.OrdSet.html +//! [vector::Vector]: ./struct.Vector.html +//! [vector::Vector::push_back]: ./vector/enum.Vector.html#method.push_back +//! [rrb-tree]: https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf +//! [hamt]: https://en.wikipedia.org/wiki/Hash_array_mapped_trie +//! [b-tree]: https://en.wikipedia.org/wiki/B-tree +//! [cons-list]: https://en.wikipedia.org/wiki/Cons#Lists + +#![forbid(rust_2018_idioms)] +#![deny(unsafe_code, nonstandard_style)] +#![warn(unreachable_pub, missing_docs)] +#![cfg_attr(has_specialisation, feature(specialization))] + +#[cfg(test)] +#[macro_use] +extern crate pretty_assertions; + +mod config; +mod nodes; +mod sort; +mod sync; + +#[macro_use] +mod util; + +#[macro_use] +mod ord; +pub use crate::ord::map as ordmap; +pub use crate::ord::set as ordset; + +#[macro_use] +mod hash; +pub use crate::hash::map as hashmap; +pub use crate::hash::set as hashset; + +#[macro_use] +pub mod vector; + +pub mod iter; + +#[cfg(any(test, feature = "proptest"))] +pub mod proptest; + +#[cfg(any(test, feature = "serde"))] +#[doc(hidden)] +pub mod ser; + +#[cfg(feature = "arbitrary")] +#[doc(hidden)] +pub mod arbitrary; + +#[cfg(all(threadsafe, feature = "quickcheck"))] +#[doc(hidden)] +pub mod quickcheck; + +#[cfg(any(threadsafe, not(feature = "pool")))] +mod fakepool; + +#[cfg(all(threadsafe, feature = "pool"))] +compile_error!( + "The `pool` feature is not threadsafe but you've enabled it on a threadsafe version of `im`." +); + +pub use crate::hashmap::HashMap; +pub use crate::hashset::HashSet; +pub use crate::ordmap::OrdMap; +pub use crate::ordset::OrdSet; +#[doc(inline)] +pub use crate::vector::Vector; + +#[cfg(test)] +mod test; + +#[cfg(test)] +mod tests; + +/// Update a value inside multiple levels of data structures. +/// +/// This macro takes a [`Vector`][Vector], [`OrdMap`][OrdMap] or [`HashMap`][HashMap], +/// a key or a series of keys, and a value, and returns the data structure with the +/// new value at the location described by the keys. +/// +/// If one of the keys in the path doesn't exist, the macro will panic. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use std::sync::Arc; +/// # fn main() { +/// let vec_inside_vec = vector![vector![1, 2, 3], vector![4, 5, 6]]; +/// +/// let expected = vector![vector![1, 2, 3], vector![4, 5, 1337]]; +/// +/// assert_eq!(expected, update_in![vec_inside_vec, 1 => 2, 1337]); +/// # } +/// ``` +/// +/// [Vector]: ../vector/enum.Vector.html +/// [HashMap]: ../hashmap/struct.HashMap.html +/// [OrdMap]: ../ordmap/struct.OrdMap.html +#[macro_export] +macro_rules! update_in { + ($target:expr, $path:expr => $($tail:tt) => *, $value:expr ) => {{ + let inner = $target.get($path).expect("update_in! macro: key not found in target"); + $target.update($path, update_in!(inner, $($tail) => *, $value)) + }}; + + ($target:expr, $path:expr, $value:expr) => { + $target.update($path, $value) + }; +} + +/// Get a value inside multiple levels of data structures. +/// +/// This macro takes a [`Vector`][Vector], [`OrdMap`][OrdMap] or [`HashMap`][HashMap], +/// along with a key or a series of keys, and returns the value at the location inside +/// the data structure described by the key sequence, or `None` if any of the keys didn't +/// exist. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use std::sync::Arc; +/// # fn main() { +/// let vec_inside_vec = vector![vector![1, 2, 3], vector![4, 5, 6]]; +/// +/// assert_eq!(Some(&6), get_in![vec_inside_vec, 1 => 2]); +/// # } +/// ``` +/// +/// [Vector]: ../vector/enum.Vector.html +/// [HashMap]: ../hashmap/struct.HashMap.html +/// [OrdMap]: ../ordmap/struct.OrdMap.html +#[macro_export] +macro_rules! get_in { + ($target:expr, $path:expr => $($tail:tt) => * ) => {{ + $target.get($path).and_then(|v| get_in!(v, $($tail) => *)) + }}; + + ($target:expr, $path:expr) => { + $target.get($path) + }; +} + +#[cfg(test)] +mod lib_test { + #[test] + fn update_in() { + let vector = vector![1, 2, 3, 4, 5]; + assert_eq!(vector![1, 2, 23, 4, 5], update_in!(vector, 2, 23)); + let hashmap = hashmap![1 => 1, 2 => 2, 3 => 3]; + assert_eq!( + hashmap![1 => 1, 2 => 23, 3 => 3], + update_in!(hashmap, 2, 23) + ); + let ordmap = ordmap![1 => 1, 2 => 2, 3 => 3]; + assert_eq!(ordmap![1 => 1, 2 => 23, 3 => 3], update_in!(ordmap, 2, 23)); + + let vecs = vector![vector![1, 2, 3], vector![4, 5, 6], vector![7, 8, 9]]; + let vecs_target = vector![vector![1, 2, 3], vector![4, 5, 23], vector![7, 8, 9]]; + assert_eq!(vecs_target, update_in!(vecs, 1 => 2, 23)); + } + + #[test] + fn get_in() { + let vector = vector![1, 2, 3, 4, 5]; + assert_eq!(Some(&3), get_in!(vector, 2)); + let hashmap = hashmap![1 => 1, 2 => 2, 3 => 3]; + assert_eq!(Some(&2), get_in!(hashmap, &2)); + let ordmap = ordmap![1 => 1, 2 => 2, 3 => 3]; + assert_eq!(Some(&2), get_in!(ordmap, &2)); + + let vecs = vector![vector![1, 2, 3], vector![4, 5, 6], vector![7, 8, 9]]; + assert_eq!(Some(&6), get_in!(vecs, 1 => 2)); + } +} diff --git a/vendor/im-rc/src/nodes/btree.rs b/vendor/im-rc/src/nodes/btree.rs new file mode 100644 index 000000000..84f63fa96 --- /dev/null +++ b/vendor/im-rc/src/nodes/btree.rs @@ -0,0 +1,1368 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use std::borrow::Borrow; +use std::cmp::Ordering; +use std::mem; +use std::ops::{Bound, RangeBounds}; + +use sized_chunks::Chunk; +use typenum::{Add1, Unsigned}; + +use crate::config::OrdChunkSize as NodeSize; +use crate::util::{Pool, PoolClone, PoolDefault, PoolRef}; + +use self::Insert::*; +use self::InsertAction::*; + +pub(crate) const NODE_SIZE: usize = NodeSize::USIZE; +const MEDIAN: usize = (NODE_SIZE + 1) >> 1; + +pub trait BTreeValue { + type Key; + fn ptr_eq(&self, other: &Self) -> bool; + fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self: Sized, + Self::Key: Borrow<BK>; + fn search_value(slice: &[Self], value: &Self) -> Result<usize, usize> + where + Self: Sized; + fn cmp_keys<BK>(&self, other: &BK) -> Ordering + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>; + fn cmp_values(&self, other: &Self) -> Ordering; +} + +pub(crate) struct Node<A> { + keys: Chunk<A, NodeSize>, + children: Chunk<Option<PoolRef<Node<A>>>, Add1<NodeSize>>, +} + +#[cfg(feature = "pool")] +#[allow(unsafe_code)] +unsafe fn cast_uninit<A>(target: &mut A) -> &mut mem::MaybeUninit<A> { + &mut *(target as *mut A as *mut mem::MaybeUninit<A>) +} + +#[allow(unsafe_code)] +impl<A> PoolDefault for Node<A> { + #[cfg(feature = "pool")] + unsafe fn default_uninit(target: &mut mem::MaybeUninit<Self>) { + let ptr: *mut Self = target.as_mut_ptr(); + Chunk::default_uninit(cast_uninit(&mut (*ptr).keys)); + Chunk::default_uninit(cast_uninit(&mut (*ptr).children)); + (*ptr).children.push_back(None); + } +} + +#[allow(unsafe_code)] +impl<A> PoolClone for Node<A> +where + A: Clone, +{ + #[cfg(feature = "pool")] + unsafe fn clone_uninit(&self, target: &mut mem::MaybeUninit<Self>) { + self.keys + .clone_uninit(cast_uninit(&mut (*target.as_mut_ptr()).keys)); + self.children + .clone_uninit(cast_uninit(&mut (*target.as_mut_ptr()).children)); + } +} + +pub(crate) enum Insert<A> { + Added, + Replaced(A), + Split(Node<A>, A, Node<A>), +} + +enum InsertAction<A> { + AddedAction, + ReplacedAction(A), + InsertAt, + InsertSplit(Node<A>, A, Node<A>), +} + +pub(crate) enum Remove<A> { + NoChange, + Removed(A), + Update(A, Node<A>), +} + +enum Boundary { + Lowest, + Highest, +} + +enum RemoveAction { + DeleteAt(usize), + PullUp(Boundary, usize, usize), + Merge(usize), + StealFromLeft(usize), + StealFromRight(usize), + MergeFirst(usize), + ContinueDown(usize), +} + +impl<A> Clone for Node<A> +where + A: Clone, +{ + fn clone(&self) -> Self { + Node { + keys: self.keys.clone(), + children: self.children.clone(), + } + } +} + +impl<A> Default for Node<A> { + fn default() -> Self { + Node { + keys: Chunk::new(), + children: Chunk::unit(None), + } + } +} + +impl<A> Node<A> { + #[inline] + fn has_room(&self) -> bool { + self.keys.len() < NODE_SIZE + } + + #[inline] + fn too_small(&self) -> bool { + self.keys.len() < MEDIAN + } + + #[inline] + pub(crate) fn unit(value: A) -> Self { + Node { + keys: Chunk::unit(value), + children: Chunk::pair(None, None), + } + } + + #[inline] + pub(crate) fn new_from_split( + pool: &Pool<Node<A>>, + left: Node<A>, + median: A, + right: Node<A>, + ) -> Self { + Node { + keys: Chunk::unit(median), + children: Chunk::pair( + Some(PoolRef::new(pool, left)), + Some(PoolRef::new(pool, right)), + ), + } + } + + pub(crate) fn min(&self) -> Option<&A> { + match self.children.first().unwrap() { + None => self.keys.first(), + Some(ref child) => child.min(), + } + } + + pub(crate) fn max(&self) -> Option<&A> { + match self.children.last().unwrap() { + None => self.keys.last(), + Some(ref child) => child.max(), + } + } +} + +impl<A: BTreeValue> Node<A> { + fn child_contains<BK>(&self, index: usize, key: &BK) -> bool + where + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if let Some(Some(ref child)) = self.children.get(index) { + child.lookup(key).is_some() + } else { + false + } + } + + pub(crate) fn lookup<BK>(&self, key: &BK) -> Option<&A> + where + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return None; + } + // Perform a binary search, resulting in either a match or + // the index of the first higher key, meaning we search the + // child to the left of it. + match A::search_key(&self.keys, key) { + Ok(index) => Some(&self.keys[index]), + Err(index) => match self.children[index] { + None => None, + Some(ref node) => node.lookup(key), + }, + } + } + + pub(crate) fn lookup_mut<BK>(&mut self, pool: &Pool<Node<A>>, key: &BK) -> Option<&mut A> + where + A: Clone, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return None; + } + // Perform a binary search, resulting in either a match or + // the index of the first higher key, meaning we search the + // child to the left of it. + match A::search_key(&self.keys, key) { + Ok(index) => Some(&mut self.keys[index]), + Err(index) => match self.children[index] { + None => None, + Some(ref mut child_ref) => { + let child = PoolRef::make_mut(pool, child_ref); + child.lookup_mut(pool, key) + } + }, + } + } + + pub(crate) fn lookup_prev<'a, BK>(&'a self, key: &BK) -> Option<&A> + where + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return None; + } + match A::search_key(&self.keys, key) { + Ok(index) => Some(&self.keys[index]), + Err(index) => match self.children[index] { + None if index == 0 => None, + None => self.keys.get(index - 1).map(|_| &self.keys[index - 1]), + Some(ref node) => node.lookup_prev(key), + }, + } + } + + pub(crate) fn lookup_next<'a, BK>(&'a self, key: &BK) -> Option<&A> + where + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return None; + } + match A::search_key(&self.keys, key) { + Ok(index) => Some(&self.keys[index]), + Err(index) => match self.children[index] { + None => self.keys.get(index).map(|_| &self.keys[index]), + Some(ref node) => node.lookup_next(key), + }, + } + } + + pub(crate) fn lookup_prev_mut<'a, BK>( + &'a mut self, + pool: &Pool<Node<A>>, + key: &BK, + ) -> Option<&mut A> + where + A: Clone, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return None; + } + match A::search_key(&self.keys, key) { + Ok(index) => Some(&mut self.keys[index]), + Err(index) => match self.children[index] { + None if index == 0 => None, + None => match self.keys.get(index - 1) { + Some(_) => Some(&mut self.keys[index - 1]), + None => None, + }, + Some(ref mut node) => PoolRef::make_mut(pool, node).lookup_prev_mut(pool, key), + }, + } + } + + pub(crate) fn lookup_next_mut<'a, BK>( + &'a mut self, + pool: &Pool<Node<A>>, + key: &BK, + ) -> Option<&mut A> + where + A: Clone, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return None; + } + match A::search_key(&self.keys, key) { + Ok(index) => Some(&mut self.keys[index]), + Err(index) => match self.children[index] { + None => match self.keys.get(index) { + Some(_) => Some(&mut self.keys[index]), + None => None, + }, + Some(ref mut node) => PoolRef::make_mut(pool, node).lookup_next_mut(pool, key), + }, + } + } + + pub(crate) fn path_first<'a, BK>( + &'a self, + mut path: Vec<(&'a Node<A>, usize)>, + ) -> Vec<(&'a Node<A>, usize)> + where + A: 'a, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return Vec::new(); + } + match self.children[0] { + None => { + path.push((self, 0)); + path + } + Some(ref node) => { + path.push((self, 0)); + node.path_first(path) + } + } + } + + pub(crate) fn path_last<'a, BK>( + &'a self, + mut path: Vec<(&'a Node<A>, usize)>, + ) -> Vec<(&'a Node<A>, usize)> + where + A: 'a, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return Vec::new(); + } + let end = self.children.len() - 1; + match self.children[end] { + None => { + path.push((self, end - 1)); + path + } + Some(ref node) => { + path.push((self, end)); + node.path_last(path) + } + } + } + + pub(crate) fn path_next<'a, BK>( + &'a self, + key: &BK, + mut path: Vec<(&'a Node<A>, usize)>, + ) -> Vec<(&'a Node<A>, usize)> + where + A: 'a, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return Vec::new(); + } + match A::search_key(&self.keys, key) { + Ok(index) => { + path.push((self, index)); + path + } + Err(index) => match self.children[index] { + None => match self.keys.get(index) { + Some(_) => { + path.push((self, index)); + path + } + None => { + // go back up to find next + while let Some((node, idx)) = path.last() { + if node.keys.len() == *idx { + path.pop(); + } else { + break; + } + } + path + } + }, + Some(ref node) => { + path.push((self, index)); + node.path_next(key, path) + } + }, + } + } + + pub(crate) fn path_prev<'a, BK>( + &'a self, + key: &BK, + mut path: Vec<(&'a Node<A>, usize)>, + ) -> Vec<(&'a Node<A>, usize)> + where + A: 'a, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + if self.keys.is_empty() { + return Vec::new(); + } + match A::search_key(&self.keys, key) { + Ok(index) => { + path.push((self, index)); + path + } + Err(index) => match self.children[index] { + None if index == 0 => { + // go back up to find prev + while let Some((_, idx)) = path.last_mut() { + if *idx == 0 { + path.pop(); + } else { + *idx -= 1; + break; + } + } + path + } + None => { + path.push((self, index - 1)); + path + } + Some(ref node) => { + path.push((self, index)); + node.path_prev(key, path) + } + }, + } + } + + fn split( + &mut self, + pool: &Pool<Node<A>>, + value: A, + ins_left: Option<Node<A>>, + ins_right: Option<Node<A>>, + ) -> Insert<A> { + let left_child = ins_left.map(|node| PoolRef::new(pool, node)); + let right_child = ins_right.map(|node| PoolRef::new(pool, node)); + let index = A::search_value(&self.keys, &value).unwrap_err(); + let mut left_keys; + let mut left_children; + let mut right_keys; + let mut right_children; + let median; + match index.cmp(&MEDIAN) { + Ordering::Less => { + self.children[index] = left_child; + + left_keys = Chunk::from_front(&mut self.keys, index); + left_keys.push_back(value); + left_keys.drain_from_front(&mut self.keys, MEDIAN - index - 1); + + left_children = Chunk::from_front(&mut self.children, index + 1); + left_children.push_back(right_child); + left_children.drain_from_front(&mut self.children, MEDIAN - index - 1); + + median = self.keys.pop_front(); + + right_keys = Chunk::drain_from(&mut self.keys); + right_children = Chunk::drain_from(&mut self.children); + } + Ordering::Greater => { + self.children[index] = left_child; + + left_keys = Chunk::from_front(&mut self.keys, MEDIAN); + left_children = Chunk::from_front(&mut self.children, MEDIAN + 1); + + median = self.keys.pop_front(); + + right_keys = Chunk::from_front(&mut self.keys, index - MEDIAN - 1); + right_keys.push_back(value); + right_keys.append(&mut self.keys); + + right_children = Chunk::from_front(&mut self.children, index - MEDIAN); + right_children.push_back(right_child); + right_children.append(&mut self.children); + } + Ordering::Equal => { + left_keys = Chunk::from_front(&mut self.keys, MEDIAN); + left_children = Chunk::from_front(&mut self.children, MEDIAN); + left_children.push_back(left_child); + + median = value; + + right_keys = Chunk::drain_from(&mut self.keys); + right_children = Chunk::drain_from(&mut self.children); + right_children[0] = right_child; + } + } + + debug_assert!(left_keys.len() == MEDIAN); + debug_assert!(left_children.len() == MEDIAN + 1); + debug_assert!(right_keys.len() == MEDIAN); + debug_assert!(right_children.len() == MEDIAN + 1); + + Split( + Node { + keys: left_keys, + children: left_children, + }, + median, + Node { + keys: right_keys, + children: right_children, + }, + ) + } + + fn merge(middle: A, left: Node<A>, mut right: Node<A>) -> Node<A> { + let mut keys = left.keys; + keys.push_back(middle); + keys.append(&mut right.keys); + let mut children = left.children; + children.append(&mut right.children); + Node { keys, children } + } + + fn pop_min(&mut self) -> (A, Option<PoolRef<Node<A>>>) { + let value = self.keys.pop_front(); + let child = self.children.pop_front(); + (value, child) + } + + fn pop_max(&mut self) -> (A, Option<PoolRef<Node<A>>>) { + let value = self.keys.pop_back(); + let child = self.children.pop_back(); + (value, child) + } + + fn push_min(&mut self, child: Option<PoolRef<Node<A>>>, value: A) { + self.keys.push_front(value); + self.children.push_front(child); + } + + fn push_max(&mut self, child: Option<PoolRef<Node<A>>>, value: A) { + self.keys.push_back(value); + self.children.push_back(child); + } + + pub(crate) fn insert(&mut self, pool: &Pool<Node<A>>, value: A) -> Insert<A> + where + A: Clone, + { + if self.keys.is_empty() { + self.keys.push_back(value); + self.children.push_back(None); + return Insert::Added; + } + let (median, left, right) = match A::search_value(&self.keys, &value) { + // Key exists in node + Ok(index) => { + return Insert::Replaced(mem::replace(&mut self.keys[index], value)); + } + // Key is adjacent to some key in node + Err(index) => { + let has_room = self.has_room(); + let action = match self.children[index] { + // No child at location, this is the target node. + None => InsertAt, + // Child at location, pass it on. + Some(ref mut child_ref) => { + let child = PoolRef::make_mut(pool, child_ref); + match child.insert(pool, value.clone()) { + Insert::Added => AddedAction, + Insert::Replaced(value) => ReplacedAction(value), + Insert::Split(left, median, right) => InsertSplit(left, median, right), + } + } + }; + match action { + ReplacedAction(value) => return Insert::Replaced(value), + AddedAction => { + return Insert::Added; + } + InsertAt => { + if has_room { + self.keys.insert(index, value); + self.children.insert(index + 1, None); + return Insert::Added; + } else { + (value, None, None) + } + } + InsertSplit(left, median, right) => { + if has_room { + self.children[index] = Some(PoolRef::new(pool, left)); + self.keys.insert(index, median); + self.children + .insert(index + 1, Some(PoolRef::new(pool, right))); + return Insert::Added; + } else { + (median, Some(left), Some(right)) + } + } + } + } + }; + self.split(pool, median, left, right) + } + + pub(crate) fn remove<BK>(&mut self, pool: &Pool<Node<A>>, key: &BK) -> Remove<A> + where + A: Clone, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + let index = A::search_key(&self.keys, key); + self.remove_index(pool, index, Ok(key)) + } + + fn remove_target<BK>( + &mut self, + pool: &Pool<Node<A>>, + target: Result<&BK, Boundary>, + ) -> Remove<A> + where + A: Clone, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + let index = match target { + Ok(key) => A::search_key(&self.keys, key), + Err(Boundary::Lowest) => Err(0), + Err(Boundary::Highest) => Err(self.keys.len()), + }; + self.remove_index(pool, index, target) + } + + fn remove_index<BK>( + &mut self, + pool: &Pool<Node<A>>, + index: Result<usize, usize>, + target: Result<&BK, Boundary>, + ) -> Remove<A> + where + A: Clone, + BK: Ord + ?Sized, + A::Key: Borrow<BK>, + { + let action = match index { + // Key exists in node, remove it. + Ok(index) => { + match (&self.children[index], &self.children[index + 1]) { + // If we're a leaf, just delete the entry. + (&None, &None) => RemoveAction::DeleteAt(index), + // First consider pulling either predecessor (from left) or successor (from right). + // otherwise just merge the two small children. + (&Some(ref left), &Some(ref right)) => { + if !left.too_small() { + RemoveAction::PullUp(Boundary::Highest, index, index) + } else if !right.too_small() { + RemoveAction::PullUp(Boundary::Lowest, index, index + 1) + } else { + RemoveAction::Merge(index) + } + } + _ => unreachable!("Branch missing children"), + } + } + // Target is adjacent to some key in node + Err(index) => match self.children[index] { + // We're deading with a leaf node + None => match target { + // No child at location means key isn't in map. + Ok(_key) => return Remove::NoChange, + // Looking for the lowest or highest key + Err(Boundary::Lowest) => RemoveAction::DeleteAt(0), + Err(Boundary::Highest) => RemoveAction::DeleteAt(self.keys.len() - 1), + }, + // Child at location, but it's at minimum capacity. + Some(ref child) if child.too_small() => { + let left = if index > 0 { + self.children.get(index - 1) + } else { + None + }; // index is usize and can't be negative, best make sure it never is. + match (left, self.children.get(index + 1)) { + // If it has a left sibling with capacity, steal a key from it. + (Some(&Some(ref old_left)), _) if !old_left.too_small() => { + RemoveAction::StealFromLeft(index) + } + // If it has a right sibling with capacity, same as above. + (_, Some(&Some(ref old_right))) if !old_right.too_small() => { + RemoveAction::StealFromRight(index) + } + // If it has neither, we'll have to merge it with a sibling. + // If we have a right sibling, we'll merge with that. + (_, Some(&Some(_))) => RemoveAction::MergeFirst(index), + // If we have a left sibling, we'll merge with that. + (Some(&Some(_)), _) => RemoveAction::MergeFirst(index - 1), + // If none of the above, we're in a bad state. + _ => unreachable!(), + } + } + // Child at location, and it's big enough, we can recurse down. + Some(_) => RemoveAction::ContinueDown(index), + }, + }; + match action { + RemoveAction::DeleteAt(index) => { + let pair = self.keys.remove(index); + self.children.remove(index); + Remove::Removed(pair) + } + RemoveAction::PullUp(boundary, pull_to, child_index) => { + let children = &mut self.children; + let mut update = None; + let value; + if let Some(&mut Some(ref mut child_ref)) = children.get_mut(child_index) { + let child = PoolRef::make_mut(pool, child_ref); + match child.remove_target(pool, Err(boundary)) { + Remove::NoChange => unreachable!(), + Remove::Removed(pulled_value) => { + value = self.keys.set(pull_to, pulled_value); + } + Remove::Update(pulled_value, new_child) => { + value = self.keys.set(pull_to, pulled_value); + update = Some(new_child); + } + } + } else { + unreachable!() + } + if let Some(new_child) = update { + children[child_index] = Some(PoolRef::new(pool, new_child)); + } + Remove::Removed(value) + } + RemoveAction::Merge(index) => { + let left = self.children.remove(index).unwrap(); + let right = mem::replace(&mut self.children[index], None).unwrap(); + let value = self.keys.remove(index); + let mut merged_child = Node::merge( + value, + PoolRef::unwrap_or_clone(left), + PoolRef::unwrap_or_clone(right), + ); + let (removed, new_child) = match merged_child.remove_target(pool, target) { + Remove::NoChange => unreachable!(), + Remove::Removed(removed) => (removed, merged_child), + Remove::Update(removed, updated_child) => (removed, updated_child), + }; + if self.keys.is_empty() { + // If we've depleted the root node, the merged child becomes the root. + Remove::Update(removed, new_child) + } else { + self.children[index] = Some(PoolRef::new(pool, new_child)); + Remove::Removed(removed) + } + } + RemoveAction::StealFromLeft(index) => { + let mut update = None; + let out_value; + { + let mut children = self.children.as_mut_slice()[index - 1..=index] + .iter_mut() + .map(|n| n.as_mut().unwrap()); + let left = PoolRef::make_mut(pool, children.next().unwrap()); + let child = PoolRef::make_mut(pool, children.next().unwrap()); + // Prepare the rebalanced node. + child.push_min( + left.children.last().unwrap().clone(), + self.keys[index - 1].clone(), + ); + match child.remove_target(pool, target) { + Remove::NoChange => { + // Key wasn't there, we need to revert the steal. + child.pop_min(); + return Remove::NoChange; + } + Remove::Removed(value) => { + // If we did remove something, we complete the rebalancing. + let (left_value, _) = left.pop_max(); + self.keys[index - 1] = left_value; + out_value = value; + } + Remove::Update(value, new_child) => { + // If we did remove something, we complete the rebalancing. + let (left_value, _) = left.pop_max(); + self.keys[index - 1] = left_value; + update = Some(new_child); + out_value = value; + } + } + } + if let Some(new_child) = update { + self.children[index] = Some(PoolRef::new(pool, new_child)); + } + Remove::Removed(out_value) + } + RemoveAction::StealFromRight(index) => { + let mut update = None; + let out_value; + { + let mut children = self.children.as_mut_slice()[index..index + 2] + .iter_mut() + .map(|n| n.as_mut().unwrap()); + let child = PoolRef::make_mut(pool, children.next().unwrap()); + let right = PoolRef::make_mut(pool, children.next().unwrap()); + // Prepare the rebalanced node. + child.push_max(right.children[0].clone(), self.keys[index].clone()); + match child.remove_target(pool, target) { + Remove::NoChange => { + // Key wasn't there, we need to revert the steal. + child.pop_max(); + return Remove::NoChange; + } + Remove::Removed(value) => { + // If we did remove something, we complete the rebalancing. + let (right_value, _) = right.pop_min(); + self.keys[index] = right_value; + out_value = value; + } + Remove::Update(value, new_child) => { + // If we did remove something, we complete the rebalancing. + let (right_value, _) = right.pop_min(); + self.keys[index] = right_value; + update = Some(new_child); + out_value = value; + } + } + } + if let Some(new_child) = update { + self.children[index] = Some(PoolRef::new(pool, new_child)); + } + Remove::Removed(out_value) + } + RemoveAction::MergeFirst(index) => { + if let Ok(key) = target { + // Bail early if we're looking for a not existing key + match self.keys[index].cmp_keys(key) { + Ordering::Less if !self.child_contains(index + 1, key) => { + return Remove::NoChange + } + Ordering::Greater if !self.child_contains(index, key) => { + return Remove::NoChange + } + _ => (), + } + } + let left = self.children.remove(index).unwrap(); + let right = mem::replace(&mut self.children[index], None).unwrap(); + let middle = self.keys.remove(index); + let mut merged = Node::merge( + middle, + PoolRef::unwrap_or_clone(left), + PoolRef::unwrap_or_clone(right), + ); + let update; + let out_value; + match merged.remove_target(pool, target) { + Remove::NoChange => { + panic!("nodes::btree::Node::remove: caught an absent key too late while merging"); + } + Remove::Removed(value) => { + if self.keys.is_empty() { + return Remove::Update(value, merged); + } + update = merged; + out_value = value; + } + Remove::Update(value, new_child) => { + if self.keys.is_empty() { + return Remove::Update(value, new_child); + } + update = new_child; + out_value = value; + } + } + self.children[index] = Some(PoolRef::new(pool, update)); + Remove::Removed(out_value) + } + RemoveAction::ContinueDown(index) => { + let mut update = None; + let out_value; + if let Some(&mut Some(ref mut child_ref)) = self.children.get_mut(index) { + let child = PoolRef::make_mut(pool, child_ref); + match child.remove_target(pool, target) { + Remove::NoChange => return Remove::NoChange, + Remove::Removed(value) => { + out_value = value; + } + Remove::Update(value, new_child) => { + update = Some(new_child); + out_value = value; + } + } + } else { + unreachable!() + } + if let Some(new_child) = update { + self.children[index] = Some(PoolRef::new(pool, new_child)); + } + Remove::Removed(out_value) + } + } + } +} + +// Iterator + +/// An iterator over an ordered set. +pub struct Iter<'a, A> { + fwd_path: Vec<(&'a Node<A>, usize)>, + back_path: Vec<(&'a Node<A>, usize)>, + pub(crate) remaining: usize, +} + +impl<'a, A: BTreeValue> Iter<'a, A> { + pub(crate) fn new<R, BK>(root: &'a Node<A>, size: usize, range: R) -> Self + where + R: RangeBounds<BK>, + A::Key: Borrow<BK>, + BK: Ord + ?Sized, + { + let fwd_path = match range.start_bound() { + Bound::Included(key) => root.path_next(key, Vec::new()), + Bound::Excluded(key) => { + let mut path = root.path_next(key, Vec::new()); + if let Some(value) = Self::get(&path) { + if value.cmp_keys(key) == Ordering::Equal { + Self::step_forward(&mut path); + } + } + path + } + Bound::Unbounded => root.path_first(Vec::new()), + }; + let back_path = match range.end_bound() { + Bound::Included(key) => root.path_prev(key, Vec::new()), + Bound::Excluded(key) => { + let mut path = root.path_prev(key, Vec::new()); + if let Some(value) = Self::get(&path) { + if value.cmp_keys(key) == Ordering::Equal { + Self::step_back(&mut path); + } + } + path + } + Bound::Unbounded => root.path_last(Vec::new()), + }; + Iter { + fwd_path, + back_path, + remaining: size, + } + } + + fn get(path: &[(&'a Node<A>, usize)]) -> Option<&'a A> { + match path.last() { + Some((node, index)) => Some(&node.keys[*index]), + None => None, + } + } + + fn step_forward(path: &mut Vec<(&'a Node<A>, usize)>) -> Option<&'a A> { + match path.pop() { + Some((node, index)) => { + let index = index + 1; + match node.children[index] { + // Child between current and next key -> step down + Some(ref child) => { + path.push((node, index)); + path.push((child, 0)); + let mut node = child; + while let Some(ref left_child) = node.children[0] { + path.push((left_child, 0)); + node = left_child; + } + Some(&node.keys[0]) + } + None => match node.keys.get(index) { + // Yield next key + value @ Some(_) => { + path.push((node, index)); + value + } + // No more keys -> exhausted level, step up and yield + None => loop { + match path.pop() { + None => { + return None; + } + Some((node, index)) => { + if let value @ Some(_) = node.keys.get(index) { + path.push((node, index)); + return value; + } + } + } + }, + }, + } + } + None => None, + } + } + + fn step_back(path: &mut Vec<(&'a Node<A>, usize)>) -> Option<&'a A> { + match path.pop() { + Some((node, index)) => match node.children[index] { + Some(ref child) => { + path.push((node, index)); + let mut end = child.keys.len() - 1; + path.push((child, end)); + let mut node = child; + while let Some(ref right_child) = node.children[end + 1] { + end = right_child.keys.len() - 1; + path.push((right_child, end)); + node = right_child; + } + Some(&node.keys[end]) + } + None => { + if index == 0 { + loop { + match path.pop() { + None => { + return None; + } + Some((node, index)) => { + if index > 0 { + let index = index - 1; + path.push((node, index)); + return Some(&node.keys[index]); + } + } + } + } + } else { + let index = index - 1; + path.push((node, index)); + Some(&node.keys[index]) + } + } + }, + None => None, + } + } +} + +impl<'a, A: 'a + BTreeValue> Iterator for Iter<'a, A> { + type Item = &'a A; + + fn next(&mut self) -> Option<Self::Item> { + match Iter::get(&self.fwd_path) { + None => None, + Some(value) => match Iter::get(&self.back_path) { + Some(last_value) if value.cmp_values(last_value) == Ordering::Greater => None, + None => None, + Some(_) => { + Iter::step_forward(&mut self.fwd_path); + self.remaining -= 1; + Some(value) + } + }, + } + } + + fn size_hint(&self) -> (usize, Option<usize>) { + // (0, Some(self.remaining)) + (0, None) + } +} + +impl<'a, A: 'a + BTreeValue> DoubleEndedIterator for Iter<'a, A> { + fn next_back(&mut self) -> Option<Self::Item> { + match Iter::get(&self.back_path) { + None => None, + Some(value) => match Iter::get(&self.fwd_path) { + Some(last_value) if value.cmp_values(last_value) == Ordering::Less => None, + None => None, + Some(_) => { + Iter::step_back(&mut self.back_path); + self.remaining -= 1; + Some(value) + } + }, + } + } +} + +// Consuming iterator + +enum ConsumingIterItem<A> { + Consider(Node<A>), + Yield(A), +} + +/// A consuming iterator over an ordered set. +pub struct ConsumingIter<A> { + fwd_last: Option<A>, + fwd_stack: Vec<ConsumingIterItem<A>>, + back_last: Option<A>, + back_stack: Vec<ConsumingIterItem<A>>, + remaining: usize, +} + +impl<A: Clone> ConsumingIter<A> { + pub(crate) fn new(root: &Node<A>, total: usize) -> Self { + ConsumingIter { + fwd_last: None, + fwd_stack: vec![ConsumingIterItem::Consider(root.clone())], + back_last: None, + back_stack: vec![ConsumingIterItem::Consider(root.clone())], + remaining: total, + } + } + + fn push_node(stack: &mut Vec<ConsumingIterItem<A>>, maybe_node: Option<PoolRef<Node<A>>>) { + if let Some(node) = maybe_node { + stack.push(ConsumingIterItem::Consider(PoolRef::unwrap_or_clone(node))) + } + } + + fn push(stack: &mut Vec<ConsumingIterItem<A>>, mut node: Node<A>) { + for _n in 0..node.keys.len() { + ConsumingIter::push_node(stack, node.children.pop_back()); + stack.push(ConsumingIterItem::Yield(node.keys.pop_back())); + } + ConsumingIter::push_node(stack, node.children.pop_back()); + } + + fn push_fwd(&mut self, node: Node<A>) { + ConsumingIter::push(&mut self.fwd_stack, node) + } + + fn push_node_back(&mut self, maybe_node: Option<PoolRef<Node<A>>>) { + if let Some(node) = maybe_node { + self.back_stack + .push(ConsumingIterItem::Consider(PoolRef::unwrap_or_clone(node))) + } + } + + fn push_back(&mut self, mut node: Node<A>) { + for _i in 0..node.keys.len() { + self.push_node_back(node.children.pop_front()); + self.back_stack + .push(ConsumingIterItem::Yield(node.keys.pop_front())); + } + self.push_node_back(node.children.pop_back()); + } +} + +impl<A> Iterator for ConsumingIter<A> +where + A: BTreeValue + Clone, +{ + type Item = A; + + fn next(&mut self) -> Option<Self::Item> { + loop { + match self.fwd_stack.pop() { + None => { + self.remaining = 0; + return None; + } + Some(ConsumingIterItem::Consider(node)) => self.push_fwd(node), + Some(ConsumingIterItem::Yield(value)) => { + if let Some(ref last) = self.back_last { + if value.cmp_values(last) != Ordering::Less { + self.fwd_stack.clear(); + self.back_stack.clear(); + self.remaining = 0; + return None; + } + } + self.remaining -= 1; + self.fwd_last = Some(value.clone()); + return Some(value); + } + } + } + } + + fn size_hint(&self) -> (usize, Option<usize>) { + (self.remaining, Some(self.remaining)) + } +} + +impl<A> DoubleEndedIterator for ConsumingIter<A> +where + A: BTreeValue + Clone, +{ + fn next_back(&mut self) -> Option<Self::Item> { + loop { + match self.back_stack.pop() { + None => { + self.remaining = 0; + return None; + } + Some(ConsumingIterItem::Consider(node)) => self.push_back(node), + Some(ConsumingIterItem::Yield(value)) => { + if let Some(ref last) = self.fwd_last { + if value.cmp_values(last) != Ordering::Greater { + self.fwd_stack.clear(); + self.back_stack.clear(); + self.remaining = 0; + return None; + } + } + self.remaining -= 1; + self.back_last = Some(value.clone()); + return Some(value); + } + } + } + } +} + +impl<A: BTreeValue + Clone> ExactSizeIterator for ConsumingIter<A> {} + +// DiffIter + +/// An iterator over the differences between two ordered sets. +pub struct DiffIter<'a, A> { + old_stack: Vec<IterItem<'a, A>>, + new_stack: Vec<IterItem<'a, A>>, +} + +/// A description of a difference between two ordered sets. +#[derive(PartialEq, Eq, Debug)] +pub enum DiffItem<'a, A> { + /// This value has been added to the new set. + Add(&'a A), + /// This value has been changed between the two sets. + Update { + /// The old value. + old: &'a A, + /// The new value. + new: &'a A, + }, + /// This value has been removed from the new set. + Remove(&'a A), +} + +enum IterItem<'a, A> { + Consider(&'a Node<A>), + Yield(&'a A), +} + +impl<'a, A: 'a> DiffIter<'a, A> { + pub(crate) fn new(old: &'a Node<A>, new: &'a Node<A>) -> Self { + DiffIter { + old_stack: if old.keys.is_empty() { + Vec::new() + } else { + vec![IterItem::Consider(old)] + }, + new_stack: if new.keys.is_empty() { + Vec::new() + } else { + vec![IterItem::Consider(new)] + }, + } + } + + fn push_node(stack: &mut Vec<IterItem<'a, A>>, maybe_node: &'a Option<PoolRef<Node<A>>>) { + if let Some(ref node) = *maybe_node { + stack.push(IterItem::Consider(node)) + } + } + + fn push(stack: &mut Vec<IterItem<'a, A>>, node: &'a Node<A>) { + for n in 0..node.keys.len() { + let i = node.keys.len() - n; + Self::push_node(stack, &node.children[i]); + stack.push(IterItem::Yield(&node.keys[i - 1])); + } + Self::push_node(stack, &node.children[0]); + } +} + +impl<'a, A> Iterator for DiffIter<'a, A> +where + A: 'a + BTreeValue + PartialEq, +{ + type Item = DiffItem<'a, A>; + + fn next(&mut self) -> Option<Self::Item> { + loop { + match (self.old_stack.pop(), self.new_stack.pop()) { + (None, None) => return None, + (None, Some(new)) => match new { + IterItem::Consider(new) => Self::push(&mut self.new_stack, new), + IterItem::Yield(new) => return Some(DiffItem::Add(new)), + }, + (Some(old), None) => match old { + IterItem::Consider(old) => Self::push(&mut self.old_stack, old), + IterItem::Yield(old) => return Some(DiffItem::Remove(old)), + }, + (Some(old), Some(new)) => match (old, new) { + (IterItem::Consider(old), IterItem::Consider(new)) => { + if !std::ptr::eq(old, new) { + match old.keys[0].cmp_values(&new.keys[0]) { + Ordering::Less => { + Self::push(&mut self.old_stack, old); + self.new_stack.push(IterItem::Consider(new)); + } + Ordering::Greater => { + self.old_stack.push(IterItem::Consider(old)); + Self::push(&mut self.new_stack, new); + } + Ordering::Equal => { + Self::push(&mut self.old_stack, old); + Self::push(&mut self.new_stack, new); + } + } + } + } + (IterItem::Consider(old), IterItem::Yield(new)) => { + Self::push(&mut self.old_stack, old); + self.new_stack.push(IterItem::Yield(new)); + } + (IterItem::Yield(old), IterItem::Consider(new)) => { + self.old_stack.push(IterItem::Yield(old)); + Self::push(&mut self.new_stack, new); + } + (IterItem::Yield(old), IterItem::Yield(new)) => match old.cmp_values(new) { + Ordering::Less => { + self.new_stack.push(IterItem::Yield(new)); + return Some(DiffItem::Remove(old)); + } + Ordering::Equal => { + if old != new { + return Some(DiffItem::Update { old, new }); + } + } + Ordering::Greater => { + self.old_stack.push(IterItem::Yield(old)); + return Some(DiffItem::Add(new)); + } + }, + }, + } + } + } +} diff --git a/vendor/im-rc/src/nodes/hamt.rs b/vendor/im-rc/src/nodes/hamt.rs new file mode 100644 index 000000000..945068be3 --- /dev/null +++ b/vendor/im-rc/src/nodes/hamt.rs @@ -0,0 +1,726 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use std::borrow::Borrow; +use std::fmt; +use std::hash::{BuildHasher, Hash, Hasher}; +use std::iter::FusedIterator; +use std::slice::{Iter as SliceIter, IterMut as SliceIterMut}; +use std::{mem, ptr}; + +use bitmaps::Bits; +use sized_chunks::sparse_chunk::{Iter as ChunkIter, IterMut as ChunkIterMut, SparseChunk}; +use typenum::{Pow, Unsigned, U2}; + +use crate::config::HashLevelSize; +use crate::util::{clone_ref, Pool, PoolClone, PoolDefault, PoolRef, Ref}; + +pub(crate) type HashWidth = <U2 as Pow<HashLevelSize>>::Output; +pub(crate) type HashBits = <HashWidth as Bits>::Store; // a uint of HASH_SIZE bits +pub(crate) const HASH_SHIFT: usize = HashLevelSize::USIZE; +pub(crate) const HASH_WIDTH: usize = HashWidth::USIZE; +pub(crate) const HASH_MASK: HashBits = (HASH_WIDTH - 1) as HashBits; + +pub(crate) fn hash_key<K: Hash + ?Sized, S: BuildHasher>(bh: &S, key: &K) -> HashBits { + let mut hasher = bh.build_hasher(); + key.hash(&mut hasher); + hasher.finish() as HashBits +} + +#[inline] +fn mask(hash: HashBits, shift: usize) -> HashBits { + hash >> shift & HASH_MASK +} + +pub trait HashValue { + type Key: Eq; + + fn extract_key(&self) -> &Self::Key; + fn ptr_eq(&self, other: &Self) -> bool; +} + +#[derive(Clone)] +pub(crate) struct Node<A> { + data: SparseChunk<Entry<A>, HashWidth>, +} + +#[allow(unsafe_code)] +impl<A> PoolDefault for Node<A> { + #[cfg(feature = "pool")] + unsafe fn default_uninit(target: &mut mem::MaybeUninit<Self>) { + SparseChunk::default_uninit( + target + .as_mut_ptr() + .cast::<mem::MaybeUninit<SparseChunk<Entry<A>, HashWidth>>>() + .as_mut() + .unwrap(), + ) + } +} + +#[allow(unsafe_code)] +impl<A> PoolClone for Node<A> +where + A: Clone, +{ + #[cfg(feature = "pool")] + unsafe fn clone_uninit(&self, target: &mut mem::MaybeUninit<Self>) { + self.data.clone_uninit( + target + .as_mut_ptr() + .cast::<mem::MaybeUninit<SparseChunk<Entry<A>, HashWidth>>>() + .as_mut() + .unwrap(), + ) + } +} + +#[derive(Clone)] +pub(crate) struct CollisionNode<A> { + hash: HashBits, + data: Vec<A>, +} + +pub(crate) enum Entry<A> { + Value(A, HashBits), + Collision(Ref<CollisionNode<A>>), + Node(PoolRef<Node<A>>), +} + +impl<A: Clone> Clone for Entry<A> { + fn clone(&self) -> Self { + match self { + Entry::Value(value, hash) => Entry::Value(value.clone(), *hash), + Entry::Collision(coll) => Entry::Collision(coll.clone()), + Entry::Node(node) => Entry::Node(node.clone()), + } + } +} + +impl<A> Entry<A> { + fn is_value(&self) -> bool { + matches!(self, Entry::Value(_, _)) + } + + fn unwrap_value(self) -> A { + match self { + Entry::Value(a, _) => a, + _ => panic!("nodes::hamt::Entry::unwrap_value: unwrapped a non-value"), + } + } + + fn from_node(pool: &Pool<Node<A>>, node: Node<A>) -> Self { + Entry::Node(PoolRef::new(pool, node)) + } +} + +impl<A> From<CollisionNode<A>> for Entry<A> { + fn from(node: CollisionNode<A>) -> Self { + Entry::Collision(Ref::new(node)) + } +} + +impl<A> Default for Node<A> { + fn default() -> Self { + Self::new() + } +} + +impl<A> Node<A> { + #[inline] + pub(crate) fn new() -> Self { + Node { + data: SparseChunk::new(), + } + } + + #[inline] + fn len(&self) -> usize { + self.data.len() + } + + #[inline] + pub(crate) fn unit(index: usize, value: Entry<A>) -> Self { + Node { + data: SparseChunk::unit(index, value), + } + } + + #[inline] + pub(crate) fn pair(index1: usize, value1: Entry<A>, index2: usize, value2: Entry<A>) -> Self { + Node { + data: SparseChunk::pair(index1, value1, index2, value2), + } + } + + #[inline] + pub(crate) fn single_child(pool: &Pool<Node<A>>, index: usize, node: Self) -> Self { + Node { + data: SparseChunk::unit(index, Entry::from_node(pool, node)), + } + } + + fn pop(&mut self) -> Entry<A> { + self.data.pop().unwrap() + } +} + +impl<A: HashValue> Node<A> { + fn merge_values( + pool: &Pool<Node<A>>, + value1: A, + hash1: HashBits, + value2: A, + hash2: HashBits, + shift: usize, + ) -> Self { + let index1 = mask(hash1, shift) as usize; + let index2 = mask(hash2, shift) as usize; + if index1 != index2 { + // Both values fit on the same level. + Node::pair( + index1, + Entry::Value(value1, hash1), + index2, + Entry::Value(value2, hash2), + ) + } else if shift + HASH_SHIFT >= HASH_WIDTH { + // If we're at the bottom, we've got a collision. + Node::unit( + index1, + Entry::from(CollisionNode::new(hash1, value1, value2)), + ) + } else { + // Pass the values down a level. + let node = Node::merge_values(pool, value1, hash1, value2, hash2, shift + HASH_SHIFT); + Node::single_child(pool, index1, node) + } + } + + pub(crate) fn get<BK>(&self, hash: HashBits, shift: usize, key: &BK) -> Option<&A> + where + BK: Eq + ?Sized, + A::Key: Borrow<BK>, + { + let index = mask(hash, shift) as usize; + if let Some(entry) = self.data.get(index) { + match entry { + Entry::Value(ref value, _) => { + if key == value.extract_key().borrow() { + Some(value) + } else { + None + } + } + Entry::Collision(ref coll) => coll.get(key), + Entry::Node(ref child) => child.get(hash, shift + HASH_SHIFT, key), + } + } else { + None + } + } + + pub(crate) fn get_mut<BK>( + &mut self, + pool: &Pool<Node<A>>, + hash: HashBits, + shift: usize, + key: &BK, + ) -> Option<&mut A> + where + A: Clone, + BK: Eq + ?Sized, + A::Key: Borrow<BK>, + { + let index = mask(hash, shift) as usize; + if let Some(entry) = self.data.get_mut(index) { + match entry { + Entry::Value(ref mut value, _) => { + if key == value.extract_key().borrow() { + Some(value) + } else { + None + } + } + Entry::Collision(ref mut coll_ref) => { + let coll = Ref::make_mut(coll_ref); + coll.get_mut(key) + } + Entry::Node(ref mut child_ref) => { + let child = PoolRef::make_mut(pool, child_ref); + child.get_mut(pool, hash, shift + HASH_SHIFT, key) + } + } + } else { + None + } + } + + pub(crate) fn insert( + &mut self, + pool: &Pool<Node<A>>, + hash: HashBits, + shift: usize, + value: A, + ) -> Option<A> + where + A: Clone, + { + let index = mask(hash, shift) as usize; + if let Some(entry) = self.data.get_mut(index) { + let mut fallthrough = false; + // Value is here + match entry { + // Update value or create a subtree + Entry::Value(ref current, _) => { + if current.extract_key() == value.extract_key() { + // If we have a key match, fall through to the outer + // level where we replace the current value. If we + // don't, fall through to the inner level where we merge + // some nodes. + fallthrough = true; + } + } + // There's already a collision here. + Entry::Collision(ref mut collision) => { + let coll = Ref::make_mut(collision); + return coll.insert(value); + } + Entry::Node(ref mut child_ref) => { + // Child node + let child = PoolRef::make_mut(pool, child_ref); + return child.insert(pool, hash, shift + HASH_SHIFT, value); + } + } + if !fallthrough { + // If we get here, we're looking at a value entry that needs a merge. + // We're going to be unsafe and pry it out of the reference, trusting + // that we overwrite it with the merged node. + #[allow(unsafe_code)] + let old_entry = unsafe { ptr::read(entry) }; + if shift + HASH_SHIFT >= HASH_WIDTH { + // We're at the lowest level, need to set up a collision node. + let coll = CollisionNode::new(hash, old_entry.unwrap_value(), value); + #[allow(unsafe_code)] + unsafe { + ptr::write(entry, Entry::from(coll)) + }; + } else if let Entry::Value(old_value, old_hash) = old_entry { + let node = Node::merge_values( + pool, + old_value, + old_hash, + value, + hash, + shift + HASH_SHIFT, + ); + #[allow(unsafe_code)] + unsafe { + ptr::write(entry, Entry::from_node(pool, node)) + }; + } else { + unreachable!() + } + return None; + } + } + // If we get here, either we found nothing at this index, in which case + // we insert a new entry, or we hit a value entry with the same key, in + // which case we replace it. + self.data + .insert(index, Entry::Value(value, hash)) + .map(Entry::unwrap_value) + } + + pub(crate) fn remove<BK>( + &mut self, + pool: &Pool<Node<A>>, + hash: HashBits, + shift: usize, + key: &BK, + ) -> Option<A> + where + A: Clone, + BK: Eq + ?Sized, + A::Key: Borrow<BK>, + { + let index = mask(hash, shift) as usize; + let mut new_node = None; + let mut removed = None; + if let Some(entry) = self.data.get_mut(index) { + match entry { + Entry::Value(ref value, _) => { + if key != value.extract_key().borrow() { + // Key wasn't in the map. + return None; + } // Otherwise, fall through to the removal. + } + Entry::Collision(ref mut coll_ref) => { + let coll = Ref::make_mut(coll_ref); + removed = coll.remove(key); + if coll.len() == 1 { + new_node = Some(coll.pop()); + } else { + return removed; + } + } + Entry::Node(ref mut child_ref) => { + let child = PoolRef::make_mut(pool, child_ref); + match child.remove(pool, hash, shift + HASH_SHIFT, key) { + None => { + return None; + } + Some(value) => { + if child.len() == 1 + && child.data[child.data.first_index().unwrap()].is_value() + { + // If the child now contains only a single value node, + // pull it up one level and discard the child. + removed = Some(value); + new_node = Some(child.pop()); + } else { + return Some(value); + } + } + } + } + } + } + if let Some(node) = new_node { + self.data.insert(index, node); + return removed; + } + self.data.remove(index).map(Entry::unwrap_value) + } +} + +impl<A: HashValue> CollisionNode<A> { + fn new(hash: HashBits, value1: A, value2: A) -> Self { + CollisionNode { + hash, + data: vec![value1, value2], + } + } + + #[inline] + fn len(&self) -> usize { + self.data.len() + } + + fn get<BK>(&self, key: &BK) -> Option<&A> + where + BK: Eq + ?Sized, + A::Key: Borrow<BK>, + { + for entry in &self.data { + if key == entry.extract_key().borrow() { + return Some(entry); + } + } + None + } + + fn get_mut<BK>(&mut self, key: &BK) -> Option<&mut A> + where + BK: Eq + ?Sized, + A::Key: Borrow<BK>, + { + for entry in &mut self.data { + if key == entry.extract_key().borrow() { + return Some(entry); + } + } + None + } + + fn insert(&mut self, value: A) -> Option<A> { + for item in &mut self.data { + if value.extract_key() == item.extract_key() { + return Some(mem::replace(item, value)); + } + } + self.data.push(value); + None + } + + fn remove<BK>(&mut self, key: &BK) -> Option<A> + where + BK: Eq + ?Sized, + A::Key: Borrow<BK>, + { + let mut loc = None; + for (index, item) in self.data.iter().enumerate() { + if key == item.extract_key().borrow() { + loc = Some(index); + } + } + if let Some(index) = loc { + Some(self.data.remove(index)) + } else { + None + } + } + + fn pop(&mut self) -> Entry<A> { + Entry::Value(self.data.pop().unwrap(), self.hash) + } +} + +// Ref iterator + +pub(crate) struct Iter<'a, A> { + count: usize, + stack: Vec<ChunkIter<'a, Entry<A>, HashWidth>>, + current: ChunkIter<'a, Entry<A>, HashWidth>, + collision: Option<(HashBits, SliceIter<'a, A>)>, +} + +impl<'a, A> Iter<'a, A> +where + A: 'a, +{ + pub(crate) fn new(root: &'a Node<A>, size: usize) -> Self { + Iter { + count: size, + stack: Vec::with_capacity((HASH_WIDTH / HASH_SHIFT) + 1), + current: root.data.iter(), + collision: None, + } + } +} + +impl<'a, A> Iterator for Iter<'a, A> +where + A: 'a, +{ + type Item = (&'a A, HashBits); + + fn next(&mut self) -> Option<Self::Item> { + if self.count == 0 { + return None; + } + if self.collision.is_some() { + if let Some((hash, ref mut coll)) = self.collision { + match coll.next() { + None => {} + Some(value) => { + self.count -= 1; + return Some((value, hash)); + } + } + } + self.collision = None; + return self.next(); + } + match self.current.next() { + Some(Entry::Value(value, hash)) => { + self.count -= 1; + Some((value, *hash)) + } + Some(Entry::Node(child)) => { + let current = mem::replace(&mut self.current, child.data.iter()); + self.stack.push(current); + self.next() + } + Some(Entry::Collision(coll)) => { + self.collision = Some((coll.hash, coll.data.iter())); + self.next() + } + None => match self.stack.pop() { + None => None, + Some(iter) => { + self.current = iter; + self.next() + } + }, + } + } + + fn size_hint(&self) -> (usize, Option<usize>) { + (self.count, Some(self.count)) + } +} + +impl<'a, A> ExactSizeIterator for Iter<'a, A> where A: 'a {} + +impl<'a, A> FusedIterator for Iter<'a, A> where A: 'a {} + +// Mut ref iterator + +pub(crate) struct IterMut<'a, A> { + count: usize, + pool: Pool<Node<A>>, + stack: Vec<ChunkIterMut<'a, Entry<A>, HashWidth>>, + current: ChunkIterMut<'a, Entry<A>, HashWidth>, + collision: Option<(HashBits, SliceIterMut<'a, A>)>, +} + +impl<'a, A> IterMut<'a, A> +where + A: 'a, +{ + pub(crate) fn new(pool: &Pool<Node<A>>, root: &'a mut Node<A>, size: usize) -> Self { + IterMut { + count: size, + pool: pool.clone(), + stack: Vec::with_capacity((HASH_WIDTH / HASH_SHIFT) + 1), + current: root.data.iter_mut(), + collision: None, + } + } +} + +impl<'a, A> Iterator for IterMut<'a, A> +where + A: Clone + 'a, +{ + type Item = (&'a mut A, HashBits); + + fn next(&mut self) -> Option<Self::Item> { + if self.count == 0 { + return None; + } + if self.collision.is_some() { + if let Some((hash, ref mut coll)) = self.collision { + match coll.next() { + None => {} + Some(value) => { + self.count -= 1; + return Some((value, hash)); + } + } + } + self.collision = None; + return self.next(); + } + match self.current.next() { + Some(Entry::Value(value, hash)) => { + self.count -= 1; + Some((value, *hash)) + } + Some(Entry::Node(child_ref)) => { + let child = PoolRef::make_mut(&self.pool, child_ref); + let current = mem::replace(&mut self.current, child.data.iter_mut()); + self.stack.push(current); + self.next() + } + Some(Entry::Collision(coll_ref)) => { + let coll = Ref::make_mut(coll_ref); + self.collision = Some((coll.hash, coll.data.iter_mut())); + self.next() + } + None => match self.stack.pop() { + None => None, + Some(iter) => { + self.current = iter; + self.next() + } + }, + } + } + + fn size_hint(&self) -> (usize, Option<usize>) { + (self.count, Some(self.count)) + } +} + +impl<'a, A> ExactSizeIterator for IterMut<'a, A> where A: Clone + 'a {} + +impl<'a, A> FusedIterator for IterMut<'a, A> where A: Clone + 'a {} + +// Consuming iterator + +pub(crate) struct Drain<A> +where + A: HashValue, +{ + count: usize, + pool: Pool<Node<A>>, + stack: Vec<PoolRef<Node<A>>>, + current: PoolRef<Node<A>>, + collision: Option<CollisionNode<A>>, +} + +impl<A> Drain<A> +where + A: HashValue, +{ + pub(crate) fn new(pool: &Pool<Node<A>>, root: PoolRef<Node<A>>, size: usize) -> Self { + Drain { + count: size, + pool: pool.clone(), + stack: vec![], + current: root, + collision: None, + } + } +} + +impl<A> Iterator for Drain<A> +where + A: HashValue + Clone, +{ + type Item = (A, HashBits); + + fn next(&mut self) -> Option<Self::Item> { + if self.count == 0 { + return None; + } + if self.collision.is_some() { + if let Some(ref mut coll) = self.collision { + if let Some(value) = coll.data.pop() { + self.count -= 1; + return Some((value, coll.hash)); + } + } + self.collision = None; + return self.next(); + } + match PoolRef::make_mut(&self.pool, &mut self.current).data.pop() { + Some(Entry::Value(value, hash)) => { + self.count -= 1; + Some((value, hash)) + } + Some(Entry::Collision(coll_ref)) => { + self.collision = Some(clone_ref(coll_ref)); + self.next() + } + Some(Entry::Node(child)) => { + let parent = mem::replace(&mut self.current, child); + self.stack.push(parent); + self.next() + } + None => match self.stack.pop() { + None => None, + Some(parent) => { + self.current = parent; + self.next() + } + }, + } + } + + fn size_hint(&self) -> (usize, Option<usize>) { + (self.count, Some(self.count)) + } +} + +impl<A: HashValue> ExactSizeIterator for Drain<A> where A: Clone {} + +impl<A: HashValue> FusedIterator for Drain<A> where A: Clone {} + +impl<A: HashValue + fmt::Debug> fmt::Debug for Node<A> { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> { + write!(f, "Node[ ")?; + for i in self.data.indices() { + write!(f, "{}: ", i)?; + match &self.data[i] { + Entry::Value(v, h) => write!(f, "{:?} :: {}, ", v, h)?, + Entry::Collision(c) => write!(f, "Coll{:?} :: {}", c.data, c.hash)?, + Entry::Node(n) => write!(f, "{:?}, ", n)?, + } + } + write!(f, " ]") + } +} diff --git a/vendor/im-rc/src/nodes/mod.rs b/vendor/im-rc/src/nodes/mod.rs new file mode 100644 index 000000000..24e745504 --- /dev/null +++ b/vendor/im-rc/src/nodes/mod.rs @@ -0,0 +1,16 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +pub(crate) mod btree; +pub(crate) mod hamt; +pub(crate) mod rrb; + +pub(crate) mod chunk { + use crate::config::VectorChunkSize; + use sized_chunks as sc; + use typenum::Unsigned; + + pub(crate) type Chunk<A> = sc::sized_chunk::Chunk<A, VectorChunkSize>; + pub(crate) const CHUNK_SIZE: usize = VectorChunkSize::USIZE; +} diff --git a/vendor/im-rc/src/nodes/rrb.rs b/vendor/im-rc/src/nodes/rrb.rs new file mode 100644 index 000000000..8809b84b8 --- /dev/null +++ b/vendor/im-rc/src/nodes/rrb.rs @@ -0,0 +1,1101 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use std::mem::replace; +use std::ops::Range; + +use crate::nodes::chunk::{Chunk, CHUNK_SIZE}; +use crate::util::{ + Pool, PoolRef, + Side::{self, Left, Right}, +}; +use crate::vector::RRBPool; + +use self::Entry::*; + +pub(crate) const NODE_SIZE: usize = CHUNK_SIZE; + +#[derive(Debug)] +enum Size { + Size(usize), + Table(PoolRef<Chunk<usize>>), +} + +impl Clone for Size { + fn clone(&self) -> Self { + match *self { + Size::Size(size) => Size::Size(size), + Size::Table(ref table) => Size::Table(table.clone()), + } + } +} + +impl Size { + fn size(&self) -> usize { + match self { + Size::Size(s) => *s, + Size::Table(sizes) => *sizes.last().unwrap_or(&0), + } + } + + fn is_size(&self) -> bool { + match self { + Size::Size(_) => true, + Size::Table(_) => false, + } + } + + fn table_from_size(pool: &Pool<Chunk<usize>>, level: usize, size: usize) -> Self { + let mut chunk = Chunk::new(); + let mut remaining = size; + if let Some(child_size) = NODE_SIZE.checked_pow(level as u32) { + while remaining > child_size { + let next_value = chunk.last().unwrap_or(&0) + child_size; + chunk.push_back(next_value); + remaining -= child_size; + } + } + if remaining > 0 { + let next_value = chunk.last().unwrap_or(&0) + remaining; + chunk.push_back(next_value); + } + Size::Table(PoolRef::new(pool, chunk)) + } + + fn push(&mut self, pool: &Pool<Chunk<usize>>, side: Side, level: usize, value: usize) { + let size = match self { + Size::Size(ref mut size) => match side { + Left => *size, + Right => { + *size += value; + return; + } + }, + Size::Table(ref mut size_ref) => { + let size_table = PoolRef::make_mut(pool, size_ref); + debug_assert!(size_table.len() < NODE_SIZE); + match side { + Left => { + for entry in size_table.iter_mut() { + *entry += value; + } + size_table.push_front(value); + } + Right => { + let prev = *(size_table.last().unwrap_or(&0)); + size_table.push_back(value + prev); + } + } + return; + } + }; + *self = Size::table_from_size(pool, level, size); + self.push(pool, side, level, value); + } + + fn pop(&mut self, pool: &Pool<Chunk<usize>>, side: Side, level: usize, value: usize) { + let size = match self { + Size::Size(ref mut size) => match side { + Left => *size, + Right => { + *size -= value; + return; + } + }, + Size::Table(ref mut size_ref) => { + let size_table = PoolRef::make_mut(pool, size_ref); + match side { + Left => { + let first = size_table.pop_front(); + debug_assert_eq!(value, first); + for entry in size_table.iter_mut() { + *entry -= value; + } + } + Right => { + let pop = size_table.pop_back(); + let last = size_table.last().unwrap_or(&0); + debug_assert_eq!(value, pop - last); + } + } + return; + } + }; + *self = Size::table_from_size(pool, level, size); + self.pop(pool, side, level, value); + } + + fn update(&mut self, pool: &Pool<Chunk<usize>>, index: usize, level: usize, value: isize) { + let size = match self { + Size::Size(ref size) => *size, + Size::Table(ref mut size_ref) => { + let size_table = PoolRef::make_mut(pool, size_ref); + for entry in size_table.iter_mut().skip(index) { + *entry = (*entry as isize + value) as usize; + } + return; + } + }; + *self = Size::table_from_size(pool, level, size); + self.update(pool, index, level, value); + } +} + +pub(crate) enum PushResult<A> { + Full(A, usize), + Done, +} + +pub(crate) enum PopResult<A> { + Done(A), + Drained(A), + Empty, +} + +pub(crate) enum SplitResult { + Dropped(usize), + OutOfBounds, +} + +// Invariants: Nodes only at level > 0, Values/Empty only at level = 0 +enum Entry<A> { + Nodes(Size, PoolRef<Chunk<Node<A>>>), + Values(PoolRef<Chunk<A>>), + Empty, +} + +impl<A: Clone> Clone for Entry<A> { + fn clone(&self) -> Self { + match *self { + Nodes(ref size, ref nodes) => Nodes(size.clone(), nodes.clone()), + Values(ref values) => Values(values.clone()), + Empty => Empty, + } + } +} + +impl<A: Clone> Entry<A> { + fn len(&self) -> usize { + match self { + Nodes(_, ref nodes) => nodes.len(), + Values(ref values) => values.len(), + Empty => 0, + } + } + + fn is_full(&self) -> bool { + match self { + Nodes(_, ref nodes) => nodes.is_full(), + Values(ref values) => values.is_full(), + Empty => false, + } + } + + fn unwrap_values(&self) -> &Chunk<A> { + match self { + Values(ref values) => values, + _ => panic!("rrb::Entry::unwrap_values: expected values, found nodes"), + } + } + + fn unwrap_nodes(&self) -> &Chunk<Node<A>> { + match self { + Nodes(_, ref nodes) => nodes, + _ => panic!("rrb::Entry::unwrap_nodes: expected nodes, found values"), + } + } + + fn unwrap_values_mut(&mut self, pool: &RRBPool<A>) -> &mut Chunk<A> { + match self { + Values(ref mut values) => PoolRef::make_mut(&pool.value_pool, values), + _ => panic!("rrb::Entry::unwrap_values_mut: expected values, found nodes"), + } + } + + fn unwrap_nodes_mut(&mut self, pool: &RRBPool<A>) -> &mut Chunk<Node<A>> { + match self { + Nodes(_, ref mut nodes) => PoolRef::make_mut(&pool.node_pool, nodes), + _ => panic!("rrb::Entry::unwrap_nodes_mut: expected nodes, found values"), + } + } + + fn values(self) -> Chunk<A> { + match self { + Values(values) => PoolRef::unwrap_or_clone(values), + _ => panic!("rrb::Entry::values: expected values, found nodes"), + } + } + + fn nodes(self) -> Chunk<Node<A>> { + match self { + Nodes(_, nodes) => PoolRef::unwrap_or_clone(nodes), + _ => panic!("rrb::Entry::nodes: expected nodes, found values"), + } + } + + fn is_empty_node(&self) -> bool { + matches!(self, Empty) + } +} + +// Node + +pub(crate) struct Node<A> { + children: Entry<A>, +} + +impl<A: Clone> Clone for Node<A> { + fn clone(&self) -> Self { + Node { + children: self.children.clone(), + } + } +} + +impl<A: Clone> Default for Node<A> { + fn default() -> Self { + Self::new() + } +} + +impl<A: Clone> Node<A> { + pub(crate) fn new() -> Self { + Node { children: Empty } + } + + pub(crate) fn parent(pool: &RRBPool<A>, level: usize, children: Chunk<Self>) -> Self { + let size = { + let mut size = Size::Size(0); + let mut it = children.iter().peekable(); + loop { + match it.next() { + None => break, + Some(child) => { + if size.is_size() + && !child.is_completely_dense(level - 1) + && it.peek().is_some() + { + size = Size::table_from_size(&pool.size_pool, level, size.size()); + } + size.push(&pool.size_pool, Right, level, child.len()) + } + } + } + size + }; + Node { + children: Nodes(size, PoolRef::new(&pool.node_pool, children)), + } + } + + pub(crate) fn clear_node(&mut self) { + self.children = Empty; + } + + pub(crate) fn from_chunk(pool: &RRBPool<A>, level: usize, chunk: PoolRef<Chunk<A>>) -> Self { + let node = Node { + children: Values(chunk), + }; + node.elevate(pool, level) + } + + pub(crate) fn single_parent(pool: &RRBPool<A>, node: Self) -> Self { + let size = if node.is_dense() { + Size::Size(node.len()) + } else { + let size_table = Chunk::unit(node.len()); + Size::Table(PoolRef::new(&pool.size_pool, size_table)) + }; + let children = PoolRef::new(&pool.node_pool, Chunk::unit(node)); + Node { + children: Nodes(size, children), + } + } + + pub(crate) fn join_dense(pool: &RRBPool<A>, left: Self, right: Self) -> Self { + let left_len = left.len(); + let right_len = right.len(); + Node { + children: { + let children = PoolRef::new(&pool.node_pool, Chunk::pair(left, right)); + Nodes(Size::Size(left_len + right_len), children) + }, + } + } + + pub(crate) fn elevate(self, pool: &RRBPool<A>, level_increment: usize) -> Self { + if level_increment > 0 { + Self::single_parent(pool, self.elevate(pool, level_increment - 1)) + } else { + self + } + } + + pub(crate) fn join_branches(self, pool: &RRBPool<A>, right: Self, level: usize) -> Self { + let left_len = self.len(); + let right_len = right.len(); + let size = if self.is_completely_dense(level) && right.is_dense() { + Size::Size(left_len + right_len) + } else { + let size_table = Chunk::pair(left_len, left_len + right_len); + Size::Table(PoolRef::new(&pool.size_pool, size_table)) + }; + Node { + children: { + let children = Chunk::pair(self, right); + Nodes(size, PoolRef::new(&pool.node_pool, children)) + }, + } + } + + pub(crate) fn len(&self) -> usize { + match self.children { + Entry::Nodes(Size::Size(size), _) => size, + Entry::Nodes(Size::Table(ref size_table), _) => *(size_table.last().unwrap_or(&0)), + Entry::Values(ref values) => values.len(), + Entry::Empty => 0, + } + } + + pub(crate) fn is_empty(&self) -> bool { + self.len() == 0 + } + + pub(crate) fn is_single(&self) -> bool { + self.children.len() == 1 + } + + pub(crate) fn is_full(&self) -> bool { + self.children.is_full() + } + + #[allow(dead_code)] // this is only used by tests + pub(crate) fn number_of_children(&self) -> usize { + self.children.len() + } + + pub(crate) fn first_child(&self) -> &Self { + self.children.unwrap_nodes().first().unwrap() + } + + /// True if the node is dense and so doesn't have a size table + fn is_dense(&self) -> bool { + !matches!(self.children, Entry::Nodes(Size::Table(_), _)) + } + + /// True if the node and its children are dense and at capacity + // TODO can use this technique to quickly test if a Size::Table + // should be converted back to a Size::Size + fn is_completely_dense(&self, level: usize) -> bool { + // Size of a full node is NODE_SIZE at level 0, NODE_SIZE² at + // level 1, etc. + if let Some(expected_size) = NODE_SIZE.checked_pow(level as u32 + 1) { + self.size() == expected_size + } else { + // We overflowed a usize, there's no way we can be completely dense as we know the size + // fits in a usize. + false + } + } + + #[inline] + fn size(&self) -> usize { + match self.children { + Entry::Nodes(ref size, _) => size.size(), + Entry::Values(ref values) => values.len(), + Entry::Empty => 0, + } + } + + #[inline] + fn push_size(&mut self, pool: &RRBPool<A>, side: Side, level: usize, value: usize) { + if let Entry::Nodes(ref mut size, _) = self.children { + size.push(&pool.size_pool, side, level, value) + } + } + + #[inline] + fn pop_size(&mut self, pool: &RRBPool<A>, side: Side, level: usize, value: usize) { + if let Entry::Nodes(ref mut size, _) = self.children { + size.pop(&pool.size_pool, side, level, value) + } + } + + #[inline] + fn update_size(&mut self, pool: &RRBPool<A>, index: usize, level: usize, value: isize) { + if let Entry::Nodes(ref mut size, _) = self.children { + size.update(&pool.size_pool, index, level, value) + } + } + + fn size_up_to(&self, level: usize, index: usize) -> usize { + if let Entry::Nodes(ref size, _) = self.children { + if index == 0 { + 0 + } else { + match size { + Size::Table(ref size_table) => size_table[index - 1], + Size::Size(_) => index * NODE_SIZE.pow(level as u32), + } + } + } else { + index + } + } + + fn index_in(&self, level: usize, index: usize) -> Option<usize> { + let mut target_idx = if let Some(child_size) = NODE_SIZE.checked_pow(level as u32) { + index / child_size + } else { + 0 + }; + if target_idx >= self.children.len() { + return None; + } + if let Entry::Nodes(Size::Table(ref size_table), _) = self.children { + while size_table[target_idx] <= index { + target_idx += 1; + if target_idx >= size_table.len() { + return None; + } + } + } + Some(target_idx) + } + + pub(crate) fn index(&self, level: usize, index: usize) -> &A { + if level == 0 { + &self.children.unwrap_values()[index] + } else { + let target_idx = self.index_in(level, index).unwrap(); + self.children.unwrap_nodes()[target_idx] + .index(level - 1, index - self.size_up_to(level, target_idx)) + } + } + + pub(crate) fn index_mut(&mut self, pool: &RRBPool<A>, level: usize, index: usize) -> &mut A { + if level == 0 { + &mut self.children.unwrap_values_mut(pool)[index] + } else { + let target_idx = self.index_in(level, index).unwrap(); + let offset = index - self.size_up_to(level, target_idx); + let child = &mut self.children.unwrap_nodes_mut(pool)[target_idx]; + child.index_mut(pool, level - 1, offset) + } + } + + pub(crate) fn lookup_chunk( + &self, + level: usize, + base: usize, + index: usize, + ) -> (Range<usize>, *const Chunk<A>) { + if level == 0 { + ( + base..(base + self.children.len()), + self.children.unwrap_values() as *const Chunk<A>, + ) + } else { + let target_idx = self.index_in(level, index).unwrap(); + let offset = self.size_up_to(level, target_idx); + let child_base = base + offset; + let children = self.children.unwrap_nodes(); + let child = &children[target_idx]; + child.lookup_chunk(level - 1, child_base, index - offset) + } + } + + pub(crate) fn lookup_chunk_mut( + &mut self, + pool: &RRBPool<A>, + level: usize, + base: usize, + index: usize, + ) -> (Range<usize>, *mut Chunk<A>) { + if level == 0 { + ( + base..(base + self.children.len()), + self.children.unwrap_values_mut(pool) as *mut Chunk<A>, + ) + } else { + let target_idx = self.index_in(level, index).unwrap(); + let offset = self.size_up_to(level, target_idx); + let child_base = base + offset; + let children = self.children.unwrap_nodes_mut(pool); + let child = &mut children[target_idx]; + child.lookup_chunk_mut(pool, level - 1, child_base, index - offset) + } + } + + fn push_child_node(&mut self, pool: &RRBPool<A>, side: Side, child: Node<A>) { + let children = self.children.unwrap_nodes_mut(pool); + match side { + Left => children.push_front(child), + Right => children.push_back(child), + } + } + + fn pop_child_node(&mut self, pool: &RRBPool<A>, side: Side) -> Node<A> { + let children = self.children.unwrap_nodes_mut(pool); + match side { + Left => children.pop_front(), + Right => children.pop_back(), + } + } + + pub(crate) fn push_chunk( + &mut self, + pool: &RRBPool<A>, + level: usize, + side: Side, + mut chunk: PoolRef<Chunk<A>>, + ) -> PushResult<PoolRef<Chunk<A>>> { + if chunk.is_empty() { + return PushResult::Done; + } + let is_full = self.is_full(); + if level == 0 { + if self.children.is_empty_node() { + self.push_size(pool, side, level, chunk.len()); + self.children = Values(chunk); + PushResult::Done + } else { + let values = self.children.unwrap_values_mut(pool); + if values.len() + chunk.len() <= NODE_SIZE { + let chunk = PoolRef::make_mut(&pool.value_pool, &mut chunk); + match side { + Side::Left => { + chunk.append(values); + values.append(chunk); + } + Side::Right => values.append(chunk), + } + PushResult::Done + } else { + PushResult::Full(chunk, 0) + } + } + } else if level == 1 { + // If rightmost existing node has any room, merge as much as + // possible over from the new node. + let num_drained = match side { + Side::Right => { + if let Entry::Nodes(ref mut size, ref mut children) = self.children { + let rightmost = PoolRef::make_mut(&pool.node_pool, children) + .last_mut() + .unwrap(); + let old_size = rightmost.len(); + let chunk = PoolRef::make_mut(&pool.value_pool, &mut chunk); + let values = rightmost.children.unwrap_values_mut(pool); + let to_drain = chunk.len().min(NODE_SIZE - values.len()); + values.drain_from_front(chunk, to_drain); + size.pop(&pool.size_pool, Side::Right, level, old_size); + size.push(&pool.size_pool, Side::Right, level, values.len()); + to_drain + } else { + 0 + } + } + Side::Left => { + if let Entry::Nodes(ref mut size, ref mut children) = self.children { + let leftmost = PoolRef::make_mut(&pool.node_pool, children) + .first_mut() + .unwrap(); + let old_size = leftmost.len(); + let chunk = PoolRef::make_mut(&pool.value_pool, &mut chunk); + let values = leftmost.children.unwrap_values_mut(pool); + let to_drain = chunk.len().min(NODE_SIZE - values.len()); + values.drain_from_back(chunk, to_drain); + size.pop(&pool.size_pool, Side::Left, level, old_size); + size.push(&pool.size_pool, Side::Left, level, values.len()); + to_drain + } else { + 0 + } + } + }; + if is_full { + PushResult::Full(chunk, num_drained) + } else { + // If the chunk is empty after being drained, there might be + // more space in existing chunks. To keep the middle dense, we + // do not add it here. + if !chunk.is_empty() { + if side == Left && chunk.len() < NODE_SIZE { + if let Entry::Nodes(ref mut size, _) = self.children { + if let Size::Size(value) = *size { + *size = Size::table_from_size(&pool.size_pool, level, value); + } + } + } + self.push_size(pool, side, level, chunk.len()); + self.push_child_node(pool, side, Node::from_chunk(pool, 0, chunk)); + } + PushResult::Done + } + } else { + let chunk_size = chunk.len(); + let index = match side { + Right => self.children.len() - 1, + Left => 0, + }; + let new_child = { + let children = self.children.unwrap_nodes_mut(pool); + let child = &mut children[index]; + match child.push_chunk(pool, level - 1, side, chunk) { + PushResult::Done => None, + PushResult::Full(chunk, num_drained) => { + // Our chunk was too large for `child`, so it could not + // be pushed there. However, exactly `num_drained` + // elements were added to the child. We need to reflect + // that change in the size field of the node. + match side { + Right => match self.children { + Entry::Nodes(Size::Table(ref mut sizes), _) => { + let sizes = PoolRef::make_mut(&pool.size_pool, sizes); + sizes[index] += num_drained; + } + Entry::Nodes(Size::Size(ref mut size), _) => { + *size += num_drained; + } + Entry::Values(_) | Entry::Empty => (), + }, + Left => { + self.update_size(pool, 0, level, num_drained as isize); + } + } + if is_full { + return PushResult::Full(chunk, 0); + } else { + Some(Node::from_chunk(pool, level - 1, chunk)) + } + } + } + }; + match new_child { + None => { + self.update_size(pool, index, level, chunk_size as isize); + PushResult::Done + } + Some(child) => { + if side == Left && chunk_size < NODE_SIZE { + if let Entry::Nodes(ref mut size, _) = self.children { + if let Size::Size(value) = *size { + *size = Size::table_from_size(&pool.size_pool, level, value); + } + } + } + self.push_size(pool, side, level, child.len()); + self.push_child_node(pool, side, child); + PushResult::Done + } + } + } + } + + pub(crate) fn pop_chunk( + &mut self, + pool: &RRBPool<A>, + level: usize, + side: Side, + ) -> PopResult<PoolRef<Chunk<A>>> { + if self.is_empty() { + return PopResult::Empty; + } + if level == 0 { + // should only get here if the tree is just one leaf node + match replace(&mut self.children, Empty) { + Values(chunk) => PopResult::Drained(chunk), + Empty => panic!("rrb::Node::pop_chunk: non-empty tree with Empty leaf"), + Nodes(_, _) => panic!("rrb::Node::pop_chunk: branch node at leaf"), + } + } else if level == 1 { + let child_node = self.pop_child_node(pool, side); + self.pop_size(pool, side, level, child_node.len()); + let chunk = match child_node.children { + Values(ref chunk) => chunk.clone(), + Empty => panic!("rrb::Node::pop_chunk: non-empty tree with Empty leaf"), + Nodes(_, _) => panic!("rrb::Node::pop_chunk: branch node at leaf"), + }; + if self.is_empty() { + PopResult::Drained(chunk) + } else { + PopResult::Done(chunk) + } + } else { + let index = match side { + Right => self.children.len() - 1, + Left => 0, + }; + let mut drained = false; + let chunk = { + let children = self.children.unwrap_nodes_mut(pool); + let child = &mut children[index]; + match child.pop_chunk(pool, level - 1, side) { + PopResult::Empty => return PopResult::Empty, + PopResult::Done(chunk) => chunk, + PopResult::Drained(chunk) => { + drained = true; + chunk + } + } + }; + if drained { + self.pop_size(pool, side, level, chunk.len()); + self.pop_child_node(pool, side); + if self.is_empty() { + PopResult::Drained(chunk) + } else { + PopResult::Done(chunk) + } + } else { + self.update_size(pool, index, level, -(chunk.len() as isize)); + PopResult::Done(chunk) + } + } + } + + pub(crate) fn split( + &mut self, + pool: &RRBPool<A>, + level: usize, + drop_side: Side, + index: usize, + ) -> SplitResult { + if index == 0 && drop_side == Side::Left { + // Dropped nothing + return SplitResult::Dropped(0); + } + if level > 0 && index == 0 && drop_side == Side::Right { + // Dropped everything + let dropped = if let Entry::Nodes(ref size, _) = self.children { + size.size() + } else { + panic!("leaf node at non-leaf level!"); + }; + self.children = Entry::Empty; + return SplitResult::Dropped(dropped); + } + let mut dropped; + if level == 0 { + let len = self.children.len(); + if index >= len { + return SplitResult::OutOfBounds; + } + let children = self.children.unwrap_values_mut(pool); + match drop_side { + Side::Left => children.drop_left(index), + Side::Right => children.drop_right(index), + } + SplitResult::Dropped(match drop_side { + Left => index, + Right => len - index, + }) + } else if let Some(target_idx) = self.index_in(level, index) { + let size_up_to = self.size_up_to(level, target_idx); + let (size, children) = + if let Entry::Nodes(ref mut size, ref mut children) = self.children { + (size, PoolRef::make_mut(&pool.node_pool, children)) + } else { + unreachable!() + }; + let child_gone = 0 == { + let child_node = &mut children[target_idx]; + match child_node.split(pool, level - 1, drop_side, index - size_up_to) { + SplitResult::OutOfBounds => return SplitResult::OutOfBounds, + SplitResult::Dropped(amount) => dropped = amount, + } + child_node.len() + }; + match drop_side { + Left => { + let mut drop_from = target_idx; + if child_gone { + drop_from += 1; + } + children.drop_left(drop_from); + if let Size::Size(value) = *size { + *size = Size::table_from_size(&pool.size_pool, level, value); + } + let size_table = if let Size::Table(ref mut size_ref) = size { + PoolRef::make_mut(&pool.size_pool, size_ref) + } else { + unreachable!() + }; + let dropped_size = if target_idx > 0 { + size_table[target_idx - 1] + } else { + 0 + }; + dropped += dropped_size; + size_table.drop_left(drop_from); + for i in size_table.iter_mut() { + *i -= dropped; + } + } + Right => { + let at_last = target_idx == children.len() - 1; + let mut drop_from = target_idx + 1; + if child_gone { + drop_from -= 1; + } + if drop_from < children.len() { + children.drop_right(drop_from); + } + match size { + Size::Size(ref mut size) if at_last => { + *size -= dropped; + } + Size::Size(ref mut size) => { + let size_per_child = NODE_SIZE.pow(level as u32); + let remainder = (target_idx + 1) * size_per_child; + let new_size = remainder - dropped; + if new_size < *size { + dropped = *size - new_size; + *size = new_size; + } else { + unreachable!( + "this means node is empty, should be caught at start of method" + ); + } + } + Size::Table(ref mut size_ref) => { + let size_table = PoolRef::make_mut(&pool.size_pool, size_ref); + let dropped_size = + size_table[size_table.len() - 1] - size_table[target_idx]; + if drop_from < size_table.len() { + size_table.drop_right(drop_from); + } + if !child_gone { + size_table[target_idx] -= dropped; + } + dropped += dropped_size; + } + } + } + } + SplitResult::Dropped(dropped) + } else { + SplitResult::OutOfBounds + } + } + + fn merge_leaves(pool: &RRBPool<A>, mut left: Self, mut right: Self) -> Self { + if left.children.is_empty_node() { + // Left is empty, just use right + Self::single_parent(pool, right) + } else if right.children.is_empty_node() { + // Right is empty, just use left + Self::single_parent(pool, left) + } else { + { + let left_vals = left.children.unwrap_values_mut(pool); + let left_len = left_vals.len(); + let right_vals = right.children.unwrap_values_mut(pool); + let right_len = right_vals.len(); + if left_len + right_len <= NODE_SIZE { + left_vals.append(right_vals); + } else { + let count = right_len.min(NODE_SIZE - left_len); + left_vals.drain_from_front(right_vals, count); + } + } + if right.is_empty() { + Self::single_parent(pool, left) + } else { + Self::join_dense(pool, left, right) + } + } + } + + fn merge_rebalance( + pool: &RRBPool<A>, + level: usize, + left: Self, + middle: Self, + right: Self, + ) -> Self { + let left_nodes = left.children.nodes().into_iter(); + let middle_nodes = middle.children.nodes().into_iter(); + let right_nodes = right.children.nodes().into_iter(); + let mut subtree_still_balanced = true; + let mut next_leaf = Chunk::new(); + let mut next_node = Chunk::new(); + let mut next_subtree = Chunk::new(); + let mut root = Chunk::new(); + + for subtree in left_nodes.chain(middle_nodes).chain(right_nodes) { + if subtree.is_empty() { + continue; + } + if subtree.is_completely_dense(level) && subtree_still_balanced { + root.push_back(subtree); + continue; + } + subtree_still_balanced = false; + + if level == 1 { + for value in subtree.children.values() { + next_leaf.push_back(value); + if next_leaf.is_full() { + let new_node = + Node::from_chunk(pool, 0, PoolRef::new(&pool.value_pool, next_leaf)); + next_subtree.push_back(new_node); + next_leaf = Chunk::new(); + if next_subtree.is_full() { + let new_subtree = Node::parent(pool, level, next_subtree); + root.push_back(new_subtree); + next_subtree = Chunk::new(); + } + } + } + } else { + for node in subtree.children.nodes() { + next_node.push_back(node); + if next_node.is_full() { + let new_node = Node::parent(pool, level - 1, next_node); + next_subtree.push_back(new_node); + next_node = Chunk::new(); + if next_subtree.is_full() { + let new_subtree = Node::parent(pool, level, next_subtree); + root.push_back(new_subtree); + next_subtree = Chunk::new(); + } + } + } + } + } + if !next_leaf.is_empty() { + let new_node = Node::from_chunk(pool, 0, PoolRef::new(&pool.value_pool, next_leaf)); + next_subtree.push_back(new_node); + } + if !next_node.is_empty() { + let new_node = Node::parent(pool, level - 1, next_node); + next_subtree.push_back(new_node); + } + if !next_subtree.is_empty() { + let new_subtree = Node::parent(pool, level, next_subtree); + root.push_back(new_subtree); + } + Node::parent(pool, level + 1, root) + } + + pub(crate) fn merge(pool: &RRBPool<A>, mut left: Self, mut right: Self, level: usize) -> Self { + if level == 0 { + Self::merge_leaves(pool, left, right) + } else { + let merged = { + if level == 1 { + // We're going to rebalance all the leaves anyway, there's + // no need for a middle at level 1 + Node::parent(pool, 0, Chunk::new()) + } else { + let left_last = + if let Entry::Nodes(ref mut size, ref mut children) = left.children { + let node = PoolRef::make_mut(&pool.node_pool, children).pop_back(); + if !node.is_empty() { + size.pop(&pool.size_pool, Side::Right, level, node.len()); + } + node + } else { + panic!("expected nodes, found entries or empty"); + }; + let right_first = + if let Entry::Nodes(ref mut size, ref mut children) = right.children { + let node = PoolRef::make_mut(&pool.node_pool, children).pop_front(); + if !node.is_empty() { + size.pop(&pool.size_pool, Side::Left, level, node.len()); + } + node + } else { + panic!("expected nodes, found entries or empty"); + }; + Self::merge(pool, left_last, right_first, level - 1) + } + }; + Self::merge_rebalance(pool, level, left, merged, right) + } + } + + #[cfg(any(test, feature = "debug"))] + pub(crate) fn assert_invariants(&self, level: usize) -> usize { + // Verifies that the size table matches reality. + match self.children { + Entry::Empty => 0, + Entry::Values(ref values) => { + // An empty value node is pointless and should never occur. + assert_ne!(0, values.len()); + // Value nodes should only occur at level 0. + assert_eq!(0, level); + values.len() + } + Entry::Nodes(ref size, ref children) => { + // A parent node with no children should never occur. + assert_ne!(0, children.len()); + // Parent nodes should never occur at level 0. + assert_ne!(0, level); + let mut lengths = Vec::new(); + let should_be_dense = matches!(size, Size::Size(_)); + for (index, child) in children.iter().enumerate() { + let len = child.assert_invariants(level - 1); + if should_be_dense && index < children.len() - 1 { + // Assert that non-end nodes without size tables are full. + assert_eq!(len, NODE_SIZE.pow(level as u32)); + } + lengths.push(len); + } + match size { + Size::Size(size) => { + let total: usize = lengths.iter().sum(); + assert_eq!(*size, total); + } + Size::Table(ref table) => { + assert_eq!(table.iter().len(), children.len()); + for (index, current) in table.iter().enumerate() { + let expected: usize = lengths.iter().take(index + 1).sum(); + assert_eq!(expected, *current); + } + } + } + lengths.iter().sum() + } + } + } + + // pub fn print<W>(&self, f: &mut W, indent: usize, level: usize) -> Result<(), fmt::Error> + // where + // W: fmt::Write, + // A: fmt::Debug, + // { + // print_indent(f, indent)?; + // if level == 0 { + // if self.children.is_empty_node() { + // writeln!(f, "Leaf: EMPTY") + // } else { + // writeln!(f, "Leaf: {:?}", self.children.unwrap_values()) + // } + // } else { + // match &self.children { + // Entry::Nodes(size, children) => { + // writeln!(f, "Node level {} size_table {:?}", level, size)?; + // for child in children.iter() { + // child.print(f, indent + 4, level - 1)?; + // } + // Ok(()) + // } + // _ => unreachable!(), + // } + // } + // } +} + +// fn print_indent<W>(f: &mut W, indent: usize) -> Result<(), fmt::Error> +// where +// W: fmt::Write, +// { +// for _i in 0..indent { +// write!(f, " ")?; +// } +// Ok(()) +// } diff --git a/vendor/im-rc/src/ord/map.rs b/vendor/im-rc/src/ord/map.rs new file mode 100644 index 000000000..ad87932dc --- /dev/null +++ b/vendor/im-rc/src/ord/map.rs @@ -0,0 +1,2649 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +//! An ordered map. +//! +//! An immutable ordered map implemented as a [B-tree] [1]. +//! +//! Most operations on this type of map are O(log n). A +//! [`HashMap`][hashmap::HashMap] is usually a better choice for +//! performance, but the `OrdMap` has the advantage of only requiring +//! an [`Ord`][std::cmp::Ord] constraint on the key, and of being +//! ordered, so that keys always come out from lowest to highest, +//! where a [`HashMap`][hashmap::HashMap] has no guaranteed ordering. +//! +//! [1]: https://en.wikipedia.org/wiki/B-tree +//! [hashmap::HashMap]: ../hashmap/struct.HashMap.html +//! [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html + +use std::borrow::Borrow; +use std::cmp::Ordering; +use std::collections; +use std::fmt::{Debug, Error, Formatter}; +use std::hash::{BuildHasher, Hash, Hasher}; +use std::iter::{FromIterator, Iterator, Sum}; +use std::mem; +use std::ops::{Add, Index, IndexMut, RangeBounds}; + +use crate::hashmap::HashMap; +use crate::nodes::btree::{BTreeValue, Insert, Node, Remove}; +#[cfg(has_specialisation)] +use crate::util::linear_search_by; +use crate::util::{Pool, PoolRef}; + +pub use crate::nodes::btree::{ + ConsumingIter, DiffItem as NodeDiffItem, DiffIter as NodeDiffIter, Iter as RangedIter, +}; + +/// Construct a map from a sequence of key/value pairs. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use im::ordmap::OrdMap; +/// # fn main() { +/// assert_eq!( +/// ordmap!{ +/// 1 => 11, +/// 2 => 22, +/// 3 => 33 +/// }, +/// OrdMap::from(vec![(1, 11), (2, 22), (3, 33)]) +/// ); +/// # } +/// ``` +#[macro_export] +macro_rules! ordmap { + () => { $crate::ordmap::OrdMap::new() }; + + ( $( $key:expr => $value:expr ),* ) => {{ + let mut map = $crate::ordmap::OrdMap::new(); + $({ + map.insert($key, $value); + })*; + map + }}; +} + +#[cfg(not(has_specialisation))] +impl<K: Ord, V> BTreeValue for (K, V) { + type Key = K; + + fn ptr_eq(&self, _other: &Self) -> bool { + false + } + + fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + slice.binary_search_by(|value| Self::Key::borrow(&value.0).cmp(key)) + } + + fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> { + slice.binary_search_by(|value| value.0.cmp(&key.0)) + } + + fn cmp_keys<BK>(&self, other: &BK) -> Ordering + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + Self::Key::borrow(&self.0).cmp(other) + } + + fn cmp_values(&self, other: &Self) -> Ordering { + self.0.cmp(&other.0) + } +} + +#[cfg(has_specialisation)] +impl<K: Ord, V> BTreeValue for (K, V) { + type Key = K; + + fn ptr_eq(&self, _other: &Self) -> bool { + false + } + + default fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + slice.binary_search_by(|value| Self::Key::borrow(&value.0).cmp(key)) + } + + default fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> { + slice.binary_search_by(|value| value.0.cmp(&key.0)) + } + + fn cmp_keys<BK>(&self, other: &BK) -> Ordering + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + Self::Key::borrow(&self.0).cmp(other) + } + + fn cmp_values(&self, other: &Self) -> Ordering { + self.0.cmp(&other.0) + } +} + +#[cfg(has_specialisation)] +impl<K: Ord + Copy, V> BTreeValue for (K, V) { + fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + linear_search_by(slice, |value| Self::Key::borrow(&value.0).cmp(key)) + } + + fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> { + linear_search_by(slice, |value| value.0.cmp(&key.0)) + } +} + +def_pool!(OrdMapPool<K, V>, Node<(K, V)>); + +/// An ordered map. +/// +/// An immutable ordered map implemented as a B-tree. +/// +/// Most operations on this type of map are O(log n). A +/// [`HashMap`][hashmap::HashMap] is usually a better choice for +/// performance, but the `OrdMap` has the advantage of only requiring +/// an [`Ord`][std::cmp::Ord] constraint on the key, and of being +/// ordered, so that keys always come out from lowest to highest, +/// where a [`HashMap`][hashmap::HashMap] has no guaranteed ordering. +/// +/// [hashmap::HashMap]: ../hashmap/struct.HashMap.html +/// [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html +pub struct OrdMap<K, V> { + size: usize, + pool: OrdMapPool<K, V>, + root: PoolRef<Node<(K, V)>>, +} + +impl<K, V> OrdMap<K, V> { + /// Construct an empty map. + #[must_use] + pub fn new() -> Self { + let pool = OrdMapPool::default(); + let root = PoolRef::default(&pool.0); + OrdMap { + size: 0, + pool, + root, + } + } + + /// Construct an empty map using a specific memory pool. + #[cfg(feature = "pool")] + #[must_use] + pub fn with_pool(pool: &OrdMapPool<K, V>) -> Self { + let root = PoolRef::default(&pool.0); + OrdMap { + size: 0, + pool: pool.clone(), + root, + } + } + + /// Construct a map with a single mapping. + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map = OrdMap::unit(123, "onetwothree"); + /// assert_eq!( + /// map.get(&123), + /// Some(&"onetwothree") + /// ); + /// ``` + #[inline] + #[must_use] + pub fn unit(key: K, value: V) -> Self { + let pool = OrdMapPool::default(); + let root = PoolRef::new(&pool.0, Node::unit((key, value))); + OrdMap { + size: 1, + pool, + root, + } + } + + /// Test whether a map is empty. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// assert!( + /// !ordmap!{1 => 2}.is_empty() + /// ); + /// assert!( + /// OrdMap::<i32, i32>::new().is_empty() + /// ); + /// ``` + #[inline] + #[must_use] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Test whether two maps refer to the same content in memory. + /// + /// This is true if the two sides are references to the same map, + /// or if the two maps refer to the same root node. + /// + /// This would return true if you're comparing a map to itself, or + /// if you're comparing a map to a fresh clone of itself. + /// + /// Time: O(1) + pub fn ptr_eq(&self, other: &Self) -> bool { + std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root) + } + + /// Get the size of a map. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// assert_eq!(3, ordmap!{ + /// 1 => 11, + /// 2 => 22, + /// 3 => 33 + /// }.len()); + /// ``` + #[inline] + #[must_use] + pub fn len(&self) -> usize { + self.size + } + + /// Get a reference to the memory pool used by this map. + /// + /// Note that if you didn't specifically construct it with a pool, you'll + /// get back a reference to a pool of size 0. + #[cfg(feature = "pool")] + pub fn pool(&self) -> &OrdMapPool<K, V> { + &self.pool + } + + /// Discard all elements from the map. + /// + /// This leaves you with an empty map, and all elements that + /// were previously inside it are dropped. + /// + /// Time: O(n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdMap; + /// let mut map = ordmap![1=>1, 2=>2, 3=>3]; + /// map.clear(); + /// assert!(map.is_empty()); + /// ``` + pub fn clear(&mut self) { + if !self.is_empty() { + self.root = PoolRef::default(&self.pool.0); + self.size = 0; + } + } +} + +impl<K, V> OrdMap<K, V> +where + K: Ord, +{ + /// Get the largest key in a map, along with its value. If the map + /// is empty, return `None`. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// assert_eq!(Some(&(3, 33)), ordmap!{ + /// 1 => 11, + /// 2 => 22, + /// 3 => 33 + /// }.get_max()); + /// ``` + #[must_use] + pub fn get_max(&self) -> Option<&(K, V)> { + self.root.max() + } + + /// Get the smallest key in a map, along with its value. If the + /// map is empty, return `None`. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// assert_eq!(Some(&(1, 11)), ordmap!{ + /// 1 => 11, + /// 2 => 22, + /// 3 => 33 + /// }.get_min()); + /// ``` + #[must_use] + pub fn get_min(&self) -> Option<&(K, V)> { + self.root.min() + } + + /// Get an iterator over the key/value pairs of a map. + #[must_use] + pub fn iter(&self) -> Iter<'_, K, V> { + Iter { + it: RangedIter::new(&self.root, self.size, ..), + } + } + + /// Create an iterator over a range of key/value pairs. + #[must_use] + pub fn range<R, BK>(&self, range: R) -> Iter<'_, K, V> + where + R: RangeBounds<BK>, + K: Borrow<BK>, + BK: Ord + ?Sized, + { + Iter { + it: RangedIter::new(&self.root, self.size, range), + } + } + + /// Get an iterator over a map's keys. + #[must_use] + pub fn keys(&self) -> Keys<'_, K, V> { + Keys { it: self.iter() } + } + + /// Get an iterator over a map's values. + #[must_use] + pub fn values(&self) -> Values<'_, K, V> { + Values { it: self.iter() } + } + + /// Get an iterator over the differences between this map and + /// another, i.e. the set of entries to add, update, or remove to + /// this map in order to make it equal to the other map. + /// + /// This function will avoid visiting nodes which are shared + /// between the two maps, meaning that even very large maps can be + /// compared quickly if most of their structure is shared. + /// + /// Time: O(n) (where n is the number of unique elements across + /// the two maps, minus the number of elements belonging to nodes + /// shared between them) + #[must_use] + pub fn diff<'a>(&'a self, other: &'a Self) -> DiffIter<'a, K, V> { + DiffIter { + it: NodeDiffIter::new(&self.root, &other.root), + } + } + + /// Get the value for a key from a map. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map = ordmap!{123 => "lol"}; + /// assert_eq!( + /// map.get(&123), + /// Some(&"lol") + /// ); + /// ``` + #[must_use] + pub fn get<BK>(&self, key: &BK) -> Option<&V> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.root.lookup(key).map(|(_, v)| v) + } + + /// Get the key/value pair for a key from a map. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map = ordmap!{123 => "lol"}; + /// assert_eq!( + /// map.get_key_value(&123), + /// Some((&123, &"lol")) + /// ); + /// ``` + #[must_use] + pub fn get_key_value<BK>(&self, key: &BK) -> Option<(&K, &V)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.root.lookup(key).map(|&(ref k, ref v)| (k, v)) + } + + /// Get the closest smaller entry in a map to a given key + /// as a mutable reference. + /// + /// If the map contains the given key, this is returned. + /// Otherwise, the closest key in the map smaller than the + /// given value is returned. If the smallest key in the map + /// is larger than the given key, `None` is returned. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdMap; + /// let map = ordmap![1 => 1, 3 => 3, 5 => 5]; + /// assert_eq!(Some((&3, &3)), map.get_prev(&4)); + /// ``` + #[must_use] + pub fn get_prev<BK>(&self, key: &BK) -> Option<(&K, &V)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.root.lookup_prev(key).map(|(k, v)| (k, v)) + } + + /// Get the closest larger entry in a map to a given key + /// as a mutable reference. + /// + /// If the set contains the given value, this is returned. + /// Otherwise, the closest value in the set larger than the + /// given value is returned. If the largest value in the set + /// is smaller than the given value, `None` is returned. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdMap; + /// let map = ordmap![1 => 1, 3 => 3, 5 => 5]; + /// assert_eq!(Some((&5, &5)), map.get_next(&4)); + /// ``` + #[must_use] + pub fn get_next<BK>(&self, key: &BK) -> Option<(&K, &V)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.root.lookup_next(key).map(|(k, v)| (k, v)) + } + + /// Test for the presence of a key in a map. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map = ordmap!{123 => "lol"}; + /// assert!( + /// map.contains_key(&123) + /// ); + /// assert!( + /// !map.contains_key(&321) + /// ); + /// ``` + #[must_use] + pub fn contains_key<BK>(&self, k: &BK) -> bool + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.get(k).is_some() + } + + /// Test whether a map is a submap of another map, meaning that + /// all keys in our map must also be in the other map, with the + /// same values. + /// + /// Use the provided function to decide whether values are equal. + /// + /// Time: O(n log n) + #[must_use] + pub fn is_submap_by<B, RM, F>(&self, other: RM, mut cmp: F) -> bool + where + F: FnMut(&V, &B) -> bool, + RM: Borrow<OrdMap<K, B>>, + { + self.iter() + .all(|(k, v)| other.borrow().get(k).map(|ov| cmp(v, ov)).unwrap_or(false)) + } + + /// Test whether a map is a proper submap of another map, meaning + /// that all keys in our map must also be in the other map, with + /// the same values. To be a proper submap, ours must also contain + /// fewer keys than the other map. + /// + /// Use the provided function to decide whether values are equal. + /// + /// Time: O(n log n) + #[must_use] + pub fn is_proper_submap_by<B, RM, F>(&self, other: RM, cmp: F) -> bool + where + F: FnMut(&V, &B) -> bool, + RM: Borrow<OrdMap<K, B>>, + { + self.len() != other.borrow().len() && self.is_submap_by(other, cmp) + } + + /// Test whether a map is a submap of another map, meaning that + /// all keys in our map must also be in the other map, with the + /// same values. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 2 => 2}; + /// let map2 = ordmap!{1 => 1, 2 => 2, 3 => 3}; + /// assert!(map1.is_submap(map2)); + /// ``` + #[must_use] + pub fn is_submap<RM>(&self, other: RM) -> bool + where + V: PartialEq, + RM: Borrow<Self>, + { + self.is_submap_by(other.borrow(), PartialEq::eq) + } + + /// Test whether a map is a proper submap of another map, meaning + /// that all keys in our map must also be in the other map, with + /// the same values. To be a proper submap, ours must also contain + /// fewer keys than the other map. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 2 => 2}; + /// let map2 = ordmap!{1 => 1, 2 => 2, 3 => 3}; + /// assert!(map1.is_proper_submap(map2)); + /// + /// let map3 = ordmap!{1 => 1, 2 => 2}; + /// let map4 = ordmap!{1 => 1, 2 => 2}; + /// assert!(!map3.is_proper_submap(map4)); + /// ``` + #[must_use] + pub fn is_proper_submap<RM>(&self, other: RM) -> bool + where + V: PartialEq, + RM: Borrow<Self>, + { + self.is_proper_submap_by(other.borrow(), PartialEq::eq) + } +} + +impl<K, V> OrdMap<K, V> +where + K: Ord + Clone, + V: Clone, +{ + /// Get a mutable reference to the value for a key from a map. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let mut map = ordmap!{123 => "lol"}; + /// if let Some(value) = map.get_mut(&123) { + /// *value = "omg"; + /// } + /// assert_eq!( + /// map.get(&123), + /// Some(&"omg") + /// ); + /// ``` + #[must_use] + pub fn get_mut<BK>(&mut self, key: &BK) -> Option<&mut V> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + root.lookup_mut(&self.pool.0, key).map(|(_, v)| v) + } + + /// Get the closest smaller entry in a map to a given key + /// as a mutable reference. + /// + /// If the map contains the given key, this is returned. + /// Otherwise, the closest key in the map smaller than the + /// given value is returned. If the smallest key in the map + /// is larger than the given key, `None` is returned. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdMap; + /// let mut map = ordmap![1 => 1, 3 => 3, 5 => 5]; + /// if let Some((key, value)) = map.get_prev_mut(&4) { + /// *value = 4; + /// } + /// assert_eq!(ordmap![1 => 1, 3 => 4, 5 => 5], map); + /// ``` + #[must_use] + pub fn get_prev_mut<BK>(&mut self, key: &BK) -> Option<(&K, &mut V)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + let pool = &self.pool.0; + PoolRef::make_mut(pool, &mut self.root) + .lookup_prev_mut(pool, key) + .map(|(ref k, ref mut v)| (k, v)) + } + + /// Get the closest larger entry in a map to a given key + /// as a mutable reference. + /// + /// If the set contains the given value, this is returned. + /// Otherwise, the closest value in the set larger than the + /// given value is returned. If the largest value in the set + /// is smaller than the given value, `None` is returned. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdMap; + /// let mut map = ordmap![1 => 1, 3 => 3, 5 => 5]; + /// if let Some((key, value)) = map.get_next_mut(&4) { + /// *value = 4; + /// } + /// assert_eq!(ordmap![1 => 1, 3 => 3, 5 => 4], map); + /// ``` + #[must_use] + pub fn get_next_mut<BK>(&mut self, key: &BK) -> Option<(&K, &mut V)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + let pool = &self.pool.0; + PoolRef::make_mut(pool, &mut self.root) + .lookup_next_mut(pool, key) + .map(|(ref k, ref mut v)| (k, v)) + } + + /// Insert a key/value mapping into a map. + /// + /// This is a copy-on-write operation, so that the parts of the + /// map's structure which are shared with other maps will be + /// safely copied before mutating. + /// + /// If the map already has a mapping for the given key, the + /// previous value is overwritten. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let mut map = ordmap!{}; + /// map.insert(123, "123"); + /// map.insert(456, "456"); + /// assert_eq!( + /// map, + /// ordmap!{123 => "123", 456 => "456"} + /// ); + /// ``` + /// + /// [insert]: #method.insert + #[inline] + pub fn insert(&mut self, key: K, value: V) -> Option<V> { + let new_root = { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + match root.insert(&self.pool.0, (key, value)) { + Insert::Replaced((_, old_value)) => return Some(old_value), + Insert::Added => { + self.size += 1; + return None; + } + Insert::Split(left, median, right) => PoolRef::new( + &self.pool.0, + Node::new_from_split(&self.pool.0, left, median, right), + ), + } + }; + self.size += 1; + self.root = new_root; + None + } + + /// Remove a key/value mapping from a map if it exists. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let mut map = ordmap!{123 => "123", 456 => "456"}; + /// map.remove(&123); + /// map.remove(&456); + /// assert!(map.is_empty()); + /// ``` + /// + /// [remove]: #method.remove + #[inline] + pub fn remove<BK>(&mut self, k: &BK) -> Option<V> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.remove_with_key(k).map(|(_, v)| v) + } + + /// Remove a key/value pair from a map, if it exists, and return + /// the removed key and value. + /// + /// Time: O(log n) + pub fn remove_with_key<BK>(&mut self, k: &BK) -> Option<(K, V)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + let (new_root, removed_value) = { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + match root.remove(&self.pool.0, k) { + Remove::NoChange => return None, + Remove::Removed(pair) => { + self.size -= 1; + return Some(pair); + } + Remove::Update(pair, root) => (PoolRef::new(&self.pool.0, root), Some(pair)), + } + }; + self.size -= 1; + self.root = new_root; + removed_value + } + + /// Construct a new map by inserting a key/value mapping into a + /// map. + /// + /// If the map already has a mapping for the given key, the + /// previous value is overwritten. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map = ordmap!{}; + /// assert_eq!( + /// map.update(123, "123"), + /// ordmap!{123 => "123"} + /// ); + /// ``` + #[must_use] + pub fn update(&self, key: K, value: V) -> Self { + let mut out = self.clone(); + out.insert(key, value); + out + } + + /// Construct a new map by inserting a key/value mapping into a + /// map. + /// + /// If the map already has a mapping for the given key, we call + /// the provided function with the old value and the new value, + /// and insert the result as the new value. + /// + /// Time: O(log n) + #[must_use] + pub fn update_with<F>(self, k: K, v: V, f: F) -> Self + where + F: FnOnce(V, V) -> V, + { + self.update_with_key(k, v, |_, v1, v2| f(v1, v2)) + } + + /// Construct a new map by inserting a key/value mapping into a + /// map. + /// + /// If the map already has a mapping for the given key, we call + /// the provided function with the key, the old value and the new + /// value, and insert the result as the new value. + /// + /// Time: O(log n) + #[must_use] + pub fn update_with_key<F>(self, k: K, v: V, f: F) -> Self + where + F: FnOnce(&K, V, V) -> V, + { + match self.extract_with_key(&k) { + None => self.update(k, v), + Some((_, v2, m)) => { + let out_v = f(&k, v2, v); + m.update(k, out_v) + } + } + } + + /// Construct a new map by inserting a key/value mapping into a + /// map, returning the old value for the key as well as the new + /// map. + /// + /// If the map already has a mapping for the given key, we call + /// the provided function with the key, the old value and the new + /// value, and insert the result as the new value. + /// + /// Time: O(log n) + #[must_use] + pub fn update_lookup_with_key<F>(self, k: K, v: V, f: F) -> (Option<V>, Self) + where + F: FnOnce(&K, &V, V) -> V, + { + match self.extract_with_key(&k) { + None => (None, self.update(k, v)), + Some((_, v2, m)) => { + let out_v = f(&k, &v2, v); + (Some(v2), m.update(k, out_v)) + } + } + } + + /// Update the value for a given key by calling a function with + /// the current value and overwriting it with the function's + /// return value. + /// + /// The function gets an [`Option<V>`][std::option::Option] and + /// returns the same, so that it can decide to delete a mapping + /// instead of updating the value, and decide what to do if the + /// key isn't in the map. + /// + /// Time: O(log n) + /// + /// [std::option::Option]: https://doc.rust-lang.org/std/option/enum.Option.html + #[must_use] + pub fn alter<F>(&self, f: F, k: K) -> Self + where + F: FnOnce(Option<V>) -> Option<V>, + { + let pop = self.extract_with_key(&k); + match (f(pop.as_ref().map(|&(_, ref v, _)| v.clone())), pop) { + (None, None) => self.clone(), + (Some(v), None) => self.update(k, v), + (None, Some((_, _, m))) => m, + (Some(v), Some((_, _, m))) => m.update(k, v), + } + } + + /// Remove a key/value pair from a map, if it exists. + /// + /// Time: O(log n) + #[must_use] + pub fn without<BK>(&self, k: &BK) -> Self + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.extract(k) + .map(|(_, m)| m) + .unwrap_or_else(|| self.clone()) + } + + /// Remove a key/value pair from a map, if it exists, and return + /// the removed value as well as the updated list. + /// + /// Time: O(log n) + #[must_use] + pub fn extract<BK>(&self, k: &BK) -> Option<(V, Self)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + self.extract_with_key(k).map(|(_, v, m)| (v, m)) + } + + /// Remove a key/value pair from a map, if it exists, and return + /// the removed key and value as well as the updated list. + /// + /// Time: O(log n) + #[must_use] + pub fn extract_with_key<BK>(&self, k: &BK) -> Option<(K, V, Self)> + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + let mut out = self.clone(); + let result = out.remove_with_key(k); + result.map(|(k, v)| (k, v, out)) + } + + /// Construct the union of two maps, keeping the values in the + /// current map when keys exist in both maps. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 3}; + /// let map2 = ordmap!{2 => 2, 3 => 4}; + /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 3}; + /// assert_eq!(expected, map1.union(map2)); + /// ``` + #[inline] + #[must_use] + pub fn union(self, other: Self) -> Self { + let (mut to_mutate, to_consume) = if self.len() >= other.len() { + (self, other) + } else { + (other, self) + }; + for (k, v) in to_consume { + to_mutate.entry(k).or_insert(v); + } + to_mutate + } + + /// Construct the union of two maps, using a function to decide + /// what to do with the value when a key is in both maps. + /// + /// The function is called when a value exists in both maps, and + /// receives the value from the current map as its first argument, + /// and the value from the other map as the second. It should + /// return the value to be inserted in the resulting map. + /// + /// Time: O(n log n) + #[inline] + #[must_use] + pub fn union_with<F>(self, other: Self, mut f: F) -> Self + where + F: FnMut(V, V) -> V, + { + self.union_with_key(other, |_, v1, v2| f(v1, v2)) + } + + /// Construct the union of two maps, using a function to decide + /// what to do with the value when a key is in both maps. + /// + /// The function is called when a value exists in both maps, and + /// receives a reference to the key as its first argument, the + /// value from the current map as the second argument, and the + /// value from the other map as the third argument. It should + /// return the value to be inserted in the resulting map. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 4}; + /// let map2 = ordmap!{2 => 2, 3 => 5}; + /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 9}; + /// assert_eq!(expected, map1.union_with_key( + /// map2, + /// |key, left, right| left + right + /// )); + /// ``` + #[must_use] + pub fn union_with_key<F>(self, other: Self, mut f: F) -> Self + where + F: FnMut(&K, V, V) -> V, + { + if self.len() >= other.len() { + self.union_with_key_inner(other, f) + } else { + other.union_with_key_inner(self, |key, other_value, self_value| { + f(key, self_value, other_value) + }) + } + } + + fn union_with_key_inner<F>(mut self, other: Self, mut f: F) -> Self + where + F: FnMut(&K, V, V) -> V, + { + for (key, right_value) in other { + match self.remove(&key) { + None => { + self.insert(key, right_value); + } + Some(left_value) => { + let final_value = f(&key, left_value, right_value); + self.insert(key, final_value); + } + } + } + self + } + + /// Construct the union of a sequence of maps, selecting the value + /// of the leftmost when a key appears in more than one map. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 3}; + /// let map2 = ordmap!{2 => 2}; + /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 3}; + /// assert_eq!(expected, OrdMap::unions(vec![map1, map2])); + /// ``` + #[must_use] + pub fn unions<I>(i: I) -> Self + where + I: IntoIterator<Item = Self>, + { + i.into_iter().fold(Self::default(), Self::union) + } + + /// Construct the union of a sequence of maps, using a function to + /// decide what to do with the value when a key is in more than + /// one map. + /// + /// The function is called when a value exists in multiple maps, + /// and receives the value from the current map as its first + /// argument, and the value from the next map as the second. It + /// should return the value to be inserted in the resulting map. + /// + /// Time: O(n log n) + #[must_use] + pub fn unions_with<I, F>(i: I, f: F) -> Self + where + I: IntoIterator<Item = Self>, + F: Fn(V, V) -> V, + { + i.into_iter() + .fold(Self::default(), |a, b| a.union_with(b, &f)) + } + + /// Construct the union of a sequence of maps, using a function to + /// decide what to do with the value when a key is in more than + /// one map. + /// + /// The function is called when a value exists in multiple maps, + /// and receives a reference to the key as its first argument, the + /// value from the current map as the second argument, and the + /// value from the next map as the third argument. It should + /// return the value to be inserted in the resulting map. + /// + /// Time: O(n log n) + #[must_use] + pub fn unions_with_key<I, F>(i: I, f: F) -> Self + where + I: IntoIterator<Item = Self>, + F: Fn(&K, V, V) -> V, + { + i.into_iter() + .fold(Self::default(), |a, b| a.union_with_key(b, &f)) + } + + /// Construct the symmetric difference between two maps by discarding keys + /// which occur in both maps. + /// + /// This is an alias for the + /// [`symmetric_difference`][symmetric_difference] method. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 4}; + /// let map2 = ordmap!{2 => 2, 3 => 5}; + /// let expected = ordmap!{1 => 1, 2 => 2}; + /// assert_eq!(expected, map1.difference(map2)); + /// ``` + /// + /// [symmetric_difference]: #method.symmetric_difference + #[inline] + #[must_use] + pub fn difference(self, other: Self) -> Self { + self.symmetric_difference(other) + } + + /// Construct the symmetric difference between two maps by discarding keys + /// which occur in both maps. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 4}; + /// let map2 = ordmap!{2 => 2, 3 => 5}; + /// let expected = ordmap!{1 => 1, 2 => 2}; + /// assert_eq!(expected, map1.symmetric_difference(map2)); + /// ``` + #[inline] + #[must_use] + pub fn symmetric_difference(self, other: Self) -> Self { + self.symmetric_difference_with_key(other, |_, _, _| None) + } + + /// Construct the symmetric difference between two maps by using a function + /// to decide what to do if a key occurs in both. + /// + /// This is an alias for the + /// [`symmetric_difference_with`][symmetric_difference_with] method. + /// + /// Time: O(n log n) + /// + /// [symmetric_difference_with]: #method.symmetric_difference_with + #[inline] + #[must_use] + pub fn difference_with<F>(self, other: Self, f: F) -> Self + where + F: FnMut(V, V) -> Option<V>, + { + self.symmetric_difference_with(other, f) + } + + /// Construct the symmetric difference between two maps by using a function + /// to decide what to do if a key occurs in both. + /// + /// Time: O(n log n) + #[inline] + #[must_use] + pub fn symmetric_difference_with<F>(self, other: Self, mut f: F) -> Self + where + F: FnMut(V, V) -> Option<V>, + { + self.symmetric_difference_with_key(other, |_, a, b| f(a, b)) + } + + /// Construct the symmetric difference between two maps by using a function + /// to decide what to do if a key occurs in both. The function + /// receives the key as well as both values. + /// + /// This is an alias for the + /// [`symmetric_difference_with_key`][symmetric_difference_with_key] + /// method. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 4}; + /// let map2 = ordmap!{2 => 2, 3 => 5}; + /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 9}; + /// assert_eq!(expected, map1.difference_with_key( + /// map2, + /// |key, left, right| Some(left + right) + /// )); + /// ``` + /// [symmetric_difference_with_key]: #method.symmetric_difference_with_key + #[must_use] + pub fn difference_with_key<F>(self, other: Self, f: F) -> Self + where + F: FnMut(&K, V, V) -> Option<V>, + { + self.symmetric_difference_with_key(other, f) + } + + /// Construct the symmetric difference between two maps by using a function + /// to decide what to do if a key occurs in both. The function + /// receives the key as well as both values. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 4}; + /// let map2 = ordmap!{2 => 2, 3 => 5}; + /// let expected = ordmap!{1 => 1, 2 => 2, 3 => 9}; + /// assert_eq!(expected, map1.symmetric_difference_with_key( + /// map2, + /// |key, left, right| Some(left + right) + /// )); + /// ``` + #[must_use] + pub fn symmetric_difference_with_key<F>(mut self, other: Self, mut f: F) -> Self + where + F: FnMut(&K, V, V) -> Option<V>, + { + let mut out = Self::default(); + for (key, right_value) in other { + match self.remove(&key) { + None => { + out.insert(key, right_value); + } + Some(left_value) => { + if let Some(final_value) = f(&key, left_value, right_value) { + out.insert(key, final_value); + } + } + } + } + out.union(self) + } + + /// Construct the relative complement between two maps by discarding keys + /// which occur in `other`. + /// + /// Time: O(m log n) where m is the size of the other map + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 3 => 4}; + /// let map2 = ordmap!{2 => 2, 3 => 5}; + /// let expected = ordmap!{1 => 1}; + /// assert_eq!(expected, map1.relative_complement(map2)); + /// ``` + #[inline] + #[must_use] + pub fn relative_complement(mut self, other: Self) -> Self { + for (key, _) in other { + let _ = self.remove(&key); + } + self + } + + /// Construct the intersection of two maps, keeping the values + /// from the current map. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 2 => 2}; + /// let map2 = ordmap!{2 => 3, 3 => 4}; + /// let expected = ordmap!{2 => 2}; + /// assert_eq!(expected, map1.intersection(map2)); + /// ``` + #[inline] + #[must_use] + pub fn intersection(self, other: Self) -> Self { + self.intersection_with_key(other, |_, v, _| v) + } + + /// Construct the intersection of two maps, calling a function + /// with both values for each key and using the result as the + /// value for the key. + /// + /// Time: O(n log n) + #[inline] + #[must_use] + pub fn intersection_with<B, C, F>(self, other: OrdMap<K, B>, mut f: F) -> OrdMap<K, C> + where + B: Clone, + C: Clone, + F: FnMut(V, B) -> C, + { + self.intersection_with_key(other, |_, v1, v2| f(v1, v2)) + } + + /// Construct the intersection of two maps, calling a function + /// with the key and both values for each key and using the result + /// as the value for the key. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordmap::OrdMap; + /// let map1 = ordmap!{1 => 1, 2 => 2}; + /// let map2 = ordmap!{2 => 3, 3 => 4}; + /// let expected = ordmap!{2 => 5}; + /// assert_eq!(expected, map1.intersection_with_key( + /// map2, + /// |key, left, right| left + right + /// )); + /// ``` + #[must_use] + pub fn intersection_with_key<B, C, F>(mut self, other: OrdMap<K, B>, mut f: F) -> OrdMap<K, C> + where + B: Clone, + C: Clone, + F: FnMut(&K, V, B) -> C, + { + let mut out = OrdMap::<K, C>::default(); + for (key, right_value) in other { + match self.remove(&key) { + None => (), + Some(left_value) => { + let result = f(&key, left_value, right_value); + out.insert(key, result); + } + } + } + out + } + + /// Split a map into two, with the left hand map containing keys + /// which are smaller than `split`, and the right hand map + /// containing keys which are larger than `split`. + /// + /// The `split` mapping is discarded. + #[must_use] + pub fn split<BK>(&self, split: &BK) -> (Self, Self) + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + let (l, _, r) = self.split_lookup(split); + (l, r) + } + + /// Split a map into two, with the left hand map containing keys + /// which are smaller than `split`, and the right hand map + /// containing keys which are larger than `split`. + /// + /// Returns both the two maps and the value of `split`. + #[must_use] + pub fn split_lookup<BK>(&self, split: &BK) -> (Self, Option<V>, Self) + where + BK: Ord + ?Sized, + K: Borrow<BK>, + { + // TODO this is atrociously slow, got to be a better way + self.iter() + .fold((ordmap![], None, ordmap![]), |(l, m, r), (k, v)| { + match k.borrow().cmp(split) { + Ordering::Less => (l.update(k.clone(), v.clone()), m, r), + Ordering::Equal => (l, Some(v.clone()), r), + Ordering::Greater => (l, m, r.update(k.clone(), v.clone())), + } + }) + } + + /// Construct a map with only the `n` smallest keys from a given + /// map. + #[must_use] + pub fn take(&self, n: usize) -> Self { + self.iter() + .take(n) + .map(|(k, v)| (k.clone(), v.clone())) + .collect() + } + + /// Construct a map with the `n` smallest keys removed from a + /// given map. + #[must_use] + pub fn skip(&self, n: usize) -> Self { + self.iter() + .skip(n) + .map(|(k, v)| (k.clone(), v.clone())) + .collect() + } + + /// Remove the smallest key from a map, and return its value as + /// well as the updated map. + #[must_use] + pub fn without_min(&self) -> (Option<V>, Self) { + let (pop, next) = self.without_min_with_key(); + (pop.map(|(_, v)| v), next) + } + + /// Remove the smallest key from a map, and return that key, its + /// value as well as the updated map. + #[must_use] + pub fn without_min_with_key(&self) -> (Option<(K, V)>, Self) { + match self.get_min() { + None => (None, self.clone()), + Some((k, _)) => { + let (key, value, next) = self.extract_with_key(k).unwrap(); + (Some((key, value)), next) + } + } + } + + /// Remove the largest key from a map, and return its value as + /// well as the updated map. + #[must_use] + pub fn without_max(&self) -> (Option<V>, Self) { + let (pop, next) = self.without_max_with_key(); + (pop.map(|(_, v)| v), next) + } + + /// Remove the largest key from a map, and return that key, its + /// value as well as the updated map. + #[must_use] + pub fn without_max_with_key(&self) -> (Option<(K, V)>, Self) { + match self.get_max() { + None => (None, self.clone()), + Some((k, _)) => { + let (key, value, next) = self.extract_with_key(k).unwrap(); + (Some((key, value)), next) + } + } + } + + /// Get the [`Entry`][Entry] for a key in the map for in-place manipulation. + /// + /// Time: O(log n) + /// + /// [Entry]: enum.Entry.html + #[must_use] + pub fn entry(&mut self, key: K) -> Entry<'_, K, V> { + if self.contains_key(&key) { + Entry::Occupied(OccupiedEntry { map: self, key }) + } else { + Entry::Vacant(VacantEntry { map: self, key }) + } + } +} + +// Entries + +/// A handle for a key and its associated value. +pub enum Entry<'a, K, V> +where + K: Ord + Clone, + V: Clone, +{ + /// An entry which exists in the map. + Occupied(OccupiedEntry<'a, K, V>), + /// An entry which doesn't exist in the map. + Vacant(VacantEntry<'a, K, V>), +} + +impl<'a, K, V> Entry<'a, K, V> +where + K: Ord + Clone, + V: Clone, +{ + /// Insert the default value provided if there was no value + /// already, and return a mutable reference to the value. + pub fn or_insert(self, default: V) -> &'a mut V { + self.or_insert_with(|| default) + } + + /// Insert the default value from the provided function if there + /// was no value already, and return a mutable reference to the + /// value. + pub fn or_insert_with<F>(self, default: F) -> &'a mut V + where + F: FnOnce() -> V, + { + match self { + Entry::Occupied(entry) => entry.into_mut(), + Entry::Vacant(entry) => entry.insert(default()), + } + } + + /// Insert a default value if there was no value already, and + /// return a mutable reference to the value. + pub fn or_default(self) -> &'a mut V + where + V: Default, + { + self.or_insert_with(Default::default) + } + + /// Get the key for this entry. + #[must_use] + pub fn key(&self) -> &K { + match self { + Entry::Occupied(entry) => entry.key(), + Entry::Vacant(entry) => entry.key(), + } + } + + /// Call the provided function to modify the value if the value + /// exists. + pub fn and_modify<F>(mut self, f: F) -> Self + where + F: FnOnce(&mut V), + { + match &mut self { + Entry::Occupied(ref mut entry) => f(entry.get_mut()), + Entry::Vacant(_) => (), + } + self + } +} + +/// An entry for a mapping that already exists in the map. +pub struct OccupiedEntry<'a, K, V> +where + K: Ord + Clone, + V: Clone, +{ + map: &'a mut OrdMap<K, V>, + key: K, +} + +impl<'a, K, V> OccupiedEntry<'a, K, V> +where + K: 'a + Ord + Clone, + V: 'a + Clone, +{ + /// Get the key for this entry. + #[must_use] + pub fn key(&self) -> &K { + &self.key + } + + /// Remove this entry from the map and return the removed mapping. + pub fn remove_entry(self) -> (K, V) { + self.map + .remove_with_key(&self.key) + .expect("ordmap::OccupiedEntry::remove_entry: key has vanished!") + } + + /// Get the current value. + #[must_use] + pub fn get(&self) -> &V { + self.map.get(&self.key).unwrap() + } + + /// Get a mutable reference to the current value. + #[must_use] + pub fn get_mut(&mut self) -> &mut V { + self.map.get_mut(&self.key).unwrap() + } + + /// Convert this entry into a mutable reference. + #[must_use] + pub fn into_mut(self) -> &'a mut V { + self.map.get_mut(&self.key).unwrap() + } + + /// Overwrite the current value. + pub fn insert(&mut self, value: V) -> V { + mem::replace(self.get_mut(), value) + } + + /// Remove this entry from the map and return the removed value. + pub fn remove(self) -> V { + self.remove_entry().1 + } +} + +/// An entry for a mapping that does not already exist in the map. +pub struct VacantEntry<'a, K, V> +where + K: Ord + Clone, + V: Clone, +{ + map: &'a mut OrdMap<K, V>, + key: K, +} + +impl<'a, K, V> VacantEntry<'a, K, V> +where + K: 'a + Ord + Clone, + V: 'a + Clone, +{ + /// Get the key for this entry. + #[must_use] + pub fn key(&self) -> &K { + &self.key + } + + /// Convert this entry into its key. + #[must_use] + pub fn into_key(self) -> K { + self.key + } + + /// Insert a value into this entry. + pub fn insert(self, value: V) -> &'a mut V { + self.map.insert(self.key.clone(), value); + // TODO insert_mut ought to return this reference + self.map.get_mut(&self.key).unwrap() + } +} + +// Core traits + +impl<K, V> Clone for OrdMap<K, V> { + /// Clone a map. + /// + /// Time: O(1) + #[inline] + fn clone(&self) -> Self { + OrdMap { + size: self.size, + pool: self.pool.clone(), + root: self.root.clone(), + } + } +} + +#[cfg(not(has_specialisation))] +impl<K, V> PartialEq for OrdMap<K, V> +where + K: Ord + PartialEq, + V: PartialEq, +{ + fn eq(&self, other: &Self) -> bool { + self.len() == other.len() && self.diff(other).next().is_none() + } +} + +#[cfg(has_specialisation)] +impl<K, V> PartialEq for OrdMap<K, V> +where + K: Ord + PartialEq, + V: PartialEq, +{ + default fn eq(&self, other: &Self) -> bool { + self.len() == other.len() && self.diff(other).next().is_none() + } +} + +#[cfg(has_specialisation)] +impl<K, V> PartialEq for OrdMap<K, V> +where + K: Ord + Eq, + V: Eq, +{ + fn eq(&self, other: &Self) -> bool { + PoolRef::ptr_eq(&self.root, &other.root) + || (self.len() == other.len() && self.diff(other).next().is_none()) + } +} + +impl<K: Ord + Eq, V: Eq> Eq for OrdMap<K, V> {} + +impl<K, V> PartialOrd for OrdMap<K, V> +where + K: Ord, + V: PartialOrd, +{ + fn partial_cmp(&self, other: &Self) -> Option<Ordering> { + self.iter().partial_cmp(other.iter()) + } +} + +impl<K, V> Ord for OrdMap<K, V> +where + K: Ord, + V: Ord, +{ + fn cmp(&self, other: &Self) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +impl<K, V> Hash for OrdMap<K, V> +where + K: Ord + Hash, + V: Hash, +{ + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + for i in self.iter() { + i.hash(state); + } + } +} + +impl<K, V> Default for OrdMap<K, V> { + fn default() -> Self { + Self::new() + } +} + +impl<'a, K, V> Add for &'a OrdMap<K, V> +where + K: Ord + Clone, + V: Clone, +{ + type Output = OrdMap<K, V>; + + fn add(self, other: Self) -> Self::Output { + self.clone().union(other.clone()) + } +} + +impl<K, V> Add for OrdMap<K, V> +where + K: Ord + Clone, + V: Clone, +{ + type Output = OrdMap<K, V>; + + fn add(self, other: Self) -> Self::Output { + self.union(other) + } +} + +impl<K, V> Sum for OrdMap<K, V> +where + K: Ord + Clone, + V: Clone, +{ + fn sum<I>(it: I) -> Self + where + I: Iterator<Item = Self>, + { + it.fold(Self::default(), |a, b| a + b) + } +} + +impl<K, V, RK, RV> Extend<(RK, RV)> for OrdMap<K, V> +where + K: Ord + Clone + From<RK>, + V: Clone + From<RV>, +{ + fn extend<I>(&mut self, iter: I) + where + I: IntoIterator<Item = (RK, RV)>, + { + for (key, value) in iter { + self.insert(From::from(key), From::from(value)); + } + } +} + +impl<'a, BK, K, V> Index<&'a BK> for OrdMap<K, V> +where + BK: Ord + ?Sized, + K: Ord + Borrow<BK>, +{ + type Output = V; + + fn index(&self, key: &BK) -> &Self::Output { + match self.root.lookup(key) { + None => panic!("OrdMap::index: invalid key"), + Some(&(_, ref value)) => value, + } + } +} + +impl<'a, BK, K, V> IndexMut<&'a BK> for OrdMap<K, V> +where + BK: Ord + ?Sized, + K: Ord + Clone + Borrow<BK>, + V: Clone, +{ + fn index_mut(&mut self, key: &BK) -> &mut Self::Output { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + match root.lookup_mut(&self.pool.0, key) { + None => panic!("OrdMap::index: invalid key"), + Some(&mut (_, ref mut value)) => value, + } + } +} + +impl<K, V> Debug for OrdMap<K, V> +where + K: Ord + Debug, + V: Debug, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + let mut d = f.debug_map(); + for (k, v) in self.iter() { + d.entry(k, v); + } + d.finish() + } +} + +// Iterators + +/// An iterator over the key/value pairs of a map. +pub struct Iter<'a, K, V> { + it: RangedIter<'a, (K, V)>, +} + +impl<'a, K, V> Iterator for Iter<'a, K, V> +where + (K, V): 'a + BTreeValue, +{ + type Item = (&'a K, &'a V); + + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|(k, v)| (k, v)) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + (self.it.remaining, Some(self.it.remaining)) + } +} + +impl<'a, K, V> DoubleEndedIterator for Iter<'a, K, V> +where + (K, V): 'a + BTreeValue, +{ + fn next_back(&mut self) -> Option<Self::Item> { + self.it.next_back().map(|(k, v)| (k, v)) + } +} + +impl<'a, K, V> ExactSizeIterator for Iter<'a, K, V> where (K, V): 'a + BTreeValue {} + +/// An iterator over the differences between two maps. +pub struct DiffIter<'a, K, V> { + it: NodeDiffIter<'a, (K, V)>, +} + +/// A description of a difference between two ordered maps. +#[derive(PartialEq, Eq, Debug)] +pub enum DiffItem<'a, K, V> { + /// This value has been added to the new map. + Add(&'a K, &'a V), + /// This value has been changed between the two maps. + Update { + /// The old value. + old: (&'a K, &'a V), + /// The new value. + new: (&'a K, &'a V), + }, + /// This value has been removed from the new map. + Remove(&'a K, &'a V), +} + +impl<'a, K, V> Iterator for DiffIter<'a, K, V> +where + (K, V): 'a + BTreeValue + PartialEq, +{ + type Item = DiffItem<'a, K, V>; + + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|item| match item { + NodeDiffItem::Add((k, v)) => DiffItem::Add(k, v), + NodeDiffItem::Update { + old: (oldk, oldv), + new: (newk, newv), + } => DiffItem::Update { + old: (oldk, oldv), + new: (newk, newv), + }, + NodeDiffItem::Remove((k, v)) => DiffItem::Remove(k, v), + }) + } +} + +/// An iterator ove the keys of a map. +pub struct Keys<'a, K, V> { + it: Iter<'a, K, V>, +} + +impl<'a, K, V> Iterator for Keys<'a, K, V> +where + K: 'a + Ord, + V: 'a, +{ + type Item = &'a K; + + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|(k, _)| k) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + self.it.size_hint() + } +} + +impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> +where + K: 'a + Ord, + V: 'a, +{ + fn next_back(&mut self) -> Option<Self::Item> { + self.it.next_back().map(|(k, _)| k) + } +} + +impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> +where + K: 'a + Ord, + V: 'a, +{ +} + +/// An iterator over the values of a map. +pub struct Values<'a, K, V> { + it: Iter<'a, K, V>, +} + +impl<'a, K, V> Iterator for Values<'a, K, V> +where + K: 'a + Ord, + V: 'a, +{ + type Item = &'a V; + + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|(_, v)| v) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + self.it.size_hint() + } +} + +impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> +where + K: 'a + Ord, + V: 'a, +{ + fn next_back(&mut self) -> Option<Self::Item> { + self.it.next_back().map(|(_, v)| v) + } +} + +impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> +where + K: 'a + Ord, + V: 'a, +{ +} + +impl<K, V, RK, RV> FromIterator<(RK, RV)> for OrdMap<K, V> +where + K: Ord + Clone + From<RK>, + V: Clone + From<RV>, +{ + fn from_iter<T>(i: T) -> Self + where + T: IntoIterator<Item = (RK, RV)>, + { + let mut m = OrdMap::default(); + for (k, v) in i { + m.insert(From::from(k), From::from(v)); + } + m + } +} + +impl<'a, K, V> IntoIterator for &'a OrdMap<K, V> +where + K: Ord, +{ + type Item = (&'a K, &'a V); + type IntoIter = Iter<'a, K, V>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<K, V> IntoIterator for OrdMap<K, V> +where + K: Ord + Clone, + V: Clone, +{ + type Item = (K, V); + type IntoIter = ConsumingIter<(K, V)>; + + fn into_iter(self) -> Self::IntoIter { + ConsumingIter::new(&self.root, self.size) + } +} + +// Conversions + +impl<K, V> AsRef<OrdMap<K, V>> for OrdMap<K, V> { + fn as_ref(&self) -> &Self { + self + } +} + +impl<'m, 'k, 'v, K, V, OK, OV> From<&'m OrdMap<&'k K, &'v V>> for OrdMap<OK, OV> +where + K: Ord + ToOwned<Owned = OK> + ?Sized, + V: ToOwned<Owned = OV> + ?Sized, + OK: Ord + Clone + Borrow<K>, + OV: Clone + Borrow<V>, +{ + fn from(m: &OrdMap<&K, &V>) -> Self { + m.iter() + .map(|(k, v)| ((*k).to_owned(), (*v).to_owned())) + .collect() + } +} + +impl<'a, K, V, RK, RV, OK, OV> From<&'a [(RK, RV)]> for OrdMap<K, V> +where + K: Ord + Clone + From<OK>, + V: Clone + From<OV>, + OK: Borrow<RK>, + OV: Borrow<RV>, + RK: ToOwned<Owned = OK>, + RV: ToOwned<Owned = OV>, +{ + fn from(m: &'a [(RK, RV)]) -> OrdMap<K, V> { + m.iter() + .map(|&(ref k, ref v)| (k.to_owned(), v.to_owned())) + .collect() + } +} + +impl<K, V, RK, RV> From<Vec<(RK, RV)>> for OrdMap<K, V> +where + K: Ord + Clone + From<RK>, + V: Clone + From<RV>, +{ + fn from(m: Vec<(RK, RV)>) -> OrdMap<K, V> { + m.into_iter().collect() + } +} + +impl<'a, K: Ord, V, RK, RV, OK, OV> From<&'a Vec<(RK, RV)>> for OrdMap<K, V> +where + K: Ord + Clone + From<OK>, + V: Clone + From<OV>, + OK: Borrow<RK>, + OV: Borrow<RV>, + RK: ToOwned<Owned = OK>, + RV: ToOwned<Owned = OV>, +{ + fn from(m: &'a Vec<(RK, RV)>) -> OrdMap<K, V> { + m.iter() + .map(|&(ref k, ref v)| (k.to_owned(), v.to_owned())) + .collect() + } +} + +impl<K: Ord, V, RK: Eq + Hash, RV> From<collections::HashMap<RK, RV>> for OrdMap<K, V> +where + K: Ord + Clone + From<RK>, + V: Clone + From<RV>, +{ + fn from(m: collections::HashMap<RK, RV>) -> OrdMap<K, V> { + m.into_iter().collect() + } +} + +impl<'a, K, V, OK, OV, RK, RV> From<&'a collections::HashMap<RK, RV>> for OrdMap<K, V> +where + K: Ord + Clone + From<OK>, + V: Clone + From<OV>, + OK: Borrow<RK>, + OV: Borrow<RV>, + RK: Hash + Eq + ToOwned<Owned = OK>, + RV: ToOwned<Owned = OV>, +{ + fn from(m: &'a collections::HashMap<RK, RV>) -> OrdMap<K, V> { + m.iter() + .map(|(k, v)| (k.to_owned(), v.to_owned())) + .collect() + } +} + +impl<K: Ord, V, RK, RV> From<collections::BTreeMap<RK, RV>> for OrdMap<K, V> +where + K: Ord + Clone + From<RK>, + V: Clone + From<RV>, +{ + fn from(m: collections::BTreeMap<RK, RV>) -> OrdMap<K, V> { + m.into_iter().collect() + } +} + +impl<'a, K: Ord, V, RK, RV, OK, OV> From<&'a collections::BTreeMap<RK, RV>> for OrdMap<K, V> +where + K: Ord + Clone + From<OK>, + V: Clone + From<OV>, + OK: Borrow<RK>, + OV: Borrow<RV>, + RK: Ord + ToOwned<Owned = OK>, + RV: ToOwned<Owned = OV>, +{ + fn from(m: &'a collections::BTreeMap<RK, RV>) -> OrdMap<K, V> { + m.iter() + .map(|(k, v)| (k.to_owned(), v.to_owned())) + .collect() + } +} + +impl<K: Ord + Hash + Eq + Clone, V: Clone, S: BuildHasher> From<HashMap<K, V, S>> for OrdMap<K, V> { + fn from(m: HashMap<K, V, S>) -> Self { + m.into_iter().collect() + } +} + +impl<'a, K: Ord + Hash + Eq + Clone, V: Clone, S: BuildHasher> From<&'a HashMap<K, V, S>> + for OrdMap<K, V> +{ + fn from(m: &'a HashMap<K, V, S>) -> Self { + m.iter().map(|(k, v)| (k.clone(), v.clone())).collect() + } +} + +// Proptest +#[cfg(any(test, feature = "proptest"))] +#[doc(hidden)] +pub mod proptest { + #[deprecated( + since = "14.3.0", + note = "proptest strategies have moved to im::proptest" + )] + pub use crate::proptest::ord_map; +} + +// Tests + +#[cfg(test)] +mod test { + use super::*; + use crate::proptest::*; + use crate::test::is_sorted; + use ::proptest::num::{i16, usize}; + use ::proptest::{bool, collection, proptest}; + + #[test] + fn iterates_in_order() { + let map = ordmap! { + 2 => 22, + 1 => 11, + 3 => 33, + 8 => 88, + 9 => 99, + 4 => 44, + 5 => 55, + 7 => 77, + 6 => 66 + }; + let mut it = map.iter(); + assert_eq!(it.next(), Some((&1, &11))); + assert_eq!(it.next(), Some((&2, &22))); + assert_eq!(it.next(), Some((&3, &33))); + assert_eq!(it.next(), Some((&4, &44))); + assert_eq!(it.next(), Some((&5, &55))); + assert_eq!(it.next(), Some((&6, &66))); + assert_eq!(it.next(), Some((&7, &77))); + assert_eq!(it.next(), Some((&8, &88))); + assert_eq!(it.next(), Some((&9, &99))); + assert_eq!(it.next(), None); + } + + #[test] + fn into_iter() { + let map = ordmap! { + 2 => 22, + 1 => 11, + 3 => 33, + 8 => 88, + 9 => 99, + 4 => 44, + 5 => 55, + 7 => 77, + 6 => 66 + }; + let mut vec = vec![]; + for (k, v) in map { + assert_eq!(k * 11, v); + vec.push(k) + } + assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7, 8, 9]); + } + + #[test] + fn deletes_correctly() { + let map = ordmap! { + 2 => 22, + 1 => 11, + 3 => 33, + 8 => 88, + 9 => 99, + 4 => 44, + 5 => 55, + 7 => 77, + 6 => 66 + }; + assert_eq!(map.extract(&11), None); + let (popped, less) = map.extract(&5).unwrap(); + assert_eq!(popped, 55); + let mut it = less.iter(); + assert_eq!(it.next(), Some((&1, &11))); + assert_eq!(it.next(), Some((&2, &22))); + assert_eq!(it.next(), Some((&3, &33))); + assert_eq!(it.next(), Some((&4, &44))); + assert_eq!(it.next(), Some((&6, &66))); + assert_eq!(it.next(), Some((&7, &77))); + assert_eq!(it.next(), Some((&8, &88))); + assert_eq!(it.next(), Some((&9, &99))); + assert_eq!(it.next(), None); + } + + #[test] + fn debug_output() { + assert_eq!( + format!("{:?}", ordmap! { 3 => 4, 5 => 6, 1 => 2 }), + "{1: 2, 3: 4, 5: 6}" + ); + } + + #[test] + fn equality2() { + let v1 = "1".to_string(); + let v2 = "1".to_string(); + assert_eq!(v1, v2); + let p1 = Vec::<String>::new(); + let p2 = Vec::<String>::new(); + assert_eq!(p1, p2); + let c1 = OrdMap::unit(v1, p1); + let c2 = OrdMap::unit(v2, p2); + assert_eq!(c1, c2); + } + + #[test] + fn insert_remove_single_mut() { + let mut m = OrdMap::new(); + m.insert(0, 0); + assert_eq!(OrdMap::unit(0, 0), m); + m.remove(&0); + assert_eq!(OrdMap::new(), m); + } + + #[test] + fn double_ended_iterator_1() { + let m = ordmap! {1 => 1, 2 => 2, 3 => 3, 4 => 4}; + let mut it = m.iter(); + assert_eq!(Some((&1, &1)), it.next()); + assert_eq!(Some((&4, &4)), it.next_back()); + assert_eq!(Some((&2, &2)), it.next()); + assert_eq!(Some((&3, &3)), it.next_back()); + assert_eq!(None, it.next()); + } + + #[test] + fn double_ended_iterator_2() { + let m = ordmap! {1 => 1, 2 => 2, 3 => 3, 4 => 4}; + let mut it = m.iter(); + assert_eq!(Some((&1, &1)), it.next()); + assert_eq!(Some((&4, &4)), it.next_back()); + assert_eq!(Some((&2, &2)), it.next()); + assert_eq!(Some((&3, &3)), it.next_back()); + assert_eq!(None, it.next_back()); + } + + #[test] + fn safe_mutation() { + let v1 = (0..131_072).map(|i| (i, i)).collect::<OrdMap<_, _>>(); + let mut v2 = v1.clone(); + v2.insert(131_000, 23); + assert_eq!(Some(&23), v2.get(&131_000)); + assert_eq!(Some(&131_000), v1.get(&131_000)); + } + + #[test] + fn index_operator() { + let mut map = ordmap! {1 => 2, 3 => 4, 5 => 6}; + assert_eq!(4, map[&3]); + map[&3] = 8; + assert_eq!(ordmap! {1 => 2, 3 => 8, 5 => 6}, map); + } + + #[test] + fn entry_api() { + let mut map = ordmap! {"bar" => 5}; + map.entry("foo").and_modify(|v| *v += 5).or_insert(1); + assert_eq!(1, map[&"foo"]); + map.entry("foo").and_modify(|v| *v += 5).or_insert(1); + assert_eq!(6, map[&"foo"]); + map.entry("bar").and_modify(|v| *v += 5).or_insert(1); + assert_eq!(10, map[&"bar"]); + assert_eq!( + 10, + match map.entry("bar") { + Entry::Occupied(entry) => entry.remove(), + _ => panic!(), + } + ); + assert!(!map.contains_key(&"bar")); + } + + #[test] + fn match_string_keys_with_string_slices() { + let mut map: OrdMap<String, i32> = + From::from(ºap! { "foo" => &1, "bar" => &2, "baz" => &3 }); + assert_eq!(Some(&1), map.get("foo")); + map = map.without("foo"); + assert_eq!(Some(3), map.remove("baz")); + map["bar"] = 8; + assert_eq!(8, map["bar"]); + } + + #[test] + fn ranged_iter() { + let map: OrdMap<i32, i32> = ordmap![1=>2, 2=>3, 3=>4, 4=>5, 5=>6, 7=>8]; + let range: Vec<(i32, i32)> = map.range(..).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (7, 8)], range); + let range: Vec<(i32, i32)> = map.range(..).rev().map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(7, 8), (5, 6), (4, 5), (3, 4), (2, 3), (1, 2)], range); + let range: Vec<(i32, i32)> = map.range(2..5).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(2, 3), (3, 4), (4, 5)], range); + let range: Vec<(i32, i32)> = map.range(2..5).rev().map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(4, 5), (3, 4), (2, 3)], range); + let range: Vec<(i32, i32)> = map.range(3..).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(3, 4), (4, 5), (5, 6), (7, 8)], range); + let range: Vec<(i32, i32)> = map.range(3..).rev().map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(7, 8), (5, 6), (4, 5), (3, 4)], range); + let range: Vec<(i32, i32)> = map.range(..4).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(1, 2), (2, 3), (3, 4)], range); + let range: Vec<(i32, i32)> = map.range(..4).rev().map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(3, 4), (2, 3), (1, 2)], range); + let range: Vec<(i32, i32)> = map.range(..=3).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(1, 2), (2, 3), (3, 4)], range); + let range: Vec<(i32, i32)> = map.range(..=3).rev().map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(3, 4), (2, 3), (1, 2)], range); + let range: Vec<(i32, i32)> = map.range(..6).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)], range); + let range: Vec<(i32, i32)> = map.range(..=6).map(|(k, v)| (*k, *v)).collect(); + assert_eq!(vec![(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)], range); + } + + #[test] + fn range_iter_big() { + use crate::nodes::btree::NODE_SIZE; + use std::ops::Bound::Included; + const N: usize = NODE_SIZE * NODE_SIZE * 5; // enough for a sizeable 3 level tree + + let data = (1usize..N).filter(|i| i % 2 == 0).map(|i| (i, ())); + let bmap = data + .clone() + .collect::<std::collections::BTreeMap<usize, ()>>(); + let omap = data.collect::<OrdMap<usize, ()>>(); + + for i in (0..NODE_SIZE * 5).chain(N - NODE_SIZE * 5..=N + 1) { + assert_eq!(omap.range(i..).count(), bmap.range(i..).count()); + assert_eq!(omap.range(..i).count(), bmap.range(..i).count()); + assert_eq!(omap.range(i..i + 7).count(), bmap.range(i..i + 7).count()); + assert_eq!(omap.range(i..=i + 7).count(), bmap.range(i..=i + 7).count()); + assert_eq!( + omap.range((Included(i), Included(i + 7))).count(), + bmap.range((Included(i), Included(i + 7))).count(), + ); + } + } + + #[test] + fn issue_124() { + let mut map = OrdMap::new(); + let contents = include_str!("test-fixtures/issue_124.txt"); + for line in contents.lines() { + if line.starts_with("insert ") { + map.insert(line[7..].parse::<u32>().unwrap(), 0); + } else if line.starts_with("remove ") { + map.remove(&line[7..].parse::<u32>().unwrap()); + } + } + } + + proptest! { + #[test] + fn length(ref input in collection::btree_map(i16::ANY, i16::ANY, 0..1000)) { + let map: OrdMap<i32, i32> = OrdMap::from(input.clone()); + assert_eq!(input.len(), map.len()); + } + + #[test] + fn order(ref input in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) { + let map: OrdMap<i32, i32> = OrdMap::from(input.clone()); + assert!(is_sorted(map.keys())); + } + + #[test] + fn overwrite_values(ref vec in collection::vec((i16::ANY, i16::ANY), 1..1000), index_rand in usize::ANY, new_val in i16::ANY) { + let index = vec[index_rand % vec.len()].0; + let map1 = OrdMap::from_iter(vec.clone()); + let map2 = map1.update(index, new_val); + for (k, v) in map2 { + if k == index { + assert_eq!(v, new_val); + } else { + match map1.get(&k) { + None => panic!("map1 didn't have key {:?}", k), + Some(other_v) => { + assert_eq!(v, *other_v); + } + } + } + } + } + + #[test] + fn delete_values(ref vec in collection::vec((usize::ANY, usize::ANY), 1..1000), index_rand in usize::ANY) { + let index = vec[index_rand % vec.len()].0; + let map1: OrdMap<usize, usize> = OrdMap::from_iter(vec.clone()); + let map2 = map1.without(&index); + assert_eq!(map1.len(), map2.len() + 1); + for k in map2.keys() { + assert_ne!(*k, index); + } + } + + #[test] + fn insert_and_delete_values( + ref input in ord_map(0usize..64, 0usize..64, 1..1000), + ref ops in collection::vec((bool::ANY, usize::ANY, usize::ANY), 1..1000) + ) { + let mut map = input.clone(); + let mut tree: collections::BTreeMap<usize, usize> = input.iter().map(|(k, v)| (*k, *v)).collect(); + for (ins, key, val) in ops { + if *ins { + tree.insert(*key, *val); + map = map.update(*key, *val) + } else { + tree.remove(key); + map = map.without(key) + } + } + assert!(map.iter().map(|(k, v)| (*k, *v)).eq(tree.iter().map(|(k, v)| (*k, *v)))); + } + + #[test] + fn proptest_works(ref m in ord_map(0..9999, ".*", 10..100)) { + assert!(m.len() < 100); + assert!(m.len() >= 10); + } + + #[test] + fn insert_and_length(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) { + let mut map: OrdMap<i16, i16> = OrdMap::new(); + for (k, v) in m.iter() { + map = map.update(*k, *v) + } + assert_eq!(m.len(), map.len()); + } + + #[test] + fn from_iterator(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) { + let map: OrdMap<i16, i16> = + FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v))); + assert_eq!(m.len(), map.len()); + } + + #[test] + fn iterate_over(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) { + let map: OrdMap<i16, i16> = + FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v))); + assert_eq!(m.len(), map.iter().count()); + } + + #[test] + fn equality(ref m in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) { + let map1: OrdMap<i16, i16> = + FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v))); + let map2: OrdMap<i16, i16> = + FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v))); + assert_eq!(map1, map2); + } + + #[test] + fn lookup(ref m in ord_map(i16::ANY, i16::ANY, 0..1000)) { + let map: OrdMap<i16, i16> = + FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v))); + for (k, v) in m.iter() { + assert_eq!(Some(*v), map.get(k).cloned()); + } + } + + #[test] + fn remove(ref m in ord_map(i16::ANY, i16::ANY, 0..1000)) { + let mut map: OrdMap<i16, i16> = + FromIterator::from_iter(m.iter().map(|(k, v)| (*k, *v))); + for k in m.keys() { + let l = map.len(); + assert_eq!(m.get(k).cloned(), map.get(k).cloned()); + map = map.without(k); + assert_eq!(None, map.get(k)); + assert_eq!(l - 1, map.len()); + } + } + + #[test] + fn insert_mut(ref m in ord_map(i16::ANY, i16::ANY, 0..1000)) { + let mut mut_map = OrdMap::new(); + let mut map = OrdMap::new(); + for (k, v) in m.iter() { + map = map.update(*k, *v); + mut_map.insert(*k, *v); + } + assert_eq!(map, mut_map); + } + + #[test] + fn remove_mut(ref orig in ord_map(i16::ANY, i16::ANY, 0..1000)) { + let mut map = orig.clone(); + for key in orig.keys() { + let len = map.len(); + assert_eq!(orig.get(key), map.get(key)); + assert_eq!(orig.get(key).cloned(), map.remove(key)); + assert_eq!(None, map.get(key)); + assert_eq!(len - 1, map.len()); + } + } + + #[test] + fn remove_alien(ref orig in collection::hash_map(i16::ANY, i16::ANY, 0..1000)) { + let mut map = OrdMap::<i16, i16>::from(orig.clone()); + for key in orig.keys() { + let len = map.len(); + assert_eq!(orig.get(key), map.get(key)); + assert_eq!(orig.get(key).cloned(), map.remove(key)); + assert_eq!(None, map.get(key)); + assert_eq!(len - 1, map.len()); + } + } + + #[test] + fn delete_and_reinsert( + ref input in collection::hash_map(i16::ANY, i16::ANY, 1..1000), + index_rand in usize::ANY + ) { + let index = *input.keys().nth(index_rand % input.len()).unwrap(); + let map1 = OrdMap::from_iter(input.clone()); + let (val, map2): (i16, _) = map1.extract(&index).unwrap(); + let map3 = map2.update(index, val); + for key in map2.keys() { + assert!(*key != index); + } + assert_eq!(map1.len(), map2.len() + 1); + assert_eq!(map1, map3); + } + + #[test] + fn exact_size_iterator(ref m in ord_map(i16::ANY, i16::ANY, 1..1000)) { + let mut should_be = m.len(); + let mut it = m.iter(); + loop { + assert_eq!(should_be, it.len()); + match it.next() { + None => break, + Some(_) => should_be -= 1, + } + } + assert_eq!(0, it.len()); + } + + #[test] + fn diff_all_values(a in collection::vec((usize::ANY, usize::ANY), 1..1000), b in collection::vec((usize::ANY, usize::ANY), 1..1000)) { + let a: OrdMap<usize, usize> = OrdMap::from(a); + let b: OrdMap<usize, usize> = OrdMap::from(b); + + let diff: Vec<_> = a.diff(&b).collect(); + let union = b.clone().union(a.clone()); + let expected: Vec<_> = union.iter().filter_map(|(k, v)| { + if a.contains_key(k) { + if b.contains_key(k) { + let old = a.get(k).unwrap(); + if old != v { + Some(DiffItem::Update { + old: (k, old), + new: (k, v), + }) + } else { + None + } + } else { + Some(DiffItem::Remove(k, v)) + } + } else { + Some(DiffItem::Add(k, v)) + } + }).collect(); + assert_eq!(expected, diff); + } + } +} diff --git a/vendor/im-rc/src/ord/mod.rs b/vendor/im-rc/src/ord/mod.rs new file mode 100644 index 000000000..27a56a5e2 --- /dev/null +++ b/vendor/im-rc/src/ord/mod.rs @@ -0,0 +1,8 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +#[macro_use] +pub mod map; +#[macro_use] +pub mod set; diff --git a/vendor/im-rc/src/ord/set.rs b/vendor/im-rc/src/ord/set.rs new file mode 100644 index 000000000..60ad6adcc --- /dev/null +++ b/vendor/im-rc/src/ord/set.rs @@ -0,0 +1,1243 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +//! An ordered set. +//! +//! An immutable ordered set implemented as a [B-tree] [1]. +//! +//! Most operations on this type of set are O(log n). A +//! [`HashSet`][hashset::HashSet] is usually a better choice for +//! performance, but the `OrdSet` has the advantage of only requiring +//! an [`Ord`][std::cmp::Ord] constraint on its values, and of being +//! ordered, so values always come out from lowest to highest, where a +//! [`HashSet`][hashset::HashSet] has no guaranteed ordering. +//! +//! [1]: https://en.wikipedia.org/wiki/B-tree +//! [hashset::HashSet]: ./struct.HashSet.html +//! [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html + +use std::borrow::Borrow; +use std::cmp::Ordering; +use std::collections; +use std::fmt::{Debug, Error, Formatter}; +use std::hash::{BuildHasher, Hash, Hasher}; +use std::iter::{FromIterator, IntoIterator, Sum}; +use std::ops::{Add, Deref, Mul, RangeBounds}; + +use crate::hashset::HashSet; +use crate::nodes::btree::{ + BTreeValue, ConsumingIter as ConsumingNodeIter, DiffIter as NodeDiffIter, Insert, + Iter as NodeIter, Node, Remove, +}; +#[cfg(has_specialisation)] +use crate::util::linear_search_by; +use crate::util::{Pool, PoolRef}; + +pub use crate::nodes::btree::DiffItem; + +/// Construct a set from a sequence of values. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use im::ordset::OrdSet; +/// # fn main() { +/// assert_eq!( +/// ordset![1, 2, 3], +/// OrdSet::from(vec![1, 2, 3]) +/// ); +/// # } +/// ``` +#[macro_export] +macro_rules! ordset { + () => { $crate::ordset::OrdSet::new() }; + + ( $($x:expr),* ) => {{ + let mut l = $crate::ordset::OrdSet::new(); + $( + l.insert($x); + )* + l + }}; +} + +#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug)] +struct Value<A>(A); + +impl<A> Deref for Value<A> { + type Target = A; + fn deref(&self) -> &Self::Target { + &self.0 + } +} + +// FIXME lacking specialisation, we can't simply implement `BTreeValue` +// for `A`, we have to use the `Value<A>` indirection. +#[cfg(not(has_specialisation))] +impl<A: Ord> BTreeValue for Value<A> { + type Key = A; + + fn ptr_eq(&self, _other: &Self) -> bool { + false + } + + fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + slice.binary_search_by(|value| Self::Key::borrow(value).cmp(key)) + } + + fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> { + slice.binary_search_by(|value| value.cmp(key)) + } + + fn cmp_keys<BK>(&self, other: &BK) -> Ordering + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + Self::Key::borrow(self).cmp(other) + } + + fn cmp_values(&self, other: &Self) -> Ordering { + self.cmp(other) + } +} + +#[cfg(has_specialisation)] +impl<A: Ord> BTreeValue for Value<A> { + type Key = A; + + fn ptr_eq(&self, _other: &Self) -> bool { + false + } + + default fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + slice.binary_search_by(|value| Self::Key::borrow(value).cmp(key)) + } + + default fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> { + slice.binary_search_by(|value| value.cmp(key)) + } + + fn cmp_keys<BK>(&self, other: &BK) -> Ordering + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + Self::Key::borrow(self).cmp(other) + } + + fn cmp_values(&self, other: &Self) -> Ordering { + self.cmp(other) + } +} + +#[cfg(has_specialisation)] +impl<A: Ord + Copy> BTreeValue for Value<A> { + fn search_key<BK>(slice: &[Self], key: &BK) -> Result<usize, usize> + where + BK: Ord + ?Sized, + Self::Key: Borrow<BK>, + { + linear_search_by(slice, |value| Self::Key::borrow(value).cmp(key)) + } + + fn search_value(slice: &[Self], key: &Self) -> Result<usize, usize> { + linear_search_by(slice, |value| value.cmp(key)) + } +} + +def_pool!(OrdSetPool<A>, Node<Value<A>>); + +/// An ordered set. +/// +/// An immutable ordered set implemented as a [B-tree] [1]. +/// +/// Most operations on this type of set are O(log n). A +/// [`HashSet`][hashset::HashSet] is usually a better choice for +/// performance, but the `OrdSet` has the advantage of only requiring +/// an [`Ord`][std::cmp::Ord] constraint on its values, and of being +/// ordered, so values always come out from lowest to highest, where a +/// [`HashSet`][hashset::HashSet] has no guaranteed ordering. +/// +/// [1]: https://en.wikipedia.org/wiki/B-tree +/// [hashset::HashSet]: ./struct.HashSet.html +/// [std::cmp::Ord]: https://doc.rust-lang.org/std/cmp/trait.Ord.html +pub struct OrdSet<A> { + size: usize, + pool: OrdSetPool<A>, + root: PoolRef<Node<Value<A>>>, +} + +impl<A> OrdSet<A> { + /// Construct an empty set. + #[must_use] + pub fn new() -> Self { + let pool = OrdSetPool::default(); + let root = PoolRef::default(&pool.0); + OrdSet { + size: 0, + pool, + root, + } + } + + /// Construct an empty set using a specific memory pool. + #[cfg(feature = "pool")] + #[must_use] + pub fn with_pool(pool: &OrdSetPool<A>) -> Self { + let root = PoolRef::default(&pool.0); + OrdSet { + size: 0, + pool: pool.clone(), + root, + } + } + + /// Construct a set with a single value. + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set = OrdSet::unit(123); + /// assert!(set.contains(&123)); + /// ``` + #[inline] + #[must_use] + pub fn unit(a: A) -> Self { + let pool = OrdSetPool::default(); + let root = PoolRef::new(&pool.0, Node::unit(Value(a))); + OrdSet { + size: 1, + pool, + root, + } + } + + /// Test whether a set is empty. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// assert!( + /// !ordset![1, 2, 3].is_empty() + /// ); + /// assert!( + /// OrdSet::<i32>::new().is_empty() + /// ); + /// ``` + #[inline] + #[must_use] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Get the size of a set. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// assert_eq!(3, ordset![1, 2, 3].len()); + /// ``` + #[inline] + #[must_use] + pub fn len(&self) -> usize { + self.size + } + + /// Test whether two sets refer to the same content in memory. + /// + /// This is true if the two sides are references to the same set, + /// or if the two sets refer to the same root node. + /// + /// This would return true if you're comparing a set to itself, or + /// if you're comparing a set to a fresh clone of itself. + /// + /// Time: O(1) + pub fn ptr_eq(&self, other: &Self) -> bool { + std::ptr::eq(self, other) || PoolRef::ptr_eq(&self.root, &other.root) + } + + /// Get a reference to the memory pool used by this set. + /// + /// Note that if you didn't specifically construct it with a pool, you'll + /// get back a reference to a pool of size 0. + #[cfg(feature = "pool")] + pub fn pool(&self) -> &OrdSetPool<A> { + &self.pool + } + + /// Discard all elements from the set. + /// + /// This leaves you with an empty set, and all elements that + /// were previously inside it are dropped. + /// + /// Time: O(n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdSet; + /// let mut set = ordset![1, 2, 3]; + /// set.clear(); + /// assert!(set.is_empty()); + /// ``` + pub fn clear(&mut self) { + if !self.is_empty() { + self.root = PoolRef::default(&self.pool.0); + self.size = 0; + } + } +} + +impl<A> OrdSet<A> +where + A: Ord, +{ + /// Get the smallest value in a set. + /// + /// If the set is empty, returns `None`. + /// + /// Time: O(log n) + #[must_use] + pub fn get_min(&self) -> Option<&A> { + self.root.min().map(Deref::deref) + } + + /// Get the largest value in a set. + /// + /// If the set is empty, returns `None`. + /// + /// Time: O(log n) + #[must_use] + pub fn get_max(&self) -> Option<&A> { + self.root.max().map(Deref::deref) + } + + /// Create an iterator over the contents of the set. + #[must_use] + pub fn iter(&self) -> Iter<'_, A> { + Iter { + it: NodeIter::new(&self.root, self.size, ..), + } + } + + /// Create an iterator over a range inside the set. + #[must_use] + pub fn range<R, BA>(&self, range: R) -> RangedIter<'_, A> + where + R: RangeBounds<BA>, + A: Borrow<BA>, + BA: Ord + ?Sized, + { + RangedIter { + it: NodeIter::new(&self.root, self.size, range), + } + } + + /// Get an iterator over the differences between this set and + /// another, i.e. the set of entries to add or remove to this set + /// in order to make it equal to the other set. + /// + /// This function will avoid visiting nodes which are shared + /// between the two sets, meaning that even very large sets can be + /// compared quickly if most of their structure is shared. + /// + /// Time: O(n) (where n is the number of unique elements across + /// the two sets, minus the number of elements belonging to nodes + /// shared between them) + #[must_use] + pub fn diff<'a>(&'a self, other: &'a Self) -> DiffIter<'_, A> { + DiffIter { + it: NodeDiffIter::new(&self.root, &other.root), + } + } + + /// Test if a value is part of a set. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let mut set = ordset!{1, 2, 3}; + /// assert!(set.contains(&1)); + /// assert!(!set.contains(&4)); + /// ``` + #[inline] + #[must_use] + pub fn contains<BA>(&self, a: &BA) -> bool + where + BA: Ord + ?Sized, + A: Borrow<BA>, + { + self.root.lookup(a).is_some() + } + + /// Get the closest smaller value in a set to a given value. + /// + /// If the set contains the given value, this is returned. + /// Otherwise, the closest value in the set smaller than the + /// given value is returned. If the smallest value in the set + /// is larger than the given value, `None` is returned. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdSet; + /// let set = ordset![1, 3, 5, 7, 9]; + /// assert_eq!(Some(&5), set.get_prev(&6)); + /// ``` + #[must_use] + pub fn get_prev(&self, key: &A) -> Option<&A> { + self.root.lookup_prev(key).map(|v| &v.0) + } + + /// Get the closest larger value in a set to a given value. + /// + /// If the set contains the given value, this is returned. + /// Otherwise, the closest value in the set larger than the + /// given value is returned. If the largest value in the set + /// is smaller than the given value, `None` is returned. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::OrdSet; + /// let set = ordset![1, 3, 5, 7, 9]; + /// assert_eq!(Some(&5), set.get_next(&4)); + /// ``` + #[must_use] + pub fn get_next(&self, key: &A) -> Option<&A> { + self.root.lookup_next(key).map(|v| &v.0) + } + + /// Test whether a set is a subset of another set, meaning that + /// all values in our set must also be in the other set. + /// + /// Time: O(n log m) where m is the size of the other set + #[must_use] + pub fn is_subset<RS>(&self, other: RS) -> bool + where + RS: Borrow<Self>, + { + let other = other.borrow(); + if other.len() < self.len() { + return false; + } + self.iter().all(|a| other.contains(a)) + } + + /// Test whether a set is a proper subset of another set, meaning + /// that all values in our set must also be in the other set. A + /// proper subset must also be smaller than the other set. + /// + /// Time: O(n log m) where m is the size of the other set + #[must_use] + pub fn is_proper_subset<RS>(&self, other: RS) -> bool + where + RS: Borrow<Self>, + { + self.len() != other.borrow().len() && self.is_subset(other) + } +} + +impl<A> OrdSet<A> +where + A: Ord + Clone, +{ + /// Insert a value into a set. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let mut set = ordset!{}; + /// set.insert(123); + /// set.insert(456); + /// assert_eq!( + /// set, + /// ordset![123, 456] + /// ); + /// ``` + #[inline] + pub fn insert(&mut self, a: A) -> Option<A> { + let new_root = { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + match root.insert(&self.pool.0, Value(a)) { + Insert::Replaced(Value(old_value)) => return Some(old_value), + Insert::Added => { + self.size += 1; + return None; + } + Insert::Split(left, median, right) => PoolRef::new( + &self.pool.0, + Node::new_from_split(&self.pool.0, left, median, right), + ), + } + }; + self.size += 1; + self.root = new_root; + None + } + + /// Remove a value from a set. + /// + /// Time: O(log n) + #[inline] + pub fn remove<BA>(&mut self, a: &BA) -> Option<A> + where + BA: Ord + ?Sized, + A: Borrow<BA>, + { + let (new_root, removed_value) = { + let root = PoolRef::make_mut(&self.pool.0, &mut self.root); + match root.remove(&self.pool.0, a) { + Remove::Update(value, root) => (PoolRef::new(&self.pool.0, root), Some(value.0)), + Remove::Removed(value) => { + self.size -= 1; + return Some(value.0); + } + Remove::NoChange => return None, + } + }; + self.size -= 1; + self.root = new_root; + removed_value + } + + /// Remove the smallest value from a set. + /// + /// Time: O(log n) + pub fn remove_min(&mut self) -> Option<A> { + // FIXME implement this at the node level for better efficiency + let key = match self.get_min() { + None => return None, + Some(v) => v, + } + .clone(); + self.remove(&key) + } + + /// Remove the largest value from a set. + /// + /// Time: O(log n) + pub fn remove_max(&mut self) -> Option<A> { + // FIXME implement this at the node level for better efficiency + let key = match self.get_max() { + None => return None, + Some(v) => v, + } + .clone(); + self.remove(&key) + } + + /// Construct a new set from the current set with the given value + /// added. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set = ordset![456]; + /// assert_eq!( + /// set.update(123), + /// ordset![123, 456] + /// ); + /// ``` + #[must_use] + pub fn update(&self, a: A) -> Self { + let mut out = self.clone(); + out.insert(a); + out + } + + /// Construct a new set with the given value removed if it's in + /// the set. + /// + /// Time: O(log n) + #[must_use] + pub fn without<BA>(&self, a: &BA) -> Self + where + BA: Ord + ?Sized, + A: Borrow<BA>, + { + let mut out = self.clone(); + out.remove(a); + out + } + + /// Remove the smallest value from a set, and return that value as + /// well as the updated set. + /// + /// Time: O(log n) + #[must_use] + pub fn without_min(&self) -> (Option<A>, Self) { + match self.get_min() { + Some(v) => (Some(v.clone()), self.without(v)), + None => (None, self.clone()), + } + } + + /// Remove the largest value from a set, and return that value as + /// well as the updated set. + /// + /// Time: O(log n) + #[must_use] + pub fn without_max(&self) -> (Option<A>, Self) { + match self.get_max() { + Some(v) => (Some(v.clone()), self.without(v)), + None => (None, self.clone()), + } + } + + /// Construct the union of two sets. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set1 = ordset!{1, 2}; + /// let set2 = ordset!{2, 3}; + /// let expected = ordset!{1, 2, 3}; + /// assert_eq!(expected, set1.union(set2)); + /// ``` + #[must_use] + pub fn union(self, other: Self) -> Self { + let (mut to_mutate, to_consume) = if self.len() >= other.len() { + (self, other) + } else { + (other, self) + }; + for value in to_consume { + to_mutate.insert(value); + } + to_mutate + } + + /// Construct the union of multiple sets. + /// + /// Time: O(n log n) + #[must_use] + pub fn unions<I>(i: I) -> Self + where + I: IntoIterator<Item = Self>, + { + i.into_iter().fold(Self::default(), Self::union) + } + + /// Construct the symmetric difference between two sets. + /// + /// This is an alias for the + /// [`symmetric_difference`][symmetric_difference] method. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set1 = ordset!{1, 2}; + /// let set2 = ordset!{2, 3}; + /// let expected = ordset!{1, 3}; + /// assert_eq!(expected, set1.difference(set2)); + /// ``` + /// + /// [symmetric_difference]: #method.symmetric_difference + #[must_use] + pub fn difference(self, other: Self) -> Self { + self.symmetric_difference(other) + } + + /// Construct the symmetric difference between two sets. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set1 = ordset!{1, 2}; + /// let set2 = ordset!{2, 3}; + /// let expected = ordset!{1, 3}; + /// assert_eq!(expected, set1.symmetric_difference(set2)); + /// ``` + #[must_use] + pub fn symmetric_difference(mut self, other: Self) -> Self { + for value in other { + if self.remove(&value).is_none() { + self.insert(value); + } + } + self + } + + /// Construct the relative complement between two sets, that is the set + /// of values in `self` that do not occur in `other`. + /// + /// Time: O(m log n) where m is the size of the other set + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set1 = ordset!{1, 2}; + /// let set2 = ordset!{2, 3}; + /// let expected = ordset!{1}; + /// assert_eq!(expected, set1.relative_complement(set2)); + /// ``` + #[must_use] + pub fn relative_complement(mut self, other: Self) -> Self { + for value in other { + let _ = self.remove(&value); + } + self + } + + /// Construct the intersection of two sets. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::ordset::OrdSet; + /// let set1 = ordset!{1, 2}; + /// let set2 = ordset!{2, 3}; + /// let expected = ordset!{2}; + /// assert_eq!(expected, set1.intersection(set2)); + /// ``` + #[must_use] + pub fn intersection(self, other: Self) -> Self { + let mut out = Self::default(); + for value in other { + if self.contains(&value) { + out.insert(value); + } + } + out + } + + /// Split a set into two, with the left hand set containing values + /// which are smaller than `split`, and the right hand set + /// containing values which are larger than `split`. + /// + /// The `split` value itself is discarded. + /// + /// Time: O(n) + #[must_use] + pub fn split<BA>(self, split: &BA) -> (Self, Self) + where + BA: Ord + ?Sized, + A: Borrow<BA>, + { + let (left, _, right) = self.split_member(split); + (left, right) + } + + /// Split a set into two, with the left hand set containing values + /// which are smaller than `split`, and the right hand set + /// containing values which are larger than `split`. + /// + /// Returns a tuple of the two sets and a boolean which is true if + /// the `split` value existed in the original set, and false + /// otherwise. + /// + /// Time: O(n) + #[must_use] + pub fn split_member<BA>(self, split: &BA) -> (Self, bool, Self) + where + BA: Ord + ?Sized, + A: Borrow<BA>, + { + let mut left = Self::default(); + let mut right = Self::default(); + let mut present = false; + for value in self { + match value.borrow().cmp(split) { + Ordering::Less => { + left.insert(value); + } + Ordering::Equal => { + present = true; + } + Ordering::Greater => { + right.insert(value); + } + } + } + (left, present, right) + } + + /// Construct a set with only the `n` smallest values from a given + /// set. + /// + /// Time: O(n) + #[must_use] + pub fn take(&self, n: usize) -> Self { + self.iter().take(n).cloned().collect() + } + + /// Construct a set with the `n` smallest values removed from a + /// given set. + /// + /// Time: O(n) + #[must_use] + pub fn skip(&self, n: usize) -> Self { + self.iter().skip(n).cloned().collect() + } +} + +// Core traits + +impl<A> Clone for OrdSet<A> { + /// Clone a set. + /// + /// Time: O(1) + #[inline] + fn clone(&self) -> Self { + OrdSet { + size: self.size, + pool: self.pool.clone(), + root: self.root.clone(), + } + } +} + +impl<A: Ord> PartialEq for OrdSet<A> { + fn eq(&self, other: &Self) -> bool { + PoolRef::ptr_eq(&self.root, &other.root) + || (self.len() == other.len() && self.diff(other).next().is_none()) + } +} + +impl<A: Ord + Eq> Eq for OrdSet<A> {} + +impl<A: Ord> PartialOrd for OrdSet<A> { + fn partial_cmp(&self, other: &Self) -> Option<Ordering> { + self.iter().partial_cmp(other.iter()) + } +} + +impl<A: Ord> Ord for OrdSet<A> { + fn cmp(&self, other: &Self) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +impl<A: Ord + Hash> Hash for OrdSet<A> { + fn hash<H>(&self, state: &mut H) + where + H: Hasher, + { + for i in self.iter() { + i.hash(state); + } + } +} + +impl<A> Default for OrdSet<A> { + fn default() -> Self { + OrdSet::new() + } +} + +impl<A: Ord + Clone> Add for OrdSet<A> { + type Output = OrdSet<A>; + + fn add(self, other: Self) -> Self::Output { + self.union(other) + } +} + +impl<'a, A: Ord + Clone> Add for &'a OrdSet<A> { + type Output = OrdSet<A>; + + fn add(self, other: Self) -> Self::Output { + self.clone().union(other.clone()) + } +} + +impl<A: Ord + Clone> Mul for OrdSet<A> { + type Output = OrdSet<A>; + + fn mul(self, other: Self) -> Self::Output { + self.intersection(other) + } +} + +impl<'a, A: Ord + Clone> Mul for &'a OrdSet<A> { + type Output = OrdSet<A>; + + fn mul(self, other: Self) -> Self::Output { + self.clone().intersection(other.clone()) + } +} + +impl<A: Ord + Clone> Sum for OrdSet<A> { + fn sum<I>(it: I) -> Self + where + I: Iterator<Item = Self>, + { + it.fold(Self::new(), |a, b| a + b) + } +} + +impl<A, R> Extend<R> for OrdSet<A> +where + A: Ord + Clone + From<R>, +{ + fn extend<I>(&mut self, iter: I) + where + I: IntoIterator<Item = R>, + { + for value in iter { + self.insert(From::from(value)); + } + } +} + +impl<A: Ord + Debug> Debug for OrdSet<A> { + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + f.debug_set().entries(self.iter()).finish() + } +} + +// Iterators + +/// An iterator over the elements of a set. +pub struct Iter<'a, A> { + it: NodeIter<'a, Value<A>>, +} + +impl<'a, A> Iterator for Iter<'a, A> +where + A: 'a + Ord, +{ + type Item = &'a A; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(Deref::deref) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + (self.it.remaining, Some(self.it.remaining)) + } +} + +impl<'a, A> DoubleEndedIterator for Iter<'a, A> +where + A: 'a + Ord, +{ + fn next_back(&mut self) -> Option<Self::Item> { + self.it.next_back().map(Deref::deref) + } +} + +impl<'a, A> ExactSizeIterator for Iter<'a, A> where A: 'a + Ord {} + +/// A ranged iterator over the elements of a set. +/// +/// The only difference from `Iter` is that this one doesn't implement +/// `ExactSizeIterator` because we can't know the size of the range without first +/// iterating over it to count. +pub struct RangedIter<'a, A> { + it: NodeIter<'a, Value<A>>, +} + +impl<'a, A> Iterator for RangedIter<'a, A> +where + A: 'a + Ord, +{ + type Item = &'a A; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(Deref::deref) + } + + fn size_hint(&self) -> (usize, Option<usize>) { + self.it.size_hint() + } +} + +impl<'a, A> DoubleEndedIterator for RangedIter<'a, A> +where + A: 'a + Ord, +{ + fn next_back(&mut self) -> Option<Self::Item> { + self.it.next_back().map(Deref::deref) + } +} + +/// A consuming iterator over the elements of a set. +pub struct ConsumingIter<A> { + it: ConsumingNodeIter<Value<A>>, +} + +impl<A> Iterator for ConsumingIter<A> +where + A: Ord + Clone, +{ + type Item = A; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|v| v.0) + } +} + +/// An iterator over the difference between two sets. +pub struct DiffIter<'a, A> { + it: NodeDiffIter<'a, Value<A>>, +} + +impl<'a, A> Iterator for DiffIter<'a, A> +where + A: Ord + PartialEq, +{ + type Item = DiffItem<'a, A>; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + self.it.next().map(|item| match item { + DiffItem::Add(v) => DiffItem::Add(v.deref()), + DiffItem::Update { old, new } => DiffItem::Update { + old: old.deref(), + new: new.deref(), + }, + DiffItem::Remove(v) => DiffItem::Remove(v.deref()), + }) + } +} + +impl<A, R> FromIterator<R> for OrdSet<A> +where + A: Ord + Clone + From<R>, +{ + fn from_iter<T>(i: T) -> Self + where + T: IntoIterator<Item = R>, + { + let mut out = Self::new(); + for item in i { + out.insert(From::from(item)); + } + out + } +} + +impl<'a, A> IntoIterator for &'a OrdSet<A> +where + A: 'a + Ord, +{ + type Item = &'a A; + type IntoIter = Iter<'a, A>; + + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<A> IntoIterator for OrdSet<A> +where + A: Ord + Clone, +{ + type Item = A; + type IntoIter = ConsumingIter<A>; + + fn into_iter(self) -> Self::IntoIter { + ConsumingIter { + it: ConsumingNodeIter::new(&self.root, self.size), + } + } +} + +// Conversions + +impl<'s, 'a, A, OA> From<&'s OrdSet<&'a A>> for OrdSet<OA> +where + A: ToOwned<Owned = OA> + Ord + ?Sized, + OA: Borrow<A> + Ord + Clone, +{ + fn from(set: &OrdSet<&A>) -> Self { + set.iter().map(|a| (*a).to_owned()).collect() + } +} + +impl<'a, A> From<&'a [A]> for OrdSet<A> +where + A: Ord + Clone, +{ + fn from(slice: &'a [A]) -> Self { + slice.iter().cloned().collect() + } +} + +impl<A: Ord + Clone> From<Vec<A>> for OrdSet<A> { + fn from(vec: Vec<A>) -> Self { + vec.into_iter().collect() + } +} + +impl<'a, A: Ord + Clone> From<&'a Vec<A>> for OrdSet<A> { + fn from(vec: &Vec<A>) -> Self { + vec.iter().cloned().collect() + } +} + +impl<A: Eq + Hash + Ord + Clone> From<collections::HashSet<A>> for OrdSet<A> { + fn from(hash_set: collections::HashSet<A>) -> Self { + hash_set.into_iter().collect() + } +} + +impl<'a, A: Eq + Hash + Ord + Clone> From<&'a collections::HashSet<A>> for OrdSet<A> { + fn from(hash_set: &collections::HashSet<A>) -> Self { + hash_set.iter().cloned().collect() + } +} + +impl<A: Ord + Clone> From<collections::BTreeSet<A>> for OrdSet<A> { + fn from(btree_set: collections::BTreeSet<A>) -> Self { + btree_set.into_iter().collect() + } +} + +impl<'a, A: Ord + Clone> From<&'a collections::BTreeSet<A>> for OrdSet<A> { + fn from(btree_set: &collections::BTreeSet<A>) -> Self { + btree_set.iter().cloned().collect() + } +} + +impl<A: Hash + Eq + Ord + Clone, S: BuildHasher> From<HashSet<A, S>> for OrdSet<A> { + fn from(hashset: HashSet<A, S>) -> Self { + hashset.into_iter().collect() + } +} + +impl<'a, A: Hash + Eq + Ord + Clone, S: BuildHasher> From<&'a HashSet<A, S>> for OrdSet<A> { + fn from(hashset: &HashSet<A, S>) -> Self { + hashset.into_iter().cloned().collect() + } +} + +// Proptest +#[cfg(any(test, feature = "proptest"))] +#[doc(hidden)] +pub mod proptest { + #[deprecated( + since = "14.3.0", + note = "proptest strategies have moved to im::proptest" + )] + pub use crate::proptest::ord_set; +} + +#[cfg(test)] +mod test { + use super::*; + use crate::proptest::*; + use ::proptest::proptest; + + #[test] + fn match_strings_with_string_slices() { + let mut set: OrdSet<String> = From::from(&ordset!["foo", "bar"]); + set = set.without("bar"); + assert!(!set.contains("bar")); + set.remove("foo"); + assert!(!set.contains("foo")); + } + + #[test] + fn ranged_iter() { + let set: OrdSet<i32> = ordset![1, 2, 3, 4, 5]; + let range: Vec<i32> = set.range(..).cloned().collect(); + assert_eq!(vec![1, 2, 3, 4, 5], range); + let range: Vec<i32> = set.range(..).rev().cloned().collect(); + assert_eq!(vec![5, 4, 3, 2, 1], range); + let range: Vec<i32> = set.range(2..5).cloned().collect(); + assert_eq!(vec![2, 3, 4], range); + let range: Vec<i32> = set.range(2..5).rev().cloned().collect(); + assert_eq!(vec![4, 3, 2], range); + let range: Vec<i32> = set.range(3..).cloned().collect(); + assert_eq!(vec![3, 4, 5], range); + let range: Vec<i32> = set.range(3..).rev().cloned().collect(); + assert_eq!(vec![5, 4, 3], range); + let range: Vec<i32> = set.range(..4).cloned().collect(); + assert_eq!(vec![1, 2, 3], range); + let range: Vec<i32> = set.range(..4).rev().cloned().collect(); + assert_eq!(vec![3, 2, 1], range); + let range: Vec<i32> = set.range(..=3).cloned().collect(); + assert_eq!(vec![1, 2, 3], range); + let range: Vec<i32> = set.range(..=3).rev().cloned().collect(); + assert_eq!(vec![3, 2, 1], range); + } + + proptest! { + #[test] + fn proptest_a_set(ref s in ord_set(".*", 10..100)) { + assert!(s.len() < 100); + assert!(s.len() >= 10); + } + + #[test] + fn long_ranged_iter(max in 1..1000) { + let range = 0..max; + let expected: Vec<i32> = range.clone().collect(); + let set: OrdSet<i32> = range.clone().collect::<OrdSet<_>>(); + let result: Vec<i32> = set.range(..).cloned().collect(); + assert_eq!(expected, result); + + let expected: Vec<i32> = range.clone().rev().collect(); + let set: OrdSet<i32> = range.collect::<OrdSet<_>>(); + let result: Vec<i32> = set.range(..).rev().cloned().collect(); + assert_eq!(expected, result); + } + } +} diff --git a/vendor/im-rc/src/ord/test-fixtures/issue_124.txt b/vendor/im-rc/src/ord/test-fixtures/issue_124.txt new file mode 100644 index 000000000..51786177e --- /dev/null +++ b/vendor/im-rc/src/ord/test-fixtures/issue_124.txt @@ -0,0 +1,3492 @@ +insert 1495 +insert 1568 +insert 1313 +insert 824 +insert 926 +insert 3031 +insert 872 +insert 1330 +insert 2356 +insert 298 +insert 1957 +insert 2133 +insert 3295 +insert 1139 +insert 2895 +insert 2442 +insert 553 +insert 2637 +insert 2571 +insert 352 +insert 1076 +insert 1611 +insert 902 +insert 480 +insert 1489 +insert 3223 +insert 169 +insert 2912 +insert 2276 +insert 1512 +insert 291 +insert 137 +insert 2917 +insert 2509 +insert 1729 +insert 62 +insert 1381 +insert 647 +insert 1647 +insert 2064 +insert 1847 +insert 1618 +insert 528 +insert 431 +insert 639 +insert 1910 +insert 1764 +insert 114 +insert 2872 +insert 2911 +insert 999 +insert 15 +insert 53 +insert 1924 +insert 2195 +insert 1134 +insert 269 +insert 2903 +insert 432 +insert 149 +insert 1241 +insert 3266 +insert 1975 +insert 2095 +insert 1384 +insert 2858 +insert 2814 +insert 2735 +insert 2779 +insert 991 +insert 1725 +insert 1804 +insert 959 +insert 1395 +insert 720 +insert 1758 +insert 1459 +insert 925 +insert 860 +insert 1035 +insert 1310 +insert 2892 +insert 3129 +insert 891 +insert 913 +insert 2136 +insert 45 +insert 255 +insert 2980 +insert 2918 +insert 2234 +insert 2845 +insert 2135 +insert 2818 +insert 978 +insert 2038 +insert 2251 +insert 14 +insert 333 +insert 649 +insert 1947 +insert 1768 +insert 3309 +insert 3063 +insert 788 +insert 65 +insert 833 +insert 1038 +insert 1966 +insert 1746 +insert 1595 +insert 2512 +insert 1543 +insert 1269 +insert 243 +insert 175 +insert 259 +insert 4 +insert 2715 +insert 297 +insert 2386 +insert 1060 +insert 2686 +insert 2400 +insert 2548 +insert 278 +insert 1890 +insert 1777 +insert 1424 +insert 2109 +insert 3307 +insert 1974 +insert 1985 +insert 3144 +insert 1186 +insert 1945 +insert 3184 +insert 1488 +insert 1707 +insert 2915 +insert 2995 +insert 2467 +insert 1791 +insert 1309 +insert 2916 +insert 1941 +insert 1824 +insert 1525 +insert 1626 +insert 1687 +insert 2333 +insert 2198 +insert 1237 +insert 2931 +insert 2764 +insert 2609 +insert 1202 +insert 1314 +insert 1556 +insert 1892 +insert 2329 +insert 2065 +insert 1559 +insert 2282 +insert 3279 +insert 1651 +insert 1610 +insert 2039 +insert 3269 +insert 1948 +insert 1663 +insert 1627 +insert 943 +insert 2313 +insert 1048 +insert 2399 +insert 2302 +insert 1022 +insert 946 +insert 2303 +insert 1085 +insert 108 +insert 2738 +insert 1311 +insert 844 +insert 1166 +insert 3198 +insert 1093 +insert 1192 +insert 1508 +insert 2471 +insert 2518 +insert 3209 +insert 1149 +insert 1743 +insert 1770 +insert 960 +insert 895 +insert 1806 +insert 1137 +insert 1654 +insert 1386 +insert 2727 +insert 1379 +insert 2572 +insert 128 +insert 2476 +insert 182 +insert 1037 +insert 605 +insert 2494 +insert 2561 +insert 941 +insert 2748 +insert 1448 +insert 2260 +insert 1273 +insert 2558 +insert 1198 +insert 1774 +insert 1740 +insert 1861 +insert 3049 +insert 2821 +insert 1341 +insert 1661 +insert 1506 +insert 1741 +insert 1811 +insert 1737 +insert 1693 +insert 1877 +insert 1756 +insert 1755 +insert 1553 +insert 1864 +insert 1734 +insert 1790 +insert 1753 +insert 2396 +insert 2531 +insert 1878 +insert 1809 +insert 2692 +insert 1854 +insert 1960 +insert 1999 +insert 2028 +insert 1879 +insert 1590 +insert 2521 +insert 3081 +insert 2665 +insert 1638 +insert 1667 +insert 1417 +insert 1876 +insert 3113 +insert 2757 +insert 2711 +insert 2587 +insert 1607 +insert 2568 +insert 2724 +insert 2685 +insert 2523 +insert 3151 +insert 1530 +insert 2454 +insert 2539 +insert 1356 +insert 1885 +insert 769 +insert 1982 +insert 3059 +insert 1232 +insert 2773 +insert 3270 +insert 2599 +insert 294 +insert 164 +insert 22 +insert 239 +insert 648 +insert 1679 +insert 644 +insert 398 +insert 455 +insert 443 +insert 1686 +insert 758 +insert 1720 +insert 1387 +insert 672 +insert 2569 +insert 2921 +insert 1228 +insert 1521 +insert 2115 +insert 2101 +insert 3035 +insert 2088 +insert 2094 +insert 1290 +insert 940 +insert 1303 +insert 2515 +insert 2863 +insert 1319 +insert 1315 +insert 2445 +insert 1949 +insert 2935 +insert 1992 +insert 1435 +insert 1413 +insert 1742 +insert 2769 +insert 2266 +insert 3290 +insert 3224 +insert 3171 +insert 2981 +insert 3200 +insert 3140 +insert 493 +insert 1299 +insert 338 +insert 1639 +insert 1463 +insert 730 +insert 1779 +insert 1918 +insert 2804 +insert 1476 +remove 432 +insert 296 +insert 1469 +insert 1364 +insert 1732 +insert 1908 +insert 2076 +insert 2489 +insert 2401 +insert 2560 +insert 2299 +insert 1451 +insert 3303 +insert 2174 +insert 2048 +insert 3293 +insert 2097 +insert 1705 +insert 1731 +insert 2296 +insert 2925 +insert 2932 +insert 1711 +insert 2397 +insert 2520 +insert 2742 +insert 1324 +insert 1160 +insert 1458 +insert 1439 +insert 3277 +insert 1374 +insert 1217 +insert 1218 +insert 2197 +insert 2185 +insert 1952 +insert 1798 +insert 1442 +insert 2601 +insert 2675 +insert 2283 +insert 12 +insert 567 +insert 638 +insert 1904 +insert 704 +insert 1447 +insert 1965 +insert 2728 +insert 2741 +insert 2441 +insert 2122 +insert 862 +insert 958 +insert 1955 +insert 850 +insert 2696 +insert 955 +insert 2867 +insert 2042 +insert 1925 +insert 2952 +insert 2265 +insert 1220 +insert 3289 +insert 2650 +insert 2215 +insert 2288 +insert 1373 +insert 2096 +insert 1167 +insert 830 +insert 829 +insert 1558 +insert 1189 +insert 2263 +insert 2341 +insert 2337 +insert 2270 +insert 3024 +insert 3182 +insert 1420 +insert 1557 +insert 1441 +insert 3037 +insert 3206 +insert 2913 +insert 1398 +insert 1392 +insert 1493 +insert 843 +insert 1287 +insert 2199 +insert 2838 +insert 2225 +insert 2181 +insert 736 +insert 2201 +insert 2907 +insert 808 +insert 712 +insert 2165 +insert 1219 +insert 1221 +insert 1715 +insert 1710 +insert 1700 +insert 2218 +insert 2187 +insert 1204 +insert 1709 +insert 2278 +insert 2698 +insert 1718 +insert 2240 +insert 2704 +insert 2340 +insert 1168 +insert 2256 +insert 2227 +insert 2203 +insert 2848 +insert 2305 +insert 1698 +insert 2647 +insert 2342 +insert 2275 +insert 1307 +insert 3062 +insert 2354 +insert 1312 +insert 3074 +insert 3060 +insert 1665 +insert 989 +insert 2591 +insert 3076 +insert 3136 +insert 3117 +insert 3123 +insert 234 +insert 6 +insert 698 +insert 719 +insert 3156 +insert 2358 +insert 2819 +insert 1793 +insert 3235 +insert 3000 +insert 28 +insert 3304 +insert 1856 +insert 1795 +insert 1733 +insert 1803 +insert 3127 +insert 1866 +insert 1642 +insert 1657 +insert 1723 +insert 2966 +insert 927 +insert 1055 +insert 3078 +insert 3201 +insert 3226 +insert 1014 +insert 3208 +insert 3262 +insert 2567 +insert 1430 +insert 2781 +insert 2425 +insert 1185 +insert 2385 +insert 1724 +insert 3181 +insert 2365 +insert 2361 +insert 1787 +insert 1410 +insert 1172 +insert 2746 +insert 2573 +insert 90 +insert 2268 +insert 2756 +insert 1304 +insert 1203 +insert 1860 +insert 841 +insert 1913 +insert 2284 +insert 2309 +insert 2946 +insert 1697 +remove 1975 +insert 2087 +insert 1921 +insert 3281 +insert 1894 +insert 1905 +insert 1206 +insert 1552 +insert 1179 +insert 2269 +insert 1606 +insert 1223 +insert 634 +insert 2594 +insert 1426 +insert 1164 +insert 1129 +insert 1019 +insert 897 +insert 2632 +insert 523 +insert 405 +insert 531 +insert 541 +insert 2285 +insert 1210 +insert 1212 +insert 2018 +insert 1524 +insert 1175 +insert 1857 +insert 1701 +insert 1712 +insert 1597 +insert 2737 +insert 363 +insert 3118 +insert 2006 +insert 2314 +insert 1205 +insert 1922 +insert 1293 +insert 1169 +insert 613 +insert 740 +insert 2678 +insert 655 +insert 385 +insert 1200 +insert 494 +insert 799 +insert 821 +insert 1282 +insert 2747 +insert 892 +insert 2656 +insert 1735 +insert 1766 +insert 2379 +insert 620 +insert 1776 +insert 1660 +insert 2999 +insert 3012 +insert 747 +insert 1797 +insert 1843 +insert 2074 +insert 1046 +insert 1194 +insert 136 +insert 551 +insert 147 +insert 41 +insert 429 +insert 198 +insert 272 +insert 459 +insert 2297 +insert 3174 +insert 1281 +insert 1274 +insert 1225 +insert 1780 +insert 1814 +insert 1726 +insert 1251 +insert 1305 +insert 1826 +insert 1859 +insert 1226 +insert 1187 +insert 2129 +insert 2853 +insert 3164 +insert 1497 +insert 2910 +insert 187 +insert 985 +insert 1414 +insert 2720 +insert 3299 +insert 2866 +insert 2850 +insert 1207 +insert 2308 +insert 879 +insert 2553 +insert 2554 +insert 1796 +insert 1802 +insert 1881 +insert 1738 +insert 1432 +insert 1317 +insert 2143 +insert 1747 +insert 2108 +insert 1406 +insert 3187 +insert 3065 +insert 3214 +insert 2364 +insert 2646 +insert 1942 +insert 25 +insert 162 +insert 469 +insert 511 +insert 370 +insert 377 +insert 3175 +insert 1609 +insert 2873 +insert 2802 +insert 3071 +insert 2623 +insert 2689 +insert 1358 +insert 2610 +insert 1903 +insert 2885 +insert 2036 +insert 2113 +insert 2784 +insert 2588 +insert 945 +insert 2744 +insert 190 +insert 2869 +insert 1505 +remove 2912 +insert 117 +insert 155 +insert 2723 +insert 1279 +insert 2801 +insert 2216 +insert 1736 +insert 688 +insert 3026 +insert 10 +insert 2771 +insert 2739 +insert 2162 +insert 546 +insert 1526 +insert 1501 +insert 1584 +insert 1541 +insert 1471 +insert 1548 +insert 508 +insert 2086 +insert 1858 +insert 2718 +insert 399 +insert 140 +insert 109 +insert 1869 +insert 560 +insert 1769 +insert 871 +insert 450 +insert 555 +insert 382 +insert 911 +insert 442 +insert 2236 +insert 2798 +insert 2069 +insert 795 +insert 931 +insert 1291 +insert 1275 +insert 576 +insert 2209 +insert 2212 +insert 2759 +insert 2248 +insert 2061 +insert 2224 +insert 2237 +insert 2525 +insert 2574 +insert 2244 +insert 2562 +insert 2196 +insert 3052 +insert 1266 +insert 1998 +insert 3020 +insert 3038 +insert 832 +insert 822 +insert 1359 +insert 2923 +insert 2063 +insert 2147 +insert 1976 +insert 1328 +insert 2976 +insert 1090 +insert 988 +insert 2761 +insert 1066 +insert 1719 +insert 126 +insert 151 +insert 1339 +insert 2158 +insert 1690 +insert 1692 +insert 2073 +insert 1829 +insert 1896 +insert 2005 +insert 2719 +insert 1376 +insert 2001 +insert 2057 +insert 2035 +insert 2924 +insert 1936 +insert 1461 +insert 2168 +insert 2245 +insert 1429 +insert 1409 +insert 2406 +insert 1318 +insert 1648 +insert 2843 +insert 3018 +insert 3011 +insert 3161 +insert 3028 +insert 2497 +insert 231 +insert 191 +insert 286 +insert 2188 +insert 2841 +insert 2228 +insert 2140 +insert 3133 +insert 1450 +insert 2103 +insert 1473 +insert 1487 +insert 3072 +insert 3093 +insert 3056 +insert 2894 +insert 1416 +insert 2897 +insert 2429 +insert 1956 +insert 1934 +insert 1940 +insert 1929 +insert 3084 +insert 2740 +insert 3298 +insert 3308 +insert 3247 +insert 2832 +insert 2163 +remove 2039 +insert 1899 +insert 1939 +insert 1399 +insert 1412 +insert 1365 +insert 2876 +insert 1897 +insert 2037 +insert 1930 +insert 1640 +insert 1931 +insert 3159 +insert 2899 +insert 2231 +insert 3147 +insert 2825 +insert 1243 +insert 1810 +insert 1872 +insert 3116 +insert 3165 +insert 2068 +insert 1874 +insert 2226 +insert 2250 +insert 2249 +insert 618 +insert 1370 +remove 1220 +insert 1354 +insert 1438 +insert 2213 +insert 1377 +insert 563 +insert 637 +insert 1933 +insert 734 +insert 761 +insert 29 +insert 2114 +insert 2194 +insert 2152 +insert 2217 +insert 314 +insert 440 +insert 393 +insert 670 +insert 785 +insert 2455 +insert 729 +insert 2271 +insert 2463 +insert 2481 +insert 2519 +insert 2488 +insert 1502 +insert 2485 +insert 2279 +insert 2638 +insert 656 +insert 574 +insert 2508 +insert 612 +insert 877 +insert 683 +insert 938 +insert 1298 +insert 1257 +insert 550 +insert 2117 +insert 2603 +insert 2702 +insert 2480 +insert 2941 +insert 2613 +insert 2281 +insert 1006 +insert 1016 +insert 2961 +insert 3033 +insert 1534 +insert 2962 +insert 2357 +insert 1216 +insert 1197 +insert 968 +insert 1002 +insert 1030 +insert 1003 +insert 1026 +insert 2708 +insert 2666 +insert 2542 +insert 2736 +insert 1870 +insert 2318 +insert 2344 +insert 3220 +insert 2635 +insert 3294 +insert 1183 +insert 2347 +insert 1396 +insert 2731 +insert 2164 +insert 2167 +insert 1411 +insert 2159 +insert 1694 +insert 1689 +insert 1714 +insert 1713 +insert 2373 +insert 2763 +insert 2820 +insert 3083 +insert 3030 +insert 3160 +insert 3010 +insert 3054 +insert 3112 +insert 3130 +insert 3095 +insert 3090 +insert 3158 +insert 3242 +insert 1691 +insert 3211 +insert 2418 +insert 1666 +insert 971 +insert 1695 +insert 1634 +insert 888 +insert 2794 +insert 2532 +insert 2887 +insert 2797 +insert 1316 +insert 2125 +insert 1696 +insert 1888 +insert 1706 +insert 1231 +insert 1234 +insert 2050 +insert 1235 +insert 2102 +insert 218 +insert 228 +insert 2461 +insert 3291 +insert 3267 +insert 1708 +insert 1721 +insert 1704 +insert 2792 +insert 2782 +insert 83 +insert 2906 +insert 1981 +insert 1245 +insert 1326 +insert 2622 +insert 2254 +insert 184 +insert 2750 +insert 2618 +insert 2679 +insert 2778 +insert 2628 +insert 855 +insert 2092 +insert 2118 +insert 1347 +insert 1527 +insert 2575 +insert 2119 +insert 2098 +insert 537 +insert 1623 +insert 2402 +insert 2054 +insert 193 +insert 1180 +insert 1378 +insert 1483 +insert 1188 +insert 2099 +insert 1184 +insert 1480 +insert 233 +insert 170 +insert 268 +insert 220 +insert 2261 +insert 1425 +insert 1932 +insert 1938 +insert 3047 +insert 1440 +insert 3105 +insert 3039 +insert 1443 +insert 1978 +insert 1996 +insert 1542 +insert 1547 +insert 1423 +insert 180 +insert 1585 +insert 1431 +insert 1586 +insert 2100 +insert 1444 +insert 2107 +insert 2896 +insert 1445 +insert 2743 +insert 1109 +insert 2751 +insert 2315 +insert 2634 +insert 1446 +insert 3288 +insert 1835 +insert 253 +insert 1504 +insert 371 +insert 504 +insert 204 +insert 2617 +insert 2388 +insert 107 +insert 131 +insert 111 +insert 1523 +insert 2909 +insert 1703 +insert 1717 +insert 1566 +insert 1151 +insert 1116 +insert 3172 +insert 2605 +insert 2641 +insert 1227 +insert 1230 +insert 1256 +insert 2725 +insert 1588 +insert 1529 +insert 1173 +insert 3142 +insert 3125 +insert 1581 +insert 578 +insert 3228 +insert 3239 +insert 599 +insert 759 +insert 3016 +insert 3025 +insert 619 +insert 653 +insert 626 +insert 2768 +insert 754 +insert 3231 +insert 3260 +insert 791 +insert 756 +insert 2405 +insert 2404 +insert 1474 +insert 1213 +insert 1211 +insert 2019 +insert 3077 +insert 3087 +insert 2555 +insert 1699 +insert 1464 +insert 2687 +insert 1578 +insert 1975 +insert 1490 +insert 1478 +insert 573 +insert 592 +insert 1655 +insert 1652 +insert 1669 +insert 1649 +insert 1092 +insert 1122 +insert 1153 +insert 2734 +insert 1676 +insert 1871 +insert 1131 +insert 2730 +insert 2729 +insert 1222 +insert 1196 +insert 2733 +insert 2793 +insert 1421 +insert 2672 +insert 1633 +insert 1472 +insert 2749 +insert 1477 +insert 1460 +insert 3050 +insert 1491 +insert 3114 +insert 2378 +insert 1427 +insert 1419 +insert 1722 +insert 1580 +insert 1449 +insert 1484 +insert 1053 +insert 1485 +insert 3085 +insert 2153 +insert 3002 +insert 2023 +insert 3008 +insert 2280 +insert 3003 +insert 2958 +insert 2972 +insert 3015 +insert 2803 +insert 3045 +insert 2127 +insert 2971 +insert 1437 +insert 1494 +insert 1486 +insert 3032 +insert 2809 +remove 1627 +insert 1428 +insert 775 +insert 5 +insert 3064 +insert 3107 +insert 3115 +insert 3138 +insert 3128 +insert 3111 +insert 1032 +insert 3075 +remove 298 +insert 3145 +insert 1572 +insert 186 +insert 1039 +insert 1086 +insert 236 +insert 1052 +insert 1385 +insert 252 +insert 1133 +insert 1108 +insert 928 +insert 1369 +insert 2116 +insert 2934 +insert 203 +insert 1113 +insert 2619 +insert 275 +insert 1844 +insert 1165 +insert 1868 +insert 194 +insert 254 +remove 297 +insert 2104 +insert 1603 +insert 2963 +insert 1672 +insert 3004 +insert 1683 +insert 1057 +insert 1807 +insert 2978 +insert 2004 +insert 1452 +insert 1482 +insert 2112 +insert 1436 +insert 1433 +insert 1602 +insert 1422 +insert 1575 +insert 1560 +insert 2649 +insert 1454 +insert 2658 +insert 2621 +insert 1702 +insert 1583 +insert 1467 +insert 1140 +insert 1229 +insert 1121 +insert 987 +insert 980 +insert 1174 +insert 1475 +insert 1615 +insert 1190 +insert 1619 +insert 1265 +insert 1621 +insert 1616 +insert 1492 +remove 1430 +insert 2905 +insert 1224 +insert 1538 +insert 1023 +insert 2807 +insert 1848 +insert 2659 +insert 1496 +insert 2710 +insert 1132 +insert 1154 +insert 1887 +insert 2593 +insert 1875 +remove 1429 +insert 1163 +insert 2983 +insert 2968 +insert 1587 +insert 222 +insert 283 +insert 263 +remove 1428 +insert 535 +insert 547 +insert 470 +insert 457 +insert 518 +insert 199 +insert 1263 +insert 1084 +insert 526 +insert 933 +insert 889 +remove 1437 +insert 246 +insert 530 +insert 903 +remove 2489 +insert 2682 +insert 2914 +insert 1716 +insert 2688 +insert 1332 +insert 2690 +insert 2722 +insert 2657 +insert 2908 +insert 1345 +insert 1582 +insert 2969 +insert 2612 +insert 213 +insert 225 +insert 1401 +insert 1340 +insert 1889 +insert 2017 +insert 961 +insert 1042 +insert 1873 +insert 2790 +insert 224 +insert 1177 +insert 202 +insert 1372 +insert 185 +insert 1520 +insert 1346 +insert 211 +insert 181 +insert 2745 +insert 2726 +insert 2870 +insert 1214 +insert 2940 +insert 2653 +insert 2219 +insert 2813 +insert 1532 +insert 2890 +insert 1195 +insert 1128 +insert 468 +insert 1592 +insert 1144 +remove 1219 +insert 3183 +insert 2774 +insert 1622 +insert 1141 +insert 3285 +insert 2274 +insert 2680 +insert 1161 +insert 1158 +insert 279 +insert 1613 +insert 142 +insert 1510 +insert 100 +insert 467 +insert 106 +insert 367 +insert 1546 +insert 1867 +insert 851 +insert 918 +insert 1845 +insert 1176 +insert 1178 +insert 1193 +insert 1884 +insert 2663 +insert 1617 +insert 1614 +insert 461 +insert 1783 +insert 2721 +insert 1851 +insert 3255 +insert 1517 +insert 237 +insert 1535 +insert 1973 +insert 2880 +insert 2883 +insert 1928 +remove 1424 +insert 2991 +insert 2202 +insert 1574 +insert 2206 +insert 538 +insert 1573 +insert 96 +insert 3 +insert 32 +insert 13 +insert 98 +insert 121 +insert 30 +insert 66 +insert 127 +insert 118 +insert 2732 +remove 1166 +insert 113 +insert 628 +insert 2246 +insert 1567 +insert 1688 +insert 1579 +insert 3014 +insert 2223 +insert 2145 +insert 2232 +insert 2190 +insert 2053 +insert 1882 +insert 381 +insert 3170 +insert 2651 +insert 3148 +insert 1805 +insert 543 +insert 406 +insert 517 +insert 454 +insert 1664 +insert 2806 +insert 1886 +insert 1865 +insert 3135 +insert 3179 +insert 2156 +insert 1628 +insert 1636 +insert 1819 +insert 2151 +insert 1968 +insert 2009 +insert 2134 +insert 3237 +insert 2886 +insert 2262 +insert 2957 +insert 2959 +insert 1972 +insert 31 +insert 842 +insert 2193 +insert 2106 +insert 2755 +insert 2645 +insert 2091 +insert 3001 +insert 2901 +insert 1678 +insert 2144 +insert 2891 +insert 1728 +insert 1645 +insert 1745 +insert 3166 +insert 1662 +insert 1366 +insert 2105 +insert 1612 +insert 2882 +insert 2528 +insert 1987 +insert 1599 +insert 229 +insert 1284 +insert 1156 +insert 1296 +insert 1297 +insert 2570 +insert 2078 +insert 2307 +insert 2565 +insert 2847 +insert 1343 +insert 1323 +insert 2900 +insert 2902 +insert 2089 +insert 1259 +insert 1288 +insert 2912 +insert 1252 +insert 256 +insert 232 +insert 230 +insert 2888 +insert 2684 +insert 2111 +insert 2090 +insert 2693 +insert 240 +insert 2898 +insert 295 +insert 2893 +insert 2264 +insert 2884 +insert 2705 +insert 2859 +insert 2904 +insert 2222 +insert 2889 +insert 389 +insert 1397 +insert 1407 +insert 1862 +insert 1250 +insert 1969 +insert 1375 +insert 1404 +insert 2433 +insert 2436 +insert 2948 +insert 1402 +insert 1320 +insert 1271 +insert 2453 +insert 2439 +insert 1300 +insert 2421 +insert 2110 +insert 2430 +insert 2121 +insert 2205 +insert 1353 +insert 509 +insert 515 +insert 1249 +insert 2919 +insert 2960 +insert 1389 +insert 139 +insert 542 +insert 2026 +insert 2039 +insert 2586 +insert 2581 +insert 2137 +insert 2936 +insert 2412 +insert 2431 +insert 2393 +insert 2362 +insert 2484 +insert 2440 +insert 2413 +insert 2468 +insert 2556 +insert 1898 +insert 1624 +insert 766 +insert 1608 +insert 1600 +insert 669 +insert 659 +insert 658 +insert 328 +insert 3221 +insert 3194 +insert 144 +insert 477 +insert 372 +insert 426 +insert 145 +insert 310 +insert 423 +insert 621 +insert 641 +insert 725 +insert 738 +insert 2093 +insert 2590 +insert 2499 +insert 1919 +insert 329 +insert 311 +insert 2580 +insert 2221 +insert 2833 +insert 2243 +insert 1564 +insert 2258 +insert 1917 +insert 2239 +insert 1901 +insert 2235 +insert 2701 +insert 2992 +insert 2752 +insert 395 +insert 2047 +insert 1967 +insert 1962 +insert 353 +insert 391 +insert 339 +insert 2211 +insert 419 +insert 409 +insert 2230 +insert 2247 +insert 2189 +insert 2229 +insert 907 +insert 957 +insert 1604 +insert 859 +insert 848 +insert 1838 +insert 883 +insert 1620 +insert 3213 +insert 456 +insert 2438 +insert 444 +insert 402 +insert 414 +insert 331 +insert 2448 +insert 400 +insert 284 +insert 421 +insert 365 +insert 280 +insert 208 +insert 2290 +insert 1596 +insert 1570 +insert 1594 +insert 1550 +remove 1490 +insert 1348 +insert 1344 +insert 1390 +insert 1511 +insert 1342 +insert 1306 +insert 1264 +insert 1286 +insert 2977 +insert 1371 +insert 1408 +insert 1544 +insert 1238 +insert 1242 +insert 2852 +insert 1605 +insert 1625 +insert 1334 +insert 1327 +insert 1576 +insert 2949 +insert 1565 +insert 3034 +insert 1589 +insert 2945 +insert 2973 +insert 2975 +insert 1637 +insert 2422 +insert 2860 +insert 2056 +insert 2045 +insert 2811 +insert 2812 +insert 2289 +insert 2041 +insert 2207 +insert 2920 +insert 1632 +insert 1394 +insert 3199 +insert 3287 +insert 3305 +insert 1368 +remove 3116 +insert 2021 +insert 3280 +insert 1964 +insert 2161 +insert 3273 +insert 1986 +insert 2022 +insert 2130 +insert 3240 +insert 3261 +insert 2040 +insert 3272 +insert 1883 +insert 1577 +insert 1555 +insert 1828 +insert 2055 +insert 2072 +insert 2257 +insert 2259 +insert 2070 +insert 2238 +insert 1591 +insert 2180 +insert 2120 +insert 2182 +insert 1360 +insert 2506 +insert 1382 +insert 2510 +insert 2220 +insert 1355 +insert 2141 +insert 1337 +insert 2437 +insert 2469 +insert 2443 +insert 1863 +insert 2166 +insert 2585 +insert 2139 +insert 2522 +insert 2331 +insert 2503 +insert 2210 +insert 2175 +insert 11 +insert 1515 +insert 119 +insert 1519 +insert 1593 +insert 201 +insert 258 +insert 1601 +insert 205 +insert 2176 +insert 1403 +insert 1598 +insert 1522 +insert 1514 +insert 1466 +insert 3274 +insert 1561 +insert 1393 +insert 2157 +insert 1503 +insert 910 +insert 924 +insert 861 +insert 388 +insert 3205 +insert 407 +insert 932 +insert 195 +insert 942 +insert 241 +insert 922 +insert 2024 +insert 864 +insert 1627 +insert 271 +insert 265 +insert 2376 +insert 247 +insert 2077 +insert 2277 +insert 3202 +insert 2267 +insert 2464 +insert 2446 +insert 1367 +insert 1380 +insert 2301 +insert 1405 +insert 2348 +insert 418 +insert 396 +insert 413 +insert 1363 +insert 1294 +insert 3229 +insert 3217 +remove 1411 +insert 2540 +insert 2633 +insert 1388 +insert 2577 +insert 2557 +insert 1272 +insert 2502 +insert 2516 +insert 2564 +insert 2559 +insert 2434 +insert 1953 +insert 2664 +insert 1837 +insert 2677 +insert 1827 +insert 2625 +insert 2667 +insert 2369 +insert 2360 +insert 1880 +insert 2387 +insert 335 +insert 2416 +insert 2643 +remove 1312 +insert 2410 +insert 2420 +insert 2411 +insert 2368 +insert 2374 +insert 2375 +insert 2417 +insert 2383 +insert 2395 +insert 1350 +insert 1260 +insert 1244 +insert 2123 +insert 1509 +insert 2584 +insert 2582 +insert 2578 +insert 1911 +insert 2479 +insert 2566 +insert 2346 +insert 2292 +insert 691 +insert 1277 +insert 882 +insert 846 +insert 2287 +insert 849 +insert 866 +insert 55 +insert 2526 +insert 869 +insert 827 +insert 1171 +insert 1533 +insert 350 +insert 46 +insert 135 +insert 2615 +insert 1528 +insert 1554 +insert 1539 +insert 1468 +insert 3185 +insert 1182 +insert 1479 +remove 1495 +insert 1507 +insert 1518 +insert 384 +insert 1301 +insert 1240 +insert 1254 +insert 112 +insert 75 +insert 72 +remove 1494 +insert 138 +insert 89 +insert 2840 +insert 200 +insert 1191 +insert 168 +insert 167 +insert 890 +insert 944 +insert 920 +insert 868 +insert 839 +insert 1146 +insert 1012 +insert 2255 +insert 2815 +insert 1563 +insert 2579 +insert 1545 +insert 2583 +insert 3089 +insert 1785 +insert 2273 +remove 1370 +insert 1739 +insert 3098 +insert 192 +insert 2242 +insert 172 +insert 3091 +insert 935 +insert 221 +insert 251 +insert 178 +insert 1751 +insert 369 +insert 929 +insert 82 +insert 436 +insert 276 +insert 244 +insert 387 +remove 2216 +insert 410 +insert 3053 +insert 1498 +insert 2826 +insert 366 +remove 1238 +insert 289 +insert 972 +insert 1761 +insert 441 +insert 361 +insert 401 +insert 2306 +insert 2390 +insert 2291 +insert 1199 +insert 982 +insert 270 +remove 1399 +insert 1551 +remove 1346 +insert 2169 +insert 986 +insert 394 +insert 3116 +insert 2272 +insert 3119 +insert 1494 +insert 3236 +insert 916 +insert 896 +insert 3152 +insert 3248 +insert 2132 +insert 2131 +insert 2155 +insert 1338 +insert 1043 +insert 954 +insert 3167 +insert 1562 +insert 3134 +insert 1571 +insert 898 +insert 1540 +insert 930 +insert 949 +insert 863 +insert 507 +insert 923 +insert 840 +insert 914 +insert 899 +insert 2184 +insert 2204 +insert 2128 +insert 2160 +insert 2173 +insert 2191 +insert 2171 +insert 2177 +insert 2179 +insert 1549 +insert 1569 +insert 1500 +remove 1389 +insert 1823 +insert 1812 +remove 1371 +remove 1375 +insert 1792 +insert 831 +insert 1831 +insert 1516 +insert 1822 +insert 1846 +insert 125 +insert 1799 +insert 129 +insert 1825 +insert 1836 +insert 210 +insert 188 +insert 1499 +insert 174 +insert 99 +insert 1833 +insert 1028 +insert 1024 +insert 1362 +insert 217 +insert 952 +insert 838 +insert 835 +insert 886 +insert 904 +insert 1041 +insert 1047 +insert 124 +insert 179 +insert 134 +insert 173 +insert 209 +insert 215 +insert 901 +insert 19 +insert 141 +remove 1387 +insert 177 +insert 160 +insert 157 +insert 998 +insert 16 +insert 1789 +insert 1748 +insert 1784 +insert 1818 +insert 908 +insert 950 +insert 939 +insert 936 +insert 1531 +insert 919 +insert 905 +insert 937 +insert 582 +insert 664 +insert 597 +insert 906 +insert 549 +insert 506 +insert 575 +insert 479 +insert 947 +insert 76 +insert 577 +insert 56 +insert 51 +insert 623 +insert 652 +remove 1364 +insert 1537 +remove 1396 +insert 1434 +insert 1415 +insert 1346 +insert 1399 +insert 1335 +insert 1513 +remove 1403 +insert 1536 +remove 1409 +remove 1366 +insert 1391 +remove 1287 +insert 1280 +remove 1503 +remove 1406 +insert 1383 +insert 2549 +insert 2538 +insert 2495 +insert 1268 +remove 1390 +insert 2527 +remove 1493 +remove 1394 +insert 1255 +remove 1315 +remove 1311 +insert 1276 +insert 1331 +remove 1317 +insert 1400 +remove 1354 +insert 1322 +insert 1357 +insert 1481 +remove 1405 +insert 285 +insert 288 +insert 261 +insert 640 +insert 632 +insert 525 +insert 266 +insert 962 +insert 629 +insert 378 +insert 380 +remove 1359 +insert 1351 +insert 587 +insert 368 +insert 376 +insert 1333 +insert 1050 +insert 1040 +insert 337 +insert 1352 +insert 3196 +insert 1997 +insert 326 +remove 2228 +insert 17 +insert 320 +insert 86 +remove 1502 +insert 1135 +remove 1298 +insert 132 +insert 156 +insert 1361 +insert 1215 +insert 2775 +insert 122 +insert 2816 +insert 2800 +insert 2799 +insert 1208 +insert 1285 +insert 1329 +insert 1201 +insert 1951 +insert 2786 +insert 2783 +insert 2822 +insert 2827 +insert 2805 +insert 2956 +insert 2862 +insert 2988 +insert 953 +insert 2791 +insert 2844 +insert 2777 +insert 2846 +insert 2785 +insert 2951 +insert 430 +insert 375 +insert 104 +insert 154 +insert 427 +insert 373 +insert 1025 +insert 146 +insert 379 +insert 894 +insert 867 +insert 969 +insert 159 +insert 887 +insert 876 +insert 176 +insert 1027 +insert 1119 +insert 994 +insert 917 +insert 1349 +insert 153 +insert 1033 +insert 875 +insert 0 +insert 1336 +insert 912 +remove 1357 +insert 501 +insert 206 +insert 1029 +insert 1081 +insert 152 +insert 1115 +insert 545 +insert 1044 +insert 1145 +insert 909 +insert 472 +insert 1056 +insert 845 +insert 881 +insert 1112 +insert 915 +insert 536 +insert 383 +insert 544 +insert 163 +insert 558 +remove 1343 +insert 1292 +insert 103 +insert 1321 +insert 554 +insert 825 +insert 559 +insert 539 +insert 242 +insert 556 +insert 235 +insert 245 +insert 133 +insert 374 +insert 161 +insert 34 +insert 1143 +insert 1136 +insert 1059 +insert 1087 +insert 1155 +insert 143 +insert 158 +insert 123 +insert 115 +insert 166 +insert 893 +insert 94 +insert 71 +insert 88 +insert 18 +remove 1314 +insert 238 +insert 260 +insert 1130 +insert 984 +insert 1152 +insert 1079 +insert 557 +insert 223 +insert 207 +insert 257 +insert 281 +insert 292 +insert 532 +insert 197 +insert 274 +insert 497 +insert 2655 +insert 267 +insert 686 +insert 212 +insert 854 +insert 880 +insert 325 +insert 673 +insert 216 +insert 196 +insert 7 +insert 782 +insert 2669 +insert 63 +insert 744 +insert 1 +insert 277 +insert 214 +insert 364 +insert 148 +insert 57 +remove 1274 +insert 727 +insert 787 +insert 772 +insert 20 +insert 293 +insert 773 +insert 1010 +insert 183 +insert 873 +insert 617 +insert 836 +insert 878 +insert 451 +insert 313 +insert 607 +insert 1102 +insert 386 +insert 424 +insert 404 +insert 650 +insert 826 +insert 1162 +insert 794 +insert 334 +insert 101 +insert 345 +insert 110 +insert 865 +insert 226 +insert 667 +insert 1088 +insert 651 +insert 273 +insert 870 +insert 852 +insert 189 +insert 1045 +insert 1031 +insert 102 +insert 347 +insert 54 +remove 1345 +insert 354 +insert 631 +insert 1159 +insert 837 +insert 150 +insert 105 +insert 583 +insert 657 +insert 606 +insert 624 +insert 2 +insert 9 +insert 601 +insert 248 +insert 360 +insert 663 +insert 777 +insert 315 +insert 615 +insert 765 +insert 750 +insert 593 +insert 595 +insert 548 +insert 979 +insert 1049 +insert 1157 +insert 1148 +insert 322 +insert 332 +insert 1051 +insert 1013 +insert 349 +insert 552 +insert 390 +insert 974 +insert 1080 +insert 392 +insert 1325 +remove 1328 +insert 1054 +insert 1034 +insert 478 +insert 287 +insert 1302 +insert 805 +insert 492 +insert 24 +insert 529 +insert 533 +insert 165 +insert 79 +insert 584 +insert 884 +insert 815 +insert 776 +insert 534 +insert 49 +insert 524 +insert 874 +insert 264 +insert 482 +insert 495 +insert 505 +insert 810 +insert 885 +insert 64 +insert 1364 +insert 726 +insert 858 +insert 249 +insert 757 +insert 743 +insert 358 +insert 921 +insert 521 +insert 739 +insert 857 +insert 318 +insert 282 +insert 951 +insert 1246 +insert 745 +insert 26 +insert 21 +insert 58 +remove 1352 +insert 302 +insert 1270 +insert 1058 +insert 8 +insert 803 +insert 316 +insert 770 +insert 262 +insert 27 +insert 611 +insert 1289 +insert 73 +insert 23 +insert 856 +insert 527 +insert 52 +insert 1253 +insert 760 +insert 120 +insert 807 +insert 643 +insert 116 +insert 362 +insert 646 +insert 668 +insert 642 +insert 227 +insert 1104 +insert 680 +insert 812 +insert 793 +insert 823 +insert 717 +insert 755 +insert 1781 +insert 1065 +insert 636 +insert 290 +insert 767 +insert 1261 +insert 1283 +insert 1295 +remove 1351 +remove 1341 +remove 1339 +insert 1262 +insert 397 +insert 408 +insert 445 +insert 746 +insert 437 +insert 710 +insert 723 +insert 403 +insert 715 +insert 434 +insert 514 +insert 681 +insert 540 +insert 463 +insert 490 +insert 438 +insert 806 +insert 420 +insert 741 +insert 714 +insert 692 +insert 458 +insert 447 +insert 448 +insert 753 +insert 412 +insert 728 +insert 718 +remove 1296 +remove 1276 +insert 735 +insert 1209 +insert 1036 +insert 1124 +insert 722 +insert 748 +insert 742 +insert 724 +insert 1181 +insert 751 +insert 733 +insert 416 +insert 1170 +insert 446 +insert 2881 +remove 1358 +remove 1288 +insert 449 +insert 40 +insert 33 +insert 130 +insert 1456 +insert 1418 +remove 1489 +insert 1455 +insert 1453 +remove 1473 +remove 1478 +remove 1484 +insert 2154 +insert 1470 +insert 1462 +remove 1487 +insert 1909 +insert 1914 +insert 1465 +insert 1853 +remove 1410 +insert 2252 +remove 1483 +remove 1467 +remove 1316 +insert 948 +insert 1296 +insert 1750 +insert 171 +insert 1238 +insert 749 +insert 697 +insert 219 +insert 721 +insert 828 +insert 2327 +insert 737 +insert 1760 +insert 1775 +insert 1782 +insert 685 +insert 1778 +insert 731 +insert 2352 +insert 706 +insert 1762 +insert 679 +insert 732 +insert 1767 +insert 2325 +insert 2208 +insert 1788 +insert 1772 +insert 1771 +insert 1765 +insert 752 +insert 674 +insert 690 +insert 2353 +insert 1980 +insert 2142 +insert 2286 +insert 2200 +insert 1954 +insert 2338 +insert 453 +insert 411 +insert 2339 +insert 2192 +insert 1749 +insert 2334 +insert 1993 +insert 2015 +insert 428 +insert 2322 +insert 433 +insert 2178 +insert 1727 +remove 1488 +remove 1363 +insert 1916 +insert 2335 +insert 1311 +remove 1461 +insert 2332 +insert 2319 +insert 2930 +insert 1278 +insert 2753 +insert 1754 +insert 2321 +insert 2851 +insert 2214 +insert 2172 +insert 2170 +insert 1314 +remove 1283 +insert 1786 +insert 250 +remove 1355 +insert 1317 +insert 1958 +remove 1325 +insert 2839 +insert 1074 +insert 1752 +insert 2124 +remove 2259 +insert 1457 +insert 1487 +insert 2146 +insert 2138 +remove 2257 +insert 2150 +insert 2241 +insert 1937 +insert 2148 +insert 1730 +insert 1308 +insert 1239 +remove 1165 +insert 2183 +insert 1920 +insert 834 +insert 764 +insert 853 +remove 2258 +insert 2233 +insert 1842 +insert 1943 +insert 847 +insert 783 +insert 1935 +insert 816 +insert 2186 +insert 2126 +insert 2149 +insert 792 +insert 1927 +insert 1315 +insert 1912 +remove 1280 +insert 1902 +insert 1915 +insert 820 +remove 1324 +insert 1923 +insert 1390 +insert 813 +insert 695 +insert 817 +insert 1926 +insert 1895 +insert 705 +insert 1389 +insert 790 +insert 682 +remove 1491 +insert 786 +insert 796 +insert 804 +insert 800 +insert 1950 +insert 811 +insert 771 +insert 435 +insert 452 +insert 464 +insert 432 +insert 784 +insert 900 +remove 1957 +insert 417 +insert 425 +insert 2695 +insert 2796 +insert 415 +insert 48 +insert 801 +insert 802 +insert 1069 +insert 603 +insert 460 +insert 422 +insert 439 +insert 774 +remove 1448 +insert 779 +insert 579 +insert 809 +insert 762 +insert 778 +insert 798 +insert 622 +insert 797 +insert 819 +insert 814 +insert 565 +insert 780 +insert 600 +insert 781 +insert 789 +insert 763 +insert 768 +insert 818 +remove 1408 +insert 1794 +insert 2350 +insert 581 +insert 2384 +insert 590 +insert 2349 +insert 466 +insert 2351 +insert 2394 +insert 608 +insert 598 +insert 519 +insert 633 +insert 485 +insert 627 +insert 2293 +insert 2253 +insert 2817 +insert 2366 +insert 500 +insert 2600 +insert 2627 +insert 2310 +remove 980 +insert 1110 +insert 1757 +insert 512 +insert 568 +insert 462 +insert 498 +remove 1342 +insert 2808 +insert 496 +insert 1258 +insert 1120 +insert 1150 +insert 91 +insert 1316 +insert 47 +insert 1312 +insert 1324 +insert 513 +insert 499 +insert 481 +insert 465 +insert 483 +insert 474 +insert 487 +insert 491 +insert 522 +insert 502 +insert 934 +remove 1300 +insert 510 +remove 1297 +remove 1273 +insert 1946 +insert 476 +insert 97 +insert 1138 +insert 503 +insert 1357 +insert 489 +insert 1147 +insert 42 +insert 1267 +insert 1248 +remove 1329 +insert 486 +insert 520 +insert 1082 +remove 1272 +insert 1068 +remove 1360 +insert 50 +remove 987 +remove 1364 +remove 1314 +insert 1283 +insert 1280 +insert 84 +remove 1344 +remove 1318 +insert 1341 +insert 59 +insert 471 +insert 1077 +insert 473 +insert 1070 +remove 1299 +remove 1315 +remove 1282 +insert 1276 +insert 3132 +remove 1347 +insert 3124 +insert 516 +insert 488 +remove 1362 +insert 300 +insert 1891 +insert 312 +insert 1118 +insert 475 +insert 359 +insert 1362 +insert 309 +insert 1067 +insert 1830 +insert 3027 +insert 2052 +insert 1816 +insert 2027 +insert 1098 +insert 1855 +insert 1078 +insert 1817 +insert 484 +insert 1142 +remove 962 +insert 1062 +insert 2563 +insert 1839 +insert 2576 +insert 1072 +insert 1107 +insert 992 +insert 1020 +insert 355 +insert 343 +insert 1094 +insert 1064 +insert 1125 +insert 1808 +insert 1236 +insert 1071 +insert 1103 +insert 1233 +insert 1840 +insert 1850 +remove 1235 +insert 1089 +insert 1815 +insert 1763 +insert 976 +insert 1773 +insert 1091 +insert 1018 +insert 1083 +insert 1075 +insert 1114 +insert 35 +insert 1123 +insert 1106 +insert 1834 +insert 1017 +insert 1117 +remove 1269 +insert 1111 +insert 1247 +insert 993 +insert 604 +insert 1849 +insert 1820 +insert 1105 +insert 2336 +insert 1095 +insert 569 +insert 2320 +insert 341 +insert 3249 +insert 983 +insert 308 +insert 306 +insert 2551 +insert 564 +remove 1311 +insert 1011 +insert 2311 +insert 1841 +insert 2871 +insert 2865 +insert 610 +insert 2828 +insert 609 +insert 2829 +insert 2834 +insert 2837 +insert 2836 +insert 321 +insert 2861 +insert 2324 +insert 2875 +insert 995 +insert 585 +insert 570 +insert 616 +insert 1906 +insert 1900 +insert 2874 +insert 2312 +insert 2787 +insert 80 +insert 2372 +insert 970 +insert 588 +insert 95 +insert 1126 +insert 324 +insert 602 +insert 571 +insert 589 +insert 561 +insert 586 +insert 342 +insert 61 +insert 2835 +insert 36 +insert 2879 +insert 2856 +insert 317 +insert 39 +insert 572 +insert 1009 +insert 654 +insert 625 +insert 2857 +insert 2830 +insert 2854 +insert 2345 +insert 2878 +insert 614 +insert 1073 +insert 1096 +insert 580 +remove 674 +insert 1005 +remove 681 +insert 635 +insert 1007 +insert 2491 +insert 2606 +insert 298 +remove 706 +insert 356 +insert 645 +insert 2595 +remove 698 +remove 692 +insert 2624 +insert 630 +insert 2642 +remove 668 +insert 2864 +insert 37 +insert 3245 +insert 2849 +insert 980 +insert 2877 +insert 2868 +insert 977 +insert 2316 +insert 2842 +insert 67 +remove 659 +insert 2500 +insert 336 +insert 81 +insert 3192 +remove 720 +remove 1164 +insert 3244 +insert 2824 +insert 2543 +insert 2295 +insert 703 +insert 2328 +insert 348 +insert 323 +insert 2823 +insert 2855 +insert 566 +insert 562 +insert 2831 +insert 2654 +insert 330 +insert 596 +insert 2700 +insert 981 +insert 346 +insert 299 +insert 591 +insert 38 +insert 1970 +remove 1268 +insert 2355 +insert 2507 +insert 2079 +insert 43 +insert 74 +insert 301 +insert 357 +insert 327 +insert 351 +insert 1990 +insert 2323 +insert 297 +insert 2300 +insert 594 +insert 2330 +insert 344 +insert 965 +insert 967 +insert 307 +insert 304 +insert 340 +insert 3241 +insert 3284 +insert 2673 +remove 1090 +insert 319 +insert 87 +insert 2699 +insert 305 +insert 85 +insert 3283 +insert 77 +insert 1008 +insert 93 +insert 2671 +insert 2530 +insert 684 +insert 78 +insert 303 +insert 2661 +insert 674 +insert 707 +insert 3169 +remove 1234 +remove 1104 +insert 2020 +insert 996 +insert 68 +insert 92 +insert 69 +insert 963 +insert 70 +insert 1977 +insert 2033 +insert 2524 +insert 1004 +insert 2450 +insert 60 +insert 701 +insert 44 +insert 671 +insert 1097 +insert 1099 +insert 720 +insert 962 +insert 1021 +insert 702 +insert 997 +insert 2709 +insert 2462 +remove 1096 +insert 2370 +insert 2298 +insert 2676 +remove 1199 +insert 2414 +insert 687 +insert 2080 +remove 1095 +insert 706 +insert 1100 +insert 1101 +insert 2668 +insert 1127 +insert 2046 +insert 2060 +insert 2044 +remove 1110 +insert 699 +insert 2714 +insert 2472 +insert 2014 +remove 1120 +insert 3234 +insert 2428 +insert 3250 +insert 1994 +insert 700 +insert 3233 +insert 964 +insert 2998 +insert 3193 +insert 2011 +insert 709 +insert 2030 +insert 3257 +insert 3264 +insert 3216 +insert 1000 +insert 3276 +insert 2717 +insert 2660 +insert 975 +remove 1087 +insert 3278 +insert 2533 +insert 3268 +insert 990 +insert 1001 +insert 2487 +insert 973 +insert 2034 +remove 1111 +insert 2517 +insert 1063 +insert 3306 +insert 696 +insert 1061 +insert 2552 +remove 1119 +insert 2432 +insert 2707 +insert 2326 +insert 716 +insert 660 +remove 1122 +insert 3271 +insert 2424 +insert 3013 +insert 3238 +insert 3258 +insert 692 +insert 3203 +insert 2294 +insert 1979 +insert 2997 +insert 2391 +insert 2029 +insert 1630 +insert 956 +insert 2505 +insert 3215 +insert 1641 +insert 3302 +insert 2367 +insert 676 +insert 2381 +insert 666 +insert 675 +insert 1015 +remove 1112 +insert 2071 +insert 3043 +insert 3301 +insert 2475 +insert 698 +insert 2031 +insert 3048 +insert 2644 +insert 2419 +insert 2059 +insert 2550 +insert 3046 +insert 2067 +insert 3312 +insert 3296 +insert 3006 +insert 2965 +insert 2460 +insert 2652 +insert 2758 +insert 677 +insert 1959 +insert 713 +insert 2359 +insert 2694 +insert 2674 +insert 2703 +insert 1684 +insert 2713 +insert 1653 +insert 2964 +insert 2389 +insert 3086 +insert 3204 +insert 3021 +insert 2639 +insert 2616 +insert 3246 +insert 3195 +insert 2795 +insert 3036 +insert 3207 +insert 2630 +insert 1682 +insert 2670 +insert 2085 +insert 3297 +insert 711 +insert 2712 +insert 2477 +insert 2681 +insert 659 +insert 2706 +insert 2683 +insert 3219 +insert 3282 +insert 3101 +insert 3109 +insert 2049 +insert 2007 +insert 3094 +insert 2716 +insert 2451 +insert 2922 +insert 2081 +insert 1629 +insert 2075 +insert 2483 +insert 2025 +insert 2691 +insert 693 +insert 2602 +insert 2513 +insert 2662 +insert 681 +insert 662 +insert 678 +insert 2986 +insert 3292 +insert 2492 +insert 3251 +insert 661 +insert 1988 +insert 2032 +insert 689 +insert 708 +insert 2944 +insert 694 +insert 2697 +insert 2604 +insert 2620 +insert 2435 +insert 3029 +insert 2970 +insert 2974 +insert 2607 +insert 2766 +insert 3061 +insert 3103 +insert 1674 +insert 1673 +insert 2648 +insert 3009 +insert 2051 +insert 1852 +insert 2082 +insert 2008 +insert 3079 +insert 1971 +insert 3212 +insert 2084 +insert 1656 +insert 665 +insert 1685 +insert 2990 +insert 2984 +insert 2942 +insert 2536 +insert 3190 +insert 2062 +insert 3188 +insert 3073 +insert 3102 +insert 3096 +insert 2987 +insert 3092 +insert 2760 +insert 2631 +insert 2066 +insert 2943 +insert 2926 +insert 2950 +insert 2058 +insert 2589 +insert 2598 +insert 3131 +insert 3120 +insert 1832 +insert 2363 +insert 2083 +insert 2933 +insert 2967 +insert 3082 +insert 3100 +insert 2415 +insert 2776 +insert 1983 +insert 1813 +insert 3099 +insert 2493 +insert 2597 +insert 2537 +insert 2010 +insert 1643 +insert 3191 +insert 2989 +insert 2937 +insert 3149 +insert 3057 +insert 2013 +insert 2929 +insert 3176 +insert 2636 +insert 3163 +remove 1163 +insert 1984 +insert 2000 +insert 2608 +insert 2043 +insert 3137 +insert 3189 +insert 3263 +insert 2994 +insert 2498 +insert 2596 +insert 1800 +insert 3259 +insert 1759 +insert 2762 +insert 3023 +insert 3017 +insert 2955 +insert 2592 +insert 2511 +insert 3005 +insert 3097 +insert 3121 +insert 2629 +insert 2534 +insert 2927 +insert 2544 +insert 3055 +insert 2640 +insert 1821 +insert 3300 +insert 3153 +insert 2954 +insert 3275 +insert 3227 +insert 3168 +insert 3225 +insert 1801 +insert 1744 +insert 3154 +insert 3143 +insert 2452 +insert 2614 +insert 3044 +insert 2611 +insert 2409 +insert 2407 +insert 3070 +insert 2545 +insert 2953 +insert 3243 +insert 2947 +insert 2626 +insert 2398 +insert 2392 +insert 3222 +insert 3108 +insert 2377 +insert 3177 +insert 3150 +insert 2490 +insert 2456 +insert 2478 +insert 3155 +insert 2535 +insert 2501 +insert 2380 +insert 3232 +insert 1670 +remove 1129 +insert 2985 +insert 2408 +insert 2473 +insert 3122 +insert 1991 +insert 3067 +insert 1963 +insert 2423 +insert 2928 +insert 2458 +insert 2382 +insert 2993 +insert 3019 +insert 2489 +insert 3139 +insert 3068 +insert 3088 +insert 1961 +insert 2003 +insert 3146 +insert 3066 +insert 3173 +insert 3162 +insert 2016 +insert 2486 +insert 3042 +insert 1995 +insert 2444 +insert 2457 +insert 3069 +insert 3157 +insert 3186 +insert 2939 +insert 1646 +insert 2470 +insert 2982 +insert 2547 +insert 2780 +insert 3265 +insert 3178 +insert 1681 +insert 2788 +insert 3218 +insert 2012 +insert 3253 +insert 3252 +insert 1668 +insert 2789 +insert 3041 +insert 2938 +insert 2754 +insert 2002 +insert 1644 +insert 2343 +insert 3180 +insert 1675 +insert 3230 +insert 1631 +insert 2504 +insert 2767 +insert 3126 +insert 3254 +insert 3310 +insert 2466 +insert 3141 +insert 2770 +insert 3311 +insert 1907 +insert 3286 +insert 3110 +insert 3051 +insert 1957 +insert 2772 +insert 1944 +insert 1989 +insert 3256 +insert 2529 +insert 2317 +insert 3040 +insert 1658 +insert 1893 +insert 3104 +insert 2810 +insert 2482 +insert 2979 +insert 3058 +insert 2474 +insert 1671 +insert 1659 +insert 3007 +insert 2541 +insert 966 +insert 2459 +insert 2546 +insert 1677 +insert 2496 +insert 1635 +insert 1650 +insert 1680 +insert 2403 +insert 3106 +insert 2426 +insert 3080 +insert 2447 +insert 3022 +insert 3210 +insert 2304 +insert 2996 +insert 2465 +insert 2449 +insert 2371 +insert 2765 +insert 2514 +insert 3197 +insert 2427 +remove 1086 diff --git a/vendor/im-rc/src/proptest.rs b/vendor/im-rc/src/proptest.rs new file mode 100644 index 000000000..9180ef273 --- /dev/null +++ b/vendor/im-rc/src/proptest.rs @@ -0,0 +1,164 @@ +//! Proptest strategies. +//! +//! These are only available when using the `proptest` feature flag. + +use crate::{HashMap, HashSet, OrdMap, OrdSet, Vector}; +use ::proptest::collection::vec; +use ::proptest::strategy::{BoxedStrategy, Strategy, ValueTree}; +use std::hash::Hash; +use std::iter::FromIterator; +use std::ops::Range; + +/// A strategy for generating a [`Vector`][Vector] of a certain size. +/// +/// # Examples +/// +/// ```rust,no_run +/// # use ::proptest::proptest; +/// proptest! { +/// #[test] +/// fn proptest_a_vector(ref l in vector(".*", 10..100)) { +/// assert!(l.len() < 100); +/// assert!(l.len() >= 10); +/// } +/// } +/// ``` +/// +/// [Vector]: ../struct.Vector.html +pub fn vector<A: Strategy + 'static>( + element: A, + size: Range<usize>, +) -> BoxedStrategy<Vector<<A::Tree as ValueTree>::Value>> +where + <A::Tree as ValueTree>::Value: Clone, +{ + vec(element, size).prop_map(Vector::from_iter).boxed() +} + +/// A strategy for an [`OrdMap`][OrdMap] of a given size. +/// +/// # Examples +/// +/// ```rust,no_run +/// # use ::proptest::proptest; +/// proptest! { +/// #[test] +/// fn proptest_works(ref m in ord_map(0..9999, ".*", 10..100)) { +/// assert!(m.len() < 100); +/// assert!(m.len() >= 10); +/// } +/// } +/// ``` +/// +/// [OrdMap]: ../struct.OrdMap.html +pub fn ord_map<K: Strategy + 'static, V: Strategy + 'static>( + key: K, + value: V, + size: Range<usize>, +) -> BoxedStrategy<OrdMap<<K::Tree as ValueTree>::Value, <V::Tree as ValueTree>::Value>> +where + <K::Tree as ValueTree>::Value: Ord + Clone, + <V::Tree as ValueTree>::Value: Clone, +{ + ::proptest::collection::vec((key, value), size.clone()) + .prop_map(OrdMap::from) + .prop_filter("OrdMap minimum size".to_owned(), move |m| { + m.len() >= size.start + }) + .boxed() +} + +/// A strategy for an [`OrdSet`][OrdSet] of a given size. +/// +/// # Examples +/// +/// ```rust,no_run +/// # use ::proptest::proptest; +/// proptest! { +/// #[test] +/// fn proptest_a_set(ref s in ord_set(".*", 10..100)) { +/// assert!(s.len() < 100); +/// assert!(s.len() >= 10); +/// } +/// } +/// ``` +/// +/// [OrdSet]: ../struct.OrdSet.html +pub fn ord_set<A: Strategy + 'static>( + element: A, + size: Range<usize>, +) -> BoxedStrategy<OrdSet<<A::Tree as ValueTree>::Value>> +where + <A::Tree as ValueTree>::Value: Ord + Clone, +{ + ::proptest::collection::vec(element, size.clone()) + .prop_map(OrdSet::from) + .prop_filter("OrdSet minimum size".to_owned(), move |s| { + s.len() >= size.start + }) + .boxed() +} + +/// A strategy for a [`HashMap`][HashMap] of a given size. +/// +/// # Examples +/// +/// ```rust,no_run +/// # use ::proptest::proptest; +/// proptest! { +/// #[test] +/// fn proptest_works(ref m in hash_map(0..9999, ".*", 10..100)) { +/// assert!(m.len() < 100); +/// assert!(m.len() >= 10); +/// } +/// } +/// ``` +/// +/// [HashMap]: ../struct.HashMap.html +pub fn hash_map<K: Strategy + 'static, V: Strategy + 'static>( + key: K, + value: V, + size: Range<usize>, +) -> BoxedStrategy<HashMap<<K::Tree as ValueTree>::Value, <V::Tree as ValueTree>::Value>> +where + <K::Tree as ValueTree>::Value: Hash + Eq + Clone, + <V::Tree as ValueTree>::Value: Clone, +{ + ::proptest::collection::vec((key, value), size.clone()) + .prop_map(HashMap::from) + .prop_filter("Map minimum size".to_owned(), move |m| { + m.len() >= size.start + }) + .boxed() +} + +/// A strategy for a [`HashSet`][HashSet] of a given size. +/// +/// # Examples +/// +/// ```rust,no_run +/// # use ::proptest::proptest; +/// proptest! { +/// #[test] +/// fn proptest_a_set(ref s in hash_set(".*", 10..100)) { +/// assert!(s.len() < 100); +/// assert!(s.len() >= 10); +/// } +/// } +/// ``` +/// +/// [HashSet]: ../struct.HashSet.html +pub fn hash_set<A: Strategy + 'static>( + element: A, + size: Range<usize>, +) -> BoxedStrategy<HashSet<<A::Tree as ValueTree>::Value>> +where + <A::Tree as ValueTree>::Value: Hash + Eq + Clone, +{ + ::proptest::collection::vec(element, size.clone()) + .prop_map(HashSet::from) + .prop_filter("HashSet minimum size".to_owned(), move |s| { + s.len() >= size.start + }) + .boxed() +} diff --git a/vendor/im-rc/src/quickcheck.rs b/vendor/im-rc/src/quickcheck.rs new file mode 100644 index 000000000..3faade751 --- /dev/null +++ b/vendor/im-rc/src/quickcheck.rs @@ -0,0 +1,43 @@ +use crate::{HashMap, HashSet, OrdMap, OrdSet, Vector}; +use ::quickcheck::{Arbitrary, Gen}; +use std::hash::{BuildHasher, Hash}; +use std::iter::FromIterator; + +impl<A: Arbitrary + Sync + Clone> Arbitrary for Vector<A> { + fn arbitrary(g: &mut Gen) -> Self { + Vector::from_iter(Vec::<A>::arbitrary(g)) + } +} + +impl<K: Ord + Clone + Arbitrary + Sync, V: Clone + Arbitrary + Sync> Arbitrary for OrdMap<K, V> { + fn arbitrary(g: &mut Gen) -> Self { + OrdMap::from_iter(Vec::<(K, V)>::arbitrary(g)) + } +} + +impl<A: Ord + Clone + Arbitrary + Sync> Arbitrary for OrdSet<A> { + fn arbitrary(g: &mut Gen) -> Self { + OrdSet::from_iter(Vec::<A>::arbitrary(g)) + } +} + +impl<A, S> Arbitrary for HashSet<A, S> +where + A: Hash + Eq + Arbitrary + Sync, + S: BuildHasher + Default + Send + Sync + 'static, +{ + fn arbitrary(g: &mut Gen) -> Self { + HashSet::from_iter(Vec::<A>::arbitrary(g)) + } +} + +impl<K, V, S> Arbitrary for HashMap<K, V, S> +where + K: Hash + Eq + Arbitrary + Sync, + V: Arbitrary + Sync, + S: BuildHasher + Default + Send + Sync + 'static, +{ + fn arbitrary(g: &mut Gen) -> Self { + HashMap::from(Vec::<(K, V)>::arbitrary(g)) + } +} diff --git a/vendor/im-rc/src/ser.rs b/vendor/im-rc/src/ser.rs new file mode 100644 index 000000000..d9a35e5f3 --- /dev/null +++ b/vendor/im-rc/src/ser.rs @@ -0,0 +1,293 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use serde::de::{Deserialize, Deserializer, MapAccess, SeqAccess, Visitor}; +use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer}; +use std::fmt; +use std::hash::{BuildHasher, Hash}; +use std::marker::PhantomData; +use std::ops::Deref; + +use crate::hashmap::HashMap; +use crate::hashset::HashSet; +use crate::ordmap::OrdMap; +use crate::ordset::OrdSet; +use crate::vector::Vector; + +struct SeqVisitor<'de, S, A> +where + S: From<Vec<A>>, + A: Deserialize<'de>, +{ + phantom_s: PhantomData<S>, + phantom_a: PhantomData<A>, + phantom_lifetime: PhantomData<&'de ()>, +} + +impl<'de, S, A> SeqVisitor<'de, S, A> +where + S: From<Vec<A>>, + A: Deserialize<'de>, +{ + pub(crate) fn new() -> SeqVisitor<'de, S, A> { + SeqVisitor { + phantom_s: PhantomData, + phantom_a: PhantomData, + phantom_lifetime: PhantomData, + } + } +} + +impl<'de, S, A> Visitor<'de> for SeqVisitor<'de, S, A> +where + S: From<Vec<A>>, + A: Deserialize<'de>, +{ + type Value = S; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + fn visit_seq<Access>(self, mut access: Access) -> Result<Self::Value, Access::Error> + where + Access: SeqAccess<'de>, + { + let mut v: Vec<A> = match access.size_hint() { + None => Vec::new(), + Some(l) => Vec::with_capacity(l), + }; + while let Some(i) = access.next_element()? { + v.push(i) + } + Ok(From::from(v)) + } +} + +struct MapVisitor<'de, S, K, V> +where + S: From<Vec<(K, V)>>, + K: Deserialize<'de>, + V: Deserialize<'de>, +{ + phantom_s: PhantomData<S>, + phantom_k: PhantomData<K>, + phantom_v: PhantomData<V>, + phantom_lifetime: PhantomData<&'de ()>, +} + +impl<'de, S, K, V> MapVisitor<'de, S, K, V> +where + S: From<Vec<(K, V)>>, + K: Deserialize<'de>, + V: Deserialize<'de>, +{ + pub(crate) fn new() -> MapVisitor<'de, S, K, V> { + MapVisitor { + phantom_s: PhantomData, + phantom_k: PhantomData, + phantom_v: PhantomData, + phantom_lifetime: PhantomData, + } + } +} + +impl<'de, S, K, V> Visitor<'de> for MapVisitor<'de, S, K, V> +where + S: From<Vec<(K, V)>>, + K: Deserialize<'de>, + V: Deserialize<'de>, +{ + type Value = S; + + fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result { + formatter.write_str("a sequence") + } + + fn visit_map<Access>(self, mut access: Access) -> Result<Self::Value, Access::Error> + where + Access: MapAccess<'de>, + { + let mut v: Vec<(K, V)> = match access.size_hint() { + None => Vec::new(), + Some(l) => Vec::with_capacity(l), + }; + while let Some(i) = access.next_entry()? { + v.push(i) + } + Ok(From::from(v)) + } +} + +// Set + +impl<'de, A: Deserialize<'de> + Ord + Clone> Deserialize<'de> for OrdSet<A> { + fn deserialize<D>(des: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + des.deserialize_seq(SeqVisitor::new()) + } +} + +impl<A: Ord + Clone + Serialize> Serialize for OrdSet<A> { + fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut s = ser.serialize_seq(Some(self.len()))?; + for i in self.iter() { + s.serialize_element(i.deref())?; + } + s.end() + } +} + +// Map + +impl<'de, K: Deserialize<'de> + Ord + Clone, V: Deserialize<'de> + Clone> Deserialize<'de> + for OrdMap<K, V> +{ + fn deserialize<D>(des: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + des.deserialize_map(MapVisitor::<'de, OrdMap<K, V>, K, V>::new()) + } +} + +impl<K: Serialize + Ord + Clone, V: Serialize + Clone> Serialize for OrdMap<K, V> { + fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut s = ser.serialize_map(Some(self.len()))?; + for (k, v) in self.iter() { + s.serialize_entry(k.deref(), v.deref())?; + } + s.end() + } +} + +// HashMap + +impl<'de, K, V, S> Deserialize<'de> for HashMap<K, V, S> +where + K: Deserialize<'de> + Hash + Eq + Clone, + V: Deserialize<'de> + Clone, + S: BuildHasher + Default, +{ + fn deserialize<D>(des: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + des.deserialize_map(MapVisitor::<'de, HashMap<K, V, S>, K, V>::new()) + } +} + +impl<K, V, S> Serialize for HashMap<K, V, S> +where + K: Serialize + Hash + Eq + Clone, + V: Serialize + Clone, + S: BuildHasher + Default, +{ + fn serialize<Ser>(&self, ser: Ser) -> Result<Ser::Ok, Ser::Error> + where + Ser: Serializer, + { + let mut s = ser.serialize_map(Some(self.len()))?; + for (k, v) in self.iter() { + s.serialize_entry(k.deref(), v.deref())?; + } + s.end() + } +} + +// HashSet + +impl<'de, A: Deserialize<'de> + Hash + Eq + Clone, S: BuildHasher + Default> Deserialize<'de> + for HashSet<A, S> +{ + fn deserialize<D>(des: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + des.deserialize_seq(SeqVisitor::new()) + } +} + +impl<A: Serialize + Hash + Eq + Clone, S: BuildHasher + Default> Serialize for HashSet<A, S> { + fn serialize<Ser>(&self, ser: Ser) -> Result<Ser::Ok, Ser::Error> + where + Ser: Serializer, + { + let mut s = ser.serialize_seq(Some(self.len()))?; + for i in self.iter() { + s.serialize_element(i.deref())?; + } + s.end() + } +} + +// Vector + +impl<'de, A: Clone + Deserialize<'de>> Deserialize<'de> for Vector<A> { + fn deserialize<D>(des: D) -> Result<Self, D::Error> + where + D: Deserializer<'de>, + { + des.deserialize_seq(SeqVisitor::<'de, Vector<A>, A>::new()) + } +} + +impl<A: Clone + Serialize> Serialize for Vector<A> { + fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error> + where + S: Serializer, + { + let mut s = ser.serialize_seq(Some(self.len()))?; + for i in self.iter() { + s.serialize_element(i.deref())?; + } + s.end() + } +} + +// Tests + +#[cfg(test)] +mod test { + use super::*; + use crate::proptest::{hash_map, hash_set, ord_map, ord_set, vector}; + use ::proptest::num::i32; + use ::proptest::proptest; + use serde_json::{from_str, to_string}; + + proptest! { + #[test] + fn ser_ordset(ref v in ord_set(i32::ANY, 0..100)) { + assert_eq!(v, &from_str::<OrdSet<i32>>(&to_string(&v).unwrap()).unwrap()); + } + + #[test] + fn ser_ordmap(ref v in ord_map(i32::ANY, i32::ANY, 0..100)) { + assert_eq!(v, &from_str::<OrdMap<i32, i32>>(&to_string(&v).unwrap()).unwrap()); + } + + #[test] + fn ser_hashmap(ref v in hash_map(i32::ANY, i32::ANY, 0..100)) { + assert_eq!(v, &from_str::<HashMap<i32, i32>>(&to_string(&v).unwrap()).unwrap()); + } + + #[test] + fn ser_hashset(ref v in hash_set(i32::ANY, 0..100)) { + assert_eq!(v, &from_str::<HashSet<i32>>(&to_string(&v).unwrap()).unwrap()); + } + + #[test] + fn ser_vector(ref v in vector(i32::ANY, 0..100)) { + assert_eq!(v, &from_str::<Vector<i32>>(&to_string(&v).unwrap()).unwrap()); + } + } +} diff --git a/vendor/im-rc/src/sort.rs b/vendor/im-rc/src/sort.rs new file mode 100644 index 000000000..6c980019a --- /dev/null +++ b/vendor/im-rc/src/sort.rs @@ -0,0 +1,203 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use crate::vector::FocusMut; +use rand_core::{RngCore, SeedableRng}; +use std::cmp::Ordering; +use std::mem; + +fn gen_range<R: RngCore>(rng: &mut R, min: usize, max: usize) -> usize { + let range = max - min; + min + (rng.next_u64() as usize % range) +} + +// Ported from the Java version at: +// http://www.cs.princeton.edu/~rs/talks/QuicksortIsOptimal.pdf +// There are a couple of modifications made here to make it more performant on the tree structure of +// the Vector. Instead of moving of handling equal and nonequal items in a single pass we make two +// additional passes to find the exact partition places. This allows us to split the focus into +// three correctly sized parts for less than, equal to and greater than items. As a bonus this +// doesn't need to reorder the equal items to the center of the vector. +fn do_quicksort<A, F, R>(vector: FocusMut<'_, A>, cmp: &F, rng: &mut R) +where + A: Clone, + F: Fn(&A, &A) -> Ordering, + R: RngCore, +{ + if vector.len() <= 1 { + return; + } + + // We know there are at least 2 elements here + let pivot_index = gen_range(rng, 0, vector.len()); + let (mut first, mut rest) = vector.split_at(1); + + if pivot_index > 0 { + mem::swap(rest.index_mut(pivot_index - 1), first.index_mut(0)); + } + // Pivot is now always in the first slice + let pivot_item = first.index(0); + + // Find the exact place to put the pivot or pivot-equal items + let mut less_count = 0; + let mut equal_count = 0; + + for index in 0..rest.len() { + let item = rest.index(index); + let comp = cmp(item, pivot_item); + match comp { + Ordering::Less => less_count += 1, + Ordering::Equal => equal_count += 1, + Ordering::Greater => {} + } + } + + // If by accident we picked the minimum element as a pivot, we just call sort again with the + // rest of the vector. + if less_count == 0 { + do_quicksort(rest, cmp, rng); + return; + } + + // We know here that there is at least one item before the pivot, so we move the minimum to the + // beginning part of the vector. First, however we swap the pivot to the start of the equal + // zone. + less_count -= 1; + equal_count += 1; + let first_item = first.index_mut(0); + mem::swap(first_item, rest.index_mut(less_count)); + for index in 0..rest.len() { + if index == less_count { + // This is the position we swapped the pivot to. We can't move it from its position, and + // we know its not the minimum. + continue; + } + let rest_item = rest.index_mut(index); + if cmp(rest_item, first_item) == Ordering::Less { + mem::swap(first_item, rest_item); + } + } + + // Split the vector up into less_than, equal to and greater than parts. + let (remaining, mut greater_focus) = rest.split_at(less_count + equal_count); + let (mut less_focus, mut equal_focus) = remaining.split_at(less_count); + + let mut less_position = 0; + let mut equal_position = 0; + let mut greater_position = 0; + + while less_position != less_focus.len() || greater_position != greater_focus.len() { + // At start of this loop, equal_position always points to an equal item + let mut equal_swap_side = None; + let equal_item = equal_focus.index(equal_position); + + // Advance the less_position until we find an out of place item + while less_position != less_focus.len() { + let less_item = less_focus.index(less_position); + match cmp(less_item, equal_item) { + Ordering::Equal => { + equal_swap_side = Some(Ordering::Less); + break; + } + Ordering::Greater => { + break; + } + _ => {} + } + less_position += 1; + } + + // Advance the greater until we find an out of place item + while greater_position != greater_focus.len() { + let greater_item = greater_focus.index(greater_position); + match cmp(greater_item, equal_item) { + Ordering::Less => break, + Ordering::Equal => { + equal_swap_side = Some(Ordering::Greater); + break; + } + _ => {} + } + greater_position += 1; + } + + if let Some(swap_side) = equal_swap_side { + // One of the sides is equal to the pivot, advance the pivot + let item = if swap_side == Ordering::Less { + less_focus.index_mut(less_position) + } else { + greater_focus.index_mut(greater_position) + }; + + // We are guaranteed not to hit the end of the equal focus + while cmp(item, equal_focus.index(equal_position)) == Ordering::Equal { + equal_position += 1; + } + + // Swap the equal position and the desired side, it's important to note that only the + // equals focus is guaranteed to have made progress so we don't advance the side's index + mem::swap(item, equal_focus.index_mut(equal_position)); + } else if less_position != less_focus.len() && greater_position != greater_focus.len() { + // Both sides are out of place and not equal to the pivot, this can only happen if there + // is a greater item in the lesser zone and a lesser item in the greater zone. The + // solution is to swap both sides and advance both side's indices. + debug_assert_ne!( + cmp( + less_focus.index(less_position), + equal_focus.index(equal_position) + ), + Ordering::Equal + ); + debug_assert_ne!( + cmp( + greater_focus.index(greater_position), + equal_focus.index(equal_position) + ), + Ordering::Equal + ); + mem::swap( + less_focus.index_mut(less_position), + greater_focus.index_mut(greater_position), + ); + less_position += 1; + greater_position += 1; + } + } + + // Now we have partitioned both sides correctly, we just have to recurse now + do_quicksort(less_focus, cmp, rng); + if !greater_focus.is_empty() { + do_quicksort(greater_focus, cmp, rng); + } +} + +pub(crate) fn quicksort<A, F>(vector: FocusMut<'_, A>, cmp: &F) +where + A: Clone, + F: Fn(&A, &A) -> Ordering, +{ + let mut rng = rand_xoshiro::Xoshiro256Plus::seed_from_u64(0); + do_quicksort(vector, cmp, &mut rng); +} + +#[cfg(test)] +mod test { + use super::*; + use crate::test::is_sorted; + use crate::vector::proptest::vector; + use ::proptest::num::i32; + use ::proptest::proptest; + + proptest! { + #[test] + fn test_quicksort(ref input in vector(i32::ANY, 0..10000)) { + let mut vec = input.clone(); + let len = vec.len(); + if len > 1 { + quicksort(vec.focus_mut(), &Ord::cmp); + } + assert!(is_sorted(vec)); + } + } +} diff --git a/vendor/im-rc/src/sync.rs b/vendor/im-rc/src/sync.rs new file mode 100644 index 000000000..9b137555e --- /dev/null +++ b/vendor/im-rc/src/sync.rs @@ -0,0 +1,69 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +pub(crate) use self::lock::Lock; + +#[cfg(threadsafe)] +mod lock { + use std::sync::{Arc, Mutex, MutexGuard}; + + /// Thread safe lock: just wraps a `Mutex`. + pub(crate) struct Lock<A> { + lock: Arc<Mutex<A>>, + } + + impl<A> Lock<A> { + pub(crate) fn new(value: A) -> Self { + Lock { + lock: Arc::new(Mutex::new(value)), + } + } + + #[inline] + pub(crate) fn lock(&mut self) -> Option<MutexGuard<'_, A>> { + self.lock.lock().ok() + } + } + + impl<A> Clone for Lock<A> { + fn clone(&self) -> Self { + Lock { + lock: self.lock.clone(), + } + } + } +} + +#[cfg(not(threadsafe))] +mod lock { + use std::cell::{RefCell, RefMut}; + use std::rc::Rc; + + /// Single threaded lock: a `RefCell` so we should safely panic if somehow + /// trying to access the stored data twice from the same thread. + pub(crate) struct Lock<A> { + lock: Rc<RefCell<A>>, + } + + impl<A> Lock<A> { + pub(crate) fn new(value: A) -> Self { + Lock { + lock: Rc::new(RefCell::new(value)), + } + } + + #[inline] + pub(crate) fn lock(&mut self) -> Option<RefMut<'_, A>> { + self.lock.try_borrow_mut().ok() + } + } + + impl<A> Clone for Lock<A> { + fn clone(&self) -> Self { + Lock { + lock: self.lock.clone(), + } + } + } +} diff --git a/vendor/im-rc/src/test.rs b/vendor/im-rc/src/test.rs new file mode 100644 index 000000000..9887d0138 --- /dev/null +++ b/vendor/im-rc/src/test.rs @@ -0,0 +1,86 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use metrohash::MetroHash64; +use std::hash::{BuildHasher, Hasher}; +use std::marker::PhantomData; +use typenum::{Unsigned, U64}; + +pub(crate) fn is_sorted<A, I>(l: I) -> bool +where + I: IntoIterator<Item = A>, + A: Ord, +{ + let mut it = l.into_iter().peekable(); + loop { + match (it.next(), it.peek()) { + (_, None) => return true, + (Some(ref a), Some(b)) if a > b => return false, + _ => (), + } + } +} + +pub(crate) struct LolHasher<N: Unsigned = U64> { + state: u64, + shift: usize, + size: PhantomData<N>, +} + +impl<N: Unsigned> LolHasher<N> { + fn feed_me(&mut self, byte: u8) { + self.state ^= u64::from(byte) << self.shift; + self.shift += 8; + if self.shift >= 64 { + self.shift = 0; + } + } +} + +impl<N: Unsigned> Hasher for LolHasher<N> { + fn write(&mut self, bytes: &[u8]) { + for byte in bytes { + self.feed_me(*byte) + } + } + + fn finish(&self) -> u64 { + if N::USIZE == 64 { + self.state + } else { + self.state & ((1 << N::USIZE) - 1) + } + } +} + +impl<N: Unsigned> Default for LolHasher<N> { + fn default() -> Self { + LolHasher { + state: 0, + shift: 0, + size: PhantomData, + } + } +} + +pub(crate) struct MetroHashBuilder { + seed: u64, +} + +impl MetroHashBuilder { + pub(crate) fn new(seed: u64) -> Self { + MetroHashBuilder { seed } + } + + pub(crate) fn seed(&self) -> u64 { + self.seed + } +} + +impl BuildHasher for MetroHashBuilder { + type Hasher = MetroHash64; + fn build_hasher(&self) -> Self::Hasher { + MetroHash64::with_seed(self.seed) + } +} diff --git a/vendor/im-rc/src/tests/hashset.rs b/vendor/im-rc/src/tests/hashset.rs new file mode 100644 index 000000000..01df2be4e --- /dev/null +++ b/vendor/im-rc/src/tests/hashset.rs @@ -0,0 +1,85 @@ +#![allow(clippy::unit_arg)] + +use std::collections::HashSet as NatSet; +use std::fmt::{Debug, Error, Formatter, Write}; +use std::hash::Hash; + +use crate::HashSet; + +use proptest::proptest; +use proptest_derive::Arbitrary; + +#[derive(Arbitrary, Debug)] +enum Action<A> { + Insert(A), + Remove(A), +} + +#[derive(Arbitrary)] +struct Actions<A>(Vec<Action<A>>) +where + A: Hash + Eq + Clone; + +impl<A> Debug for Actions<A> +where + A: Hash + Eq + Debug + Clone, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + let mut out = String::new(); + let mut expected = NatSet::new(); + writeln!(out, "let mut set = HashSet::new();")?; + for action in &self.0 { + match action { + Action::Insert(ref value) => { + expected.insert(value.clone()); + writeln!(out, "set.insert({:?});", value)?; + } + Action::Remove(ref value) => { + expected.remove(value); + writeln!(out, "set.remove({:?});", value)?; + } + } + } + writeln!( + out, + "let expected = vec!{:?};", + expected.into_iter().collect::<Vec<_>>() + )?; + writeln!(out, "assert_eq!(HashSet::from(expected), set);")?; + write!(f, "{}", super::code_fmt(&out)) + } +} + +proptest! { + #[test] + fn comprehensive(actions: Actions<u8>) { + let mut set = HashSet::new(); + let mut nat = NatSet::new(); + for action in actions.0 { + match action { + Action::Insert(value) => { + let len = nat.len() + if nat.contains(&value) { + 0 + } else { + 1 + }; + nat.insert(value); + set.insert(value); + assert_eq!(len, set.len()); + } + Action::Remove(value) => { + let len = nat.len() - if nat.contains(&value) { + 1 + } else { + 0 + }; + nat.remove(&value); + set.remove(&value); + assert_eq!(len, set.len()); + } + } + assert_eq!(nat.len(), set.len()); + assert_eq!(HashSet::from(nat.clone()), set); + } + } +} diff --git a/vendor/im-rc/src/tests/mod.rs b/vendor/im-rc/src/tests/mod.rs new file mode 100644 index 000000000..cafea5f9f --- /dev/null +++ b/vendor/im-rc/src/tests/mod.rs @@ -0,0 +1,24 @@ +mod hashset; +mod ordset; +mod vector; + +fn code_fmt(code: &str) -> String { + // use syntect::easy::HighlightLines; + // use syntect::highlighting::{Style, ThemeSet}; + // use syntect::parsing::SyntaxSet; + // use syntect::util::{as_24_bit_terminal_escaped, LinesWithEndings}; + // + // let ps = SyntaxSet::load_defaults_newlines(); + // let ts = ThemeSet::load_defaults(); + // let syntax = ps.find_syntax_by_extension("rs").unwrap(); + // let mut h = HighlightLines::new(syntax, &ts.themes["base16-ocean.dark"]); + // let mut out = String::from("\n\n"); + // for line in LinesWithEndings::from(&code) { + // let ranges: Vec<(Style, &str)> = h.highlight(line, &ps); + // let escaped = as_24_bit_terminal_escaped(&ranges[..], false); + // out += &escaped; + // } + // out += "\n\x1b[0m"; + // out + code.to_string() +} diff --git a/vendor/im-rc/src/tests/ordset.rs b/vendor/im-rc/src/tests/ordset.rs new file mode 100644 index 000000000..15efec5c2 --- /dev/null +++ b/vendor/im-rc/src/tests/ordset.rs @@ -0,0 +1,85 @@ +#![allow(clippy::unit_arg)] + +use std::collections::BTreeSet; +use std::fmt::{Debug, Error, Formatter, Write}; + +use crate::OrdSet; + +use proptest::proptest; +use proptest_derive::Arbitrary; + +#[derive(Arbitrary, Debug)] +enum Action<A> { + Insert(A), + Remove(A), +} + +#[derive(Arbitrary)] +struct Actions<A>(Vec<Action<A>>) +where + A: Ord + Clone; + +impl<A> Debug for Actions<A> +where + A: Ord + Debug + Clone, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + let mut out = String::new(); + let mut expected = BTreeSet::new(); + writeln!(out, "let mut set = OrdSet::new();")?; + for action in &self.0 { + match action { + Action::Insert(ref value) => { + expected.insert(value.clone()); + writeln!(out, "set.insert({:?});", value)?; + } + Action::Remove(ref value) => { + expected.remove(value); + writeln!(out, "set.remove({:?});", value)?; + } + } + } + writeln!( + out, + "let expected = vec!{:?};", + expected.into_iter().collect::<Vec<_>>() + )?; + writeln!(out, "assert_eq!(OrdSet::from(expected), set);")?; + write!(f, "{}", super::code_fmt(&out)) + } +} + +proptest! { + #[test] + fn comprehensive(actions: Actions<u8>) { + let mut set = OrdSet::new(); + let mut nat = BTreeSet::new(); + for action in actions.0 { + match action { + Action::Insert(value) => { + let len = nat.len() + if nat.contains(&value) { + 0 + } else { + 1 + }; + nat.insert(value); + set.insert(value); + assert_eq!(len, set.len()); + } + Action::Remove(value) => { + let len = nat.len() - if nat.contains(&value) { + 1 + } else { + 0 + }; + nat.remove(&value); + set.remove(&value); + assert_eq!(len, set.len()); + } + } + assert_eq!(nat.len(), set.len()); + assert_eq!(OrdSet::from(nat.clone()), set); + assert!(nat.iter().eq(set.iter())); + } + } +} diff --git a/vendor/im-rc/src/tests/vector.rs b/vendor/im-rc/src/tests/vector.rs new file mode 100644 index 000000000..14e312ade --- /dev/null +++ b/vendor/im-rc/src/tests/vector.rs @@ -0,0 +1,231 @@ +#![allow(clippy::unit_arg)] + +use std::fmt::{Debug, Error, Formatter, Write}; + +use crate::Vector; + +use proptest::proptest; +use proptest_derive::Arbitrary; + +#[derive(Arbitrary, Debug)] +enum Action<A> { + PushFront(A), + PushBack(A), + PopFront, + PopBack, + Insert(usize, A), + Remove(usize), + JoinLeft(Vec<A>), + JoinRight(Vec<A>), + SplitLeft(usize), + SplitRight(usize), +} + +#[derive(Arbitrary)] +struct Actions<A>(Vec<Action<A>>) +where + A: Clone; + +impl<A> Debug for Actions<A> +where + A: Debug + Clone, +{ + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + let mut out = String::new(); + let mut expected = vec![]; + writeln!(out, "let mut vec = Vector::new();")?; + for action in &self.0 { + match action { + Action::PushFront(ref value) => { + expected.insert(0, value.clone()); + writeln!(out, "vec.push_front({:?});", value)? + } + Action::PushBack(ref value) => { + expected.push(value.clone()); + writeln!(out, "vec.push_back({:?});", value)? + } + Action::PopFront => { + if !expected.is_empty() { + expected.remove(0); + } + writeln!(out, "vec.pop_front();")? + } + Action::PopBack => { + expected.pop(); + writeln!(out, "vec.pop_back();")? + } + Action::Insert(ref index, ref value) => { + let index = cap_index(expected.len(), *index); + expected.insert(index, value.clone()); + writeln!(out, "vec.insert({:?}, {:?});", index, value)? + } + Action::Remove(ref index) => { + if !expected.is_empty() { + let index = cap_index(expected.len(), *index); + expected.remove(index); + writeln!(out, "vec.remove({:?})", index)? + } else { + continue; + } + } + Action::JoinLeft(ref vec) => { + let mut vec_new = vec.clone(); + vec_new.append(&mut expected); + expected = vec_new; + writeln!( + out, + "let mut vec_new = Vector::from(vec!{:?}); // size {:?}", + vec, + vec.len() + )?; + writeln!(out, "vec_new.append(vec);")?; + writeln!(out, "vec = vec_new;")? + } + Action::JoinRight(ref vec) => { + expected.append(&mut vec.clone()); + writeln!( + out, + "vec.append(Vector::from(vec!{:?})); // size {:?}", + vec, + vec.len() + )? + } + Action::SplitLeft(ref index) => { + let index = cap_index(expected.len(), *index); + expected.truncate(index); + writeln!(out, "vec.split_off({:?});", index)? + } + Action::SplitRight(ref index) => { + let index = cap_index(expected.len(), *index); + expected = expected.split_off(index); + writeln!(out, "vec = vec.split_off({:?});", index)? + } + } + writeln!(out, "// len = {:?}", expected.len())?; + } + writeln!(out, "let expected = vec!{:?};", expected)?; + writeln!(out, "assert_eq!(Vector::from(expected), vec);")?; + write!(f, "{}", super::code_fmt(&out)) + } +} + +fn cap_index(len: usize, index: usize) -> usize { + if len == 0 { + 0 + } else { + index % len + } +} + +proptest! { + #[test] + fn comprehensive(actions: Actions<u8>) { + let mut vec = Vector::new(); + let mut nat = Vec::new(); + vec.assert_invariants(); + for action in actions.0 { + match action { + Action::PushFront(value) => { + let len = vec.len(); + nat.insert(0, value); + vec.push_front(value); + assert_eq!(len + 1, vec.len()); + } + Action::PushBack(value) => { + let len = vec.len(); + nat.push(value); + vec.push_back(value); + assert_eq!(len + 1, vec.len()); + } + Action::PopFront => { + if vec.is_empty() { + assert_eq!(None, vec.pop_front()); + } else { + let len = vec.len(); + assert_eq!(nat.remove(0), vec.pop_front().unwrap()); + assert_eq!(len - 1, vec.len()); + } + } + Action::PopBack => { + if vec.is_empty() { + assert_eq!(None, vec.pop_back()); + } else { + let len = vec.len(); + assert_eq!(nat.pop(), vec.pop_back()); + assert_eq!(len - 1, vec.len()); + } + } + Action::Insert(index, value) => { + let index = cap_index(vec.len(), index); + let len = vec.len(); + nat.insert(index, value); + vec.insert(index, value); + assert_eq!(len + 1, vec.len()); + } + Action::Remove(index) => { + if vec.is_empty() { + continue; + } + let index = cap_index(vec.len(), index); + let len = vec.len(); + assert_eq!(nat.remove(index), vec.remove(index)); + assert_eq!(len - 1, vec.len()); + } + Action::JoinLeft(mut new_nat) => { + let mut new_vec = new_nat.iter().cloned().collect::<Vector<_>>(); + let add_len = new_nat.len(); + let len = vec.len(); + new_vec.append(vec); + vec = new_vec; + new_nat.append(&mut nat); + nat = new_nat; + assert_eq!(len + add_len, vec.len()); + } + Action::JoinRight(mut new_nat) => { + let new_vec = new_nat.iter().cloned().collect::<Vector<_>>(); + let add_len = new_nat.len(); + let len = vec.len(); + vec.append(new_vec); + nat.append(&mut new_nat); + assert_eq!(len + add_len, vec.len()); + } + Action::SplitLeft(index) => { + let index = cap_index(vec.len(), index); + let len = vec.len(); + let vec_right = vec.split_off(index); + let nat_right = nat.split_off(index); + assert_eq!(index, vec.len()); + assert_eq!(len - index, vec_right.len()); + assert_eq!(nat_right.iter().cloned().collect::<Vector<_>>(), vec_right); + } + Action::SplitRight(index) => { + let index = cap_index(vec.len(), index); + let len = vec.len(); + let vec_right = vec.split_off(index); + let nat_right = nat.split_off(index); + assert_eq!(index, vec.len()); + assert_eq!(len - index, vec_right.len()); + assert_eq!(nat.iter().cloned().collect::<Vector<_>>(), vec); + vec = vec_right; + nat = nat_right; + } + } + vec.assert_invariants(); + assert_eq!(nat.len(),vec.len()); + assert_eq!(nat.iter().cloned().collect::<Vector<_>>(), vec); + } + } +} + +#[test] +fn test_inserts() { + const N: usize = 2000; + let mut v = Vector::new(); + for i in 0..N { + v.insert(v.len() / 2, i); + } + let mut rv: Vec<usize> = Vec::new(); + rv.extend((0..N).skip(1).step_by(2)); + rv.extend((0..N).step_by(2).rev()); + assert_eq!(rv.iter().cloned().collect::<Vector<_>>(), v); +} diff --git a/vendor/im-rc/src/util.rs b/vendor/im-rc/src/util.rs new file mode 100644 index 000000000..5451f156d --- /dev/null +++ b/vendor/im-rc/src/util.rs @@ -0,0 +1,142 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +// Every codebase needs a `util` module. + +use std::cmp::Ordering; +use std::ops::{Bound, IndexMut, Range, RangeBounds}; +use std::ptr; + +#[cfg(feature = "pool")] +pub(crate) use refpool::{PoolClone, PoolDefault}; + +// The `Ref` type is an alias for either `Rc` or `Arc`, user's choice. + +// `Arc` without refpool +#[cfg(all(threadsafe))] +pub(crate) use crate::fakepool::{Arc as PoolRef, Pool, PoolClone, PoolDefault}; + +// `Ref` == `Arc` when threadsafe +#[cfg(threadsafe)] +pub(crate) type Ref<A> = std::sync::Arc<A>; + +// `Rc` without refpool +#[cfg(all(not(threadsafe), not(feature = "pool")))] +pub(crate) use crate::fakepool::{Pool, PoolClone, PoolDefault, Rc as PoolRef}; + +// `Rc` with refpool +#[cfg(all(not(threadsafe), feature = "pool"))] +pub(crate) type PoolRef<A> = refpool::PoolRef<A>; +#[cfg(all(not(threadsafe), feature = "pool"))] +pub(crate) type Pool<A> = refpool::Pool<A>; + +// `Ref` == `Rc` when not threadsafe +#[cfg(not(threadsafe))] +pub(crate) type Ref<A> = std::rc::Rc<A>; + +pub(crate) fn clone_ref<A>(r: Ref<A>) -> A +where + A: Clone, +{ + Ref::try_unwrap(r).unwrap_or_else(|r| (*r).clone()) +} + +#[derive(Clone, Copy, PartialEq, Eq, Debug)] +pub(crate) enum Side { + Left, + Right, +} + +/// Swap two values of anything implementing `IndexMut`. +/// +/// Like `slice::swap`, but more generic. +#[allow(unsafe_code)] +pub(crate) fn swap_indices<V>(vector: &mut V, a: usize, b: usize) +where + V: IndexMut<usize>, + V::Output: Sized, +{ + if a == b { + return; + } + // so sorry, but there's no implementation for this in std that's + // sufficiently generic + let pa: *mut V::Output = &mut vector[a]; + let pb: *mut V::Output = &mut vector[b]; + unsafe { + ptr::swap(pa, pb); + } +} + +#[allow(dead_code)] +pub(crate) fn linear_search_by<'a, A, I, F>(iterable: I, mut cmp: F) -> Result<usize, usize> +where + A: 'a, + I: IntoIterator<Item = &'a A>, + F: FnMut(&A) -> Ordering, +{ + let mut pos = 0; + for value in iterable { + match cmp(value) { + Ordering::Equal => return Ok(pos), + Ordering::Greater => return Err(pos), + Ordering::Less => {} + } + pos += 1; + } + Err(pos) +} + +pub(crate) fn to_range<R>(range: &R, right_unbounded: usize) -> Range<usize> +where + R: RangeBounds<usize>, +{ + let start_index = match range.start_bound() { + Bound::Included(i) => *i, + Bound::Excluded(i) => *i + 1, + Bound::Unbounded => 0, + }; + let end_index = match range.end_bound() { + Bound::Included(i) => *i + 1, + Bound::Excluded(i) => *i, + Bound::Unbounded => right_unbounded, + }; + start_index..end_index +} + +macro_rules! def_pool { + ($name:ident<$($arg:tt),*>, $pooltype:ty) => { + /// A memory pool for the appropriate node type. + pub struct $name<$($arg,)*>(Pool<$pooltype>); + + impl<$($arg,)*> $name<$($arg,)*> { + /// Create a new pool with the given size. + pub fn new(size: usize) -> Self { + Self(Pool::new(size)) + } + + /// Fill the pool with preallocated chunks. + pub fn fill(&self) { + self.0.fill(); + } + + ///Get the current size of the pool. + pub fn pool_size(&self) -> usize { + self.0.get_pool_size() + } + } + + impl<$($arg,)*> Default for $name<$($arg,)*> { + fn default() -> Self { + Self::new($crate::config::POOL_SIZE) + } + } + + impl<$($arg,)*> Clone for $name<$($arg,)*> { + fn clone(&self) -> Self { + Self(self.0.clone()) + } + } + }; +} diff --git a/vendor/im-rc/src/vector/focus.rs b/vendor/im-rc/src/vector/focus.rs new file mode 100644 index 000000000..4fdba751a --- /dev/null +++ b/vendor/im-rc/src/vector/focus.rs @@ -0,0 +1,909 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use std::mem::{replace, swap}; +use std::ops::{Range, RangeBounds}; +use std::ptr::null; +use std::sync::atomic::{AtomicPtr, Ordering}; + +use crate::nodes::chunk::Chunk; +use crate::sync::Lock; +use crate::util::{to_range, PoolRef, Ref}; +use crate::vector::{ + Iter, IterMut, RRBPool, Rrb, Vector, + VectorInner::{Full, Inline, Single}, +}; + +/// Focused indexing over a [`Vector`][Vector]. +/// +/// By remembering the last tree node accessed through an index lookup and the +/// path we took to get there, we can speed up lookups for adjacent indices +/// tremendously. Lookups on indices in the same node are instantaneous, and +/// lookups on sibling nodes are also very fast. +/// +/// A `Focus` can also be used as a restricted view into a vector, using the +/// [`narrow`][narrow] and [`split_at`][split_at] methods. +/// +/// # When should I use a `Focus` for better performance? +/// +/// `Focus` is useful when you need to perform a large number of index lookups +/// that are more likely than not to be close to each other. It's usually worth +/// using a `Focus` in any situation where you're batching a lot of index +/// lookups together, even if they're not obviously adjacent - there's likely +/// to be some performance gain for even completely random access. +/// +/// If you're just iterating forwards or backwards over the [`Vector`][Vector] +/// in order, you're better off with a regular iterator, which, in fact, is +/// implemented using a `Focus`, but provides a simpler interface. +/// +/// If you're just doing a very small number of index lookups, the setup cost +/// for the `Focus` is probably not worth it. +/// +/// A `Focus` is never faster than an index lookup on a small [`Vector`][Vector] +/// with a length below the internal RRB tree's branching factor of 64. +/// +/// # Examples +/// +/// This example is contrived, as the better way to iterate forwards or +/// backwards over a vector is with an actual iterator. Even so, the version +/// using a `Focus` should run nearly an order of magnitude faster than the +/// version using index lookups at a length of 1000. It should also be noted +/// that [`vector::Iter`][Iter] is actually implemented using a `Focus` behind +/// the scenes, so the performance of the two should be identical. +/// +/// ```rust +/// # #[macro_use] extern crate im_rc as im; +/// # use im::vector::Vector; +/// # use std::iter::FromIterator; +/// let mut vec: Vector<i64> = Vector::from_iter(0..1000); +/// +/// // Summing a vector, the slow way: +/// let mut sum = 0; +/// for i in 0..1000 { +/// sum += *vec.get(i).unwrap(); +/// } +/// assert_eq!(499500, sum); +/// +/// // Summing a vector faster using a Focus: +/// let mut sum = 0; +/// let mut focus = vec.focus(); +/// for i in 0..1000 { +/// sum += *focus.get(i).unwrap(); +/// } +/// assert_eq!(499500, sum); +/// +/// // And the easy way, for completeness: +/// let sum: i64 = vec.iter().sum(); +/// assert_eq!(499500, sum); +/// ``` +/// +/// [Vector]: enum.Vector.html +/// [Iter]: struct.Iter.html +/// [narrow]: #method.narrow +/// [split_at]: #method.split_at +pub enum Focus<'a, A> { + #[doc(hidden)] + Single(&'a [A]), + #[doc(hidden)] + Full(TreeFocus<A>), +} + +impl<'a, A> Focus<'a, A> +where + A: Clone + 'a, +{ + /// Construct a `Focus` for a [`Vector`][Vector]. + /// + /// [Vector]: enum.Vector.html + pub fn new(vector: &'a Vector<A>) -> Self { + match &vector.vector { + Inline(_, chunk) => Focus::Single(chunk), + Single(_, chunk) => Focus::Single(chunk), + Full(_, tree) => Focus::Full(TreeFocus::new(tree)), + } + } + + /// Get the length of the focused [`Vector`][Vector]. + /// + /// [Vector]: enum.Vector.html + pub fn len(&self) -> usize { + match self { + Focus::Single(chunk) => chunk.len(), + Focus::Full(tree) => tree.len(), + } + } + + /// Test if the focused [`Vector`][Vector] is empty. + /// + /// [Vector]: enum.Vector.html + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Get a reference to the value at a given index. + pub fn get(&mut self, index: usize) -> Option<&A> { + match self { + Focus::Single(chunk) => chunk.get(index), + Focus::Full(tree) => tree.get(index), + } + } + + /// Get a reference to the value at a given index. + /// + /// Panics if the index is out of bounds. + pub fn index(&mut self, index: usize) -> &A { + self.get(index).expect("index out of bounds") + } + + /// Get the chunk for the given index. + /// + /// This gives you a reference to the leaf node that contains the index, + /// along with its start and end indices. + pub fn chunk_at(&mut self, index: usize) -> (Range<usize>, &[A]) { + let len = self.len(); + if index >= len { + panic!("vector::Focus::chunk_at: index out of bounds"); + } + match self { + Focus::Single(chunk) => (0..len, chunk), + Focus::Full(tree) => tree.get_chunk(index), + } + } + + /// Narrow the focus onto a subslice of the vector. + /// + /// `Focus::narrow(range)` has the same effect as `&slice[range]`, without + /// actually modifying the underlying vector. + /// + /// Panics if the range isn't fully inside the current focus. + /// + /// ## Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// # use std::iter::FromIterator; + /// let vec = Vector::from_iter(0..1000); + /// let narrowed = vec.focus().narrow(100..200); + /// let narrowed_vec = narrowed.into_iter().cloned().collect(); + /// assert_eq!(Vector::from_iter(100..200), narrowed_vec); + /// ``` + /// + /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at + /// [Vector::split_at]: enum.Vector.html#method.split_at + pub fn narrow<R>(self, range: R) -> Self + where + R: RangeBounds<usize>, + { + let r = to_range(&range, self.len()); + if r.start >= r.end || r.start >= self.len() { + panic!("vector::Focus::narrow: range out of bounds"); + } + match self { + Focus::Single(chunk) => Focus::Single(&chunk[r]), + Focus::Full(tree) => Focus::Full(tree.narrow(r)), + } + } + + /// Split the focus into two. + /// + /// Given an index `index`, consume the focus and produce two new foci, the + /// left onto indices `0..index`, and the right onto indices `index..N` + /// where `N` is the length of the current focus. + /// + /// Panics if the index is out of bounds. + /// + /// This is the moral equivalent of [`slice::split_at`][slice::split_at], in + /// that it leaves the underlying data structure unchanged, unlike + /// [`Vector::split_at`][Vector::split_at]. + /// + /// ## Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// # use std::iter::FromIterator; + /// let vec = Vector::from_iter(0..1000); + /// let (left, right) = vec.focus().split_at(500); + /// let left_vec = left.into_iter().cloned().collect(); + /// let right_vec = right.into_iter().cloned().collect(); + /// assert_eq!(Vector::from_iter(0..500), left_vec); + /// assert_eq!(Vector::from_iter(500..1000), right_vec); + /// ``` + /// + /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at + /// [Vector::split_at]: enum.Vector.html#method.split_at + pub fn split_at(self, index: usize) -> (Self, Self) { + if index >= self.len() { + panic!("vector::Focus::split_at: index out of bounds"); + } + match self { + Focus::Single(chunk) => { + let (left, right) = chunk.split_at(index); + (Focus::Single(left), Focus::Single(right)) + } + Focus::Full(tree) => { + let (left, right) = tree.split_at(index); + (Focus::Full(left), Focus::Full(right)) + } + } + } +} + +impl<'a, A> IntoIterator for Focus<'a, A> +where + A: Clone + 'a, +{ + type Item = &'a A; + type IntoIter = Iter<'a, A>; + + fn into_iter(self) -> Self::IntoIter { + Iter::from_focus(self) + } +} + +impl<'a, A> Clone for Focus<'a, A> +where + A: Clone + 'a, +{ + fn clone(&self) -> Self { + match self { + Focus::Single(chunk) => Focus::Single(chunk), + Focus::Full(tree) => Focus::Full(tree.clone()), + } + } +} + +pub struct TreeFocus<A> { + tree: Rrb<A>, + view: Range<usize>, + middle_range: Range<usize>, + target_range: Range<usize>, + target_ptr: *const Chunk<A>, +} + +impl<A> Clone for TreeFocus<A> { + fn clone(&self) -> Self { + let tree = self.tree.clone(); + TreeFocus { + view: self.view.clone(), + middle_range: self.middle_range.clone(), + target_range: 0..0, + target_ptr: null(), + tree, + } + } +} + +#[allow(unsafe_code)] +#[cfg(threadsafe)] +unsafe impl<A: Send> Send for TreeFocus<A> {} +#[allow(unsafe_code)] +#[cfg(threadsafe)] +unsafe impl<A: Sync> Sync for TreeFocus<A> {} + +#[inline] +fn contains<A: Ord>(range: &Range<A>, index: &A) -> bool { + *index >= range.start && *index < range.end +} + +impl<A> TreeFocus<A> +where + A: Clone, +{ + fn new(tree: &Rrb<A>) -> Self { + let middle_start = tree.outer_f.len() + tree.inner_f.len(); + let middle_end = middle_start + tree.middle.len(); + TreeFocus { + tree: tree.clone(), + view: 0..tree.length, + middle_range: middle_start..middle_end, + target_range: 0..0, + target_ptr: null(), + } + } + + fn len(&self) -> usize { + self.view.end - self.view.start + } + + fn narrow(self, mut view: Range<usize>) -> Self { + view.start += self.view.start; + view.end += self.view.start; + TreeFocus { + view, + middle_range: self.middle_range.clone(), + target_range: 0..0, + target_ptr: null(), + tree: self.tree, + } + } + + fn split_at(self, index: usize) -> (Self, Self) { + let len = self.len(); + let left = self.clone().narrow(0..index); + let right = self.narrow(index..len); + (left, right) + } + + fn physical_index(&self, index: usize) -> usize { + debug_assert!(index < self.view.end); + self.view.start + index + } + + fn logical_range(&self, range: &Range<usize>) -> Range<usize> { + (range.start - self.view.start)..(range.end - self.view.start) + } + + fn set_focus(&mut self, index: usize) { + if index < self.middle_range.start { + let outer_len = self.tree.outer_f.len(); + if index < outer_len { + self.target_range = 0..outer_len; + self.target_ptr = &*self.tree.outer_f; + } else { + self.target_range = outer_len..self.middle_range.start; + self.target_ptr = &*self.tree.inner_f; + } + } else if index >= self.middle_range.end { + let outer_start = self.middle_range.end + self.tree.inner_b.len(); + if index < outer_start { + self.target_range = self.middle_range.end..outer_start; + self.target_ptr = &*self.tree.inner_b; + } else { + self.target_range = outer_start..self.tree.length; + self.target_ptr = &*self.tree.outer_b; + } + } else { + let tree_index = index - self.middle_range.start; + let (range, ptr) = self + .tree + .middle + .lookup_chunk(self.tree.middle_level, 0, tree_index); + self.target_range = + (range.start + self.middle_range.start)..(range.end + self.middle_range.start); + self.target_ptr = ptr; + } + } + + #[allow(unsafe_code)] + fn get_focus(&self) -> &Chunk<A> { + unsafe { &*self.target_ptr } + } + + pub fn get(&mut self, index: usize) -> Option<&A> { + if index >= self.len() { + return None; + } + let phys_index = self.physical_index(index); + if !contains(&self.target_range, &phys_index) { + self.set_focus(phys_index); + } + let target_phys_index = phys_index - self.target_range.start; + Some(&self.get_focus()[target_phys_index]) + } + + pub fn get_chunk(&mut self, index: usize) -> (Range<usize>, &[A]) { + let phys_index = self.physical_index(index); + if !contains(&self.target_range, &phys_index) { + self.set_focus(phys_index); + } + let mut slice: &[A] = self.get_focus().as_slice(); + let mut left = 0; + let mut right = 0; + if self.target_range.start < self.view.start { + left = self.view.start - self.target_range.start; + } + if self.target_range.end > self.view.end { + right = self.target_range.end - self.view.end; + } + slice = &slice[left..(slice.len() - right)]; + let phys_range = (self.target_range.start + left)..(self.target_range.end - right); + (self.logical_range(&phys_range), slice) + } +} + +/// A mutable version of [`Focus`][Focus]. +/// +/// See [`Focus`][Focus] for more details. +/// +/// You can only build one `FocusMut` at a time for a vector, effectively +/// keeping a lock on the vector until you're done with the focus, which relies +/// on the structure of the vector not changing while it exists. +/// +/// ```rust,compile_fail +/// # #[macro_use] extern crate im_rc as im; +/// # use im::vector::Vector; +/// # use std::iter::FromIterator; +/// let mut vec = Vector::from_iter(0..1000); +/// let focus1 = vec.focus_mut(); +/// // Fails here in 2015 edition because you're creating +/// // two mutable references to the same thing. +/// let focus2 = vec.focus_mut(); +/// // Fails here in 2018 edition because creating focus2 +/// // made focus1's lifetime go out of scope. +/// assert_eq!(Some(&0), focus1.get(0)); +/// ``` +/// +/// On the other hand, you can split that one focus into multiple sub-focuses, +/// which is safe because they can't overlap: +/// +/// ```rust +/// # #[macro_use] extern crate im_rc as im; +/// # use im::vector::Vector; +/// # use std::iter::FromIterator; +/// let mut vec = Vector::from_iter(0..1000); +/// let focus = vec.focus_mut(); +/// let (mut left, mut right) = focus.split_at(500); +/// assert_eq!(Some(&0), left.get(0)); +/// assert_eq!(Some(&500), right.get(0)); +/// ``` +/// +/// These sub-foci also work as a lock on the vector, even if the focus they +/// were created from goes out of scope. +/// +/// ```rust,compile_fail +/// # #[macro_use] extern crate im_rc as im; +/// # use im::vector::Vector; +/// # use std::iter::FromIterator; +/// let mut vec = Vector::from_iter(0..1000); +/// let (left, right) = { +/// let focus = vec.focus_mut(); +/// focus.split_at(500) +/// }; +/// // `left` and `right` are still in scope even if `focus` isn't, so we can't +/// // create another focus: +/// let focus2 = vec.focus_mut(); +/// assert_eq!(Some(&0), left.get(0)); +/// ``` +/// +/// [Focus]: enum.Focus.html +pub enum FocusMut<'a, A> { + #[doc(hidden)] + Single(RRBPool<A>, &'a mut [A]), + #[doc(hidden)] + Full(RRBPool<A>, TreeFocusMut<'a, A>), +} + +impl<'a, A> FocusMut<'a, A> +where + A: Clone + 'a, +{ + /// Construct a `FocusMut` for a `Vector`. + pub fn new(vector: &'a mut Vector<A>) -> Self { + match &mut vector.vector { + Inline(pool, chunk) => FocusMut::Single(pool.clone(), chunk), + Single(pool, chunk) => FocusMut::Single( + pool.clone(), + PoolRef::make_mut(&pool.value_pool, chunk).as_mut_slice(), + ), + Full(pool, tree) => FocusMut::Full(pool.clone(), TreeFocusMut::new(tree)), + } + } + + /// Get the length of the focused `Vector`. + pub fn len(&self) -> usize { + match self { + FocusMut::Single(_, chunk) => chunk.len(), + FocusMut::Full(_, tree) => tree.len(), + } + } + + /// Test if the focused `Vector` is empty. + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Get a reference to the value at a given index. + pub fn get(&mut self, index: usize) -> Option<&A> { + self.get_mut(index).map(|r| &*r) + } + + /// Get a mutable reference to the value at a given index. + pub fn get_mut(&mut self, index: usize) -> Option<&mut A> { + match self { + FocusMut::Single(_, chunk) => chunk.get_mut(index), + FocusMut::Full(pool, tree) => tree.get(pool, index), + } + } + + /// Get a reference to the value at a given index. + /// + /// Panics if the index is out of bounds. + pub fn index(&mut self, index: usize) -> &A { + &*self.index_mut(index) + } + + /// Get a mutable reference to the value at a given index. + /// + /// Panics if the index is out of bounds. + #[allow(clippy::should_implement_trait)] // would if I could + pub fn index_mut(&mut self, index: usize) -> &mut A { + self.get_mut(index).expect("index out of bounds") + } + + /// Update the value at a given index. + /// + /// Returns `None` if the index is out of bounds, or the replaced value + /// otherwise. + pub fn set(&mut self, index: usize, value: A) -> Option<A> { + self.get_mut(index).map(|pos| replace(pos, value)) + } + + /// Swap the values at two given indices. + /// + /// Panics if either index is out of bounds. + /// + /// If the indices are equal, this function returns without doing anything. + pub fn swap(&mut self, a: usize, b: usize) { + if a == b { + return; + } + self.pair(a, b, |left, right| swap(left, right)); + } + + /// Lookup two indices simultaneously and run a function over them. + /// + /// Useful because the borrow checker won't let you have more than one + /// mutable reference into the same data structure at any given time. + /// + /// Panics if either index is out of bounds, or if they are the same index. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// # use std::iter::FromIterator; + /// let mut vec = vector![1, 2, 3, 4, 5]; + /// vec.focus_mut().pair(1, 3, |a, b| *a += *b); + /// assert_eq!(vector![1, 6, 3, 4, 5], vec); + /// ``` + #[allow(unsafe_code)] + pub fn pair<F, B>(&mut self, a: usize, b: usize, mut f: F) -> B + where + F: FnMut(&mut A, &mut A) -> B, + { + if a == b { + panic!("vector::FocusMut::pair: indices cannot be equal!"); + } + let pa: *mut A = self.index_mut(a); + let pb: *mut A = self.index_mut(b); + unsafe { f(&mut *pa, &mut *pb) } + } + + /// Lookup three indices simultaneously and run a function over them. + /// + /// Useful because the borrow checker won't let you have more than one + /// mutable reference into the same data structure at any given time. + /// + /// Panics if any index is out of bounds, or if any indices are equal. + /// + /// # Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// # use std::iter::FromIterator; + /// let mut vec = vector![1, 2, 3, 4, 5]; + /// vec.focus_mut().triplet(0, 2, 4, |a, b, c| *a += *b + *c); + /// assert_eq!(vector![9, 2, 3, 4, 5], vec); + /// ``` + #[allow(unsafe_code)] + pub fn triplet<F, B>(&mut self, a: usize, b: usize, c: usize, mut f: F) -> B + where + F: FnMut(&mut A, &mut A, &mut A) -> B, + { + if a == b || b == c || a == c { + panic!("vector::FocusMut::triplet: indices cannot be equal!"); + } + let pa: *mut A = self.index_mut(a); + let pb: *mut A = self.index_mut(b); + let pc: *mut A = self.index_mut(c); + unsafe { f(&mut *pa, &mut *pb, &mut *pc) } + } + + /// Get the chunk for the given index. + /// + /// This gives you a reference to the leaf node that contains the index, + /// along with its start and end indices. + pub fn chunk_at(&mut self, index: usize) -> (Range<usize>, &mut [A]) { + let len = self.len(); + if index >= len { + panic!("vector::FocusMut::chunk_at: index out of bounds"); + } + match self { + FocusMut::Single(_, chunk) => (0..len, chunk), + FocusMut::Full(pool, tree) => { + let (range, chunk) = tree.get_chunk(pool, index); + (range, chunk) + } + } + } + + /// Narrow the focus onto a subslice of the vector. + /// + /// `FocusMut::narrow(range)` has the same effect as `&slice[range]`, without + /// actually modifying the underlying vector. + /// + /// Panics if the range isn't fully inside the current focus. + /// + /// ## Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// # use std::iter::FromIterator; + /// let mut vec = Vector::from_iter(0..1000); + /// let narrowed = vec.focus_mut().narrow(100..200); + /// let narrowed_vec = narrowed.unmut().into_iter().cloned().collect(); + /// assert_eq!(Vector::from_iter(100..200), narrowed_vec); + /// ``` + /// + /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at + /// [Vector::split_at]: enum.Vector.html#method.split_at + pub fn narrow<R>(self, range: R) -> Self + where + R: RangeBounds<usize>, + { + let r = to_range(&range, self.len()); + if r.start > r.end || r.start > self.len() { + panic!("vector::FocusMut::narrow: range out of bounds"); + } + match self { + FocusMut::Single(pool, chunk) => FocusMut::Single(pool, &mut chunk[r]), + FocusMut::Full(pool, tree) => FocusMut::Full(pool, tree.narrow(r)), + } + } + + /// Split the focus into two. + /// + /// Given an index `index`, consume the focus and produce two new foci, the + /// left onto indices `0..index`, and the right onto indices `index..N` + /// where `N` is the length of the current focus. + /// + /// Panics if the index is out of bounds. + /// + /// This is the moral equivalent of [`slice::split_at`][slice::split_at], in + /// that it leaves the underlying data structure unchanged, unlike + /// [`Vector::split_at`][Vector::split_at]. + /// + /// ## Examples + /// + /// ```rust + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// # use std::iter::FromIterator; + /// let mut vec = Vector::from_iter(0..1000); + /// { + /// let (left, right) = vec.focus_mut().split_at(500); + /// for ptr in left { + /// *ptr += 100; + /// } + /// for ptr in right { + /// *ptr -= 100; + /// } + /// } + /// let expected = Vector::from_iter(100..600) + /// + Vector::from_iter(400..900); + /// assert_eq!(expected, vec); + /// ``` + /// + /// [slice::split_at]: https://doc.rust-lang.org/std/primitive.slice.html#method.split_at + /// [Vector::split_at]: enum.Vector.html#method.split_at + #[allow(clippy::redundant_clone)] + pub fn split_at(self, index: usize) -> (Self, Self) { + if index > self.len() { + panic!("vector::FocusMut::split_at: index out of bounds"); + } + match self { + FocusMut::Single(pool, chunk) => { + let (left, right) = chunk.split_at_mut(index); + ( + FocusMut::Single(pool.clone(), left), + FocusMut::Single(pool, right), + ) + } + FocusMut::Full(pool, tree) => { + let (left, right) = tree.split_at(index); + ( + FocusMut::Full(pool.clone(), left), + FocusMut::Full(pool, right), + ) + } + } + } + + /// Convert a `FocusMut` into a `Focus`. + pub fn unmut(self) -> Focus<'a, A> { + match self { + FocusMut::Single(_, chunk) => Focus::Single(chunk), + FocusMut::Full(_, mut tree) => Focus::Full(TreeFocus { + tree: { + let t = tree.tree.lock().unwrap(); + (*t).clone() + }, + view: tree.view.clone(), + middle_range: tree.middle_range.clone(), + target_range: 0..0, + target_ptr: null(), + }), + } + } +} + +impl<'a, A> IntoIterator for FocusMut<'a, A> +where + A: Clone + 'a, +{ + type Item = &'a mut A; + type IntoIter = IterMut<'a, A>; + + fn into_iter(self) -> Self::IntoIter { + IterMut::from_focus(self) + } +} + +impl<'a, A> From<FocusMut<'a, A>> for Focus<'a, A> +where + A: Clone + 'a, +{ + fn from(f: FocusMut<'a, A>) -> Self { + f.unmut() + } +} + +pub struct TreeFocusMut<'a, A> { + tree: Lock<&'a mut Rrb<A>>, + view: Range<usize>, + middle_range: Range<usize>, + target_range: Range<usize>, + target_ptr: AtomicPtr<Chunk<A>>, +} + +impl<'a, A> TreeFocusMut<'a, A> +where + A: Clone + 'a, +{ + fn new(tree: &'a mut Rrb<A>) -> Self { + let middle_start = tree.outer_f.len() + tree.inner_f.len(); + let middle_end = middle_start + tree.middle.len(); + TreeFocusMut { + view: 0..tree.length, + tree: Lock::new(tree), + middle_range: middle_start..middle_end, + target_range: 0..0, + target_ptr: AtomicPtr::default(), + } + } + + fn len(&self) -> usize { + self.view.end - self.view.start + } + + fn narrow(self, mut view: Range<usize>) -> Self { + view.start += self.view.start; + view.end += self.view.start; + TreeFocusMut { + view, + middle_range: self.middle_range.clone(), + target_range: 0..0, + target_ptr: AtomicPtr::default(), + tree: self.tree, + } + } + + fn split_at(self, index: usize) -> (Self, Self) { + let len = self.len(); + debug_assert!(index <= len); + #[allow(unsafe_code)] + let left = TreeFocusMut { + view: self.view.start..(self.view.start + index), + middle_range: self.middle_range.clone(), + target_range: 0..0, + target_ptr: AtomicPtr::default(), + tree: self.tree.clone(), + }; + let right = TreeFocusMut { + view: (self.view.start + index)..(self.view.start + len), + middle_range: self.middle_range.clone(), + target_range: 0..0, + target_ptr: AtomicPtr::default(), + tree: self.tree, + }; + (left, right) + } + + fn physical_index(&self, index: usize) -> usize { + debug_assert!(index < self.view.end); + self.view.start + index + } + + fn logical_range(&self, range: &Range<usize>) -> Range<usize> { + (range.start - self.view.start)..(range.end - self.view.start) + } + + fn set_focus(&mut self, pool: &RRBPool<A>, index: usize) { + let mut tree = self + .tree + .lock() + .expect("im::vector::Focus::set_focus: unable to acquire exclusive lock on Vector"); + if index < self.middle_range.start { + let outer_len = tree.outer_f.len(); + if index < outer_len { + self.target_range = 0..outer_len; + self.target_ptr.store( + PoolRef::make_mut(&pool.value_pool, &mut tree.outer_f), + Ordering::Relaxed, + ); + } else { + self.target_range = outer_len..self.middle_range.start; + self.target_ptr.store( + PoolRef::make_mut(&pool.value_pool, &mut tree.inner_f), + Ordering::Relaxed, + ); + } + } else if index >= self.middle_range.end { + let outer_start = self.middle_range.end + tree.inner_b.len(); + if index < outer_start { + self.target_range = self.middle_range.end..outer_start; + self.target_ptr.store( + PoolRef::make_mut(&pool.value_pool, &mut tree.inner_b), + Ordering::Relaxed, + ); + } else { + self.target_range = outer_start..tree.length; + self.target_ptr.store( + PoolRef::make_mut(&pool.value_pool, &mut tree.outer_b), + Ordering::Relaxed, + ); + } + } else { + let tree_index = index - self.middle_range.start; + let level = tree.middle_level; + let middle = Ref::make_mut(&mut tree.middle); + let (range, ptr) = middle.lookup_chunk_mut(pool, level, 0, tree_index); + self.target_range = + (range.start + self.middle_range.start)..(range.end + self.middle_range.start); + self.target_ptr.store(ptr, Ordering::Relaxed); + } + } + + #[allow(unsafe_code)] + fn get_focus(&mut self) -> &mut Chunk<A> { + unsafe { &mut *self.target_ptr.load(Ordering::Relaxed) } + } + + pub fn get(&mut self, pool: &RRBPool<A>, index: usize) -> Option<&mut A> { + if index >= self.len() { + return None; + } + let phys_index = self.physical_index(index); + if !contains(&self.target_range, &phys_index) { + self.set_focus(pool, phys_index); + } + let target_phys_index = phys_index - self.target_range.start; + Some(&mut self.get_focus()[target_phys_index]) + } + + pub fn get_chunk(&mut self, pool: &RRBPool<A>, index: usize) -> (Range<usize>, &mut [A]) { + let phys_index = self.physical_index(index); + if !contains(&self.target_range, &phys_index) { + self.set_focus(pool, phys_index); + } + let mut left = 0; + let mut right = 0; + if self.target_range.start < self.view.start { + left = self.view.start - self.target_range.start; + } + if self.target_range.end > self.view.end { + right = self.target_range.end - self.view.end; + } + let phys_range = (self.target_range.start + left)..(self.target_range.end - right); + let log_range = self.logical_range(&phys_range); + let slice_len = self.get_focus().len(); + let slice = &mut (self.get_focus().as_mut_slice())[left..(slice_len - right)]; + (log_range, slice) + } +} diff --git a/vendor/im-rc/src/vector/mod.rs b/vendor/im-rc/src/vector/mod.rs new file mode 100644 index 000000000..a2ce0adf7 --- /dev/null +++ b/vendor/im-rc/src/vector/mod.rs @@ -0,0 +1,2745 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +//! A persistent vector. +//! +//! This is a sequence of elements in insertion order - if you need a +//! list of things, any kind of list of things, this is what you're +//! looking for. +//! +//! It's implemented as an [RRB vector][rrbpaper] with [smart +//! head/tail chunking][chunkedseq]. In performance terms, this means +//! that practically every operation is O(log n), except push/pop on +//! both sides, which will be O(1) amortised, and O(log n) in the +//! worst case. In practice, the push/pop operations will be +//! blindingly fast, nearly on par with the native +//! [`VecDeque`][VecDeque], and other operations will have decent, if +//! not high, performance, but they all have more or less the same +//! O(log n) complexity, so you don't need to keep their performance +//! characteristics in mind - everything, even splitting and merging, +//! is safe to use and never too slow. +//! +//! ## Performance Notes +//! +//! Because of the head/tail chunking technique, until you push a +//! number of items above double the tree's branching factor (that's +//! `self.len()` = 2 × *k* (where *k* = 64) = 128) on either side, the +//! data structure is still just a handful of arrays, not yet an RRB +//! tree, so you'll see performance and memory characteristics fairly +//! close to [`Vec`][Vec] or [`VecDeque`][VecDeque]. +//! +//! This means that the structure always preallocates four chunks of +//! size *k* (*k* being the tree's branching factor), equivalent to a +//! [`Vec`][Vec] with an initial capacity of 256. Beyond that, it will +//! allocate tree nodes of capacity *k* as needed. +//! +//! In addition, vectors start out as single chunks, and only expand into the +//! full data structure once you go past the chunk size. This makes them +//! perform identically to [`Vec`][Vec] at small sizes. +//! +//! [rrbpaper]: https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf +//! [chunkedseq]: http://deepsea.inria.fr/pasl/chunkedseq.pdf +//! [Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html +//! [VecDeque]: https://doc.rust-lang.org/std/collections/struct.VecDeque.html + +use std::borrow::Borrow; +use std::cmp::Ordering; +use std::fmt::{Debug, Error, Formatter}; +use std::hash::{Hash, Hasher}; +use std::iter::Sum; +use std::iter::{FromIterator, FusedIterator}; +use std::mem::{replace, swap}; +use std::ops::{Add, Index, IndexMut, RangeBounds}; + +use sized_chunks::InlineArray; + +use crate::nodes::chunk::{Chunk, CHUNK_SIZE}; +use crate::nodes::rrb::{Node, PopResult, PushResult, SplitResult}; +use crate::sort; +use crate::util::{clone_ref, swap_indices, to_range, Pool, PoolDefault, PoolRef, Ref, Side}; + +use self::VectorInner::{Full, Inline, Single}; + +mod focus; + +pub use self::focus::{Focus, FocusMut}; + +mod pool; +pub use self::pool::RRBPool; + +#[cfg(all(threadsafe, any(test, feature = "rayon")))] +pub mod rayon; + +/// Construct a vector from a sequence of elements. +/// +/// # Examples +/// +/// ``` +/// # #[macro_use] extern crate im_rc as im; +/// # use im::vector::Vector; +/// # fn main() { +/// assert_eq!( +/// vector![1, 2, 3], +/// Vector::from(vec![1, 2, 3]) +/// ); +/// # } +/// ``` +#[macro_export] +macro_rules! vector { + () => { $crate::vector::Vector::new() }; + + ( $($x:expr),* ) => {{ + let mut l = $crate::vector::Vector::new(); + $( + l.push_back($x); + )* + l + }}; + + ( $($x:expr ,)* ) => {{ + let mut l = $crate::vector::Vector::new(); + $( + l.push_back($x); + )* + l + }}; +} + +/// A persistent vector. +/// +/// This is a sequence of elements in insertion order - if you need a list of +/// things, any kind of list of things, this is what you're looking for. +/// +/// It's implemented as an [RRB vector][rrbpaper] with [smart head/tail +/// chunking][chunkedseq]. In performance terms, this means that practically +/// every operation is O(log n), except push/pop on both sides, which will be +/// O(1) amortised, and O(log n) in the worst case. In practice, the push/pop +/// operations will be blindingly fast, nearly on par with the native +/// [`VecDeque`][VecDeque], and other operations will have decent, if not high, +/// performance, but they all have more or less the same O(log n) complexity, so +/// you don't need to keep their performance characteristics in mind - +/// everything, even splitting and merging, is safe to use and never too slow. +/// +/// ## Performance Notes +/// +/// Because of the head/tail chunking technique, until you push a number of +/// items above double the tree's branching factor (that's `self.len()` = 2 × +/// *k* (where *k* = 64) = 128) on either side, the data structure is still just +/// a handful of arrays, not yet an RRB tree, so you'll see performance and +/// memory characteristics similar to [`Vec`][Vec] or [`VecDeque`][VecDeque]. +/// +/// This means that the structure always preallocates four chunks of size *k* +/// (*k* being the tree's branching factor), equivalent to a [`Vec`][Vec] with +/// an initial capacity of 256. Beyond that, it will allocate tree nodes of +/// capacity *k* as needed. +/// +/// In addition, vectors start out as single chunks, and only expand into the +/// full data structure once you go past the chunk size. This makes them +/// perform identically to [`Vec`][Vec] at small sizes. +/// +/// [rrbpaper]: https://infoscience.epfl.ch/record/213452/files/rrbvector.pdf +/// [chunkedseq]: http://deepsea.inria.fr/pasl/chunkedseq.pdf +/// [Vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html +/// [VecDeque]: https://doc.rust-lang.org/std/collections/struct.VecDeque.html +pub struct Vector<A> { + vector: VectorInner<A>, +} + +enum VectorInner<A> { + Inline(RRBPool<A>, InlineArray<A, Rrb<A>>), + Single(RRBPool<A>, PoolRef<Chunk<A>>), + Full(RRBPool<A>, Rrb<A>), +} + +#[doc(hidden)] +pub struct Rrb<A> { + length: usize, + middle_level: usize, + outer_f: PoolRef<Chunk<A>>, + inner_f: PoolRef<Chunk<A>>, + middle: Ref<Node<A>>, + inner_b: PoolRef<Chunk<A>>, + outer_b: PoolRef<Chunk<A>>, +} + +impl<A> Clone for Rrb<A> { + fn clone(&self) -> Self { + Rrb { + length: self.length, + middle_level: self.middle_level, + outer_f: self.outer_f.clone(), + inner_f: self.inner_f.clone(), + middle: self.middle.clone(), + inner_b: self.inner_b.clone(), + outer_b: self.outer_b.clone(), + } + } +} + +impl<A: Clone> Vector<A> { + /// Get a reference to the memory pool this `Vector` is using. + /// + /// Note that if you didn't specifically construct it with a pool, you'll + /// get back a reference to a pool of size 0. + #[cfg_attr(not(feature = "pool"), doc(hidden))] + pub fn pool(&self) -> &RRBPool<A> { + match self.vector { + Inline(ref pool, _) => pool, + Single(ref pool, _) => pool, + Full(ref pool, _) => pool, + } + } + + /// True if a vector is a full inline or single chunk, ie. must be promoted + /// to grow further. + fn needs_promotion(&self) -> bool { + match &self.vector { + Inline(_, chunk) if chunk.is_full() => true, + Single(_, chunk) if chunk.is_full() => true, + _ => false, + } + } + + /// Promote an inline to a single. + fn promote_inline(&mut self) { + if let Inline(pool, chunk) = &mut self.vector { + self.vector = Single(pool.clone(), PoolRef::new(&pool.value_pool, chunk.into())); + } + } + + /// Promote a single to a full, with the single chunk becoming inner_f, or + /// promote an inline to a single. + fn promote_front(&mut self) { + self.vector = match &mut self.vector { + Inline(pool, chunk) => { + Single(pool.clone(), PoolRef::new(&pool.value_pool, chunk.into())) + } + Single(pool, chunk) => { + let chunk = chunk.clone(); + Full( + pool.clone(), + Rrb { + length: chunk.len(), + middle_level: 0, + outer_f: PoolRef::default(&pool.value_pool), + inner_f: chunk, + middle: Ref::new(Node::new()), + inner_b: PoolRef::default(&pool.value_pool), + outer_b: PoolRef::default(&pool.value_pool), + }, + ) + } + Full(_, _) => return, + } + } + + /// Promote a single to a full, with the single chunk becoming inner_b, or + /// promote an inline to a single. + fn promote_back(&mut self) { + self.vector = match &mut self.vector { + Inline(pool, chunk) => { + Single(pool.clone(), PoolRef::new(&pool.value_pool, chunk.into())) + } + Single(pool, chunk) => { + let chunk = chunk.clone(); + Full( + pool.clone(), + Rrb { + length: chunk.len(), + middle_level: 0, + outer_f: PoolRef::default(&pool.value_pool), + inner_f: PoolRef::default(&pool.value_pool), + middle: Ref::new(Node::new()), + inner_b: chunk, + outer_b: PoolRef::default(&pool.value_pool), + }, + ) + } + Full(_, _) => return, + } + } + + /// Construct an empty vector. + #[must_use] + pub fn new() -> Self { + Self { + vector: Inline(RRBPool::default(), InlineArray::new()), + } + } + + /// Construct an empty vector using a specific memory pool. + #[cfg(feature = "pool")] + #[must_use] + pub fn with_pool(pool: &RRBPool<A>) -> Self { + Self { + vector: Inline(pool.clone(), InlineArray::new()), + } + } + + /// Get the length of a vector. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// assert_eq!(5, vector![1, 2, 3, 4, 5].len()); + /// ``` + #[inline] + #[must_use] + pub fn len(&self) -> usize { + match &self.vector { + Inline(_, chunk) => chunk.len(), + Single(_, chunk) => chunk.len(), + Full(_, tree) => tree.length, + } + } + + /// Test whether a vector is empty. + /// + /// Time: O(1) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let vec = vector!["Joe", "Mike", "Robert"]; + /// assert_eq!(false, vec.is_empty()); + /// assert_eq!(true, Vector::<i32>::new().is_empty()); + /// ``` + #[inline] + #[must_use] + pub fn is_empty(&self) -> bool { + self.len() == 0 + } + + /// Test whether a vector is currently inlined. + /// + /// Vectors small enough that their contents could be stored entirely inside + /// the space of `std::mem::size_of::<Vector<A>>()` bytes are stored inline on + /// the stack instead of allocating any chunks. This method returns `true` if + /// this vector is currently inlined, or `false` if it currently has chunks allocated + /// on the heap. + /// + /// This may be useful in conjunction with [`ptr_eq()`][ptr_eq], which checks if + /// two vectors' heap allocations are the same, and thus will never return `true` + /// for inlined vectors. + /// + /// Time: O(1) + /// + /// [ptr_eq]: #method.ptr_eq + #[inline] + #[must_use] + pub fn is_inline(&self) -> bool { + matches!(&self.vector, Inline(_, _)) + } + + /// Test whether two vectors refer to the same content in memory. + /// + /// This uses the following rules to determine equality: + /// * If the two sides are references to the same vector, return true. + /// * If the two sides are single chunk vectors pointing to the same chunk, return true. + /// * If the two sides are full trees pointing to the same chunks, return true. + /// + /// This would return true if you're comparing a vector to itself, or + /// if you're comparing a vector to a fresh clone of itself. The exception to this is + /// if you've cloned an inline array (ie. an array with so few elements they can fit + /// inside the space a `Vector` allocates for its pointers, so there are no heap allocations + /// to compare). + /// + /// Time: O(1) + #[must_use] + pub fn ptr_eq(&self, other: &Self) -> bool { + fn cmp_chunk<A>(left: &PoolRef<Chunk<A>>, right: &PoolRef<Chunk<A>>) -> bool { + (left.is_empty() && right.is_empty()) || PoolRef::ptr_eq(left, right) + } + + if std::ptr::eq(self, other) { + return true; + } + + match (&self.vector, &other.vector) { + (Single(_, left), Single(_, right)) => cmp_chunk(left, right), + (Full(_, left), Full(_, right)) => { + cmp_chunk(&left.outer_f, &right.outer_f) + && cmp_chunk(&left.inner_f, &right.inner_f) + && cmp_chunk(&left.inner_b, &right.inner_b) + && cmp_chunk(&left.outer_b, &right.outer_b) + && ((left.middle.is_empty() && right.middle.is_empty()) + || Ref::ptr_eq(&left.middle, &right.middle)) + } + _ => false, + } + } + + /// Get an iterator over a vector. + /// + /// Time: O(1) + #[inline] + #[must_use] + pub fn iter(&self) -> Iter<'_, A> { + Iter::new(self) + } + + /// Get a mutable iterator over a vector. + /// + /// Time: O(1) + #[inline] + #[must_use] + pub fn iter_mut(&mut self) -> IterMut<'_, A> { + IterMut::new(self) + } + + /// Get an iterator over the leaf nodes of a vector. + /// + /// This returns an iterator over the [`Chunk`s][Chunk] at the leaves of the + /// RRB tree. These are useful for efficient parallelisation of work on + /// the vector, but should not be used for basic iteration. + /// + /// Time: O(1) + /// + /// [Chunk]: ../chunk/struct.Chunk.html + #[inline] + #[must_use] + pub fn leaves(&self) -> Chunks<'_, A> { + Chunks::new(self) + } + + /// Get a mutable iterator over the leaf nodes of a vector. + // + /// This returns an iterator over the [`Chunk`s][Chunk] at the leaves of the + /// RRB tree. These are useful for efficient parallelisation of work on + /// the vector, but should not be used for basic iteration. + /// + /// Time: O(1) + /// + /// [Chunk]: ../chunk/struct.Chunk.html + #[inline] + #[must_use] + pub fn leaves_mut(&mut self) -> ChunksMut<'_, A> { + ChunksMut::new(self) + } + + /// Construct a [`Focus`][Focus] for a vector. + /// + /// Time: O(1) + /// + /// [Focus]: enum.Focus.html + #[inline] + #[must_use] + pub fn focus(&self) -> Focus<'_, A> { + Focus::new(self) + } + + /// Construct a [`FocusMut`][FocusMut] for a vector. + /// + /// Time: O(1) + /// + /// [FocusMut]: enum.FocusMut.html + #[inline] + #[must_use] + pub fn focus_mut(&mut self) -> FocusMut<'_, A> { + FocusMut::new(self) + } + + /// Get a reference to the value at index `index` in a vector. + /// + /// Returns `None` if the index is out of bounds. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let vec = vector!["Joe", "Mike", "Robert"]; + /// assert_eq!(Some(&"Robert"), vec.get(2)); + /// assert_eq!(None, vec.get(5)); + /// ``` + #[must_use] + pub fn get(&self, index: usize) -> Option<&A> { + if index >= self.len() { + return None; + } + + match &self.vector { + Inline(_, chunk) => chunk.get(index), + Single(_, chunk) => chunk.get(index), + Full(_, tree) => { + let mut local_index = index; + + if local_index < tree.outer_f.len() { + return Some(&tree.outer_f[local_index]); + } + local_index -= tree.outer_f.len(); + + if local_index < tree.inner_f.len() { + return Some(&tree.inner_f[local_index]); + } + local_index -= tree.inner_f.len(); + + if local_index < tree.middle.len() { + return Some(tree.middle.index(tree.middle_level, local_index)); + } + local_index -= tree.middle.len(); + + if local_index < tree.inner_b.len() { + return Some(&tree.inner_b[local_index]); + } + local_index -= tree.inner_b.len(); + + Some(&tree.outer_b[local_index]) + } + } + } + + /// Get a mutable reference to the value at index `index` in a + /// vector. + /// + /// Returns `None` if the index is out of bounds. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector!["Joe", "Mike", "Robert"]; + /// { + /// let robert = vec.get_mut(2).unwrap(); + /// assert_eq!(&mut "Robert", robert); + /// *robert = "Bjarne"; + /// } + /// assert_eq!(vector!["Joe", "Mike", "Bjarne"], vec); + /// ``` + #[must_use] + pub fn get_mut(&mut self, index: usize) -> Option<&mut A> { + if index >= self.len() { + return None; + } + + match &mut self.vector { + Inline(_, chunk) => chunk.get_mut(index), + Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).get_mut(index), + Full(pool, tree) => { + let mut local_index = index; + + if local_index < tree.outer_f.len() { + let outer_f = PoolRef::make_mut(&pool.value_pool, &mut tree.outer_f); + return Some(&mut outer_f[local_index]); + } + local_index -= tree.outer_f.len(); + + if local_index < tree.inner_f.len() { + let inner_f = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_f); + return Some(&mut inner_f[local_index]); + } + local_index -= tree.inner_f.len(); + + if local_index < tree.middle.len() { + let middle = Ref::make_mut(&mut tree.middle); + return Some(middle.index_mut(pool, tree.middle_level, local_index)); + } + local_index -= tree.middle.len(); + + if local_index < tree.inner_b.len() { + let inner_b = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_b); + return Some(&mut inner_b[local_index]); + } + local_index -= tree.inner_b.len(); + + let outer_b = PoolRef::make_mut(&pool.value_pool, &mut tree.outer_b); + Some(&mut outer_b[local_index]) + } + } + } + + /// Get the first element of a vector. + /// + /// If the vector is empty, `None` is returned. + /// + /// Time: O(log n) + #[inline] + #[must_use] + pub fn front(&self) -> Option<&A> { + self.get(0) + } + + /// Get a mutable reference to the first element of a vector. + /// + /// If the vector is empty, `None` is returned. + /// + /// Time: O(log n) + #[inline] + #[must_use] + pub fn front_mut(&mut self) -> Option<&mut A> { + self.get_mut(0) + } + + /// Get the first element of a vector. + /// + /// If the vector is empty, `None` is returned. + /// + /// This is an alias for the [`front`][front] method. + /// + /// Time: O(log n) + /// + /// [front]: #method.front + #[inline] + #[must_use] + pub fn head(&self) -> Option<&A> { + self.get(0) + } + + /// Get the last element of a vector. + /// + /// If the vector is empty, `None` is returned. + /// + /// Time: O(log n) + #[must_use] + pub fn back(&self) -> Option<&A> { + if self.is_empty() { + None + } else { + self.get(self.len() - 1) + } + } + + /// Get a mutable reference to the last element of a vector. + /// + /// If the vector is empty, `None` is returned. + /// + /// Time: O(log n) + #[must_use] + pub fn back_mut(&mut self) -> Option<&mut A> { + if self.is_empty() { + None + } else { + let len = self.len(); + self.get_mut(len - 1) + } + } + + /// Get the last element of a vector. + /// + /// If the vector is empty, `None` is returned. + /// + /// This is an alias for the [`back`][back] method. + /// + /// Time: O(log n) + /// + /// [back]: #method.back + #[inline] + #[must_use] + pub fn last(&self) -> Option<&A> { + self.back() + } + + /// Get the index of a given element in the vector. + /// + /// Searches the vector for the first occurrence of a given value, + /// and returns the index of the value if it's there. Otherwise, + /// it returns `None`. + /// + /// Time: O(n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![1, 2, 3, 4, 5]; + /// assert_eq!(Some(2), vec.index_of(&3)); + /// assert_eq!(None, vec.index_of(&31337)); + /// ``` + #[must_use] + pub fn index_of(&self, value: &A) -> Option<usize> + where + A: PartialEq, + { + for (index, item) in self.iter().enumerate() { + if value == item { + return Some(index); + } + } + None + } + + /// Test if a given element is in the vector. + /// + /// Searches the vector for the first occurrence of a given value, + /// and returns `true` if it's there. If it's nowhere to be found + /// in the vector, it returns `false`. + /// + /// Time: O(n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![1, 2, 3, 4, 5]; + /// assert_eq!(true, vec.contains(&3)); + /// assert_eq!(false, vec.contains(&31337)); + /// ``` + #[inline] + #[must_use] + pub fn contains(&self, value: &A) -> bool + where + A: PartialEq, + { + self.index_of(value).is_some() + } + + /// Discard all elements from the vector. + /// + /// This leaves you with an empty vector, and all elements that + /// were previously inside it are dropped. + /// + /// Time: O(n) + pub fn clear(&mut self) { + if !self.is_empty() { + self.vector = Inline(self.pool().clone(), InlineArray::new()); + } + } + + /// Binary search a sorted vector for a given element using a comparator + /// function. + /// + /// Assumes the vector has already been sorted using the same comparator + /// function, eg. by using [`sort_by`][sort_by]. + /// + /// If the value is found, it returns `Ok(index)` where `index` is the index + /// of the element. If the value isn't found, it returns `Err(index)` where + /// `index` is the index at which the element would need to be inserted to + /// maintain sorted order. + /// + /// Time: O(log n) + /// + /// [sort_by]: #method.sort_by + pub fn binary_search_by<F>(&self, mut f: F) -> Result<usize, usize> + where + F: FnMut(&A) -> Ordering, + { + let mut size = self.len(); + if size == 0 { + return Err(0); + } + let mut base = 0; + while size > 1 { + let half = size / 2; + let mid = base + half; + base = match f(&self[mid]) { + Ordering::Greater => base, + _ => mid, + }; + size -= half; + } + match f(&self[base]) { + Ordering::Equal => Ok(base), + Ordering::Greater => Err(base), + Ordering::Less => Err(base + 1), + } + } + + /// Binary search a sorted vector for a given element. + /// + /// If the value is found, it returns `Ok(index)` where `index` is the index + /// of the element. If the value isn't found, it returns `Err(index)` where + /// `index` is the index at which the element would need to be inserted to + /// maintain sorted order. + /// + /// Time: O(log n) + pub fn binary_search(&self, value: &A) -> Result<usize, usize> + where + A: Ord, + { + self.binary_search_by(|e| e.cmp(value)) + } + + /// Binary search a sorted vector for a given element with a key extract + /// function. + /// + /// Assumes the vector has already been sorted using the same key extract + /// function, eg. by using [`sort_by_key`][sort_by_key]. + /// + /// If the value is found, it returns `Ok(index)` where `index` is the index + /// of the element. If the value isn't found, it returns `Err(index)` where + /// `index` is the index at which the element would need to be inserted to + /// maintain sorted order. + /// + /// Time: O(log n) + /// + /// [sort_by_key]: #method.sort_by_key + pub fn binary_search_by_key<B, F>(&self, b: &B, mut f: F) -> Result<usize, usize> + where + F: FnMut(&A) -> B, + B: Ord, + { + self.binary_search_by(|k| f(k).cmp(b)) + } +} + +impl<A: Clone> Vector<A> { + /// Construct a vector with a single value. + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let vec = Vector::unit(1337); + /// assert_eq!(1, vec.len()); + /// assert_eq!( + /// vec.get(0), + /// Some(&1337) + /// ); + /// ``` + #[inline] + #[must_use] + pub fn unit(a: A) -> Self { + let pool = RRBPool::default(); + if InlineArray::<A, Rrb<A>>::CAPACITY > 0 { + let mut array = InlineArray::new(); + array.push(a); + Self { + vector: Inline(pool, array), + } + } else { + let chunk = PoolRef::new(&pool.value_pool, Chunk::unit(a)); + Self { + vector: Single(pool, chunk), + } + } + } + + /// Create a new vector with the value at index `index` updated. + /// + /// Panics if the index is out of bounds. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![1, 2, 3]; + /// assert_eq!(vector![1, 5, 3], vec.update(1, 5)); + /// ``` + #[must_use] + pub fn update(&self, index: usize, value: A) -> Self { + let mut out = self.clone(); + out[index] = value; + out + } + + /// Update the value at index `index` in a vector. + /// + /// Returns the previous value at the index. + /// + /// Panics if the index is out of bounds. + /// + /// Time: O(log n) + #[inline] + pub fn set(&mut self, index: usize, value: A) -> A { + replace(&mut self[index], value) + } + + /// Swap the elements at indices `i` and `j`. + /// + /// Time: O(log n) + pub fn swap(&mut self, i: usize, j: usize) { + swap_indices(self, i, j) + } + + /// Push a value to the front of a vector. + /// + /// Time: O(1)* + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![5, 6, 7]; + /// vec.push_front(4); + /// assert_eq!(vector![4, 5, 6, 7], vec); + /// ``` + pub fn push_front(&mut self, value: A) { + if self.needs_promotion() { + self.promote_back(); + } + match &mut self.vector { + Inline(_, chunk) => { + chunk.insert(0, value); + } + Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).push_front(value), + Full(pool, tree) => tree.push_front(pool, value), + } + } + + /// Push a value to the back of a vector. + /// + /// Time: O(1)* + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![1, 2, 3]; + /// vec.push_back(4); + /// assert_eq!(vector![1, 2, 3, 4], vec); + /// ``` + pub fn push_back(&mut self, value: A) { + if self.needs_promotion() { + self.promote_front(); + } + match &mut self.vector { + Inline(_, chunk) => { + chunk.push(value); + } + Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).push_back(value), + Full(pool, tree) => tree.push_back(pool, value), + } + } + + /// Remove the first element from a vector and return it. + /// + /// Time: O(1)* + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![1, 2, 3]; + /// assert_eq!(Some(1), vec.pop_front()); + /// assert_eq!(vector![2, 3], vec); + /// ``` + pub fn pop_front(&mut self) -> Option<A> { + if self.is_empty() { + None + } else { + match &mut self.vector { + Inline(_, chunk) => chunk.remove(0), + Single(pool, chunk) => Some(PoolRef::make_mut(&pool.value_pool, chunk).pop_front()), + Full(pool, tree) => tree.pop_front(pool), + } + } + } + + /// Remove the last element from a vector and return it. + /// + /// Time: O(1)* + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::Vector; + /// let mut vec = vector![1, 2, 3]; + /// assert_eq!(Some(3), vec.pop_back()); + /// assert_eq!(vector![1, 2], vec); + /// ``` + pub fn pop_back(&mut self) -> Option<A> { + if self.is_empty() { + None + } else { + match &mut self.vector { + Inline(_, chunk) => chunk.pop(), + Single(pool, chunk) => Some(PoolRef::make_mut(&pool.value_pool, chunk).pop_back()), + Full(pool, tree) => tree.pop_back(pool), + } + } + } + + /// Append the vector `other` to the end of the current vector. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let mut vec = vector![1, 2, 3]; + /// vec.append(vector![7, 8, 9]); + /// assert_eq!(vector![1, 2, 3, 7, 8, 9], vec); + /// ``` + pub fn append(&mut self, mut other: Self) { + if other.is_empty() { + return; + } + + if self.is_empty() { + *self = other; + return; + } + + self.promote_inline(); + other.promote_inline(); + + let total_length = self + .len() + .checked_add(other.len()) + .expect("Vector length overflow"); + + match &mut self.vector { + Inline(_, _) => unreachable!("inline vecs should have been promoted"), + Single(pool, left) => { + match &mut other.vector { + Inline(_, _) => unreachable!("inline vecs should have been promoted"), + // If both are single chunks and left has room for right: directly + // memcpy right into left + Single(_, ref mut right) if total_length <= CHUNK_SIZE => { + PoolRef::make_mut(&pool.value_pool, left) + .append(PoolRef::make_mut(&pool.value_pool, right)); + return; + } + // If only left is a single chunk and has room for right: push + // right's elements into left + _ if total_length <= CHUNK_SIZE => { + while let Some(value) = other.pop_front() { + PoolRef::make_mut(&pool.value_pool, left).push_back(value); + } + return; + } + _ => {} + } + } + Full(pool, left) => { + if let Full(_, mut right) = other.vector { + // If left and right are trees with empty middles, left has no back + // buffers, and right has no front buffers: copy right's back + // buffers over to left + if left.middle.is_empty() + && right.middle.is_empty() + && left.outer_b.is_empty() + && left.inner_b.is_empty() + && right.outer_f.is_empty() + && right.inner_f.is_empty() + { + left.inner_b = right.inner_b; + left.outer_b = right.outer_b; + left.length = total_length; + return; + } + // If left and right are trees with empty middles and left's buffers + // can fit right's buffers: push right's elements onto left + if left.middle.is_empty() + && right.middle.is_empty() + && total_length <= CHUNK_SIZE * 4 + { + while let Some(value) = right.pop_front(pool) { + left.push_back(pool, value); + } + return; + } + // Both are full and big: do the full RRB join + let inner_b1 = left.inner_b.clone(); + left.push_middle(pool, Side::Right, inner_b1); + let outer_b1 = left.outer_b.clone(); + left.push_middle(pool, Side::Right, outer_b1); + let inner_f2 = right.inner_f.clone(); + right.push_middle(pool, Side::Left, inner_f2); + let outer_f2 = right.outer_f.clone(); + right.push_middle(pool, Side::Left, outer_f2); + + let mut middle1 = clone_ref(replace(&mut left.middle, Ref::from(Node::new()))); + let mut middle2 = clone_ref(right.middle); + let normalised_middle = match left.middle_level.cmp(&right.middle_level) { + Ordering::Greater => { + middle2 = middle2.elevate(pool, left.middle_level - right.middle_level); + left.middle_level + } + Ordering::Less => { + middle1 = middle1.elevate(pool, right.middle_level - left.middle_level); + right.middle_level + } + Ordering::Equal => left.middle_level, + }; + left.middle = Ref::new(Node::merge(pool, middle1, middle2, normalised_middle)); + left.middle_level = normalised_middle + 1; + + left.inner_b = right.inner_b; + left.outer_b = right.outer_b; + left.length = total_length; + left.prune(); + return; + } + } + } + // No optimisations available, and either left, right or both are + // single: promote both to full and retry + self.promote_front(); + other.promote_back(); + self.append(other) + } + + /// Retain only the elements specified by the predicate. + /// + /// Remove all elements for which the provided function `f` + /// returns false from the vector. + /// + /// Time: O(n) + pub fn retain<F>(&mut self, mut f: F) + where + F: FnMut(&A) -> bool, + { + let len = self.len(); + let mut del = 0; + { + let mut focus = self.focus_mut(); + for i in 0..len { + if !f(focus.index(i)) { + del += 1; + } else if del > 0 { + focus.swap(i - del, i); + } + } + } + if del > 0 { + self.split_off(len - del); + } + } + + /// Split a vector at a given index. + /// + /// Split a vector at a given index, consuming the vector and + /// returning a pair of the left hand side and the right hand side + /// of the split. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let mut vec = vector![1, 2, 3, 7, 8, 9]; + /// let (left, right) = vec.split_at(3); + /// assert_eq!(vector![1, 2, 3], left); + /// assert_eq!(vector![7, 8, 9], right); + /// ``` + pub fn split_at(mut self, index: usize) -> (Self, Self) { + let right = self.split_off(index); + (self, right) + } + + /// Split a vector at a given index. + /// + /// Split a vector at a given index, leaving the left hand side in + /// the current vector and returning a new vector containing the + /// right hand side. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let mut left = vector![1, 2, 3, 7, 8, 9]; + /// let right = left.split_off(3); + /// assert_eq!(vector![1, 2, 3], left); + /// assert_eq!(vector![7, 8, 9], right); + /// ``` + pub fn split_off(&mut self, index: usize) -> Self { + assert!(index <= self.len()); + + match &mut self.vector { + Inline(pool, chunk) => Self { + vector: Inline(pool.clone(), chunk.split_off(index)), + }, + Single(pool, chunk) => Self { + vector: Single( + pool.clone(), + PoolRef::new( + &pool.value_pool, + PoolRef::make_mut(&pool.value_pool, chunk).split_off(index), + ), + ), + }, + Full(pool, tree) => { + let mut local_index = index; + + if local_index < tree.outer_f.len() { + let of2 = PoolRef::make_mut(&pool.value_pool, &mut tree.outer_f) + .split_off(local_index); + let right = Rrb { + length: tree.length - index, + middle_level: tree.middle_level, + outer_f: PoolRef::new(&pool.value_pool, of2), + inner_f: replace_pool_def(&pool.value_pool, &mut tree.inner_f), + middle: std::mem::take(&mut tree.middle), + inner_b: replace_pool_def(&pool.value_pool, &mut tree.inner_b), + outer_b: replace_pool_def(&pool.value_pool, &mut tree.outer_b), + }; + tree.length = index; + tree.middle_level = 0; + return Self { + vector: Full(pool.clone(), right), + }; + } + + local_index -= tree.outer_f.len(); + + if local_index < tree.inner_f.len() { + let if2 = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_f) + .split_off(local_index); + let right = Rrb { + length: tree.length - index, + middle_level: tree.middle_level, + outer_f: PoolRef::new(&pool.value_pool, if2), + inner_f: PoolRef::<Chunk<A>>::default(&pool.value_pool), + middle: std::mem::take(&mut tree.middle), + inner_b: replace_pool_def(&pool.value_pool, &mut tree.inner_b), + outer_b: replace_pool_def(&pool.value_pool, &mut tree.outer_b), + }; + tree.length = index; + tree.middle_level = 0; + swap(&mut tree.outer_b, &mut tree.inner_f); + return Self { + vector: Full(pool.clone(), right), + }; + } + + local_index -= tree.inner_f.len(); + + if local_index < tree.middle.len() { + let mut right_middle = tree.middle.clone(); + let (c1, c2) = { + let m1 = Ref::make_mut(&mut tree.middle); + let m2 = Ref::make_mut(&mut right_middle); + match m1.split(pool, tree.middle_level, Side::Right, local_index) { + SplitResult::Dropped(_) => (), + SplitResult::OutOfBounds => unreachable!(), + }; + match m2.split(pool, tree.middle_level, Side::Left, local_index) { + SplitResult::Dropped(_) => (), + SplitResult::OutOfBounds => unreachable!(), + }; + let c1 = match m1.pop_chunk(pool, tree.middle_level, Side::Right) { + PopResult::Empty => PoolRef::default(&pool.value_pool), + PopResult::Done(chunk) => chunk, + PopResult::Drained(chunk) => { + m1.clear_node(); + chunk + } + }; + let c2 = match m2.pop_chunk(pool, tree.middle_level, Side::Left) { + PopResult::Empty => PoolRef::default(&pool.value_pool), + PopResult::Done(chunk) => chunk, + PopResult::Drained(chunk) => { + m2.clear_node(); + chunk + } + }; + (c1, c2) + }; + let mut right = Rrb { + length: tree.length - index, + middle_level: tree.middle_level, + outer_f: c2, + inner_f: PoolRef::<Chunk<A>>::default(&pool.value_pool), + middle: right_middle, + inner_b: replace_pool_def(&pool.value_pool, &mut tree.inner_b), + outer_b: replace(&mut tree.outer_b, c1), + }; + tree.length = index; + tree.prune(); + right.prune(); + return Self { + vector: Full(pool.clone(), right), + }; + } + + local_index -= tree.middle.len(); + + if local_index < tree.inner_b.len() { + let ib2 = PoolRef::make_mut(&pool.value_pool, &mut tree.inner_b) + .split_off(local_index); + let right = Rrb { + length: tree.length - index, + outer_b: replace_pool_def(&pool.value_pool, &mut tree.outer_b), + outer_f: PoolRef::new(&pool.value_pool, ib2), + ..Rrb::new(pool) + }; + tree.length = index; + swap(&mut tree.outer_b, &mut tree.inner_b); + return Self { + vector: Full(pool.clone(), right), + }; + } + + local_index -= tree.inner_b.len(); + + let ob2 = + PoolRef::make_mut(&pool.value_pool, &mut tree.outer_b).split_off(local_index); + tree.length = index; + Self { + vector: Single(pool.clone(), PoolRef::new(&pool.value_pool, ob2)), + } + } + } + } + + /// Construct a vector with `count` elements removed from the + /// start of the current vector. + /// + /// Time: O(log n) + #[must_use] + pub fn skip(&self, count: usize) -> Self { + // FIXME can be made more efficient by dropping the unwanted side without constructing it + self.clone().split_off(count) + } + + /// Construct a vector of the first `count` elements from the + /// current vector. + /// + /// Time: O(log n) + #[must_use] + pub fn take(&self, count: usize) -> Self { + // FIXME can be made more efficient by dropping the unwanted side without constructing it + let mut left = self.clone(); + left.split_off(count); + left + } + + /// Truncate a vector to the given size. + /// + /// Discards all elements in the vector beyond the given length. + /// + /// Panics if the new length is greater than the current length. + /// + /// Time: O(log n) + pub fn truncate(&mut self, len: usize) { + // FIXME can be made more efficient by dropping the unwanted side without constructing it + self.split_off(len); + } + + /// Extract a slice from a vector. + /// + /// Remove the elements from `start_index` until `end_index` in + /// the current vector and return the removed slice as a new + /// vector. + /// + /// Time: O(log n) + pub fn slice<R>(&mut self, range: R) -> Self + where + R: RangeBounds<usize>, + { + let r = to_range(&range, self.len()); + if r.start >= r.end || r.start >= self.len() { + return Vector::new(); + } + let mut middle = self.split_off(r.start); + let right = middle.split_off(r.end - r.start); + self.append(right); + middle + } + + /// Insert an element into a vector. + /// + /// Insert an element at position `index`, shifting all elements + /// after it to the right. + /// + /// ## Performance Note + /// + /// While `push_front` and `push_back` are heavily optimised + /// operations, `insert` in the middle of a vector requires a + /// split, a push, and an append. Thus, if you want to insert + /// many elements at the same location, instead of `insert`ing + /// them one by one, you should rather create a new vector + /// containing the elements to insert, split the vector at the + /// insertion point, and append the left hand, the new vector and + /// the right hand in order. + /// + /// Time: O(log n) + pub fn insert(&mut self, index: usize, value: A) { + if index == 0 { + return self.push_front(value); + } + if index == self.len() { + return self.push_back(value); + } + assert!(index < self.len()); + if if let Inline(_, chunk) = &self.vector { + chunk.is_full() + } else { + false + } { + self.promote_inline(); + } + match &mut self.vector { + Inline(_, chunk) => { + chunk.insert(index, value); + } + Single(pool, chunk) if chunk.len() < CHUNK_SIZE => { + PoolRef::make_mut(&pool.value_pool, chunk).insert(index, value) + } + // TODO a lot of optimisations still possible here + _ => { + let right = self.split_off(index); + self.push_back(value); + self.append(right); + } + } + } + + /// Remove an element from a vector. + /// + /// Remove the element from position 'index', shifting all + /// elements after it to the left, and return the removed element. + /// + /// ## Performance Note + /// + /// While `pop_front` and `pop_back` are heavily optimised + /// operations, `remove` in the middle of a vector requires a + /// split, a pop, and an append. Thus, if you want to remove many + /// elements from the same location, instead of `remove`ing them + /// one by one, it is much better to use [`slice`][slice]. + /// + /// Time: O(log n) + /// + /// [slice]: #method.slice + pub fn remove(&mut self, index: usize) -> A { + assert!(index < self.len()); + match &mut self.vector { + Inline(_, chunk) => chunk.remove(index).unwrap(), + Single(pool, chunk) => PoolRef::make_mut(&pool.value_pool, chunk).remove(index), + _ => { + if index == 0 { + return self.pop_front().unwrap(); + } + if index == self.len() - 1 { + return self.pop_back().unwrap(); + } + // TODO a lot of optimisations still possible here + let mut right = self.split_off(index); + let value = right.pop_front().unwrap(); + self.append(right); + value + } + } + } + + /// Insert an element into a sorted vector. + /// + /// Insert an element into a vector in sorted order, assuming the vector is + /// already in sorted order. + /// + /// Time: O(log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let mut vec = vector![1, 2, 3, 7, 8, 9]; + /// vec.insert_ord(5); + /// assert_eq!(vector![1, 2, 3, 5, 7, 8, 9], vec); + /// ``` + pub fn insert_ord(&mut self, item: A) + where + A: Ord, + { + match self.binary_search(&item) { + Ok(index) => self.insert(index, item), + Err(index) => self.insert(index, item), + } + } + + /// Sort a vector. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let mut vec = vector![3, 2, 5, 4, 1]; + /// vec.sort(); + /// assert_eq!(vector![1, 2, 3, 4, 5], vec); + /// ``` + pub fn sort(&mut self) + where + A: Ord, + { + self.sort_by(Ord::cmp) + } + + /// Sort a vector using a comparator function. + /// + /// Time: O(n log n) + /// + /// # Examples + /// + /// ``` + /// # #[macro_use] extern crate im_rc as im; + /// # use im::vector::Vector; + /// let mut vec = vector![3, 2, 5, 4, 1]; + /// vec.sort_by(|left, right| left.cmp(right)); + /// assert_eq!(vector![1, 2, 3, 4, 5], vec); + /// ``` + pub fn sort_by<F>(&mut self, cmp: F) + where + F: Fn(&A, &A) -> Ordering, + { + let len = self.len(); + if len > 1 { + sort::quicksort(self.focus_mut(), &cmp); + } + } + + /// Verify the internal consistency of a vector. + /// + /// This method walks the RRB tree making up the current `Vector` + /// (if it has one) and verifies that all the invariants hold. + /// If something is wrong, it will panic. + /// + /// This method requires the `debug` feature flag. + #[cfg(any(test, feature = "debug"))] + pub fn assert_invariants(&self) { + if let Full(_, ref tree) = self.vector { + tree.assert_invariants(); + } + } +} + +// Implementation details + +impl<A: Clone> Rrb<A> { + fn new(pool: &RRBPool<A>) -> Self { + Rrb { + length: 0, + middle_level: 0, + outer_f: PoolRef::default(&pool.value_pool), + inner_f: PoolRef::default(&pool.value_pool), + middle: Ref::new(Node::new()), + inner_b: PoolRef::default(&pool.value_pool), + outer_b: PoolRef::default(&pool.value_pool), + } + } + + #[cfg(any(test, feature = "debug"))] + fn assert_invariants(&self) { + let ml = self.middle.assert_invariants(self.middle_level); + assert_eq!( + self.length, + self.outer_f.len() + self.inner_f.len() + ml + self.inner_b.len() + self.outer_b.len() + ); + } + + fn prune(&mut self) { + if self.middle.is_empty() { + self.middle = Ref::new(Node::new()); + self.middle_level = 0; + } else { + while self.middle_level > 0 && self.middle.is_single() { + // FIXME could be optimised, cloning the node is expensive + self.middle = Ref::new(self.middle.first_child().clone()); + self.middle_level -= 1; + } + } + } + + fn pop_front(&mut self, pool: &RRBPool<A>) -> Option<A> { + if self.length == 0 { + return None; + } + if self.outer_f.is_empty() { + if self.inner_f.is_empty() { + if self.middle.is_empty() { + if self.inner_b.is_empty() { + swap(&mut self.outer_f, &mut self.outer_b); + } else { + swap(&mut self.outer_f, &mut self.inner_b); + } + } else { + self.outer_f = self.pop_middle(pool, Side::Left).unwrap(); + } + } else { + swap(&mut self.outer_f, &mut self.inner_f); + } + } + self.length -= 1; + let outer_f = PoolRef::make_mut(&pool.value_pool, &mut self.outer_f); + Some(outer_f.pop_front()) + } + + fn pop_back(&mut self, pool: &RRBPool<A>) -> Option<A> { + if self.length == 0 { + return None; + } + if self.outer_b.is_empty() { + if self.inner_b.is_empty() { + if self.middle.is_empty() { + if self.inner_f.is_empty() { + swap(&mut self.outer_b, &mut self.outer_f); + } else { + swap(&mut self.outer_b, &mut self.inner_f); + } + } else { + self.outer_b = self.pop_middle(pool, Side::Right).unwrap(); + } + } else { + swap(&mut self.outer_b, &mut self.inner_b); + } + } + self.length -= 1; + let outer_b = PoolRef::make_mut(&pool.value_pool, &mut self.outer_b); + Some(outer_b.pop_back()) + } + + fn push_front(&mut self, pool: &RRBPool<A>, value: A) { + if self.outer_f.is_full() { + swap(&mut self.outer_f, &mut self.inner_f); + if !self.outer_f.is_empty() { + let mut chunk = PoolRef::new(&pool.value_pool, Chunk::new()); + swap(&mut chunk, &mut self.outer_f); + self.push_middle(pool, Side::Left, chunk); + } + } + self.length = self.length.checked_add(1).expect("Vector length overflow"); + let outer_f = PoolRef::make_mut(&pool.value_pool, &mut self.outer_f); + outer_f.push_front(value) + } + + fn push_back(&mut self, pool: &RRBPool<A>, value: A) { + if self.outer_b.is_full() { + swap(&mut self.outer_b, &mut self.inner_b); + if !self.outer_b.is_empty() { + let mut chunk = PoolRef::new(&pool.value_pool, Chunk::new()); + swap(&mut chunk, &mut self.outer_b); + self.push_middle(pool, Side::Right, chunk); + } + } + self.length = self.length.checked_add(1).expect("Vector length overflow"); + let outer_b = PoolRef::make_mut(&pool.value_pool, &mut self.outer_b); + outer_b.push_back(value) + } + + fn push_middle(&mut self, pool: &RRBPool<A>, side: Side, chunk: PoolRef<Chunk<A>>) { + if chunk.is_empty() { + return; + } + let new_middle = { + let middle = Ref::make_mut(&mut self.middle); + match middle.push_chunk(pool, self.middle_level, side, chunk) { + PushResult::Done => return, + PushResult::Full(chunk, _num_drained) => Ref::from({ + match side { + Side::Left => Node::from_chunk(pool, self.middle_level, chunk) + .join_branches(pool, middle.clone(), self.middle_level), + Side::Right => middle.clone().join_branches( + pool, + Node::from_chunk(pool, self.middle_level, chunk), + self.middle_level, + ), + } + }), + } + }; + self.middle_level += 1; + self.middle = new_middle; + } + + fn pop_middle(&mut self, pool: &RRBPool<A>, side: Side) -> Option<PoolRef<Chunk<A>>> { + let chunk = { + let middle = Ref::make_mut(&mut self.middle); + match middle.pop_chunk(pool, self.middle_level, side) { + PopResult::Empty => return None, + PopResult::Done(chunk) => chunk, + PopResult::Drained(chunk) => { + middle.clear_node(); + self.middle_level = 0; + chunk + } + } + }; + Some(chunk) + } +} + +#[inline] +fn replace_pool_def<A: PoolDefault>(pool: &Pool<A>, dest: &mut PoolRef<A>) -> PoolRef<A> { + replace(dest, PoolRef::default(pool)) +} + +// Core traits + +impl<A: Clone> Default for Vector<A> { + fn default() -> Self { + Self::new() + } +} + +impl<A: Clone> Clone for Vector<A> { + /// Clone a vector. + /// + /// Time: O(1), or O(n) with a very small, bounded *n* for an inline vector. + fn clone(&self) -> Self { + Self { + vector: match &self.vector { + Inline(pool, chunk) => Inline(pool.clone(), chunk.clone()), + Single(pool, chunk) => Single(pool.clone(), chunk.clone()), + Full(pool, tree) => Full(pool.clone(), tree.clone()), + }, + } + } +} + +impl<A: Clone + Debug> Debug for Vector<A> { + fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> { + f.debug_list().entries(self.iter()).finish() + // match self { + // Full(rrb) => { + // writeln!(f, "Head: {:?} {:?}", rrb.outer_f, rrb.inner_f)?; + // rrb.middle.print(f, 0, rrb.middle_level)?; + // writeln!(f, "Tail: {:?} {:?}", rrb.inner_b, rrb.outer_b) + // } + // Single(_) => write!(f, "nowt"), + // } + } +} + +#[cfg(not(has_specialisation))] +impl<A: Clone + PartialEq> PartialEq for Vector<A> { + fn eq(&self, other: &Self) -> bool { + self.len() == other.len() && self.iter().eq(other.iter()) + } +} + +#[cfg(has_specialisation)] +impl<A: Clone + PartialEq> PartialEq for Vector<A> { + default fn eq(&self, other: &Self) -> bool { + self.len() == other.len() && self.iter().eq(other.iter()) + } +} + +#[cfg(has_specialisation)] +impl<A: Clone + Eq> PartialEq for Vector<A> { + fn eq(&self, other: &Self) -> bool { + fn cmp_chunk<A>(left: &PoolRef<Chunk<A>>, right: &PoolRef<Chunk<A>>) -> bool { + (left.is_empty() && right.is_empty()) || PoolRef::ptr_eq(left, right) + } + + if std::ptr::eq(self, other) { + return true; + } + + match (&self.vector, &other.vector) { + (Single(_, left), Single(_, right)) => { + if cmp_chunk(left, right) { + return true; + } + self.iter().eq(other.iter()) + } + (Full(_, left), Full(_, right)) => { + if left.length != right.length { + return false; + } + + if cmp_chunk(&left.outer_f, &right.outer_f) + && cmp_chunk(&left.inner_f, &right.inner_f) + && cmp_chunk(&left.inner_b, &right.inner_b) + && cmp_chunk(&left.outer_b, &right.outer_b) + && ((left.middle.is_empty() && right.middle.is_empty()) + || Ref::ptr_eq(&left.middle, &right.middle)) + { + return true; + } + self.iter().eq(other.iter()) + } + _ => self.len() == other.len() && self.iter().eq(other.iter()), + } + } +} + +impl<A: Clone + Eq> Eq for Vector<A> {} + +impl<A: Clone + PartialOrd> PartialOrd for Vector<A> { + fn partial_cmp(&self, other: &Self) -> Option<Ordering> { + self.iter().partial_cmp(other.iter()) + } +} + +impl<A: Clone + Ord> Ord for Vector<A> { + fn cmp(&self, other: &Self) -> Ordering { + self.iter().cmp(other.iter()) + } +} + +impl<A: Clone + Hash> Hash for Vector<A> { + fn hash<H: Hasher>(&self, state: &mut H) { + for i in self { + i.hash(state) + } + } +} + +impl<A: Clone> Sum for Vector<A> { + fn sum<I>(it: I) -> Self + where + I: Iterator<Item = Self>, + { + it.fold(Self::new(), |a, b| a + b) + } +} + +impl<A: Clone> Add for Vector<A> { + type Output = Vector<A>; + + /// Concatenate two vectors. + /// + /// Time: O(log n) + fn add(mut self, other: Self) -> Self::Output { + self.append(other); + self + } +} + +impl<'a, A: Clone> Add for &'a Vector<A> { + type Output = Vector<A>; + + /// Concatenate two vectors. + /// + /// Time: O(log n) + fn add(self, other: Self) -> Self::Output { + let mut out = self.clone(); + out.append(other.clone()); + out + } +} + +impl<A: Clone> Extend<A> for Vector<A> { + /// Add values to the end of a vector by consuming an iterator. + /// + /// Time: O(n) + fn extend<I>(&mut self, iter: I) + where + I: IntoIterator<Item = A>, + { + for item in iter { + self.push_back(item) + } + } +} + +impl<A: Clone> Index<usize> for Vector<A> { + type Output = A; + /// Get a reference to the value at index `index` in the vector. + /// + /// Time: O(log n) + fn index(&self, index: usize) -> &Self::Output { + match self.get(index) { + Some(value) => value, + None => panic!( + "Vector::index: index out of bounds: {} < {}", + index, + self.len() + ), + } + } +} + +impl<A: Clone> IndexMut<usize> for Vector<A> { + /// Get a mutable reference to the value at index `index` in the + /// vector. + /// + /// Time: O(log n) + fn index_mut(&mut self, index: usize) -> &mut Self::Output { + match self.get_mut(index) { + Some(value) => value, + None => panic!("Vector::index_mut: index out of bounds"), + } + } +} + +// Conversions + +impl<'a, A: Clone> IntoIterator for &'a Vector<A> { + type Item = &'a A; + type IntoIter = Iter<'a, A>; + fn into_iter(self) -> Self::IntoIter { + self.iter() + } +} + +impl<A: Clone> IntoIterator for Vector<A> { + type Item = A; + type IntoIter = ConsumingIter<A>; + fn into_iter(self) -> Self::IntoIter { + ConsumingIter::new(self) + } +} + +impl<A: Clone> FromIterator<A> for Vector<A> { + /// Create a vector from an iterator. + /// + /// Time: O(n) + fn from_iter<I>(iter: I) -> Self + where + I: IntoIterator<Item = A>, + { + let mut seq = Self::new(); + for item in iter { + seq.push_back(item) + } + seq + } +} + +impl<'s, 'a, A, OA> From<&'s Vector<&'a A>> for Vector<OA> +where + A: ToOwned<Owned = OA>, + OA: Borrow<A> + Clone, +{ + fn from(vec: &Vector<&A>) -> Self { + vec.iter().map(|a| (*a).to_owned()).collect() + } +} + +impl<'a, A: Clone> From<&'a [A]> for Vector<A> { + fn from(slice: &[A]) -> Self { + slice.iter().cloned().collect() + } +} + +impl<A: Clone> From<Vec<A>> for Vector<A> { + /// Create a vector from a [`std::vec::Vec`][vec]. + /// + /// Time: O(n) + /// + /// [vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html + fn from(vec: Vec<A>) -> Self { + vec.into_iter().collect() + } +} + +impl<'a, A: Clone> From<&'a Vec<A>> for Vector<A> { + /// Create a vector from a [`std::vec::Vec`][vec]. + /// + /// Time: O(n) + /// + /// [vec]: https://doc.rust-lang.org/std/vec/struct.Vec.html + fn from(vec: &Vec<A>) -> Self { + vec.iter().cloned().collect() + } +} + +// Iterators + +/// An iterator over vectors with values of type `A`. +/// +/// To obtain one, use [`Vector::iter()`][iter]. +/// +/// [iter]: enum.Vector.html#method.iter +pub struct Iter<'a, A> { + focus: Focus<'a, A>, + front_index: usize, + back_index: usize, +} + +impl<'a, A: Clone> Iter<'a, A> { + fn new(seq: &'a Vector<A>) -> Self { + Iter { + focus: seq.focus(), + front_index: 0, + back_index: seq.len(), + } + } + + fn from_focus(focus: Focus<'a, A>) -> Self { + Iter { + front_index: 0, + back_index: focus.len(), + focus, + } + } +} + +impl<'a, A: Clone> Iterator for Iter<'a, A> { + type Item = &'a A; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + #[allow(unsafe_code)] + let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + let value = focus.get(self.front_index); + self.front_index += 1; + value + } + + fn size_hint(&self) -> (usize, Option<usize>) { + let remaining = self.back_index - self.front_index; + (remaining, Some(remaining)) + } +} + +impl<'a, A: Clone> DoubleEndedIterator for Iter<'a, A> { + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next_back(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + self.back_index -= 1; + #[allow(unsafe_code)] + let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + focus.get(self.back_index) + } +} + +impl<'a, A: Clone> ExactSizeIterator for Iter<'a, A> {} + +impl<'a, A: Clone> FusedIterator for Iter<'a, A> {} + +/// A mutable iterator over vectors with values of type `A`. +/// +/// To obtain one, use [`Vector::iter_mut()`][iter_mut]. +/// +/// [iter_mut]: enum.Vector.html#method.iter_mut +pub struct IterMut<'a, A> { + focus: FocusMut<'a, A>, + front_index: usize, + back_index: usize, +} + +impl<'a, A> IterMut<'a, A> +where + A: Clone, +{ + fn new(seq: &'a mut Vector<A>) -> Self { + let focus = seq.focus_mut(); + let len = focus.len(); + IterMut { + focus, + front_index: 0, + back_index: len, + } + } + + fn from_focus(focus: FocusMut<'a, A>) -> Self { + IterMut { + front_index: 0, + back_index: focus.len(), + focus, + } + } +} + +impl<'a, A> Iterator for IterMut<'a, A> +where + A: 'a + Clone, +{ + type Item = &'a mut A; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + #[allow(unsafe_code)] + let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + let value = focus.get_mut(self.front_index); + self.front_index += 1; + value + } + + fn size_hint(&self) -> (usize, Option<usize>) { + let remaining = self.back_index - self.front_index; + (remaining, Some(remaining)) + } +} + +impl<'a, A> DoubleEndedIterator for IterMut<'a, A> +where + A: 'a + Clone, +{ + /// Remove and return an element from the back of the iterator. + /// + /// Time: O(1)* + fn next_back(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + self.back_index -= 1; + #[allow(unsafe_code)] + let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + focus.get_mut(self.back_index) + } +} + +impl<'a, A: Clone> ExactSizeIterator for IterMut<'a, A> {} + +impl<'a, A: Clone> FusedIterator for IterMut<'a, A> {} + +/// A consuming iterator over vectors with values of type `A`. +pub struct ConsumingIter<A> { + vector: Vector<A>, +} + +impl<A: Clone> ConsumingIter<A> { + fn new(vector: Vector<A>) -> Self { + Self { vector } + } +} + +impl<A: Clone> Iterator for ConsumingIter<A> { + type Item = A; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + self.vector.pop_front() + } + + fn size_hint(&self) -> (usize, Option<usize>) { + let len = self.vector.len(); + (len, Some(len)) + } +} + +impl<A: Clone> DoubleEndedIterator for ConsumingIter<A> { + /// Remove and return an element from the back of the iterator. + /// + /// Time: O(1)* + fn next_back(&mut self) -> Option<Self::Item> { + self.vector.pop_back() + } +} + +impl<A: Clone> ExactSizeIterator for ConsumingIter<A> {} + +impl<A: Clone> FusedIterator for ConsumingIter<A> {} + +/// An iterator over the leaf nodes of a vector. +/// +/// To obtain one, use [`Vector::chunks()`][chunks]. +/// +/// [chunks]: enum.Vector.html#method.chunks +pub struct Chunks<'a, A> { + focus: Focus<'a, A>, + front_index: usize, + back_index: usize, +} + +impl<'a, A: Clone> Chunks<'a, A> { + fn new(seq: &'a Vector<A>) -> Self { + Chunks { + focus: seq.focus(), + front_index: 0, + back_index: seq.len(), + } + } +} + +impl<'a, A: Clone> Iterator for Chunks<'a, A> { + type Item = &'a [A]; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + #[allow(unsafe_code)] + let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + let (range, value) = focus.chunk_at(self.front_index); + self.front_index = range.end; + Some(value) + } +} + +impl<'a, A: Clone> DoubleEndedIterator for Chunks<'a, A> { + /// Remove and return an element from the back of the iterator. + /// + /// Time: O(1)* + fn next_back(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + self.back_index -= 1; + #[allow(unsafe_code)] + let focus: &'a mut Focus<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + let (range, value) = focus.chunk_at(self.back_index); + self.back_index = range.start; + Some(value) + } +} + +impl<'a, A: Clone> FusedIterator for Chunks<'a, A> {} + +/// A mutable iterator over the leaf nodes of a vector. +/// +/// To obtain one, use [`Vector::chunks_mut()`][chunks_mut]. +/// +/// [chunks_mut]: enum.Vector.html#method.chunks_mut +pub struct ChunksMut<'a, A> { + focus: FocusMut<'a, A>, + front_index: usize, + back_index: usize, +} + +impl<'a, A: Clone> ChunksMut<'a, A> { + fn new(seq: &'a mut Vector<A>) -> Self { + let len = seq.len(); + ChunksMut { + focus: seq.focus_mut(), + front_index: 0, + back_index: len, + } + } +} + +impl<'a, A: Clone> Iterator for ChunksMut<'a, A> { + type Item = &'a mut [A]; + + /// Advance the iterator and return the next value. + /// + /// Time: O(1)* + fn next(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + #[allow(unsafe_code)] + let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + let (range, value) = focus.chunk_at(self.front_index); + self.front_index = range.end; + Some(value) + } +} + +impl<'a, A: Clone> DoubleEndedIterator for ChunksMut<'a, A> { + /// Remove and return an element from the back of the iterator. + /// + /// Time: O(1)* + fn next_back(&mut self) -> Option<Self::Item> { + if self.front_index >= self.back_index { + return None; + } + self.back_index -= 1; + #[allow(unsafe_code)] + let focus: &'a mut FocusMut<'a, A> = unsafe { &mut *(&mut self.focus as *mut _) }; + let (range, value) = focus.chunk_at(self.back_index); + self.back_index = range.start; + Some(value) + } +} + +impl<'a, A: Clone> FusedIterator for ChunksMut<'a, A> {} + +// Proptest +#[cfg(any(test, feature = "proptest"))] +#[doc(hidden)] +pub mod proptest { + #[deprecated( + since = "14.3.0", + note = "proptest strategies have moved to im::proptest" + )] + pub use crate::proptest::vector; +} + +// Tests + +#[cfg(test)] +mod test { + use super::*; + use crate::proptest::vector; + use ::proptest::collection::vec; + use ::proptest::num::{i32, usize}; + use ::proptest::proptest; + + #[test] + fn macro_allows_trailing_comma() { + let vec1 = vector![1, 2, 3]; + let vec2 = vector![1, 2, 3,]; + assert_eq!(vec1, vec2); + } + + #[test] + fn indexing() { + let mut vec = vector![0, 1, 2, 3, 4, 5]; + vec.push_front(0); + assert_eq!(0, *vec.get(0).unwrap()); + assert_eq!(0, vec[0]); + } + + #[test] + fn large_vector_focus() { + let input = (0..100_000).collect::<Vector<_>>(); + let vec = input.clone(); + let mut sum: i64 = 0; + let mut focus = vec.focus(); + for i in 0..input.len() { + sum += *focus.index(i); + } + let expected: i64 = (0..100_000).sum(); + assert_eq!(expected, sum); + } + + #[test] + fn large_vector_focus_mut() { + let input = (0..100_000).collect::<Vector<_>>(); + let mut vec = input.clone(); + { + let mut focus = vec.focus_mut(); + for i in 0..input.len() { + let p = focus.index_mut(i); + *p += 1; + } + } + let expected: Vector<i32> = input.into_iter().map(|i| i + 1).collect(); + assert_eq!(expected, vec); + } + + #[test] + fn issue_55_fwd() { + let mut l = Vector::new(); + for i in 0..4098 { + l.append(Vector::unit(i)); + } + l.append(Vector::unit(4098)); + assert_eq!(Some(&4097), l.get(4097)); + assert_eq!(Some(&4096), l.get(4096)); + } + + #[test] + fn issue_55_back() { + let mut l = Vector::unit(0); + for i in 0..4099 { + let mut tmp = Vector::unit(i + 1); + tmp.append(l); + l = tmp; + } + assert_eq!(Some(&4098), l.get(1)); + assert_eq!(Some(&4097), l.get(2)); + let len = l.len(); + l.slice(2..len); + } + + #[test] + fn issue_55_append() { + let mut vec1 = (0..92).collect::<Vector<_>>(); + let vec2 = (0..165).collect::<Vector<_>>(); + vec1.append(vec2); + } + + #[test] + fn issue_70() { + let mut x = Vector::new(); + for _ in 0..262 { + x.push_back(0); + } + for _ in 0..97 { + x.pop_front(); + } + for &offset in &[160, 163, 160] { + x.remove(offset); + } + for _ in 0..64 { + x.push_back(0); + } + // At this point middle contains three chunks of size 64, 64 and 1 + // respectively. Previously the next `push_back()` would append another + // zero-sized chunk to middle even though there is enough space left. + match x.vector { + VectorInner::Full(_, ref tree) => { + assert_eq!(129, tree.middle.len()); + assert_eq!(3, tree.middle.number_of_children()); + } + _ => unreachable!(), + } + x.push_back(0); + match x.vector { + VectorInner::Full(_, ref tree) => { + assert_eq!(131, tree.middle.len()); + assert_eq!(3, tree.middle.number_of_children()) + } + _ => unreachable!(), + } + for _ in 0..64 { + x.push_back(0); + } + for _ in x.iter() {} + } + + #[test] + fn issue_67() { + let mut l = Vector::unit(4100); + for i in (0..4099).rev() { + let mut tmp = Vector::unit(i); + tmp.append(l); + l = tmp; + } + assert_eq!(4100, l.len()); + let len = l.len(); + let tail = l.slice(1..len); + assert_eq!(1, l.len()); + assert_eq!(4099, tail.len()); + assert_eq!(Some(&0), l.get(0)); + assert_eq!(Some(&1), tail.get(0)); + } + + #[test] + fn issue_74_simple_size() { + use crate::nodes::rrb::NODE_SIZE; + let mut x = Vector::new(); + for _ in 0..(CHUNK_SIZE + * ( + 1 // inner_f + + (2 * NODE_SIZE) // middle: two full Entry::Nodes (4096 elements each) + + 1 // inner_b + + 1 + // outer_b + )) + { + x.push_back(0u32); + } + let middle_first_node_start = CHUNK_SIZE; + let middle_second_node_start = middle_first_node_start + NODE_SIZE * CHUNK_SIZE; + // This reduces the size of the second node to 4095. + x.remove(middle_second_node_start); + // As outer_b is full, this will cause inner_b (length 64) to be pushed + // to middle. The first element will be merged into the second node, the + // remaining 63 elements will end up in a new node. + x.push_back(0u32); + match x.vector { + VectorInner::Full(_, tree) => { + assert_eq!(3, tree.middle.number_of_children()); + assert_eq!( + 2 * NODE_SIZE * CHUNK_SIZE + CHUNK_SIZE - 1, + tree.middle.len() + ); + } + _ => unreachable!(), + } + } + + #[test] + fn issue_77() { + let mut x = Vector::new(); + for _ in 0..44 { + x.push_back(0); + } + for _ in 0..20 { + x.insert(0, 0); + } + x.insert(1, 0); + for _ in 0..441 { + x.push_back(0); + } + for _ in 0..58 { + x.insert(0, 0); + } + x.insert(514, 0); + for _ in 0..73 { + x.push_back(0); + } + for _ in 0..10 { + x.insert(0, 0); + } + x.insert(514, 0); + } + + #[test] + fn issue_105() { + let mut v = Vector::new(); + + for i in 0..270_000 { + v.push_front(i); + } + + while !v.is_empty() { + v = v.take(v.len() - 1); + } + } + + #[test] + fn issue_107_split_off_causes_overflow() { + let mut vec = (0..4289).collect::<Vector<_>>(); + let mut control = (0..4289).collect::<Vec<_>>(); + let chunk = 64; + + while vec.len() >= chunk { + vec = vec.split_off(chunk); + control = control.split_off(chunk); + assert_eq!(vec.len(), control.len()); + assert_eq!(control, vec.iter().cloned().collect::<Vec<_>>()); + } + } + + #[test] + fn collect_crash() { + let _vector: Vector<i32> = (0..5953).collect(); + // let _vector: Vector<i32> = (0..16384).collect(); + } + + #[test] + fn issue_116() { + let vec = (0..300).collect::<Vector<_>>(); + let rev_vec: Vector<u32> = vec.clone().into_iter().rev().collect(); + assert_eq!(vec.len(), rev_vec.len()); + } + + #[test] + fn issue_131() { + let smol = std::iter::repeat(42).take(64).collect::<Vector<_>>(); + let mut smol2 = smol.clone(); + assert!(smol.ptr_eq(&smol2)); + smol2.set(63, 420); + assert!(!smol.ptr_eq(&smol2)); + + let huge = std::iter::repeat(42).take(65).collect::<Vector<_>>(); + let mut huge2 = huge.clone(); + assert!(huge.ptr_eq(&huge2)); + huge2.set(63, 420); + assert!(!huge.ptr_eq(&huge2)); + } + + #[test] + fn ptr_eq() { + for len in 32..256 { + let input = std::iter::repeat(42).take(len).collect::<Vector<_>>(); + let mut inp2 = input.clone(); + assert!(input.ptr_eq(&inp2)); + inp2.set(len - 1, 98); + assert_ne!(inp2.get(len - 1), input.get(len - 1)); + assert!(!input.ptr_eq(&inp2)); + } + } + + proptest! { + #[test] + fn iter(ref vec in vec(i32::ANY, 0..1000)) { + let seq: Vector<i32> = vec.iter().cloned().collect::<Vector<_>>(); + for (index, item) in seq.iter().enumerate() { + assert_eq!(&vec[index], item); + } + assert_eq!(vec.len(), seq.len()); + } + + #[test] + fn push_front_mut(ref input in vec(i32::ANY, 0..1000)) { + let mut vector = Vector::new(); + for (count, value) in input.iter().cloned().enumerate() { + assert_eq!(count, vector.len()); + vector.push_front(value); + assert_eq!(count + 1, vector.len()); + } + let input2 = input.iter().rev().cloned().collect::<Vec<_>>(); + assert_eq!(input2, vector.iter().cloned().collect::<Vec<_>>()); + } + + #[test] + fn push_back_mut(ref input in vec(i32::ANY, 0..1000)) { + let mut vector = Vector::new(); + for (count, value) in input.iter().cloned().enumerate() { + assert_eq!(count, vector.len()); + vector.push_back(value); + assert_eq!(count + 1, vector.len()); + } + assert_eq!(input, &vector.iter().cloned().collect::<Vec<_>>()); + } + + #[test] + fn pop_back_mut(ref input in vec(i32::ANY, 0..1000)) { + let mut vector = input.iter().cloned().collect::<Vector<_>>(); + assert_eq!(input.len(), vector.len()); + for (index, value) in input.iter().cloned().enumerate().rev() { + match vector.pop_back() { + None => panic!("vector emptied unexpectedly"), + Some(item) => { + assert_eq!(index, vector.len()); + assert_eq!(value, item); + } + } + } + assert_eq!(0, vector.len()); + } + + #[test] + fn pop_front_mut(ref input in vec(i32::ANY, 0..1000)) { + let mut vector = input.iter().cloned().collect::<Vector<_>>(); + assert_eq!(input.len(), vector.len()); + for (index, value) in input.iter().cloned().rev().enumerate().rev() { + match vector.pop_front() { + None => panic!("vector emptied unexpectedly"), + Some(item) => { + assert_eq!(index, vector.len()); + assert_eq!(value, item); + } + } + } + assert_eq!(0, vector.len()); + } + + // #[test] + // fn push_and_pop(ref input in vec(i32::ANY, 0..1000)) { + // let mut vector = Vector::new(); + // for (count, value) in input.iter().cloned().enumerate() { + // assert_eq!(count, vector.len()); + // vector.push_back(value); + // assert_eq!(count + 1, vector.len()); + // } + // for (index, value) in input.iter().cloned().rev().enumerate().rev() { + // match vector.pop_front() { + // None => panic!("vector emptied unexpectedly"), + // Some(item) => { + // assert_eq!(index, vector.len()); + // assert_eq!(value, item); + // } + // } + // } + // assert_eq!(true, vector.is_empty()); + // } + + #[test] + fn split(ref vec in vec(i32::ANY, 1..2000), split_pos in usize::ANY) { + let split_index = split_pos % (vec.len() + 1); + let mut left = vec.iter().cloned().collect::<Vector<_>>(); + let right = left.split_off(split_index); + assert_eq!(left.len(), split_index); + assert_eq!(right.len(), vec.len() - split_index); + for (index, item) in left.iter().enumerate() { + assert_eq!(& vec[index], item); + } + for (index, item) in right.iter().enumerate() { + assert_eq!(&vec[split_index + index], item); + } + } + + #[test] + fn append(ref vec1 in vec(i32::ANY, 0..1000), ref vec2 in vec(i32::ANY, 0..1000)) { + let mut seq1 = vec1.iter().cloned().collect::<Vector<_>>(); + let seq2 = vec2.iter().cloned().collect::<Vector<_>>(); + assert_eq!(seq1.len(), vec1.len()); + assert_eq!(seq2.len(), vec2.len()); + seq1.append(seq2); + let mut vec = vec1.clone(); + vec.extend(vec2); + assert_eq!(seq1.len(), vec.len()); + for (index, item) in seq1.into_iter().enumerate() { + assert_eq!(vec[index], item); + } + } + + #[test] + fn iter_mut(ref input in vector(i32::ANY, 0..10000)) { + let mut vec = input.clone(); + { + for p in vec.iter_mut() { + *p = p.overflowing_add(1).0; + } + } + let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect(); + assert_eq!(expected, vec); + } + + #[test] + fn focus(ref input in vector(i32::ANY, 0..10000)) { + let mut vec = input.clone(); + { + let mut focus = vec.focus_mut(); + for i in 0..input.len() { + let p = focus.index_mut(i); + *p = p.overflowing_add(1).0; + } + } + let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect(); + assert_eq!(expected, vec); + } + + #[test] + fn focus_mut_split(ref input in vector(i32::ANY, 0..10000)) { + let mut vec = input.clone(); + + fn split_down(focus: FocusMut<'_, i32>) { + let len = focus.len(); + if len < 8 { + for p in focus { + *p = p.overflowing_add(1).0; + } + } else { + let (left, right) = focus.split_at(len / 2); + split_down(left); + split_down(right); + } + } + + split_down(vec.focus_mut()); + + let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect(); + assert_eq!(expected, vec); + } + + #[test] + fn chunks(ref input in vector(i32::ANY, 0..10000)) { + let output: Vector<_> = input.leaves().flatten().cloned().collect(); + assert_eq!(input, &output); + let rev_in: Vector<_> = input.iter().rev().cloned().collect(); + let rev_out: Vector<_> = input.leaves().rev().map(|c| c.iter().rev()).flatten().cloned().collect(); + assert_eq!(rev_in, rev_out); + } + + #[test] + fn chunks_mut(ref mut input_src in vector(i32::ANY, 0..10000)) { + let mut input = input_src.clone(); + #[allow(clippy::map_clone)] + let output: Vector<_> = input.leaves_mut().flatten().map(|v| *v).collect(); + assert_eq!(input, output); + let rev_in: Vector<_> = input.iter().rev().cloned().collect(); + let rev_out: Vector<_> = input.leaves_mut().rev().map(|c| c.iter().rev()).flatten().cloned().collect(); + assert_eq!(rev_in, rev_out); + } + + // The following two tests are very slow and there are unit tests above + // which test for regression of issue #55. It would still be good to + // run them occasionally. + + // #[test] + // fn issue55_back(count in 0..10000, slice_at in usize::ANY) { + // let count = count as usize; + // let slice_at = slice_at % count; + // let mut l = Vector::unit(0); + // for _ in 0..count { + // let mut tmp = Vector::unit(0); + // tmp.append(l); + // l = tmp; + // } + // let len = l.len(); + // l.slice(slice_at..len); + // } + + // #[test] + // fn issue55_fwd(count in 0..10000, slice_at in usize::ANY) { + // let count = count as usize; + // let slice_at = slice_at % count; + // let mut l = Vector::new(); + // for i in 0..count { + // l.append(Vector::unit(i)); + // } + // assert_eq!(Some(&slice_at), l.get(slice_at)); + // } + } +} diff --git a/vendor/im-rc/src/vector/pool.rs b/vendor/im-rc/src/vector/pool.rs new file mode 100644 index 000000000..4d4edae6b --- /dev/null +++ b/vendor/im-rc/src/vector/pool.rs @@ -0,0 +1,74 @@ +// This Source Code Form is subject to the terms of the Mozilla Public +// License, v. 2.0. If a copy of the MPL was not distributed with this +// file, You can obtain one at http://mozilla.org/MPL/2.0/. + +use crate::config::POOL_SIZE; +use crate::nodes::chunk::Chunk; +use crate::nodes::rrb::Node; +use crate::util::Pool; + +/// A memory pool for `Vector`. +pub struct RRBPool<A> { + pub(crate) node_pool: Pool<Chunk<Node<A>>>, + pub(crate) value_pool: Pool<Chunk<A>>, + pub(crate) size_pool: Pool<Chunk<usize>>, +} + +impl<A> RRBPool<A> { + /// Create a new memory pool with the given size. + pub fn new(size: usize) -> Self { + Self::with_sizes(size, size, size) + } + + /// Create a new memory pool with the given sizes for each subpool. + pub fn with_sizes( + node_pool_size: usize, + leaf_pool_size: usize, + size_table_pool_size: usize, + ) -> Self { + Self { + node_pool: Pool::new(node_pool_size), + value_pool: Pool::new(leaf_pool_size), + size_pool: Pool::new(size_table_pool_size), + } + } + + /// Fill the memory pool with preallocated chunks. + pub fn fill(&self) { + self.node_pool.fill(); + self.value_pool.fill(); + self.size_pool.fill(); + } + + /// Get the size of the node subpool. + pub fn node_pool_size(&self) -> usize { + self.node_pool.get_pool_size() + } + + /// Get the size of the leaf node subpool. + pub fn leaf_pool_size(&self) -> usize { + self.value_pool.get_pool_size() + } + + /// Get the size of the size table subpool. + pub fn size_table_pool_size(&self) -> usize { + self.size_pool.get_pool_size() + } +} + +impl<A> Default for RRBPool<A> { + /// Construct a pool with a reasonable default pool size. + fn default() -> Self { + Self::new(POOL_SIZE) + } +} + +impl<A> Clone for RRBPool<A> { + fn clone(&self) -> Self { + Self { + node_pool: self.node_pool.clone(), + value_pool: self.value_pool.clone(), + size_pool: self.size_pool.clone(), + } + } +} diff --git a/vendor/im-rc/src/vector/rayon.rs b/vendor/im-rc/src/vector/rayon.rs new file mode 100644 index 000000000..054620dc0 --- /dev/null +++ b/vendor/im-rc/src/vector/rayon.rs @@ -0,0 +1,209 @@ +//! Parallel iterators. +//! +//! These are only available when using the `rayon` feature flag. + +use super::*; +use ::rayon::iter::plumbing::{bridge, Consumer, Producer, ProducerCallback, UnindexedConsumer}; +use ::rayon::iter::{ + IndexedParallelIterator, IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator, +}; + +impl<'a, A> IntoParallelRefIterator<'a> for Vector<A> +where + A: Clone + Send + Sync + 'a, +{ + type Item = &'a A; + type Iter = ParIter<'a, A>; + + fn par_iter(&'a self) -> Self::Iter { + ParIter { + focus: self.focus(), + } + } +} + +impl<'a, A> IntoParallelRefMutIterator<'a> for Vector<A> +where + A: Clone + Send + Sync + 'a, +{ + type Item = &'a mut A; + type Iter = ParIterMut<'a, A>; + + fn par_iter_mut(&'a mut self) -> Self::Iter { + ParIterMut { + focus: self.focus_mut(), + } + } +} + +/// A parallel iterator for [`Vector`][Vector]. +/// +/// [Vector]: ../struct.Vector.html +pub struct ParIter<'a, A> +where + A: Clone + Send + Sync, +{ + focus: Focus<'a, A>, +} + +impl<'a, A> ParallelIterator for ParIter<'a, A> +where + A: Clone + Send + Sync + 'a, +{ + type Item = &'a A; + + fn drive_unindexed<C>(self, consumer: C) -> C::Result + where + C: UnindexedConsumer<Self::Item>, + { + bridge(self, consumer) + } +} + +impl<'a, A> IndexedParallelIterator for ParIter<'a, A> +where + A: Clone + Send + Sync + 'a, +{ + fn drive<C>(self, consumer: C) -> C::Result + where + C: Consumer<Self::Item>, + { + bridge(self, consumer) + } + + fn len(&self) -> usize { + self.focus.len() + } + + fn with_producer<CB>(self, callback: CB) -> CB::Output + where + CB: ProducerCallback<Self::Item>, + { + callback.callback(VectorProducer { focus: self.focus }) + } +} + +/// A mutable parallel iterator for [`Vector`][Vector]. +/// +/// [Vector]: ../struct.Vector.html +pub struct ParIterMut<'a, A> +where + A: Clone + Send + Sync, +{ + focus: FocusMut<'a, A>, +} + +impl<'a, A> ParallelIterator for ParIterMut<'a, A> +where + A: Clone + Send + Sync + 'a, +{ + type Item = &'a mut A; + + fn drive_unindexed<C>(self, consumer: C) -> C::Result + where + C: UnindexedConsumer<Self::Item>, + { + bridge(self, consumer) + } +} + +impl<'a, A> IndexedParallelIterator for ParIterMut<'a, A> +where + A: Clone + Send + Sync + 'a, +{ + fn drive<C>(self, consumer: C) -> C::Result + where + C: Consumer<Self::Item>, + { + bridge(self, consumer) + } + + fn len(&self) -> usize { + self.focus.len() + } + + fn with_producer<CB>(self, callback: CB) -> CB::Output + where + CB: ProducerCallback<Self::Item>, + { + callback.callback(VectorMutProducer { focus: self.focus }) + } +} + +struct VectorProducer<'a, A> +where + A: Clone + Send + Sync, +{ + focus: Focus<'a, A>, +} + +impl<'a, A> Producer for VectorProducer<'a, A> +where + A: Clone + Send + Sync + 'a, +{ + type Item = &'a A; + type IntoIter = Iter<'a, A>; + + fn into_iter(self) -> Self::IntoIter { + self.focus.into_iter() + } + + fn split_at(self, index: usize) -> (Self, Self) { + let (left, right) = self.focus.split_at(index); + ( + VectorProducer { focus: left }, + VectorProducer { focus: right }, + ) + } +} + +struct VectorMutProducer<'a, A> +where + A: Clone + Send + Sync, +{ + focus: FocusMut<'a, A>, +} + +impl<'a, A> Producer for VectorMutProducer<'a, A> +where + A: Clone + Send + Sync + 'a, +{ + type Item = &'a mut A; + type IntoIter = IterMut<'a, A>; + + fn into_iter(self) -> Self::IntoIter { + self.focus.into_iter() + } + + fn split_at(self, index: usize) -> (Self, Self) { + let (left, right) = self.focus.split_at(index); + ( + VectorMutProducer { focus: left }, + VectorMutProducer { focus: right }, + ) + } +} + +#[cfg(test)] +mod test { + use super::super::*; + use super::proptest::vector; + use ::proptest::num::i32; + use ::proptest::proptest; + use ::rayon::iter::{IntoParallelRefIterator, IntoParallelRefMutIterator, ParallelIterator}; + + proptest! { + #[test] + fn par_iter(ref mut input in vector(i32::ANY, 0..10000)) { + assert_eq!(input.iter().max(), input.par_iter().max()) + } + + #[test] + fn par_mut_iter(ref mut input in vector(i32::ANY, 0..10000)) { + let mut vec = input.clone(); + vec.par_iter_mut().for_each(|i| *i = i.overflowing_add(1).0); + let expected: Vector<i32> = input.clone().into_iter().map(|i| i.overflowing_add(1).0).collect(); + assert_eq!(expected, vec); + } + } +} |