Prepare for indexmap 2.0

.github/workflows/ci.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - rust: 1.49.0 # MSRV
+          - rust: 1.56.0 # MSRV
             features:
           - rust: stable
             features: serde
@@ -30,8 +30,6 @@ jobs:
             features:
           - rust: nightly
             bench: test build benchmarks
-          - rust: nightly
-            features: test_low_transition_point
 
     steps:
       - uses: actions/checkout@v2
@@ -59,7 +57,7 @@ jobs:
     strategy:
       matrix:
         include:
-          - rust: 1.49.0
+          - rust: 1.56.0
             target: thumbv6m-none-eabi
           - rust: stable
             target: thumbv6m-none-eabi
@@ -74,7 +72,7 @@ jobs:
           target: ${{ matrix.target }}
       - name: Tests
         run: |
-          cargo build -vv --target=${{ matrix.target }}
+          cargo build -vv --target=${{ matrix.target }} --no-default-features
           cargo build -v -p test-nostd --target=${{ matrix.target }}
 
   clippy:

.rustfmt.toml

@@ -1 +1 @@
-edition = "2018"
+edition = "2021"

Cargo.toml

@@ -1,37 +1,19 @@
 [package]
 name = "indexmap"
-edition = "2018"
-version = "1.8.1"
-authors = [
-"bluss",
-"Josh Stone <cuviper@gmail.com>"
-]
+edition = "2021"
+version = "2.0.0-pre"
+publish = false
 documentation = "https://docs.rs/indexmap/"
 repository = "https://github.com/bluss/indexmap"
-license = "Apache-2.0/MIT"
-description = """
-A hash table with consistent order and fast iteration.
-
-The indexmap is a hash table where the iteration order of the key-value
-pairs is independent of the hash values of the keys. It has the usual
-hash table functionality, it preserves insertion order except after
-removals, and it allows lookup of its elements by either hash table key
-or numerical index. A corresponding hash set type is also provided.
-
-This crate was initially published under the name ordermap, but it was renamed to
-indexmap.
-"""
-
+license = "Apache-2.0 OR MIT"
+description = "A hash table with consistent order and fast iteration."
 keywords = ["hashmap", "no_std"]
 categories = ["data-structures", "no-std"]
-
-build = "build.rs"
+rust-version = "1.56"
 
 [lib]
 bench = false
 
-[build-dependencies]
-autocfg = "1"
 [dependencies]
 serde = { version = "1.0", optional = true, default-features = false }
 rayon = { version = "1.4.1", optional = true }
@@ -41,7 +23,7 @@ rayon = { version = "1.4.1", optional = true }
 rustc-rayon = { version = "0.3", optional = true }
 
 [dependencies.hashbrown]
-version = "0.11"
+version = "0.12"
 default-features = false
 features = ["raw"]
 
@@ -55,14 +37,10 @@ fxhash = "0.2.1"
 serde_derive = "1.0"
 
 [features]
-# Serialization with serde 1.0
-serde-1 = ["serde"]
-
-# Force the use of `std`, bypassing target detection.
+default = ["std"]
 std = []
 
 # for testing only, of course
-test_low_transition_point = []
 test_debug = []
 
 [profile.bench]
@@ -73,7 +51,7 @@ no-dev-version = true
 tag-name = "{{version}}"
 
 [package.metadata.docs.rs]
-features = ["serde-1", "rayon"]
+features = ["serde", "rayon"]
 
 [workspace]
 members = ["test-nostd", "test-serde"]

README.md

@@ -0,0 +1,55 @@
+# indexmap
+
+[![build status](https://github.com/bluss/indexmap/workflows/Continuous%20integration/badge.svg?branch=master)](https://github.com/bluss/indexmap/actions)
+[![crates.io](https://img.shields.io/crates/v/indexmap.svg)](https://crates.io/crates/indexmap)
+[![docs](https://docs.rs/indexmap/badge.svg)](https://docs.rs/indexmap)
+[![rustc](https://img.shields.io/badge/rust-1.56%2B-orange.svg)](https://img.shields.io/badge/rust-1.56%2B-orange.svg)
+
+A pure-Rust hash table which preserves (in a limited sense) insertion order.
+
+This crate implements compact map and set data-structures,
+where the iteration order of the keys is independent from their hash or
+value. It preserves insertion order (except after removals), and it
+allows lookup of entries by either hash table key or numerical index.
+
+Note: this crate was originally released under the name `ordermap`,
+but it was renamed to `indexmap` to better reflect its features.
+
+# Background
+
+This was inspired by Python 3.6's new dict implementation (which remembers
+the insertion order and is fast to iterate, and is compact in memory).
+
+Some of those features were translated to Rust, and some were not. The result
+was indexmap, a hash table that has following properties:
+
+- Order is **independent of hash function** and hash values of keys.
+- Fast to iterate.
+- Indexed in compact space.
+- Preserves insertion order **as long** as you don't call `.remove()`.
+- Uses hashbrown for the inner table, just like Rust's libstd `HashMap` does.
+
+## Performance
+
+`IndexMap` derives a couple of performance facts directly from how it is constructed,
+which is roughly:
+
+> A raw hash table of key-value indices, and a vector of key-value pairs.
+
+- Iteration is very fast since it is on the dense key-values.
+- Removal is fast since it moves memory areas only in the table,
+  and uses a single swap in the vector.
+- Lookup is fast-ish because the initial 7-bit hash lookup uses SIMD, and indices are
+  densely stored. Lookup also is slow-ish since the actual key-value pairs are stored
+  separately. (Visible when cpu caches size is limiting.)
+
+- In practice, `IndexMap` has been tested out as the hashmap in rustc in [PR45282] and
+  the performance was roughly on par across the whole workload.
+- If you want the properties of `IndexMap`, or its strongest performance points
+  fits your workload, it might be the best hash table implementation.
+
+[PR45282]: https://github.com/rust-lang/rust/pull/45282
+
+# Recent Changes
+
+See [RELEASES.md](https://github.com/bluss/indexmap/blob/master/README.md).