Mastodawn

Unlike linear types in traditional programming languages like Rust or Clean, where resource tracking is a constraint imposed on the programmer, here linearity is not enforced, it is the model. Tokens don't persist because they're protected, but because nothing consumed them.

Chloe :>1d ago

@neauoire I wish there was a wiki. xxiivv.com book I could buy, the sheer amount of super unique ideas and rabbitholes you've written about have infected my mind to the point where I have had sleepless nights thinking about what I read

@angelwood it's too "lively" it changes all the time. I must do about 20ish changes daily, it holds the current state of my understanding of various topics, but it's constantly growing.

∴ esoterik ∴1d ago

@neauoire @angelwood wiki -> pdf export program for e-readers

fe 1d ago

@neauoire @angelwood make yearly releases like "xxiivv as of 2026" then new editions can start with a gigantic list of everything that changed since!

@neauoire This may be the first concatenative notation for a counter machine that isn't rule-based. There is at least one deque catlang that has been made.

Also, based on our talks of how rejoice executes, would you have a ton of junk operation in your call queue?

@andnull yeah, but no junk, only the whole program basically. Kind of like Joy I suppose?

ex:

@neauoire Poking around and reading the docs, it seems like things are a bit different from the last time I peak at Rejoice. I was thinking when it was still "replace symbol with definition".

times^5
@Loop 
    Loop/times junk

I believe before this would have left a bunch of unevaluated junk items in the pending queue. The end result would have been [junk^5] but now it's [junk]. Gonna make recursion tricky cause you essentially only have tail recursion. The non-determinism of multiple address compounding that

@neauoire A simple demonstration of the "multiple label" behavior in your implementation of Rejoice. Could be worth adding as an example of what can/could happen.

[JumpA JumpB JumpC]

@JumpA a
@JumpB b
@JumpC c

[] [JumpA JumpB JumpC] a b c 
[] c 
[c] b c 
[b c] a b c 
[a b c] b c 
[a b^2 c] c 
[a b^2 c^2]

@andnull Yes! I have a ton of explaining to do still, this is kind of a early draft. Right now there's no subroutine calls, so it's quite limiting. I'm not sure how close to a full programming language I want to get yet.

@neauoire Subroutines would irocinally be falling back into typical FRACTRAN. But with the power to specify many loops and decode prefix tree*. I have a multistack esolang specdraft called AGAIN built around that idea. Gonna be updating it Eventually (tm) with HERE/LEAVE operations.

* I can show what I mean in a bit

@andnull the idea here was to have exactly that fractran but with GOTOs, to do away with the cost of scanning the entire program everytime, not that I need speed for this, but it comes with more readable programs as well, which I wanted. I tried a lispy UX at first(Bägel), but it was clumsy, it seemed like catlang was, once again, hitting all the marks.

I think the main point I'm going for is to have multisets as datastructure, concatenation flow ended up being what was most natural.

If I don't need subroutines to explain some of the stuff I'll use this for, I think.. I might just not add them X) We'll see, tail recursion might be enough.

@neauoire Okay, messing about. I have an example of what subroutines with returns look like in Rejoice:

done-a PutAs @DoneA 
done-b PutBs @DoneB
done-add A+B->C @DoneAdd 
.#c

@PutBs
    b b b b b
    Return

@A+B->C
    @A->C [c A->C]/a
    @B->C [c B->C]/b
    Return

@PutAs
    a a a
    Return

@Return
    [DoneA]/done-a
    [DoneB]/done-b
    [DoneAdd]/done-add

Basically, push a symbol the mark your return point then jump to the subroutine. Once the subroutine ends jump to your return handler. The return handler then finds the "entry" point you program should return to. Surprisingly graceful construct compared to how I thought it'd look.

@andnull WOA WAT

@andnull You made a sort of return lobby where it sends you back wherever you need to go.

This is so cool, I hadn't thought of that AT ALL, you're good..

@neauoire I love a good puzzle on how to emulate typical behaviors in atypical systems

mx alex tax1a - 2020 (6)1d ago

@andnull @neauoire if we had to put this in "normal" terms we'd say 'statically allocated control-flow trampolines'

@neauoire This kinda of "mapping return locations to symbols" is partially what inspired AGAIN. In this cause, it doesn't have gotos (aside from AGAIN which jumps to the top of the program), but you can emulate gotos by pushing a prefix to the code you want to run.

In the case of Rejoice, you push a symbol that can be decoded into an address to return back to.

Esolang: AGAIN

@andnull Is it alright if I shape this example in a way I can document it on the page? I think it's quite cool, I don't think I've ever come across this way of emulating subroutines. Do you happen to have fizzbuzz or tictactoe in AGAIN?

@andnull ok I see how AGAIN is similar, you can never jump forward in again right? Other than walking over a bunch of IF..END blocks.

Oh this is so cool, I hadn't caught this the first time I read through your posts about AGAIN.

@neauoire
1) feel free to lift whatever you want from AGAIN. It's a very conceptual page rn.

2) Not, yet, I need to write an interpreter for AGAIN. It currently exist as a little thought experiment / unimplemented specthing. I could make that my little task for tomorrow.

3) That is correct, AGAIN can only jump backwards via AGAIN or forwards with IF/END. Rejoice is more flexible since there is arbitrary jumps forwards and backwards. However, both are share the limitation that you have no return stack of addresses. Thus you need a mechanism for turning Symbols into Locations. In AGAIN, it's via "walk a prefix". For Rejoice it's "decode a symbol to an address using a LUT".

@neauoire I have been kinda obsessed with like:

Every program can be describe as prefix trees to specific instruction.
Event-based programming is kinda like searching for an entry point into a function with multiple starting points.
How do you do function calls when all you have is symbols, conditional control-flow, and loops.

I kinda have a small notebook filled with scribbles that need writing at some point.

@neauoire Also, state machines, I have just been obsessed with state machine lately.

@neauoire I guess a short way to put this whole thing: you have to encode call/return as a set of state transition when you don't have return addresses.

@andnull just got back from dinner, I'll experiment with these return trampolines of yours! You have excellent intuition for these really bizarre systems, I love to see you do your magic like that.

@neauoire What's fun is this lends naturally to say...

@OnScreen ( -- )
    ...
    Done

@OnTick ( frame -- )
    ...
    Done

@Done
   ( possible co-routines in the bag or something )
   ...

@andnull Ah yes! So I haven't really thought about input yet, but something like:

@OnButton ( arrow -- )
.YouPressedUp/up-pressed
Done

The input could be put in the bag before firering the event:

up-pressed OnButton

@andnull I've been porting some Fractran programs, and made this multiplication function, which shows a bit how it short-circuits matching.

x^3 y^4

@Mul ( x y -- res )
[Mul z res]/y
@Move ( z -- y)
[Move y]/z
Mul/x
@Clean ( y -- )
Clean/[res y]

@neauoire Yeah, I realized my A+B->C rule could decompose into A->C and B->C allowing for a tighter looping process.

Ben "ragekit"1d ago

@neauoire that looks neat, but how do you use this for your goal of generication notation ?

https://wiki.xxiivv.com/site/binary
https://wiki.xxiivv.com/site/primes
https://wiki.xxiivv.com/site/tropical_arithmetic
https://wiki.xxiivv.com/site/reversible_computing
https://wiki.xxiivv.com/site/ternary_computing

@ragekit I often write about logic, fractions or natural numbers, so I might have a bit on prime factor that will use numbers:

18 * 2/3, or 2 * 3^2 * 2/3

In some pages, I'll name primes instead of playing with numbers to make things for explicit.

[red blue^2] red/blue

This is the sort of representation that I have on various pages, but it wasn't really "specified" anywhere, and it wasn't evaluatable. Good examples of pages where I mean to use it are:

I can use this little playground to cover all that material, and instead of making up new notations for each page, it'll all come down to that one style:

[bag] [put^2]/take-away

Ben "ragekit"1d ago

@neauoire oh so it's showing step by step some combinatorial logic ?

@ragekit yes, exactly! But it's unordered, there's no difference between [a b] and [b a], so it has some limits to what it can express clearly :)

Humberto Ortiz Zuazaga 18h ago

@neauoire @ragekit Linda had an unordered "tuple space" of ordered tuples. Workers grabbed tuples from the tuple space, operated on them, and put results back.

https://www.netlib.org/utk/papers/comp-phy7/node3.html

The Linda Model and System

Devine Lu Linvega 17h ago

@azul @ragekit yup, although tuples are a bit different, since you can't know what will be where at compile time, you have to search for them at runtime. It's a bit different from multisets.

WimⓂ️21h ago

@neauoire Looks very cool. I have a question about the first example: you say the sets are unordered. So is the outcome "[this is a programming language]" an accident of the evaluator implementation? If it is unordered, elements could occur in any order in the set, isn't it?

Devine Lu Linvega 17h ago

@wim_v12e yeah, it's kind of an accident, it's just the order in which the primes are stored. I should probably pick a different thing to showcase in the repl.

bouncepaw 🍄15h ago

@neauoire the colour scheme of Rejoice REPL is very daring, I like it. Is it comfortable to use for longer periods of time? Is it meant to? Lowkey considering restyling my IDE in this Merveilles Seafoam gradient...