sligh VS tailspin-v0

But, you still seem hung up on this, so here’s actual code: https://github.com/amw-zero/sligh/blob/main/lib/codegen.ml.

Of course. Here was the first incarnation: https://github.com/amw-zero/sligh. It has a decent overview of the idea in the readme. To sum it up here, the idea is: have a language built around model-driven development and model-based testing, where you write a simple model of an application, and the implementation and model-based tests are compiled for you. I wrote about the overall model-based testing strategy here. This idea comes from self-certifying compilers that produce proofs of their correctness such as Cogent, but we drop the formality requirement and use property-based testing to compare the implementation and model.

Honorable mention - I’m working on a language with similar goals: Sligh, and I’ve written about why I think it’s such a compelling idea before as well too.

In Sligh, I spent most of the last month introducing a new intermediate representation to make tier splitting (choosing if code should live on the client or server) easier. My goal was to enable derived data, as in a model that queries other models for its data and combines them by processing them in memory. I've been using the example of a personal finance application, so imagine:

The language that I work on is Sligh, and it's out of the bulleted list because it's nowhere near as mature as any of those that I listed, and I'm more of a verification enthusiast vs. expert. Almost all of the ideas in it are borrowed from somewhere else, but I think the one quasi-unique idea is it allows you to write a pure logical description / specification of an application, and it generates full-stack web application code from that.

I’m currently using Pest, though I wouldn’t exactly recommend my compiler as a ‘good example’ just yet because I’m prototyping and just churning code out.

Sligh

So tactically it’s currently a source-to-source compiler, where in the source language (my language) you denote the system state transitions, i.e. by writing create!, update!, etc, and those get compiled to corresponding client and server code in the target language (JS for now, but hoping to support WebAssembly in the future). Heres an example program. The compiler source is there too. I’m hacking it together right now, so it’s not my finest work :D

I eventually tend to do all days in Tailspin. The ones I have done so far are in directories ending in "tt" (the others are in Pyret, just to get a feel for it) https://github.com/tobega/aoc2023/tree/main

As a general tip, it is often helpful to first try to think of how you would like to represent the data in your program. Then you need to parse the data into that structure. I'd recommend you to look at a PEG-parser, for example. Or if you like, look at my Tailspin programming language which has a very visual parser syntax and also very visual ways of creating data structures (if that should happen to be your mental affinity). Look at my day1 for example. Or if you're more mathematical, maybe a functional language (I also did day1 in Pyret)

My Tailspin language is based on processing streams of values, you might want to look at it https://github.com/tobega/tailspin-v0

Many people had trouble with the day 7 problem. Paradoxically, good developers probably had more trouble. Here some of the difficulties are explained and implementations are provided in imperative, functional and OO styles, written in the Tailspin programming language.

I test almost entirely from my language, that way the tests are independent of the implementation. Currently the tests are implemented in java because that fits the interpreter implementation https://github.com/tobega/tailspin-v0/tree/master/test/tailspin/samples

Finished off the implementation of typed and offset array indices in Tailspin

I ended up enabling left recursion in Tailspin's composer (parser) syntax. Much cleaner calculator example now.

I think it's possible that Tailspin might be suitable for you.

I think gradual typing is definitely something worth exploring more. I thought it was a shame when Dart abandoned that path. Have you seen Shen ? I guess my small offering, Tailspin, is currently evolving to gradual typing as well.