I have the same problem why not support enum as key map?

No, being a preprocessor/macro means that it needs to have direct access to the value of the key (phf is "reading" the keys from the source code), there's no way for it to access rust types & values indirectly, it needs to be a simple rust literal. phf needs the value of the key to hash it at compile time.

Take my use case for example: I need to check if an uuid is contained in a set of "hardcoded" uuids. My first approach was to define a const array and use binary search for performance, but that requires that the array is sorted by hand by the developer. phf is easier to use (no need to sort by hand) but now i can't just use uuid::Uuid objects as keys (even tho they can be constructed through a const fn). My workaround is to put uuids represented by u128s into the phf set.

dup of #188 ?

If you want to use enum keys, there is the enum-map crate.

You can use EnumMap<K, Option<V>> where K is your enum type, and V is the value type.

The Option is to allow for values to not exist (just like a normal hash map):

#[derive(Debug, Enum)]
enum Example {
    A,
    B,
    C,
    D,
}

// Initialize the map with the keys A and B defined, but C and D are not defined.
let mut map = enum_map! {
    Example::A => Some("foo"),
    Example::B => Some("bar"),
    _ => None,
};

// This is the same as `map.get(&Example::C)` in a normal hash map.
let value = &map[Example::C];

// This is the same as `map.insert(Example::C, "qux");` in a normal hash map.
map[Example::C] = Some("qux");

If you want to use enum keys, there is the enum-map crate.

You can use EnumMap<K, Option<V>> where K is your enum type, and V is the value type.

Does this work with static constant declarations (because that's the whole point of phf)?

I think the answer is no, which means this is not a good solution for someone having difficulty declaring static enum maps using phf

@thomasmost Unfortunately it cannot be used directly in a static or const.

However, using Lazy (or lazy_static!) works fine:

use once_cell::sync::Lazy;
use enum_map::{Enum, EnumMap, enum_map};

#[derive(Debug, Enum)]
enum Example {
    A,
    B,
    C,
    D,
}

static FOO: Lazy<EnumMap<Example, Option<&'static str>>> = Lazy::new(|| enum_map! {
    Example::A => Some("foo"),
    Example::B => Some("bar"),
    _ => None,
});

fn main() {
    println!("{:?}", FOO[Example::A]);
    println!("{:?}", FOO[Example::B]);
    println!("{:?}", FOO[Example::C]);
}

And using Lazy<Mutex<EnumMap<...>>> for mutability also works fine.

Two issues that make enum-map not ideal for this:

1. enum_map! builds a full table, not a sparse table. If you have a large enum and a 2d array, this can get out of hand. Having a map is more ideal because you don't have to fill all the unused entries with defaults or None or what have you.
2. enum_map! allocates on the stack, so for large enough enums and values, you will have trouble initializing without also using bytemuck.

Ideally a proc macro could have access to constant values like primitive enums (unfortunately enum_map::Enum::into_usize() is not const) but if I understand correctly they don't have anything but a token stream. There could be a proc macro that defines its own enum but then needs a mapping from the external enum to the internal one...