2025-09-15, 1102h

I wanna play around in Fennel, specifically mucking about what something like a thing would look like, given my more robust understanding of different metaphysical philosophies than last time I approached things. Unfortunately, at this point, I know there's /many/ ways to construct a metaphysics, and I also know there's some of them that can be digitizing easier than others.

I think for the sake of a MUD engine, I'll want to implement kyriontoeidic theory, which is, from what I can feel out, pretty similar to how I was programming my last MUD, TAB.

There, a thing was defined by having /attributes/ and /behaviors/, which were inherited from models. It was somewhat similar to an entity-component system, but... wasn't, due to a different lineage.

To consider what I might do now, I think I'd like to start by mapping a glossary of concepts that I'll be using, and how they're defined against each other.

The goal is to get a complete enough mapping of concepts that how to implement them in code is evident.

Before I even start, I'm realizing I might need a few levels of glossary, we'll see.

...Or maybe a glossary isn't even the right place to start.

See, I started to talk about /instancing/, which I figured would take in /forms/ as input, and output an /instantiation/.

But then I'm thinking maybe I should explain some about the triadic model I've developed with relational process theory: acts, conditions, and structures.

In short, for any claim to be made, such as "existence exists" or "there is a thing," there has to be an act of determining, which means there are acts.

This determining results in some determination, specifically of a relationship between the elements of the claim being determined. These relationships would be the conditions.

And, for some thing to be some thing, to exist, it has to sustain itself, meaning there is some thing holding these conditions, a structure.

This all might sound tautological, or nonsensical, but the nuance will matter as I develop the grammar and try to systemize the theory.

Maybe it'll help me to rediscuss this in specific terms, repeating, roughly, the derivations that establish relational dynamics.

So, repeating the induction of my first chain of derivations, to claim that some thing exists is not trivial - and it is necessary to claim that some thing exists, to make a MUD. That is, broadly speaking, what a MUD simulates: that some things exist in some relation, and multiple users can interface with those things.

But, specifically, claiming that any thing exists is to claim any thing is different than no thing, or at a minimum, any thing is not what it is not. In logical theory, this is the principle of non-contradiction and self-differentiation

In Fennel, and all programming languages, I'm working inside a box that already has a lot of assumptions about logic and stuff, so my function needs to also check that a thing isn't Fennel's a priori concept of nil.

(fn exists? [thing]
(and (not= thing nil)
(not= thing (not thing))))

(exists? "foo")

: true

The issue is, for being a test of our very first claim, this function relies on a lot of logic that comes from Fennel, not relational dynamics.

That's the issue that we run into with determining, abstractly, and why we need conditions and so on.

I know I used to know how this stuff was implemented in Fennel, but, symbols are conditions, tables are structures, and functions are, as shown, acts.

Now, also as we see, the condition of "existent" is not explicitly coded into a thing: it's the result of a predicate-checking function.

That's part of what I might class as "unary conditions" - either a thing has them, or they don't. Also, it might be worth highlighting that when I say thing, I mean objects and concepts alike.

I'll also highlight that in proper relational dynamics, this existing claim leads to specific acts, conditions, and structures, which are not similarly necessary at this low level due to Fennel's preconfiguration, but are perhaps worth covering:

including and excluding are the acts that allow for determining: - a thing includes itself in what it is - a thing excludes what it is not in what it is

These acts require the conditions of inclusion and exclusion: is a thing being included or excluded by another?

And the structuration that this including and excluding lead to is a coherent minimal thing: something with the structure to determine what conditions it has and what they are, such that other structures and conditions interact.

...Wow, trying to translate this into something I can do with simple LISP code really took the heart out of the dynamics of relational dynamics.

But i also am probably just too out-of-practice with things like monads and closures to properly do what I want to do.

So let me chug on in this improper way.