Strategies deduplication does not working for st.none as expected in OneOfStrategy.element_strategies

[Stranger6667]

Hello!

Some time ago I created an issue - #2087
and recently got back to the investigations regarding the cause of the observed behavior. A took this case:

one_of(none(), none(), booleans())

That was generating 85 examples, while there are only possible 3 cases (None, True, False).

I found this code in OneOfStrategy that should remove duplicates (I assume):

pruned = []
seen = set()
for s in strategies:
    if s is self:
        continue
    if s in seen:
        continue
    seen.add(s)
    pruned.append(s)

But if s in seen doesn't work for st.none():

In [3]: seen = set()                                                                                                                                                                                                                                                                                                    

In [4]: seen.add(st.none())                                                                                                                                                                                                                                                                                             

In [5]: seen.add(st.none())                                                                                                                                                                                                                                                                                             

In [6]: seen                                                                                                                                                                                                                                                                                                            
Out[6]: {none(), none()}

And for just (which is used in none). I assume that "just" strategy instances can be deduplicated at least in some cases (for just(None) for example). What do you think? Could you, please, share some information about this behavior?

[Zac-HD]

See #2291, especially:

master...Zac-HD:hashable-strategies shows a current draft... which doesn't quite work. Hashing really doesn't play nicely with lazy instantiation and instances which are distinguished by mutable attributes... and we have those everywhere. So it's easy to make it work a little, but intractable to make it worthwhile.

Given that this is a minor performance issue but doesn't affect correctness at all, I'm inclined to leave things as they are 😕

(and for the 84 examples, see #2030/#2185/#2290 I think - TLDR nothing to worry about, it's an artifact of a bit-level representation on non-power-of-two numbers of alternatives that only really manifests on small examples)

I think it would be reasonable to add __hash__ methods to our strategies for hashable scalars, but I still don't think making all strategies hashable is worth the trouble. I should add a comment block explaining this to the OneOfStrategy implementation, though...

[Stranger6667]

Aha, thank you for the insights! :)