Droplet: "Datalog in time and space" - https://github.com/jamii/droplet
Eve: "Datalog meets Smalltalk" - https://witheve.com
Imp: "An Eve for people who build Eves" - https://github.com/jamii/imp
These are some pretty "out there" languages with a high strangeness budget, so I'd expect the same of Zest.
I like the idea of exploring the interaction models that Eve provided but instead with a "well-trodden ground of a mostly-familiar imperative language", but I'm curious how that will work since the interactions in Eve were made possible due to the datalog-like language design. So my initial question is how "mostly-familiar" Zest really is; what imperative concessions does the language make to gain which interactions?
With Eve, a lot was gained just by keeping a database of compiler artefacts that would normally be thrown away. This allowed for a degree of "provenance" tracking, where you can ask the compiler how a runtime value came to be.
I think there's an interesting middle ground where maybe we can get a bunch of the things in Eve that were nice, but maybe tone down the weirdness budget to lower the learning curve. Maybe that's Zest? Will be interesting to follow this project.
What Datalog and co give you is the ability to do interesting program transformations. Mostly that's not because they are "declarative", if that means anything, but because they avoid all the little bits of non-determinism that imperative languages include. If you avoid those you're pretty much set. Coming from another angle, JAX [1] shows how you can do program transformations in Python with a relatively small set of semantic restrictions.
[0]: https://www.scattered-thoughts.net/writing/unexplanations-sq... [1]: https://github.com/jax-ml/jax
I find a lot of libraries don't go through the effort to actually use doctests, and just stick `no_run` everywhere, which defeats a lot of the purpose.
