What deserves to be a datatype?

[hostilefork]

A lot can change in... 7 months

@hostilefork

There isn't a "no silliness rule" in effect. What curbs the existence of things like--say--SET-ISSUE! is trying to balance competing meanings, and pick the most useful one.

rebol2>> type? first [#this:is:a-valid-issue]
== issue!

Given that : is legal internally to the ISSUE!, that's one of the points guiding us toward ruling out SET-ISSUE! (as well as ruling out issues as words more generally), and favoring that a colon at the end is literally part of the content.

The emergence of the CHAIN! type changes the landscape, here. Because on balance, it seems we get more expressivity by allowing these ISSUE! (token?) things to be in sequences.

We might disallow them at the head, but it doesn't seem we have to make that disallowance:

>> x: '#foo:bar:#baz

>> type of x
== &(chain)

>> first x
== #foo  ; issue!

>> second x
== bar  ; word!

>> third x
== #baz  ; issue!

>> y: #"foo:bar:#baz"
 
>> type of y
== &(issue)

It does mean that the character literals for sequence interstitials have to be #"/" and #":" and #"." instead of #/ and #: and #. -- but you already had to do that for things like #"[" so I don't know if it's any great argument against it.

Like I said, there's not a no-silliness rule. So if something falls out of the design and it's mechanical and unambiguous and consistent, I lean to supporting it (albeit sometimes grudgingly).

@hostilefork

Note that if colons are internal to things that look word-ish, they are actually URL! (more specifically, "Uniform Resource Names")

rebol2>> type? first [urn:isbn:0451450523]
== url!

...not anymore in Ren-C... that's a CHAIN! too.

@hostilefork

As documented here recently, my own philosophy on how far we should be willing to go with WORD! has faced reckonings. The introduction of SIGIL! solved the problems with wanting : and :: as words, and said "no, they should not be words" and went in a new direction with that.

Well, now they are words (along with / and // and /// and . and .. and ... etc)

But they're in the class of things you have to use a SET-BLOCK! to set:

>> [:]: 1020

>> :
== 1020

I am leaning to saying that using SET-BLOCK!s is probably the more sane answer than trying to make exceptions for /: to be a CHAIN! with a WORD! in the first slot. The exception shouldn't be made for :: as a CHAIN! with a word in the first slot, and it's too confusing compared to [/]:

Then if you want to assign a function, instead of it being a strange exception you'd have to distribute the leading slash:

/[/]: infix get $divide