2023-02-12





Releasing cl-simple-utils 1.0.0 (my first Common Lisp package)
══════════════════════════════════════════════════════════════

  Today I've released my first [Common Lisp] package: [cl-simple-utils],
  version [1.0.0].

  Release notes are [in the tag annotation in the repository] and in the
  [change log]. A [readme] is also available and required reading before
  using the software.

  The package is currently a collection of primitive utilities, which I
  need in order to build other stuff.


[Common Lisp] <https://en.wikipedia.org/wiki/Common_Lisp>

[cl-simple-utils] <https://gitlab.com/m-e-leypold/cl-simple-utils>

[1.0.0] <https://gitlab.com/m-e-leypold/cl-simple-utils/-/tags/1.0.0>

[in the tag annotation in the repository]
<https://gitlab.com/m-e-leypold/cl-simple-utils/-/tags/1.0.0>

[change log]
<https://gitlab.com/m-e-leypold/cl-simple-utils/-/blob/1.0.0/CHANGELOG.md>

[readme]
<https://gitlab.com/m-e-leypold/cl-simple-utils/-/blob/1.0.0/README.md>

Release Content
───────────────

  • A very basic test facility (which will enable me to bootstrap a
    better one — one needs to have a test facility to be able to test a
    better test facility …).

  • Text streams that indent output. These will possibly become
    deprecated or be re-engineered as soon as I've understood the common
    lisp pretty printer.

  • A `WITH-GENSYMS' macro that does produce symbols names where you can
    see the original placeholder variable.

    For example, `(GENSYM)' produces names like `#:G231'. In the
    debugger it is difficult to see where such symbol comes from
    especially if the compiler inlined aggressively. Most
    implementations of `WITH-GENSYMS' follow the same pattern.

    `(WITH-GENSYMS (FOO BAR) ...)' on the other side produces names like
    `#:G.FOO.242' and binds them to `FOO' for the execution of the body.

  • A method to write multi-line text blocks and have them indented
    properly. This is inspired by Python's `textwrap.dedent', but
    instead is computed at compile time, which is, of course, much
    better.

    For example instead of writing

    ┌────
    │ (let ((foo 2))
    │   (let ((expected-text "Aliquam erat volutpat.
    │ 
    │ - Nunc eleifend leo vitae magna.
    │ - In id erat non orci commodo lobortis.
    │ - Proin neque massa, cursus ut.
    │ "))
    │ 
    │     (do-something-with expected-text)))
    └────

    it is now possible to write the following:

    ┌────
    │ (let ((foo 2))
    │   (let ((expected-text (here-text ()
    │                           "Aliquam erat volutpat."
    │                           ""
    │                           "- Nunc eleifend leo vitae magna."
    │                           "- In id erat non orci commodo lobortis."
    │                           "- Proin neque massa, cursus ut.")))
    │ 
    │     (do-something-with expected-text)))
    └────

    This is much better — for example in tests, where multi-line text
    literals are often necessary.


Other Packages
──────────────

  This is not quite the only Common Lisp package I've in the works. The
  others are not released yet, though. For example current source for
  [cl-simple-test] is already available [at GitLab] and [at GitHub],
  just not released.


[cl-simple-test] <https://gitlab.com/m-e-leypold/cl-simple-test>

[at GitLab] <https://gitlab.com/m-e-leypold/cl-simple-test>

[at GitHub] <https://github.com/m-e-leypold/cl-simple-test>


Updates
───────

  • 2023-02-18 — Layout fixes. Improving one sentence.
  • 2023-03-25 — Migrated to Org Mode based site generator.