A language designed around the idea of data mutation. Like, just doing data mutation. No functions, no stack, just here’s some data and here’s how it changes. It’s very similar to imperative languages as you might guess, but it basically removes functions from the main data path and simplifies everything which leads to some weird syntax and features.

There are still functions in some ways via a trait system kind of like Rust (also where and polymorphism appears), but it’s not quite the same.

I don’t really know exactly how to explain it beyond that, so here’s a snippet:

[Import]
std

[Data]
a :: Int = 4
b :: Int = 5
a_str :: &Char = []

[Mut]
std.out write "The sum of 4 and 6 is "
b += 1
a += b
a_str alloc_num_str a
std.out write a_str

Not that += here is not equivalent to a = a + b, but rather += is the name of a Numeric trait procedure. Using words I might call it add. It’s a add b or with C+±esque syntax it’s like (&c)->add(b) or something.

There is a File struct in the std module and a Write trait implemented for &Files that includes a write(&Char) procedure as well as an instance of an &File called “out.” So to write a string of characters to stdout, you do std.out write <characters>

So from this, I can say that procedures in traits in this language are like mini versions of the stuff under [Mut] that you can call with parameters. These procedures can also have embedded C code which is how you interact with external stuff and how the core and standard libraries are implemented.

Trait and struct definitions go under [Type] and have their own syntax

Forcing all logic to be an explicit mutation of a singular datum may end up being the worst way to program ever, but it’s at least a different way

EDIT: Conceptually this is the same, but the syntax is a bit different now

I was trying to create a programming language that doesn’t have a parser. It has only AST nodes. The program is edited only inside a special editor.

Nodes in the language are defined as

type Node = ref object
  kind: Node
  childs: seq[Node]
  data: seg[byte]

That is, the node type is literally another node, which allows you to create as many types of nodes as you want without changing the program in any way. Some nodes may be functions.

For example, this is what the “function” and looks like:

note that and contains recursion to itself in the error.
also note that string "false" is just representation of what this constant means, there is no need to create new string “false” every time.

And this is what the “function” x looks like, the use of which can be seen in and:

Finally got back to writing my language, Flower. It’s going to be slow crawl onwards, but at least I’m back at developing it.

The prototype chain in JavaScript (and presumably other prototype-based OOP languages) is really quite similar to the scope chain for local variable lookup: first try to find the property/variable in the current object/scope, and if not found, look in the prototype / parent scope until we reach the outermost object/scope.

I’ve been thinking for quite a while now about the idea of a language that merges these two concepts into one. I’m not ready to talk about it much yet – it’s still very much in the planning phase, but I’m planning to post about it if and when I make significant progress on it.

Currently I’m neck deep in re2c’s guts, trying a manual translation to another language for learning purposes. I’ve found a fair few bugs (and far more … questionable code) and will file them in bulk once I’m done. Note that some bugs aren’t exposed in the command-line tool (or at least common uses thereof).