I had briefly thought about the enumeration example, but I couldn’t see a good way to make it work without union types. We could potentially add union types in the future, but the theory needs to be verified first.

One thing that occurred to me for making this more useful is if the value of the singleton type were available as an implicit value. I suspect this causes problems though, because it’s then also available as an implicit value of the supertype. An example use case was the ranged types implementation I was tinkering with a while ago. If the values were available implicitly then you could also make a range object available implicitly. It’s a bit of a stretch though.

Another thing I was wondering about: How will this interact with the type inferencer? e.g. if I write

def foo = “foo”;

presumably foo will be inferred as returning a String, not a “foo”.type? How does this work with the normal approach of always inferring the most specific type? Otherwise you’re going to have to use a lot more type annotations than you used to (for cases where foo should be overrideable, or where it’s actually a var)

The other part of the reason I ask is that sometimes you’d actively want the most specific type to be inferred. e.g. I was wondering about using this as an alternative to Enumeration, so you could define something like

val Months = “January” | “February” | etc.

and statically check membership of string literals. But this becomes really crappy to use if the literals are inferred as type String as you end up having to provide all the type parameters (though this could also work not too badly with the implicits suggestion)

Anyway, just some random thoughts.