# New Names for ^FOO, @FOO, and $FOO

**URL:** <https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447>\
**Category:** Naming\
**Tags:** best-of\
**Created:** [May 11, 2025, 7:47pm UTC](https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447 "2025-05-11T19:47:27Z")\
**Posts on this page:** 5\
**Page:** 1

<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:** [May 11, 2025, 7:47pm UTC](https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447/1 "2025-05-11T19:47:28Z")

</div>

It's beginning to look inevitable that **[all "sequencable" types will have versions with "SIGIL!s"](https://revolt.metaeducation.com/forum/t/why-is-two-values-instead-of-a-meta-comma/2524)**. At the moment it's looking like there are 3 of these: `[^ $ @]`

So **$"dollar strings"** are coming, as are decorated integers like **^1020**

Like QUASIFORM! and QUOTED!, we need a generic name to cover each Sigil.

Following historical naming, METAFORM! for `^XXX` is all right, I guess (?).

But I _don't_ want to follow that pattern with historical "THE" and "VAR", calling `@XXX` a THEFORM! and `$XXX` a VARFORM! 🤢

---

<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:** [May 13, 2025, 1:17pm UTC](https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447/2 "2025-05-13T13:17:21Z")

</div>

![assets_task_01jvs8hm5we1htzdvvv4c08wvm_1747825870_img_3](https://revolt.metaeducation.com/forum/uploads/default/original/1X/a5b41a074e8a3e1bc24753d52411988f86c6fbf1.webp)

## I Think METAFORM! Is The Best Choice For `^FOO`

This takes over the META and UNMETA verbs:

```
>> meta [a b c]
== ^[a b c]

>> unmeta first [^[a b c]]
== [a b c]

```

_(The historical operation of adding quote levels that also promotes antiforms to quasiforms is now known as LIFT, with a corresponding UNLIFT.)_

## PINNED! =\> `@foo`, `@[foo bar]` etc

Verb form PIN:

```
>> pin first [a]
== @a

```

I like it because it's like you've stuck a pin on it, that won't come off in evaluation.

## TIED! =\> $foo, $[foo bar] etc.

Verb form TIE:

```
>> tie first [(a b c)]
== $(a b c)

```

It's a little bit odd, but its evaluative purpose is ultimately "tie" its attachment to a context.

As the emoji shows (🪢) the dollar sign kind of looks like a knot!

## We Can Call `$` a "tie", `@` a "pin", and `^` a "meta" !

That's neat.

It seems that type checking can be sensitive to these, so if you say you take an `@word`! it will check to see if it's an @ form, and then do the typecheck against it without the Sigil.

But now there has to be generalized type destructuring. How do you ask if something is an `@word!` ...? Well, there's MATCH:

```
if match [@word!] value [...]

```

It's not horrible, compare it to:

```
if the-word? value [...]

```

It's better in several ways I'd say. Though you can't optimize it to omit the block, e.g.

```
if match '@word! value [...] ; word! will be unbound

```

But that's probably for the best, because `'@word!` is too easy to confuse with _quoted_ `@word!`, which will be typechecked by the quote levels in the new model. It might be worth it to have intrinsics for PINNED-WORD?, PINNED-BLOCK?, etc. ... just because they're not fundamental types doesn't mean the most useful forms can't have accelerated type checks.

Anyhow, this looks good... I'm especially pleased that it gives us short and effective modifier verbs for adding the Sigil.

## Credit to ChatGPT for PINNED! and TIED! Names 🤖

Good work, ChatGPT!

---

<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:** [May 13, 2025, 5:09pm UTC](https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447/3 "2025-05-13T17:09:32Z")

</div>

[What deserves to be a datatype?](https://revolt.metaeducation.com/forum/t/what-deserves-to-be-a-datatype/2164)

⬆ There's the generalization you were looking for, @bradrn. 🙂

---

<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:** [May 15, 2025, 4:54am UTC](https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447/4 "2025-05-15T04:54:15Z")

</div>

Split this topic on May 15, 2025, 4:54am UTC

A post was split to a new topic: [Should SIGIL! Be A Type, Or Just Decorated BLANK!](https://revolt.metaeducation.com/t/should-sigil-be-a-type-or-just-decorated-blank/2451)

---

<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:** [July 31, 2025, 11:04pm UTC](https://revolt.metaeducation.com/forum/t/new-names-for-foo-foo-and-foo/2447/5 "2025-07-31T23:04:13Z")

</div>

> [@hostilefork](#):
>
> We Can Call `$` a "tie", `@` a "pin", and `^` a "meta" !

While I'm still debating what exactly `^` will do, `@` has always been a useful operator...and I'm now fairly confident that `$` should mean basically **"bind this here (if not already bound)"**

So you can use it to do things like this:

```
>> x: 10
>> y: 20

>> code: $ collect [
       keep 'x
       keep '+
       keep 'y
   ]
== [x + y] ; bound

>> eval code
== 30

```

The block produced by COLLECT doesn't have any binding by default, but the `$` will bind it. This fits very naturally along with what `$word` does and makes sense.

But calling `$` when used as an operator "TIE" competes a bit with TIE the verb, which adds the sigil to its argument:

```
>> tie [a b c]
== $[a b c]

```

Conversationally, it's important to distinguish these two things:

```
construct $ collect [...]

construct tie collect [...]

```

When a distinction needs to be drawn:

- `$` is the **TIE OPERATOR** , a.k.a. a **TIED SPACE (RUNE!)**

- `@` is the **PIN OPERATOR** , a.k.a. a **PINNED SPACE (RUNE!)**

- `^` is the **META OPERATOR** , a.k.a. a **METAFORM SPACE (RUNE!)**

Colloquially, you'd probably read it as the symbol to make the distinction:

```
construct $ collect [...] ; "construct dollar collect..."

construct tie collect [...] ; "construct tie collect..."

```

But reading things out loud is kind of intrinsically going to have some ambiguities:

```
construct $collect [...] ; "construct dollar collect..." :-/

construct at block 5 ; "construct at block 5..." :-/

```

Anyway, the code makes sense even if the words have their confusions. What do you expect when in English TIE and PIN are both verbs and nouns. :-/
