Counter has become the default tool for counting occurences of objects in an iterable. However by construction it only works on hashable objects as it is a subclass of dict. Would it be possible to implement a "key=" keyword argument as in sort etc.? 

Here's a stackoverflow question wherein either map or implementing a hash method was proposed:
https://stackoverflow.com/questions/69401713/elegant-way-of-counting-items-in-a-list-by-enum-value-in-python

How is Counter(numbers, key=abs) any better than Counter(map(abs, numbers))?

It seems to me that "apply a function to each thing" (map) and "count the numbers of each thing" (Counter) are two orthogonal concepts, and there's no reason to entangle them. Their composition as "count the number of things with each function value" is probably better as a composition of two simple things rather than lumped together. I believe this is related to why PEP 455 was rejected.

I was thinking about use cases where one might want to preserve the original key. I was not however aware of PEP 455 and the reasons for it's rejection. My bad.

Yet It is still unclear to me what the best practice would be to reverse lookup unhashable objects. Say you have a list of objects from which you need the most common. If there is no good way of reversing the transform, your only option is iterating trough your list? Which defeats the purpose of using a Counter and you'd be better off counting explicitly. Maybe I'm imagining unrealistic/far-fetched use cases.

The values of a Counter are generally integers, not lists. Maybe you want:

    items_by_keyfunc = defaultdict(list)
    for x in all_the_items:
        items_by_keyfunc[keyfunc(x)].append(x)

Then items_by_keyfunc[42] is a list of the things with key 42.

Although I believe there have been proposals about adding some method to dict() to do basically the for-loop above.

Or keep the reverse mapping in another dict:
    
    count = Counter()
    reverse_mapping = dict()
    for x in all_the_items:
        count.update(keyfunc(x))
        reverse_mapping[keyfunc(x)] = x

Anyways I'm closing it as it is a partial duplicate of key-transforming dictionaries.