GitLab

The old "{@ ... @}" syntax was a bit clunky, so I looked for a way to
make it more like the Lisp backquotes. That meant re-using the '}'
keyword for closing both quotes, and unquotes.

Since that meant introducing additional state into the interpreter, I
took it as an opportunity to put that information to good use, and
actually start discriminating between "constant" quotes and "exec"
quotes. Indeed, the ",{ ... } exec" pattern seemed to be common enough
that it deserved its own concept. Enter "${ ... }", and the notion of
"exec step".

This new distinction will also allow some rudimentary levels of
"compilation" to be offered to the users, by means of a function that
turns every "verb step" into the "exec step" that corresponds to that
verb's value at the time of linking. It's quite simple, but if it
could eliminate verb lookups from commonly-used functions, it could be
a nice easy performance win.

Add support for writing custom examples after CaPriCon code blocks, to make the resulting pages more easily explorable

Start defining two new builtins, 'showExpr' and 'showSyntax', to help when debugging the behaviour of macros

Update the repository URLs in the Curly documentation; update the install script to allow installing Bash completions in a standard location

Integrate the 'bashcomps.shl' library into the Curly package, so that unprivileged users can still benefit from great completions

Correct a small parser bug that caused some interactive commands to need two newlines instead of one

Implement a 'pull' builtin to precisely manage the scope of terms on the stack; merge the 'intro' and 'intro-before' builtins

Improve the pretty-printing machinery with "variable name" nodes. Useful for LaTeX, where variable names can be typeset in interesting ways.

Add a templating feature to all concatenative languages implemented with Algebra.Monad.Concatenative

At its simplest, a template is just a regular quote (between '{' and
'}'). Inside a template, you can drill some holes with the syntax {@
code... @}. The holes thus drilled are automatically filled from left
to right when the template is instanciated, that is, when its value
comes into scope.

For example, you can write a generic function to define custom
setters for individual variables like so :

  'defvar { dup "set-%s" format { {@ swap @} swap def } def } def
  'A defvar 'B defvar
  3 set-A 5 set-B
  A B + A *

Allow loading textures in raw 32bpc RGB floating point format in Logos (using the new 'texture' builtin, as opposed to 'image', which now means a standard 8bpc RGBA image).