feat: add no_std macros indexmap_with_default and indexset_with_default

[iajoiner]

Closes #379.
I'm adding indexmap_with_default and indexset_with_default which should be no-std.

Thanks @JayWhite2357 for providing a solution in Proof of SQL which we are upstreaming!

[cuviper]

This will break type inference, because the compiler can't tell which S hasher to use, and the default doesn't apply when used like this. I'll bet it's fine in your local version because you've type-aliased them with ahash.

[cuviper]

Suggested change

	let mut set = $crate::IndexSet::with_capacity_with_hasher(CAP, <_>::default());
	let mut set = $crate::IndexSet::with_capacity_and_hasher(CAP, <_>::default());

[iajoiner]

@cuviper Really thanks for letting me know! How do you think we can modify it to fix the issue then? I don't really want this to depend on any particular hasher. Maybe the hasher should be made easy to specify somehow?

[iajoiner]

Will something like this be acceptable?

#[macro_export]
macro_rules! indexmap {
    ($S:ty; $($key:expr => $value:expr),*) => {{
        const CAP: usize = <[()]>::len(&[$({ stringify!($key); }),*]);
        #[allow(unused_mut)]
        // Specify your custom S (must implement Default) as the hasher:
        let mut map = $crate::IndexMap::<_, _, $S>::with_capacity_and_hasher(CAP, <$S>::default());

        $(
            map.insert($key, $value);
        )*

        map
    }};
    // fallback without hasher type specified
    ($($key:expr => $value:expr),*) => {{
        use std::collections::hash_map::RandomState;
        const CAP: usize = <[()]>::len(&[$({ stringify!($key); }),*]);
        #[allow(unused_mut)]
        let mut map = $crate::IndexMap::<_, _, RandomState>::with_capacity_and_hasher(
            CAP, 
            RandomState::default()
        );

        $(
            map.insert($key, $value);
        )*

        map
    }};
}

This way if std is enabled we can allow the old macro without any change. Otherwise we require the hasher to be specified.

[cuviper]

I don't know -- this is why the macros are currently hard-coded. 😉

FromIterator does have open S, and now that this trait is in the prelude, it will work reasonably well with array iterators:

// this still needs *something* to drive the type inference for `S`
let map = IndexMap::from_iter([(1, 'a'), (2, 'b'), (3, 'c')]);

[cuviper]

Will something like this be acceptable?

#[macro_export]
macro_rules! indexmap {
    ($S:ty; $($key:expr => $value:expr),*) => {{
        [...]
    }};
    // fallback without hasher type specified
    ($($key:expr => $value:expr),*) => {{
        [...]
    }};
}

If this works without any change to the existing tests, then yes, I think we can do that!

[JayWhite2357]

Another solution could be this:

#[cfg(feature = "std")]
let mut map = $crate::IndexMap::with_capacity(CAP);
#[cfg(not(feature = "std"))]
let mut map = $crate::IndexMap::with_capacity_and_hasher(CAP, <_>::default());

My syntax might be off, but something like that should work. It would require specifying the type explicitly when std is off, but it would be essentially identical semantics otherwise. Very similar to the from_iter.

[cuviper]

No, we can't just alternate it because indexmap could be a dependency of multiple parts of the build tree, perhaps with and without the "std" feature enabled, so it will be unified to enabled. Then the crate which wanted it with some other hasher will be broken.

[JayWhite2357]

No, we can't just alternate it because indexmap could be a dependency of multiple parts of the build tree, perhaps with and without the "std" feature enabled, so it will be unified to enabled. Then the crate which wanted it with some other hasher will be broken.

Ah, yes.

[iajoiner]

@cuviper @JayWhite2357 Alternatively maybe we can separate indexmap_with_hasher / indexset_with_hasher from indexmap and indexset. Then users who have picked a particular hasher can just define their own indexmap and indexset using indexmap_with_hasher / indexset_with_hasher.

I do not want to define indexmap and indexset using the new macros with hasher yet to make sure they actually work well without breaking downstream code.

[iajoiner]

Now use cases need to look like this if we use a different hasher

use ahash::AHasher;
use indexmap::indexmap_with_hasher;

fn main() {
    let map = indexmap_with_hasher! {
        AHasher; "a" => 1, "b" => 2,
    };
    assert_eq!(map["a"], 1);
    assert_eq!(map["b"], 2);
    assert_eq!(map.get("c"), None);
}

Alternatively people annoyed about having to specify the hasher all the time can do

use ahash::AHasher;
use indexmap::indexmap_with_hasher;

macro_rules! indexmap {
    ($($key:expr => $value:expr,)+) => { indexmap_with_hasher!{AHasher; $($key => $value),+} };
    ($($key:expr => $value:expr),*) => { indexmap_with_hasher!{AHasher; $($key => $value),*} };
}

fn main() {
    let map = indexmap! {
        "a" => 1, "b" => 2,
    };
    assert_eq!(map["a"], 1);
    assert_eq!(map["b"], 2);
    assert_eq!(map.get("c"), None);
}

[iajoiner]

I have tried this with both ahash and twox-hash and DefaultHasher is covered in doc tests so I think we are good to go.

[iajoiner]

@cuviper Really thanks! It's ready again haha.

[cuviper]

Looks good, thanks!