Datatypes have a couple of problems. One is that there's no clear representation for them literally:
rebol2>> word? first [integer!] == true rebol2>> type? 10 == integer! rebol2>> word? type? 10 == false
So we're on the cusp of having to use some notation for datatypes like
#[datatype! "integer!"] -or- perhaps see them as being expressed through an existing type. We also face the question of extensibility of types...and it's hard to think of a better extensibility mechanism to use than the existing symbol engine that is behind ANY-WORD!.
Yet making them WORD! is not very desirable. We are used to writing things like make object! [...]. And we don't want MAKE to have to quote its argument. Hence, OBJECT! would have to evaluate to something.
We could say object!: 'object! but that seems like it would get into some ugly situations.
What about the new @WORDs?
What if @object! (or @object) could act as a datatype, as well as an ANY-WORD!?
It has the advantage of being inert in the evaluator:
if @integer = type of 1 [print "Sanity prevails..."]
You wouldn't have to worry about quoting it if you were using the actual type's symbolic name, vs. an alias:
switch type of first ['''1] [ lit '''@integer [ print "You can do this..." ] ... ]
Redbol compatibility could still work:
Though you'd need to do a little extra to work with quoting such names. But Ren-C is designed for it:
switch type of first ['''1] compose [ lit '''(integer!) [ print "You can do this..." ] ... ]
So the main question would be, how often is it that you have a slot that might want an @word -or- a datatype? How frequent is that need for polymorphism?
When I look at the landscape of problems, it seems to me that an evaluator-inert type that has an intrinsic extensibility like this would be pretty much ideal for denoting a datatype. No construction syntax, just good ol' reliable behavior.
Anyone have any particularly good arguments against the idea?