[pull] master from bluss:master

.github/workflows/ci.yml

@@ -3,8 +3,9 @@ on:
     branches: [ master ]
   pull_request:
     branches: [ master ]
+  merge_group:
 
-name: Continuous integration
+name: CI
 
 env:
   CARGO_TERM_COLOR: always
@@ -16,28 +17,42 @@ jobs:
     strategy:
       matrix:
         include:
-          - rust: 1.36.0 # MSRV
+          - rust: 1.63.0 # MSRV
             features:
           - rust: stable
-            features: serde
+            features: arbitrary
+          - rust: stable
+            features: quickcheck
           - rust: stable
             features: rayon
+          - rust: stable
+            features: rustc-rayon
+          - rust: stable
+            features: serde
+          - rust: stable
+            features: borsh
           - rust: stable
             features: std
           - rust: beta
             features:
           - rust: nightly
             bench: test build benchmarks
-          - rust: nightly
-            features: test_low_transition_point
 
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        if: matrix.rust == '1.63.0'
+        with:
+          path: ~/.cargo/registry/index
+          key: cargo-git-index
+      - uses: dtolnay/rust-toolchain@master
         with:
-          profile: minimal
           toolchain: ${{ matrix.rust }}
-          override: true
+      - name: Downgrade dependencies
+        if: matrix.rust == '1.63.0'
+        run: |
+          cargo generate-lockfile
+          cargo update -p hashbrown --precise 0.15.0
       - name: Tests
         run: |
           cargo build --verbose --features "${{ matrix.features }}"
@@ -57,37 +72,81 @@ jobs:
     strategy:
       matrix:
         include:
-          - rust: 1.36.0
+          - rust: 1.63.0
             target: thumbv6m-none-eabi
           - rust: stable
             target: thumbv6m-none-eabi
 
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        if: matrix.rust == '1.63.0'
+        with:
+          path: ~/.cargo/registry/index
+          key: cargo-git-index
+      - uses: dtolnay/rust-toolchain@master
         with:
-          profile: minimal
           toolchain: ${{ matrix.rust }}
-          override: true
           target: ${{ matrix.target }}
+      - name: Downgrade dependencies
+        if: matrix.rust == '1.63.0'
+        run: |
+          cargo generate-lockfile
+          cargo update -p hashbrown --precise 0.15.0
       - 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:
     runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        rust:
-          - beta
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@beta
         with:
-          profile: minimal
-          toolchain: ${{ matrix.rust }}
-          override: true
           components: clippy
-      - run: cargo clippy
+      - run: cargo clippy --all-features
+
+  miri:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: miri
+      - run: cargo miri test
+
+  minimal-versions:
+    name: Check MSRV and minimal-versions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/cache@v4
+        with:
+          path: ~/.cargo/registry/index
+          key: cargo-git-index
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: dtolnay/[email protected] # MSRV
+      - uses: taiki-e/install-action@v2
+        with:
+          tool: cargo-hack
+      - run: cargo +nightly hack generate-lockfile --remove-dev-deps -Z direct-minimal-versions
+      - name: Build (nightly)
+        run: cargo +nightly build --verbose --all-features
+      - name: Build (MSRV)
+        run: cargo build --verbose --features arbitrary,quickcheck,serde,rayon
 
+  # One job that "summarizes" the success state of this pipeline. This can then be added to branch
+  # protection, rather than having to add each job separately.
+  success:
+    name: Success
+    runs-on: ubuntu-latest
+    needs: [tests, nostd_build, clippy, miri, minimal-versions]
+    # Github branch protection is exceedingly silly and treats "jobs skipped because a dependency
+    # failed" as success. So we have to do some contortions to ensure the job fails if any of its
+    # dependencies fails.
+    if: always() # make sure this is never "skipped"
+    steps:
+      # Manually check the status of all dependencies. `if: failure()` does not work.
+      - name: check if any dependency failed
+        run: jq --exit-status 'all(.result == "success")' <<< '${{ toJson(needs) }}'

.rustfmt.toml

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

Cargo.toml

@@ -1,75 +1,65 @@
 [package]
 name = "indexmap"
-edition = "2018"
-version = "1.6.1"
-authors = [
-"bluss",
-"Josh Stone <[email protected]>"
-]
+edition = "2021"
+version = "2.6.0"
 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.
-"""
-
+repository = "https://github.com/indexmap-rs/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.63"
 
 [lib]
 bench = false
 
-[build-dependencies]
-autocfg = "1"
 [dependencies]
+equivalent = { version = "1.0", default-features = false }
+
+arbitrary = { version = "1.0", optional = true, default-features = false }
+quickcheck = { version = "1.0", optional = true, default-features = false }
 serde = { version = "1.0", optional = true, default-features = false }
-rayon = { version = "1.0", optional = true }
+borsh = { version = "1.2", optional = true, default-features = false }
+rayon = { version = "1.9", optional = true }
+
+# Internal feature, only used when building as part of rustc,
+# not part of the stable interface of this crate.
+rustc-rayon = { package = "rustc-rayon", version = "0.5", optional = true }
 
 [dependencies.hashbrown]
-version = "0.9.1"
+version = "0.15.0"
 default-features = false
-features = ["raw"]
 
 [dev-dependencies]
-itertools = "0.9"
-rand = {version = "0.7", features = ["small_rng"] }
-quickcheck = { version = "0.9", default-features = false }
+itertools = "0.13"
+rand = {version = "0.8", features = ["small_rng"] }
+quickcheck = { version = "1.0", default-features = false }
 fnv = "1.0"
 lazy_static = "1.3"
 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]
 debug = true
 
 [package.metadata.release]
-no-dev-version = true
+allow-branch = ["master"]
+sign-tag = true
 tag-name = "{{version}}"
 
 [package.metadata.docs.rs]
-features = ["serde-1", "rayon"]
+features = ["arbitrary", "quickcheck", "serde", "borsh", "rayon"]
+rustdoc-args = ["--cfg", "docsrs"]
 
 [workspace]
 members = ["test-nostd", "test-serde"]
+
+[lints.clippy]
+style = "allow"

README.md

@@ -0,0 +1,59 @@
+# indexmap
+
+[![build status](https://github.com/indexmap-rs/indexmap/actions/workflows/ci.yml/badge.svg?branch=master)](https://github.com/indexmap-rs/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.63%2B-orange.svg)](https://img.shields.io/badge/rust-1.63%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.
+The [`ordermap`](https://crates.io/crates/ordermap) crate now exists
+as a wrapper over `indexmap` with stronger ordering properties.
+
+# 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()`,
+  `.swap_remove()`, or other methods that explicitly change order.
+  The alternate `.shift_remove()` does preserve relative order.
+- 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/indexmap-rs/indexmap/blob/master/RELEASES.md).