# What deserves to be a datatype?

**URL:** <https://revolt.metaeducation.com/forum/t/what-deserves-to-be-a-datatype/2164>\
**Category:** Philosophy\
**Created:** [March 5, 2024, 8:20am UTC](https://revolt.metaeducation.com/forum/t/what-deserves-to-be-a-datatype/2164 "2024-03-05T08:20:02Z")\
**Posts on this page:** 1\
**Showing post:** 10

<div class="post-metadata">

**Author:** ![hostilefork](https://revolt.metaeducation.com/forum/user_avatar/revolt.metaeducation.com/hostilefork/32/421_2.png) [@hostilefork](https://revolt.metaeducation.com/forum/u/hostilefork)\
**Post date:** [October 11, 2024, 3:28pm UTC](https://revolt.metaeducation.com/forum/t/what-deserves-to-be-a-datatype/2164/10 "2024-10-11T15:28:27Z")

</div>

### 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.
> 
> ```plaintext
> 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](https://revolt.metaeducation.com/forum/t/introducingnew-chain-datatype/2226) 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](https://revolt.metaeducation.com/forum/t/should-sequences-permit-non-head-sigils/2309)).

> [@hostilefork](#):
>
> Note that if colons are internal to things that look word-ish, they are actually URL! (more specifically, ["Uniform Resource Names"](https://en.wikipedia.org/wiki/Uniform_Resource_Name))
> 
> ```plaintext
> rebol2>> type? first [urn:isbn:0451450523]
> == url!
> 
> ```

...not anymore in Revolt... that's a CHAIN! too.

> [@hostilefork](#):
>
> As documented here recently, my own philosophy on [how far we should be willing to go with WORD!](https://revolt.metaeducation.com/forum/t/weird-word-s-allow-but-escape-them/1560) 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

```

---

_[View the full topic](https://revolt.metaeducation.com/forum/t/what-deserves-to-be-a-datatype/2164)._
