My upcoming initargs canonicalization library implements the platonically ideal solution using the MOP. You can just pass :canonicalize #'string as a slot option and the corresponding initarg will be canonicalized! There is also a :canonicalize class option (similar to :default-initargs) to canonicalize initargs not necessarily associated with slots.

This is a very intuitive and broadly useful killer app for the MOP!

Along the way, I solved several extensibility and usability problems regarding the MOP, which is what the 9 supporting libraries are about (mostly). I normally work on and release one library at a time, but I thought I'd take advantage of the dependency graph between them to demonstrate use-cases.

These libraries provide:

• a truly extensible version of defclass that can accurately control the expansion according to the metaclass and automatically detect the suitable metaclass by analyzing the defclass form;

• a simple extensible protocol for computing a guess using advisors (a generic protocol notably used for automatic metaclass detection);

• an easy way to ensure that special subclasses of standard-object cluster right in front of standard-object in the class precedence list, and an easy way to automatically inherit from such special subclasses where needed;

• a simple yet powerful value inheritance scheme;

• a flexible way of specifying preferences for a package (or other object);

• easy access to the defining class and its options during initialization;

• an easy way to designate simple class mixins that should bypass c2mop:validate-superclass;

• a way of extracting the compile-time side-effects of forms, notably useful when you want to replicate the compile-time side-effects of built-in definition forms;

• a canonical way of coercing a class designator to a class.

definitions-systems 1.0 is already my most important library, and
definitions-systems 2.0 will be my most important library update ever!

definitions-systems 2.0 adds support for defsys:ensure, (define defsys:system), defsys:root-system, defsys:standard-root-system, defsys:definition, defsys:owner, externalizable definitions (through generation of recursive defsys:locate forms by walking owners up to a root system), defsys:unbind-definition (a subprotocol of defsys:unbind that implements the actual removal if said definition does exist and makes it easy to notify the system and/or definition about it), defsys:check-definition (which allows to validate a definition before it's actually added to a system), defsys:simple-expansion-mixin (a very simple yet very powerful default), defsys:map-definitions, defsys:count, automatic tracking of primary and alias bindings for definitions, defsys:base-definition-class-mixin for easy determination of the class to use for definitions.

lispy-format 1.0 properly translates the essence of format into a proper s-expressions form. A guaranteed smash hit!

I know exactly what the final product will look like. There are 2 levels: individual functions which can be used standalone or in concert, and a macro for concisely and efficiently combining multiple output operations in one go.

lispy-format 1.0 will be far more readable than format, and it will be completely modular and extensible. And of course, it properly uses the package system, so you can easily write your own extended version of the standard built-in operators if you like, or design your own features which will seamlessly integrate with built-in features and third-party features.

One of several advantages of lispy-format 1.0 is that a command's arguments are specified with the command instead of all commands being specified ahead of time and then all arguments, making it hard to correlate commands with their arguments.

lispy-format 1.0 will be very easy to learn, regardless of the user's level of proficiency with format. That said, format experts will find many familiar similarities compared to format, making transition easy. Tools should eventually be provided to help migration.

Here is an old preview.

I'll have 30+ libraries in Quicklisp at that point!

HexstreamSoft Sponsors will establish more concrete, predefined incentives for supporting me at the Crusader+ levels, primarily consisting of ads for my monthly sponsors (mostly company logos linking to their site) on the HexstreamSoft front page, and similarly for lifetime sponsors on another page.

HexstreamSoft Sponsors will be a pretty breathtaking marketing operation for Common Lisp, after finishing the aforementioned libraries I'll be in a really great position to make great pitches to kickstart Common Lisp Revival 2020!! Support me at this early stage to cement your place in history!! (Remember that GitHub doubles all your contributions!)

I am confident HexstreamSoft Sponsors will quickly help me attract other major sponsors, and it would be really great if we could take full advantage of my up to 5000$ GitHub Sponsors doubler before it expires in December 2020!

This library will implement a revolutionary new paradigm for iteration and mapping. It is extremely simple, intuitive, modular, flexible, powerful and optimizable, and easily scales from trivial use-cases to very complex, so you can just use it always. It will basically obsolete every iteration and mapping construct you know of, and then some.