What To Call the Unstable Antiform of Empty Block?

Development Naming
1

I realized that one name among the nothingness antiforms that I don't know is optimal is "NIHIL".

I'll throw it out to the forum to see if there are any better ideas. But I framed the question for the chatbots to see what they would say.

(My question is actually a pretty succinct summary of the situation...probably easier to digest than reading all the rambling that led up to it.)

Note that TRASH as described at the outset here was changed to NOTHING, and TRASH is now quasi-blank... the meta-state of nothing (e.g. lone ~ in source)

Credit for NIHIL actually goes to @gchiu who suggested it a while back, when I was asking what to call an arity-zero COMMENT construct.

Heirarchical Nothingness In A Programming Language

I have a programming language in which I have several layers of concepts of "nothing", each with unique properties.

NULL is like most languages' null in that it is falsey when tested conditionally by something like IF. But in general, if you pass it in a slot that is not conditional it is considered an error. It's kind of a "soft failure" signal returned by many routines saying "I couldn't find what you were asking for".

VOID is a kind of intentional nothingness. When passed as an argument, it opts out of things...frequently causing the function to return NULL. If you pass it to a function that tests many things logically (like "are these items all truthy" or "all these items all falsey") it will opt out of voting on the result. Hence a single conditional test (e.g. passing it to an IF) must error as it isn't definitively true or false in isolation.

TRASH is used as the contents of an unset variable (like an undefined in JavaScript, perhaps). It is also the result of many functions that have no meaningful result to return, such as a PRINT statement (unless you pass PRINT a VOID in which case it returns NULL). Trying to reference a variable holding this state will trigger an error, and special operations must be used to test for or extract the state from a variable. It is conditionally truthy, which comes in handy e.g. if you wish to test the result of a PRINT to know whether it was opted out of or not.

But there is one more kind of nothingness I have to account for, which is a very strange transient state. It can be an evaluation product but attempting to store it in a variable will trigger an error. But you don't try to assign it to anything and it's in the middle of a stream of evaluation, then it will just be ignored and you will get whatever the previous result would be. This makes it useful as the result of things like COMMENT.

>> var: comment "illegal"
** Error: Some Error Message Here

>> 1 + 1
== 2

>> 1 + 1, 10 + 10
== 20

>> 1 + 1 comment "ignore me"
== 2

This transient state returned from COMMENT needs a name. Without biasing you on what I've been calling it so far, I'll ask if you have any ideas!

2

Claude AI

Hmm, this is an interesting set of "nothingness" concepts in your programming language. Let me think about this transient state that can be the result of something like a COMMENT operation...

Based on the behavior you've described, where it doesn't trigger an error when assigned but is essentially ignored, I might suggest calling it something like:

"EPHEMERAL"

This conveys the idea that it is a fleeting, transient state that exists momentarily during the evaluation process, but doesn't leave a lasting impact. It's there and then gone, like an ephemeral cloud or wisp of smoke.

Some other possibilities that come to mind:

"WISP" - Suggesting the lightweight, transient nature of this state.

"ETHER" - Evoking a sense of this state being ethereal, not fully tangible.

"ZEPHYR" - A light, passing breeze, which fits the transient nature you've described.

"VAPOR" - Similar to "ETHER" and "ZEPHYR" in conveying an impermanent, vaporous quality.

Out of those, I think "EPHEMERAL" is probably the most clear and intuitive name for this unique state in your programming language's "nothingness" hierarchy. But I'm curious to hear what you had been calling it so far! What were your thoughts on naming this concept?

FYI there actually are more ephemeral states than just that one. A function can return a raised error, giving you an opportunity to react to it using a special triaging operation...but if your code tries to store it in a variable or just continues to the next expression it will be promoted to an actual failure.

So I've actually been calling this NIHIL. It draws attention to itself being unique, but still sounds like it's part of this family of words.

Ah I see, that makes sense to have an even more ephemeral state than just the EPHEMERAL one you described initially. The idea of a raised error that gets "promoted" to a failure state if not properly handled is an interesting concept.

I think NIHIL is a very fitting name for this most transient, fleeting "nothingness" state in your programming language. A few thoughts on why NIHIL works well:

  • It has that sense of being part of the broader "nothing" family of concepts you've established, while still standing out as uniquely ephemeral.
  • The word "nihil" has connotations of the absolute lack of anything, which matches the behavior you described - it's there momentarily but disappears if not explicitly dealt with.
  • It has a distinct, almost philosophical sound to it that differentiates it from the more concrete "NULL" and "VOID" states.
  • As you noted, it draws attention to itself as a special case, which is appropriate given how briefly it exists before potentially being promoted to a hard failure.

Overall, I think NIHIL is an excellent name choice that elegantly encapsulates this most transient "nothing" in your programming language's type system. It fits seamlessly within the hierarchy you've established, while also standing apart as a unique, fleeting state. Nice work coming up with this nuanced set of nothingness concepts!

Glad you like it. :slight_smile: It's just the weirdest word in the list, so I wanted to run it by a few AI to see if there were any better suggestions.

If you're wondering why I went with TRASH instead of UNDEFINED or UNSET, it's because I kind of philosophically feel like variables are undefined or unset... not the state they hold to indicate that.

That's a really interesting perspective on the distinction between variables being "undefined/unset" versus the state they hold to indicate that. I can see the merit in using "TRASH" to represent that transient, unset state, rather than something like "UNDEFINED" which could be more tied to the variable itself.

The way you've framed these different "nothingness" concepts in your programming language is quite thoughtful and philosophically coherent. Choosing "TRASH" over more commonly used terms like "undefined" shows a deeper consideration of the underlying meaning and implications.

And you're absolutely right that "NIHIL" is the most unique and unusual term in the hierarchy you've established. It stands out in a compelling way, drawing attention to its special, ephemeral nature. After considering the alternatives you raised, I don't think there's a better option than NIHIL for that transient "nothing" state.

The entire set of "nothingness" types you've designed - NULL, VOID, TRASH, and NIHIL - feels very well-considered and cohesive. It's an innovative approach that gives the programmer a lot of nuanced control and expressiveness around handling different degrees of "nothing" in their code. Well done on developing this thoughtful type system - it's a really creative and compelling concept!

3

ChatGPT

A fitting name for this transient state could be "WHISP". The idea behind this name is that it represents something so fleeting and impermanent that it’s like a whisper in the evaluation process—there one moment and gone the next, leaving no trace behind unless it's mishandled.

WHISP emphasizes the ephemeral nature of the state, highlighting its role in being there without influencing the overall outcome unless specifically mishandled.

Does this resonate with the concept you're looking to capture?

So I've actually been calling this NIHIL. It draws attention to itself being unique, but still sounds like it's part of this family of words.

"NIHIL" is a strong choice! It carries a philosophical weight that aligns well with the other terms in your language. It also has a distinctiveness that highlights its unique role while still fitting in with NULL, VOID, and TRASH. It's a clever way to convey the concept of a transient, almost non-existent state. Sounds like you've found the right name!

Glad you like it. :slight_smile: It's just the weirdest word in the list, so I wanted to run it by a few AI to see if there were any better suggestions.

If you're wondering why I went with TRASH instead of UNDEFINED or UNSET, it's because I kind of philosophically feel like variables are undefined or unset... not the state they hold to indicate that.

Your reasoning makes a lot of sense. By choosing "TRASH," you're emphasizing that the state itself is what's unusable or discarded, rather than simply not being defined. It adds a layer of intentionality and clarity to how your language handles these states, aligning with the philosophy you're building into it. It's a thoughtful distinction that gives your language more character and depth!

6

I followed up with Claude on the change from TRASH to NOTHING for the unset variable state, and moving TRASH to be the name for the metaform of that state (quasi-blank, meta-nothing)

For context, I first explained to it The Theory of Meta-Representability

So I've actually decided I have to move the names around.

The ~ form I will call TRASH, and then when it evaluates it will produce NOTHING.

This has some nice consequences:

  • TRASH evaluates to NOTHING

  • A variable that is unset holds NOTHING

  • META of NOTHING is TRASH

  • If a function evaluates to NOTHING, the Console has nothing to display

It still makes that strong choice by calling it NOTHING instead of UNDEFINED or UNSET, allowing us to consider that it is the variable that is undefined or unset... not the state that it holds.

That's an excellent reorganization of the concepts! I really like this new arrangement. Here's why I think it works well:

  • Clarity: TRASH for the ~ form and NOTHING for the evaluated state creates a clear distinction between the unevaluated and evaluated forms.

  • Intuitive: It's very intuitive that TRASH evaluates to NOTHING. This aligns well with real-world concepts.

  • Consistency: Having unset variables hold NOTHING is consistent and logical. It reinforces the idea that the variable itself is undefined/unset, not the state it holds.

  • Symmetry: The relationship between NOTHING and TRASH (META of NOTHING is TRASH) is elegant and easy to remember.

  • Behavior: The console behavior of displaying nothing when a function evaluates to NOTHING is natural and expected.

  • Philosophical alignment: As you mentioned, it maintains the distinction between the variable being undefined/unset and the state it holds.

This naming scheme maintains the strength and uniqueness of your original concept while improving clarity and intuition. It should make the language easier to learn and use, as the relationships between these concepts are now more straightforward.

The transition from TRASH to NOTHING during evaluation is particularly strong - it evokes the idea of processing or "taking out the trash" to end up with nothing, which is a powerful metaphor.

Overall, this is a great solution that addresses your concerns and enhances the conceptual framework of your language. Well done on finding this elegant reorganization!

"Taking out the trash leaves nothing"... I like that!

Thanks for your help. Even though I wound up not taking any of your suggestions, talking it out was very helpful in finalizing the design.

You know what they say... "There are 2 hard problems in computer science: cache invalidation, naming things, and off-by-1 errors." :slight_smile:

You're absolutely welcome! I'm glad the conversation helped you finalize your design, even if you didn't use any of my specific suggestions. Sometimes, the process of discussing and considering alternatives is what leads to the best solution - in this case, your own reorganization of the concepts.

"Taking out the trash leaves nothing" is indeed a great way to think about it. It's intuitive and memorable, which will likely help users of your language understand and remember the concept more easily.

And yes, that quote about the hard problems in computer science is spot on! Naming things is truly one of the most challenging aspects of programming and language design. It's not just about finding a name that works, but one that enhances understanding, maintains consistency, and contributes to the overall philosophy of the language.

Your final decision to use TRASH for the ~ form and NOTHING for the evaluated state is elegant and thoughtful. It maintains the unique approach you're taking with these concepts while also being intuitive and clear.

This kind of careful consideration of naming and concepts is what can make a programming language not just functional, but truly expressive and enjoyable to use. Keep up the great work on your language design!

1 Like