Lightnews — Scholar-powered news

ecsolticia

@ecsolticia.seeks.quest

Why settle for a typical digital logic circuit simulator when you can build your own, but as a computer language instead? I already have a correct implementation of the core functionalities (it's rather simple), but I have yet to fully sort the UI out. Been a fun project so far!

let F = <X> AND(X, NOT(X))
assert NOT(F)

let OR(x, y) = NOT(AND(
NOT(x), NOT(y)
))

let XOR(x, y) = AND( NOT(AND(x, y)), OR(x, y) )
let EQ(x, y) = NOT(XOR(x, y))

let T = <X> EQ(X, X)
assert T

let I(x) = <a> OR(
AND(a, NOT(a)),
x
)
assert I(T)
assert NOT( I(F) )

let HalfAdderR(a, b) = XOR(a, b)
let HalfAdderC(a, b) = AND(a, b)

let SumIsNonzero(a, b) = OR( HalfAdderR(a, b), HalfAdderC(a, b) )

let One = T
let Zero = F

assert SumIsNonzero(One, One)
assert SumIsNonzero(One, Zero)
assert SumIsNonzero(Zero, One)
assert NOT(SumIsNonzero(Zero, Zero))

November 18, 2025 at 9:19 AM

ecsolticia

@ecsolticia.seeks.quest

I'm wondering to myself why I approximately quadrupled the amount of development time just for fancier error-reporting for an utterly simple DSL I'm cooking. The rules are simple enough that the errors are generally easy to spot by inspection anyway. But hey, it looks nice! (I think)

Implied terminal output of `cargo run` on said DSL project:

```
[[tokens]]

1 |[let][OR][(][A][,][B][)][NOT][(][AND][(][NOT][(][A][)][,][NOT][(][B][)][)][)]
2 |[assert][!]
---
Error code 7:
Expected assignment operator '='
-
1 | let OR(A, B) NOT(AND( NOT(A), NOT(B) ))
- -------------^^^
Error occured at line 1, from column 14 to 16
=======
Error code 9:
Expected valid identifier in expression
-
2 | assert !
- -------^
Error occured at line 2, from column 8 to 8
=======
```

November 10, 2025 at 12:01 PM

ecsolticia

@ecsolticia.seeks.quest

Autopilot. Sharp turns.
Symmetry. Periodicity.

November 9, 2025 at 4:54 AM

ecsolticia

@ecsolticia.seeks.quest

I was mainly procrastinating on it, but my indefinitely-flying paper airplane thingy has been evolving!

Now, your paper airplanes can't get out of view. Instead, you can bounce with the bounds again and again to create fun trails.

#gamedev #godotengine

October 15, 2025 at 6:49 AM

ecsolticia

@ecsolticia.seeks.quest

I don't know where I'm taking my indefinitely-flying paper airplane game anymore. Something something asymmetric symmetry. Something something mirroring

#gamedev

October 10, 2025 at 4:33 AM

ecsolticia

@ecsolticia.seeks.quest

I have been thinking about #gamedev again, and my text adventure idea went mostly nowhere.

I'm trying some other ideas. Lo and behold, an indefinitely flying paper airplane... well, indefinitely flying as long as you don't hit something. Where is THIS going? Could be nowhere, hopefully somewhere.

October 7, 2025 at 9:24 AM

ecsolticia

@ecsolticia.seeks.quest

Made a tiny, declarative, expression-based DSL for elementary cellular automata. The parsing bit is scaffolded from my own library (crates.io/crates/mipl), which still needs some polish before I can extend the grammar to work better with newlines.

Overall, though, the DSL turned out pretty fun!

October 2, 2025 at 5:52 PM

ecsolticia

@ecsolticia.seeks.quest

I m sorry

The "0 days without" Simpsons meme where the text reads "0 days without writingb uggylexers".

September 29, 2025 at 11:11 AM

ecsolticia

@ecsolticia.seeks.quest

I met the nemesis of premature abstraction. I've been trying to write parsers for things more complex than mere numeric calcs and TOML-like configs for a week, and have mostly been stuck. Have been, not am, because writing a minimal, imperative, restricted parsing library helped! Variables, anyone?

September 26, 2025 at 1:27 PM

ecsolticia

@ecsolticia.seeks.quest

It also has multiplication and exponentiation now! Exponentiation is pictured here.

$Snippet of Rust code. ``` fn two_squared_is_four() { type Claimed4 = <_2 as Exp<_2>>::Result; type Verified4 = Succ< Succ< Succ< Succ< _0 >>>>; <Claimed4 as Eq<Verified4>>::equal(); } ```$

September 2, 2025 at 3:57 PM

ecsolticia

@ecsolticia.seeks.quest

Here's an example of how it FAILS. I basically changed the definition of `Claimed10` to `<_5 as Add<_4>>::Result` (5 + 4), and then attempted to compile again. This behavior is completely expected, unless the system I constructed were to somehow equate 9 and 10.

A terminal prompt where I chant the `cargo build` spell and it yields the following:
```
Compiling rspeano v0.1.0 (/home/ecos/rspeano)
error[E0599]: no function or associated item named `check` found for struct `ProofEq` in the current scope
--> src/main.rs:21:32
|
21 | ProofEq::<Claimed10, _10>::check();
| ^^^^^ function or associated item not found in `ProofEq<Succ<Succ<Succ<Succ<Succ<Succ<Succ<Succ<Succ<...>>>>>>>>>, ...>`
```

September 1, 2025 at 6:17 PM

ecsolticia

@ecsolticia.seeks.quest

I got a bit sidetracked from my current project into further exploring the capabilities of Rust's type system. Peano axioms were way too fun play around with. I got to the point of having a proof that 5 + 5 = 10. (Compilation here proves the validity of the statement within what I constructed)

$Snippet of Rust code. Exact contents: ``` fn five_plus_five_is_ten() { type Claimed10 = <_5 as Add<_5>>::Result; type _10 = Succ< // 1 Succ< // 2 Succ< // 3 Succ< // 4 Succ< // 5 Succ< // 6 Succ< // 7 Succ< // 8 Succ< // 9 Succ< // 10 _0 >>>>>>>>>>; ProofEq::<Claimed10, _10>::check(); } ```$ A terminal prompt where I chant the `cargo build` spell and it yields a lovely
```
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.01s
```
with no compiler errors or warnings.