I spoke with Simon today, and I think I have a bit of a better idea now of
what's going on with specialization, and why it sometimes fails to
specialize things as much as it could. Apparently, the replacement of (sel
@ type dict) by sel.type is accomplished by the use of a rewrite rule
generated by the specializer when it specializes an overloaded function
using that (or something similar to that, anyway). The trouble is that as
things are currently done, there's no way in general to get the right
replacement to stick on the RHS of the rule when such forms arise in other
contexts. The type checker constructs dictionaries in type checking, but
afterwards we can't produce new ones.
The most likely way to solve this is probably to (somehow) decouple
dictionary creation and selection from type checking so as to expose those
facilities to later phases. The concept would be something vaguely like
this: instead of creating rewrite rules, the specializer would instead
check whether the appropriate dictionary already existed, and create it if
not. The simplifier would then check for a dictionary every time it
encountered a class method whose instance is determined. No, I have no idea
how much work such a change would involve.
-------------- next part --------------
An HTML attachment was scrubbed...