Forem: vindarel

Zed editor plugin for Common Lisp: installation notes

vindarel — Mon, 02 Mar 2026 14:35:19 +0000

The very new Zed extension lives here: https://github.com/etyurkin/zed-cl/

As it seems it's a quickly generated AI plugin.

install Zed: https://zed.dev/
- you need a correct GPU driver (for Vulkan). This took me 1GB of space and it required to restart the computer.
look at issue #1: https://github.com/etyurkin/zed-cl/issues/1 if it's still open, clone the project of the pending PR.
run make build and see.
you need a Rust toolchain (rustc, cargo, rustup)
- count 1GB of disk space, less if you exclude rust-docs
you will install tree-sitter-commonlisp on the Lisp and Rust sides, you'll build the LSP server, a Jupyter kernel, a TUI REPL client, the Zed extension in WASM (and a couple hundred crates)
- this will already take a few minutes of compilation, depending on your machine
- for this step you need the wasm32-wasip1 target: rustup target add wasm32-wasip1. I stopped here.

That's all for now :D

Common Lisp needs more documentation, tools and ideas (where are we on this?)

vindarel — Wed, 17 Dec 2025 16:27:45 +0000

This comment is like a mantra on reddit:

Lisp needs more fresh documentation, more fresh tooling, and more fresh ideas.

I don't disagree, but it's sad to read the same comment on threads 10 years ago or today. Let's put some perspective. Did something change for the better in the last years??

Let's see what new things we got since 2018 or so that I'm looking around here. At that time, it was so much more difficult to get into CL.

If you rant, you're allowed to, but please be happy to rant today!

common-lisp.net was revamped (it was pushing people off),
revamped and (way, way, way) better Cookbook,
CL Community Spec (everybody dreamed about this, it's done),
Novaspec,
common-lisp-libraries.readthedocs.io,
better awesome-cl, at least a list of libraries that makes sense, before we only had Cliki (a mess),
Qlot for project-local dependencies à la pip/npm/you name it (not that it's better or that Common Lisp need it, you might not need it),
ocicl (incl. its linter), a new take on package management,
Ultralisp, a new take on Quicklisp distribution,
vend, a new take on libraries management,
mallet, another linter,
more distribution channels of SBCL, including for Windows, including with system libraries baked in,

In the editors front:

newly maintained Atom/Pulsar extension, well developed, featureful,
rediscovered Eclipse plugin,
new VSCode extension (or two?) and LSP tooling, might need more love but hey! It's here and working,
new SLT extension for the Jetbrains IDE,
new extension for Sublime,
new one for Geany,
improved Jupyter kernel and extensions,
improved cl-repl,
new icl tool, an again better cl-repl,
very capable Lem for many languages, with LSP, AI and whatnot,
maybe new tooling for Vim/Neovim,
even free extensions for LispWorks,

and finally:

dare I cite a good Udemy course (there was an old bad one)… not listing libraries (wait, cl-tuition is awesome and fills a gap, wait, Coalton is phenomenal) and not counting other doc or tools attempts and projects waiting for more content or the last touch.

Let's be more precise when ranting please and let's everybody contribute to those most welcome projects and support their creators!

Best,

you'll find all the links somewhere here:

cover image: Lem editor

Common Lisp script: search and transform music files to mp3 with ffmpeg

vindarel — Tue, 09 Sep 2025 12:54:47 +0000

We leverage some cool libraries:

$ ciel -s ffmpeg delux flac

[…]

    TITLE           : Cria de Favela
    track           : 12
    TRACKTOTAL      : 12
  Duration: 00:02:51.60, start: 0.000000, bitrate: 954 kb/s
  Stream #0:0: Audio: flac, 44100 Hz, stereo, s16
  Stream #0:1: Video: mjpeg (Progressive), yuvj420p(pc, bt470bg/unknown/unknown), 1280x1280 [SAR 120:120 DAR 1:1], 90k tbr, 90k tbn, 90k tbc (attached pic)
    Metadata:
      comment         : Cover (front)
      title           : D:\Música em alta resolução\Album\Criolo\[2017] Espiral de Ilusão - Deluxe Edition\Espiral de Ilusão - Deluxe Edition.jpg
Stream mapping:
  Stream #0:1 -> #0:0 (mjpeg (native) -> png (native))
  Stream #0:0 -> #0:1 (flac (native) -> mp3 (libmp3lame))
Press [q] to stop, [?] for help

done for files: 
"/home/vince/zique/[2017] Espiral de Ilusão - Deluxe Edition/01 - Criolo - Lá Vem Você.flac"
"/home/vince/zique/[2017] Espiral de Ilusão - Deluxe Edition/02 - Criolo - Dilúvio de Solidão.flac"
"/home/vince/zique/[2017] Espiral de Ilusão - Deluxe Edition/03 - Criolo - Menino Mimado.flac"

Easy!

We find files with file-finder:

(finder:finder*
   :root root
   ;; This "and"s the params:
   :predicates (apply #'finder:every-path~ params)
   ;; This would do a "or":
   ;; :predicates (apply #'finder:path~ params)
   )

This searches for files recursively on a root directory and it "ands" our list of search terms.

We could be more precise in asking it to check that "flac" is the file extension, but it's ok for us here.

This gives us a list of "file-finder:file" objects, actually not lisp pathnames, not strings. To get file names as strings, we use finder:path file.

To get a file name with the mp3 extension, we simply replace in a string:

(let ((extension (pathname-type file)))
    (when extension
      (values
       (str:replace-all extension "mp3" file)
       extension)))

However, TIL. We have directory names that give the year in between […] characters, and uiop:file-exists-p chokes at it (it returns nil). We escape those characters:

(defun escape-file-name (name)
  "Escape [ and ] with double \\,

  otherwise uiop:file-exists-p returns NIL for an existing file."
  ;; This works on upstream file-finder <2025-09-09>
  ;; (when (finder:file? name)
    ;; (setf name (finder:path name)))
  (str:replace-using '("[" "\\["
                       "]" "\\]")
                     name))

(edit) OK, those are wildcard characters. This pattern correctly returns T when a file exists:

  (probe-file (make-pathname :name name :type extension))

so I might adapt the script.

And that's pretty it. We run ffmpeg with

(uiop:run-program (list "ffmpeg"
                                "-i"
                                (finder:path file)
                                target)
                          :output :interactive
                          :error-output t)

Here's the full listing.

Find it also on https://github.com/ciel-lang/CIEL/discussions/89 and in CIEL's scripts directory.

https://github.com/ciel-lang/CIEL/ - a batteries-included Common Lisp. Here we only rely on the built-in file-finder library, and cl-str. And the easy way to run a script from the terminal.

(in-package :ciel-user)

;;;
;;; Search files and transform them to mp3 with ffmpeg.
;;;
;;; Usage:
;;;
;;; ciel src/scripts/ffmpeg search terms
;;;
;;; Todo:
;;; - choose search directories (do we even search on the current directory?)
;;; - choose output format, etc.
;;;
;;; TIL: we need to escape file names if they contain characters such as [ ].
;;;

(defparameter *directories* '("~/Music/" "~/Downloads/" "~/zique/"))

(defvar *music-type-extensions* '("aac" "ac3" "aiff" "amr" "ape" "dts" "f4a" "f4b" "flac" "gsm"
         "m3u" "m4a" "midi" "mlp" "mka" "mp2" "mp3" "oga" "ogg" "opus" "pva"
                                  "ra" "ram" "raw" "rf64" "spx" "tta" "wav" "wavpack" "wma" "wv")
  "A bunch of audio extensions. Should be supported by ffmpeg. Thanks ready-player.el.")

(defun music-file-p (file)
  "Return non-NIL if this file (pathname) has a music file extension as of *music-type-extensions*."
  (find (pathname-type file) *music-type-extensions* :test #'equalp))


(defun find-on-directory (root params)
  "Search on default directories.

  PARAMS (list)"
  (finder:finder*
   :root root
   ;; This "and"s the params:
   :predicates (apply #'finder:every-path~ params)
   ;; This would do a "or":
   ;; :predicates (apply #'finder:path~ params)
   ))

(defun find-files (&optional params)
  "Find files matching PARAMS (a list of strings) on the default directories.

  PARAMS is an 'OR'. I would prefer to 'and' the matches actually (see find-on-directory)."
  (unless params
    (format *error-output* "No search terms supplied.~&Usage: finder.lisp search terms.~&")
    (return-from find-files))
  (let ((str:*ignore-case* t)
        (params (ensure-list params)))
    (flatten
     (loop for root in *directories*
           collect
           (find-on-directory root params)))))

(defun pprint-for-shell (list)
  "Pretty-print this list of files (with full path), one per line."
  (mapcar (lambda (p)
            (format t "~s~&" (finder:path p)))
          list)
  (terpri))

(defun change-extension (file)
  (when (finder:file? file)
    (setf file (finder:path file)))
  (let ((extension (pathname-type file)))
    (when extension
      (values
       (str:replace-all extension "mp3" file)
       extension))))

;; warn!
(defun escape-file-name (name)
  "Escape [ and ] with double \\,

  otherwise uiop:file-exists-p returns NIL for an existing file."
  ;; This works on upstream file-finder <2025-09-09>
  ;; (when (finder:file? name)
    ;; (setf name (finder:path name)))
  (str:replace-using '("[" "\\["
                       "]" "\\]")
                     name))

(defun run-ffmpeg (file)
  "Run ffmpeg on FILE, transform to mp3."
  (let ((target (change-extension file)))
    (if (uiop:file-exists-p (escape-file-name target))
        (progn
          (format t "~&mp3 already exists: ~a~&" target)
          target)
        (uiop:run-program (list "ffmpeg"
                                "-i"
                                (finder:path file)
                                target)
                          :output :interactive
                          :error-output t))))

(defun ffmpeg-on-files (files)
  "Transform files to mp3 with ffmpeg.

  Search on the default directories by AND-ing the search terms."
  (loop for file in files
        for path = (finder:path file)
        when (and (music-file-p path)
                  (uiop:file-exists-p (escape-file-name path)))
          do (format t "~&transforming: ~a~&" file)
             (run-ffmpeg file)
          and collect file into processed
        finally
           (format t "~&~%done for files: ~&")
           (pprint-for-shell processed)))

#+ciel
(ffmpeg-on-files (find-files (rest *script-args*)))

Common Lisp: read password on a terminal (by hiding its input)

vindarel — Thu, 04 Sep 2025 20:53:43 +0000

We want to have a prompt asking for a password or other sensitive information:

> enter password:

and hide the characters we type:

> enter password: *****

A solution: call /bin/stty and enable/disable its echo:

(defun enable-echo ()
  (uiop:run-program '("/bin/stty" "echo") :input :interactive :output :interactive))

(defun disable-echo ()
  (uiop:run-program '("/bin/stty" "-echo") :input :interactive :output :interactive))
  ;; or:
  ;; (sb-ext:run-program "/bin/stty" '("-echo") :input t :output t))


(defun prompt (msg)
  (format t msg)
  (force-output)
  (read-line))

(defun pass-prompt ()
  (format t "password: ")
  (force-output)
  (disable-echo)
  (unwind-protect
      (read-line)
    (enable-echo)))

(eval-when (:execute)
  (let ((pass (pass-prompt)))
    (format t "~&I still know the pass was ~s~&" pass)))

Run this: sbcl --load read-password.lisp, and you get the above prompt.

Other libraries that help hiding sensitive information on other contexts (like, in the REPL output) are:

I used them and can recommend them.

Other libraries are to be found on awesome-cl.

That's all!

Lisp?!

hell yes. https://lisp-journey.gitlab.io/pythonvslisp/
https://github.com/CodyReichert/awesome-cl/
https://github.com/azzamsa/awesome-lisp-companies/
debug and resume a program from where it left, don't restart anything: https://www.youtube.com/watch?v=jBBS4FeY7XM
learn Common Lisp efficiently

Common Lisp: a command-line interactive terminal application in 2 lines

vindarel — Sun, 27 Jul 2025 14:11:21 +0000

The quicker to a MVP the better, right?

Suppose you have a working Lisp function:

(defun play (file &optional (player (ensure-player)))
  "Play this file or directory in the background.

  Return the PLAYER instance.

  See also:

    TOGGLE-PLAY/PAUSE, STOP, QUIT, PLAYLIST-NEXT/PREVIOUS."

  ;; Play!
  (with-accessors ((p process)) player
    ;; but stop the current process if it's alive.
    (when (and p (uiop:process-alive-p p))
      (stop player))
    ;; If we get a pathname, get the file name as string.
    (setf p (uiop:launch-program (mpv-command (uiop:native-namestring file)))))
  player)

It works in the Common Lisp REPL. It works in the Lem editor. How can we make it work (fast) on the terminal?

Quickload the replic library (based on cl-readline).

Create a file run.lisp:

;; run.lisp
(load "media-player.lisp") ;; your library

(in-package :media-player)

;; TODO: yes, next step is to set-up a proper.asd system definition.
(eval-when (:compile-toplevel :load-toplevel :execute)
  ;; Load helper libraries (you need quicklisp).
  (ql:quickload "replic"))

;; The exported functions of :media-player will be available
;; in the readline prompt.
;; TAB-completion works to write them.
(replic.completion:functions-to-commands :media-player)

;; Start the readline command loop:
(replic:repl)

and that's it: 2 lines.

Run it:

$ sbcl --load run.lisp
> play "~/zique/2000\ -\ Jorge\ Aragão\ Ao\ Vivo\ 2/"
> toggle-pause 
> toggle-pause 
> stop
> 
Do you want to quit ? [Y]/n :

(it's even easier to run a file on the terminal, with batteries included, with CIEL)

This gives you:

TAB-completion for the player commands (play, stop, toggle-pause…)
dialog confirmation for quit

We could do more, like specifying what to TAB-complete for each different command, but that's our MVP, we can now have fun with the application on the terminal. For example (see replic's README), if we had a hello <name> command, we'd register every name, and the goodby <name> command would get TAB-completion of names. Other commands are unaffected.

How interesting is that to you?

What replic saved you is: reading cl-readline's documentation, writing readline boilerplate to start the command loop, writing boilerplate to say what to TAB-complete. You can now easily use your Lisp program from outside of the editor.

This was for the Lem editor

The Lem editor is really good. I assembled this media player (all the heavy lifting is done by mpv) to see how it fits in Lem.

Find the code here:

https://github.com/vindarel/lem-media-player

Send emails with Common Lisp (SMTP, Gmail, Sendgrid, Mailgun…)

vindarel — Tue, 27 May 2025 18:58:20 +0000

Today I want to give an usage example of cl-smtp. It's a good, maintained library, with a good README but no proper documentation, nor a ready-to-copy-paste usage example.

cl-smtp

Here it is:

(cl-smtp:send-email "mail.server.org" "from@mail.org" "to@mailz.org" "subject" "just a test message from Emacs/Slime."
  :port 587 :ssl :starttls
  :authentication (list "from@mail.org" "password"))

;; => ("2.0.0 Bye")

The lambda list is:

(cl-smtp:send-email host from to subject message :ssl ssl
    :port port
    :cc cc
    :bcc bcc
    :reply-to reply-to
    :extra-headers extra-headers
    :html-message html-message
    :display-name display-name
    :authentication authentication
    :attachments attachments
    :buffer-size buffer-size
    :envelope-sender envelope-sender
    :external-format external-format
    :local-hostname local-hostname
    :message-id message-id)

This code snippet allows to send an email from Common Lisp with an existing email account: be it Gmail or any other regular email provider, as long as you know its SMTP address or IP, and your account ID and password.

Postmaster

Eudoxia's postmaster is a wrapper around cl-smtp and mel-base. It adds object-orientation to create and use servers as first-class objects, as well as some defaults.

It uses cl-smtp to send emails, and mel-base to manage pop3/IMAP folders.

The repository is now read-only, let's maintain it together on https://github.com/lisp-maintainers/ if you are so inclined.

Sendgrid, Mailgun

If you want to rely on a third-party email provider, you can create an account there and these libraries have you covered:

sendgrid - send emails with Sendgrid's API.
mailgun - A thin wrapper to post HTML emails through mailgun.com.

Reading mail: trivial-imap

trivial-imap wants to make mel-base or post-office (a fork of Franz's cl-imap) easier to use. I didn't try any of them.

It even has the possibility to search for emails.

Sending (and possibility reading) emails in Common Lisp isn't trendy but just works© ;)

for any news please check the list of https://github.com/CodyReichert/awesome-cl/

Read CSV files in Common Lisp (cl-csv, data-table)

vindarel — Tue, 06 May 2025 16:52:02 +0000

I just helped friends for some CSV manipulation and did it for the first time from CL, here's a quick usage overview.

If you know a better© way please comment.

EDIT: lisp-stat's data-frame is pretty awesome.

I added the data-table utility in CIEL: http://ciel-lang.org/#/libraries?id=csv

cl-csv and a table-like data structure

We'll use cl-csv, data-table and cl-csv-data-tables (a system defined in cl-csv).

cl-csv allows to read and write a CSV file, string or stream.

data-table allows to work with a "table-like" data-structure where
you can access columns by name (instead of only by index), coerce
column types, and more.

cl-csv-data-tables brings a couple helpers.

WARN: below, csv is a nickname to ciel-csv which exports symbols from both cl-csv and data-table.

Here are the first cl-csv examples:

Read a file into a list of lists:

(csv:read-csv #P"file.csv")   ;; <--- note the #P
=> (("1" "2" "3") ("4" "5" "6"))

;; read csv from a string (streams are also supported)
(csv:read-csv "1,2,3
4,5,6")
=> (("1" "2" "3") ("4" "5" "6"))

Read a file that's TAB delimited:

(csv:read-csv #P"file.tab" :separator #\Tab)

loop over a CSV for side effects with do-csv:

(let ((sum 0))
  (csv:do-csv (row #P"file.csv")
    (incf sum (parse-integer (nth 0 row))))
  sum)

We can use map-fn to do something at each row.

Below we read a file and return a list of objects created from each row. We could create instances of our own objects like this.

(cl-csv:read-csv #P"file.csv"
                 :map-fn #'(lambda (row)
                             (make-instance 'object
                                            :foo (nth 0 row)
                                            :baz (nth 2 row))))

note that we have to access each column by index.

Use a table, guess column types

Read a CSV, create a data-table object, assume headers are on the
first row (:has-column-names), guess the column types (:munge-types):

(csv:get-data-table-from-csv #p"file.csv")   ;; <--- still the #P
;; #<DATA-TABLE:DATA-TABLE {10018A9F63}>

(describe *)
;; =>
  COLUMN-NAMES                   = ("Date" "Type" "Quantity" "Total")
  COLUMN-TYPES                   = (STRING STRING INTEGER DOUBLE-FLOAT)
  ROWS                           = (("9 jan. 1975" "Sell" 1 9.90) …)

This function is roughly as if you read the CSV file with cl-csv:read-csv, checked that the first row contains column names, created the data-table object with (make-instance 'data-table:data-table :column-names (first rows) :rows (rest rows), and coerced the columns' types with (data-table:coerce-data-table-of-strings-to-types dt) and (data-table::ensure-column-data-types dt) (unexported function).

Access rows and columns

do that with:

csv:rows
csv:data-table-value dt &key row row-idx col-name col-idx
and more

Write to file (or streams)

Write the data-table to a file with data-table-to-csv dt &optional stream).

Real-world example

That's my CIEL script that I did to help friends of a non-profit.

;;;;
;;;; Run this script on many CSV files:
;;;;
;;;; $ ciel sumuputils.lisp Rapports*
;;;;
;;;;

(in-package :ciel-user)

;; Needs the latest CIEL, or this library.
;; (ql:quickload "data-table"  :silent t)

;;; Download the CSV file from Sum Up
(defvar *file*  #p"/path/to/Rapport-ventes-2024-11-01_2024-11-30.csv"
  "Only for testing.")

(defvar *dt* nil "devel only")

(defun parse-csv (file)
  "Parse CSV, return a data-table object with column names and rows.

  file: a pathname (not just a string)."
  ;; This takes headers as the first row
  ;; and guesses the columns' types (string, int, float).
  (csv:get-data-table-from-csv (pathname file)))

(defun get-all-days (dt)
  (remove-duplicates
   (loop for row in (data-table:rows dt)
         for date/time = (data-table:data-table-value dt :row row :col-name "Date")
         for day = (str:unwords
                    (split-sequence #\Space date/time :count 3))
         collect day)
   :test #'equal))

;; (get-all-days (parse-csv *FILE*))
;; ("1 nov. 2024" "2 nov. 2024" "5 nov. 2024" "7 nov. 2024" "8 nov. 2024" …)

(defun get-all-conso-types (dt)
  (sort
   (remove-duplicates
    (loop for row in (data-table:rows dt)
          for description = (data-table:data-table-value dt :row row :col-name "Description")
          when (str:non-blank-string-p description)
            collect description)
    :test #'equal)
   #'string<))

(defun get-all-offert-types (types)
  (filter (^ (it) (str:containsp "offert" it)) types))
#++
(get-all-offert-types (get-all-conso-types (parse-csv *FILE*)))

(defun rows-offerts-for-day (day dt)
  "day: string, like '23 nov"
  (loop for row in (data-table:rows dt)
        when (and (str:containsp day (data-table:data-table-value dt :row row :col-name "Date"))
                  (str:containsp "offert" (data-table:data-table-value dt :row row :col-name "Description")))
          collect row))

(defun sum-quantities-offerts-for-day (day dt)
  ;; optionnel: pour chq jour, combien de tartines, alcool, soft… d'offerts? (en nombre)
  (loop for row in (rows-offerts-for-day day dt)
        for qty = (data-table:data-table-value dt :row row :col-name "Quantité")
        when qty
          sum qty))

;; (sum-quantities-offerts-for-day "23 nov" *dt*)
;; 15

(defun sum-quantities-offerts-for-day/by-type (day dt desc)
  ;; optionnel: pour chq jour, combien de tartines, alcool, soft… d'offerts? (en nombre)
  (loop for row in (rows-offerts-for-day day dt)
        for qty = (data-table:data-table-value dt :row row :col-name "Quantité")
        when (and qty
                  (str:containsp desc (data-table:data-table-value dt :row row :col-name "Description")))
          sum qty))

(defun report-sum-quantities-offerts-for-day/by-type (file &key (stream t) &aux dt)
  (setf dt (parse-csv file))
  (loop for day in (get-all-days dt)
        do
           (format stream "~&~%Nombre de consos offertes le ~a~&~%" day)
           (loop for desc in (get-all-offert-types (get-all-conso-types dt))
                 do
                    (format stream "~a: ~a~&" desc (sum-quantities-offerts-for-day/by-type day dt desc)))))


(defun sum-total-offerts-for-day (day dt)
  ;; le + important
  (loop for row in (rows-offerts-for-day day dt)
        for qty = (data-table:data-table-value dt :row row :col-name "Prix (TTC)")
        when qty
          sum qty))

;; (sum-total-offerts-for-day "23 nov" *dt*)
;; 49.0d0

(defun report-totals-offert-for-days (file &key (stream t))
  (let ((dt (parse-csv file)))
    (format stream "~&~%Total TTC des offerts~&~%")
    (format stream "~&(somme des colonnes Prix (TTC) pour toutes les lignes du jour comportant 'conso offerte')~&")
    (loop for day in (get-all-days dt)
         do (format stream "~20a: ~4f~&" day (sum-total-offerts-for-day day dt)))))

(defun report-number-offert-for-days (file &key (stream t))
  (let ((dt (parse-csv file)))
    (format stream "~&Nombre des consos offertes par jour~&")
    (format stream "~&(somme des colonnes 'Quantité' pour toutes les lignes du jour comportant 'conso offerte')~&")
    (loop for day in (get-all-days dt)
         do (format stream "~20a: ~4a~&" day (sum-quantities-offerts-for-day day dt)))))

#+ciel

#+ciel
(let ((files (mapcar #'pathname (rest ciel-user:*script-args*))))
  (mapcar #'report-totals-offert-for-days files)
  (mapcar #'report-sum-quantities-offerts-for-day/by-type files))

Call it from the command line:

$ ciel sumuputils.lisp Rapport*csv > rapport.txt

Show data in table

This is our CSV, by the way:

Date,Type,Réf. transaction,Moyen de paiement,Quantité,Description,Devise,Prix avant réduction,Réduction,Prix (TTC),Prix (HT),TVA,Taux de TVA,Compte
1 nov. 2024 22:09,Vente,T3YKZYZANT,Mastercard - Crédit,1,Montant personnalisé,EUR,3.00,0.00,3.00,3.00,0.00,,us@gmail.com
…

Can we display it nicely in a table? We'll use our resurrected cl-ansi-term library.

We'll use the "raw" CSV data, where the headers are on the first line, instead of the data-value object.

That way we just have to pass it to term:table *csv*, and we choose the columns to display:

(setf *rawcsv* (csv:read-csv #p"test.csv"))

(term:table *RAWCSV* :keys '("Date" "Quantité" "Prix (HT)"))

Result:

+-----------------+--------+---------+
|Date             |Quantité|Prix (HT)|
+-----------------+--------+---------+
|1 nov. 2024 22:09|1       |3.00     |
+-----------------+--------+---------+
|2 nov. 2024 19:10|1       |6.00     |
+-----------------+--------+---------+
|2 nov. 2024 20:25|1       |6.00     |
+-----------------+--------+---------+
|2 nov. 2024 20:44|1       |10.00    |
+-----------------+--------+---------+
|2 nov. 2024 21:05|1       |6.00     |
+-----------------+--------+---------+
|2 nov. 2024 21:13|1       |3.00     |
+-----------------+--------+---------+
|2 nov. 2024 21:45|1       |7.00     |
+-----------------+--------+---------+
|2 nov. 2024 21:49|1       |6.00     |
+-----------------+--------+---------+

Lisp-stat's data-frame

lisp-stat's data-frame is the smart way.

(ql:quickload :lisp-stat)
;; …

(in-package :ls-user)

;; Give a name to our dataframe,
;; read CSV.
(defdf sumup (read-csv #p"sells.csv"))
;; similar to (defparameter *data-frame* …) but with future goodies.

;; The goodies are that each column is created as a variable for our "sumup" dataframe.
;; Here we get all the "date" columns:
LS-USER> sumup:date
;; #("1 nov. 2024 19:36" "1 nov. 2024 19:36" …)

;; We didn't need to LOOP.

;; We can also use 
(select sumup t 'date)

;; We have rows an column manipulation functions.
;; Let's get the data of only 2 columns:
(columns sumup '(date quantité))

;; Let's inspect our data:
(head sumup)

;;   DATE              TYPE  RÉF--TRANSACTION MOYEN-DE-PAIEMENT  QUANTITÉ DESCRIPTION          DEVISE PRIX-AVANT-RÉDUCTION RÉDUCTION PRIX-(TTC) PRIX-(HT) TVA TAUX-DE-TVA COMPTE                     
;; 0 1 nov. 2024 19:36 Vente TE4PL6DA9X       Mastercard - Débit        1 Montant personnalisé EUR                     9.0       0.0        9.0       9.0 0.0          NA us@gmail.com

;; the data is printed as a nice table, respecting the columns width out of the box.

;; print-data would print all the data.

;; DESCRIBE output is pimped:
(describe sumup)

SUMUP
  A data-frame with 863 observations of 14 variables

Variable             | Type | Unit | Label      
--------             | ---- | ---- | -----------
DATE                 | NIL  | NIL  | NIL        
TYPE                 | NIL  | NIL  | NIL        
RÉF--TRANSACTION     | NIL  | NIL  | NIL        
MOYEN-DE-PAIEMENT    | NIL  | NIL  | NIL        
QUANTITÉ             | NIL  | NIL  | NIL        
…

;; We can guess the column types:
(heuristicate-types sumup)

;; Our types are not NIL now:
(describe sumup)
SUMUP
  A data-frame with 863 observations of 14 variables

Variable             | Type         | Unit | Label      
--------             | ----         | ---- | -----------
DATE                 | STRING       | NIL  | NIL        
TYPE                 | STRING       | NIL  | NIL        
RÉF--TRANSACTION     | STRING       | NIL  | NIL        
MOYEN-DE-PAIEMENT    | STRING       | NIL  | NIL        
QUANTITÉ             | INTEGER      | NIL  | NIL        
PRIX-AVANT-RÉDUCTION | DOUBLE-FLOAT | NIL  | NIL        
…

And we have rows and colums manipulation functions at our disposal. Much more, without looping.

Common Lisp: is LispWorks worth it?

vindarel — Wed, 12 Feb 2025 16:30:16 +0000

Let's seek some feedback by people who used it.

(emphasis mine)

I own LW for Linux, Mac, and Windows. That's a lot of $$$. But I can build trimmed down binaries for multiple platforms. If there's another platform I need, I can just pay LW, and it'll just work. (I used a beta version of LW for Android for a while, and I was impressed with how everything just works, I chose not to keep paying for it though since Android didn't remain a primary platform I was working on). As a solo dev, it would take me too much time to make my code work on multiple platforms without LW.

I like the Java support. I can use Java libraries when I need it. Very valuable.

I love LW's FLI vs something like CFFI. It's just very well thought through, and really well documented.

Speaking of documentation, the LW documentation is outstanding, and the folk at LW will respond to you explaining implementation details that aren't documented if you need it.

And it's rock solid. I have my server running for weeks and weeks at a time, with constantly reloading code. I don't think I've ever had a crash in prod except when I ran out of memory on occasion.

Cons: not every library is well tested with LW. You'll frequently have to fix libraries, or have your own fork of things.

I haven't used CAPI [their cross-platform GUI toolkit, based on Gtk on GNU/Linux] much. I don't use the IDE, I use Emacs+sly.

All that being said, SBCL is still fantastic. If you're building a web app, SBCL would work perfectly well for your use case.

@tdrhq of ScreenShotBot

https://www.reddit.com/r/Common_Lisp/comments/yq2t4r/why_buy_lispworks/ivmoexy/

My first Lisp job was building a touch-screen GUI for a law enforcement booking system that ran on an embedded Windows OS. We used LispWorks 5 if I recall correctly. It was stellar and extremely stable. Our attempts at the time to port to an open-source compiler were complete boondoggles for a multitude of reasons.

Aside from stability, the following stood out:

Their GUI toolkit is great if you're building a commercial application.
Their documentation is better than any open source Lisp compiler.
Turn-key ways to build optimized, small, and safer executables and dynamic libraries. I don't think any open source Lisp offers good options to shake out unnecessary functionality from the Lisp image.
You can pay someone to fix things that don't work as well as you want.

My big issues with LW:

It's a great Lisp implementation, but it's just an ok compiler. It takes a ton more work to get performant numerical code compared to SBCL.
Last I checked, it's $3k per OS per processor. So if you want to provide binaries for Win, Mac (Intel, ARM), Linux, you're going to have to shell out $12,000 or so.

stylewarning, same reddit link https://www.reddit.com/r/Common_Lisp/comments/yq2t4r/why_buy_lispworks/

The combination of CAPI, Common SQL, KnowledgeWorks and the Java interface inside a single image is difficult to beat. They’re all very solid and battle-tested. This integration as well as the substantial development velocity that comes from using CL is what finally convinced me to pony up the cash, which I definitely don’t regret. My current project is automated planning and scheduling in healthcare and uses all of these features.

The IDE tooling is solid and things like breakpoints, the debugger, stepper, tracer and profiler are really useful and ‘just work’ as expected. The editor isn’t quite as strong as Emacs, but can be tweaked to paper over the differences, and having immediate access to the documentation and much deeper integration with the rest of the system far outweighs minor annoyances like trailing white space that can be easily fixed with a pre-commit hook.

Other, smaller, things that I’ve come to appreciate:

the advice facility
embedded FLI modules
dspecs
action lists
with-prolog / deflogfun to interface prolog and Lisp
user defined streams over pointers into foreign memory.
extremely fast start times in delivered applications
being able to easily integrate my own extensions into the IDE
gentle on my laptop battery and no annoying ‘help' compared to products like IntelliJ.
it’s almost trivial to bang out a prototype or some utility application, complete with a user interface, in an afternoon.
- Like some others, I don’t tend to use saved sessions all that much. The compiler is fast enough that it isn’t a big problem to compile & load your code at the start of a session, and I find it helps prevent unexpected issues some delivery time.
- Yes, it is expensive compared to SBCL+Emacs or VS Code and whatever iteration of JavaScript we’re up to now. But I think you get what you pay for which is a solid, extensible, general purpose development environment with some fairly high-voltage batteries included.

same link

https://www.lispworks.com/

Refactoring in Common Lisp (and VS Python)

vindarel — Sat, 01 Feb 2025 12:17:32 +0000

How is the refactoring story for Common Lisp? Is it lacking? We don't have good IDE refactoring tools, do we?

Those are legitimate questions, specially when we are evaluating the language and its ecosystem. It pops up regularly on reddit. It's best if we talk about experience and precise points, so here's mine.

The biggest Common Lisp project I contributed to is Lem. It is close to 300k lines of Lisp code, it exists since at least 2016.

It was very easy to contribute to, and I am not the only newcomer to say this. It is well structured, clear code, almost "boring" code. It doesn't use fancy language extensions and has a few macros.

I received pull requests on top of my contributions (Lem's legit Git interface). One big PR had me do more manual testing that anticipated, but that wasn't because the code didn't compile or was incorrect (a build error or a failed linter in a CI is spotted quickly), it was because of missing behavior (a missing generic function implementation in a given package), because the PR obviously had not been tested by the author.

It's true that we don't have fancy refactoring tools in CL like in modern IDEs for other platforms (not that I know of), but we have many tools that make small (and larger) refactoring easy during development. Comparing to what I know, the development experience is miles ahead of Python's. CL makes refactorings easy thanks to:

language features (no moving syntax, multiple return values are NOT returning a list or a tuple, methods, macros…),
implementation features (all the useful errors and warnings at compile-time, when you press a keyboard shortcut to reload one single function or a file or a module or a project),
tools (the built-in cross-references: who calls this macro? Who uses that function? etc)
as well as culture (deprecation warnings staying for years (I saw 12 years))
and more? (I'm sure we could leverage Comby and such tools for more clever such and replace)

TLDR;

I want to refactor a Python code base: I sweat, I look for the latest tools (if they are compatible), I augment my test coverage, I triple check and deploy to a partner client and I fix issues in production anyways.

I want to refactor a Common Lisp project: just do it multiple times a day.

more feedback here https://www.reddit.com/r/lisp/comments/1ib08ci/on_refactoring_lisp_pros_and_cons/ and in the other linked threads.

Common Lisp HTML templates: using Djula in .lisp files

vindarel — Thu, 02 Jan 2025 20:54:22 +0000

;;;
;;; How to use Djula templates in-file, without separate file templates.
;;;
;;; This can make it easier to ship your app as a single binary.
;;; Otherwise, see
;;; https://lisp-journey.gitlab.io/blog/lisp-for-the-web-build-standalone-binaries-foreign-libraries-templates-static-assets/#embed-html-djula-templates-in-your-binary
;;;
;;; We use two Djula functions:
;;; - compile-string
;;; - render-template*
;;;
;;;

#++
(ql:quickload '("djula" "pythonic-string-reader"))

(pythonic-string-reader:enable-pythonic-string-syntax)

(defparameter *template-hello* """
{% if foo %}
 foo is true
{% else %}
 foo is false
{% endif %}
""")

(defun render (s &rest keys)
  (apply
   #'djula:render-template*
   (djula:compile-string s)
   nil
   ;; key arguments:
   keys
   ))

#++
(render *template-hello* :foo t)
;; =>
" foo is true "

Advent of Code: alexandria's map-permutations was perfect for day 08. Common Lisp tip.

vindarel — Mon, 09 Dec 2024 17:57:20 +0000

As the title says. Did you know about alexandria:map-permutations ?

If not, you could have discovered it with (apropos "permutation"). Run this on the REPL, it returns you all results it knows of symbols that have it in their name. You can also try apropos-regex from cl-ppcre. It's best to run them when you have loaded a few utility packages, like Alexandria or Serapeum. I run them when I loaded CIEL, so they are here, plus a few more.

Look at the Alexandria functions on sequences here:

https://alexandria.common-lisp.dev/draft/alexandria.html#Sequences

map-permutations:

Calls function with each permutation of length constructable from
the subsequence of sequence delimited by start and end. start
defaults to 0, end to length of the sequence, and length to the
length of the delimited subsequence.

If you call it on a large input, it won't return an insanely large list of permutations. We can work on them one after the other. You can also pass :copy nil to it, in which case "all combinations are eq to each other", so I suppose the function re-uses a structure, and it is advised to not modify the permutation.

Examples:

(alexandria:map-permutations (lambda (it) (print it)) '(a b))
;; or just
(alexandria:map-permutations #'print '(a b))

(A B)
(B A)


(alexandria:map-permutations (lambda (it) (print it)) '(a b c))

(A B C)
(B A C)
(C A B)
(A C B)
(B C A)
(C B A)

ask for permutations of length 2:

(alexandria:map-permutations (lambda (it) (print it)) '(a b c) :length 2)

(A B)
(B A)
(A C)
(C A)
(B C)
(C B)

There is also map-combinations, this one considers (a b) and (b a) to be the same combination:

(alexandria:map-combinations (lambda (it) (print it)) '(a b c) :length 2)

(A B)
(A C)
(B C)

I solved Advent of Code's day 08 with this. This year I learned ✓

AOC 2024
Learn lisp efficiently! Common Lisp videos 8+ hours of content in code-driven examples. Thanks <3

FTP and SFTP clients for Common Lisp

vindarel — Sat, 28 Sep 2024 14:48:00 +0000

You thought all companies would provide well-documented web APIs today? Well, some use a blank .docx and (S)FTP.

For Common Lisp, cl-ftp is one of those libraries that look unmaintained and undocumented, but it works very well, and it is short enough to quickly grab how to use it. It's quite well thought-out, even. It is a pure Lisp library, no system dependencies required.

For example you can do this to send a file:

(ftp:with-ftp-connection (conn :hostname hostname
                                   :username (find-ftp-username)
                                   :password password
                                   :passive-ftp-p t)
      (ftp:store-file conn local-filename filename))

You'll have to look at this for more commands: https://github.com/pinterface/cl-ftp/blob/master/simple-client.lisp

we have ftp-shell, ftp-put, ftp-list, ftp-get, ftp-pwd, and etc for ls, help, cd, dir.

For SFTP, we must find another means. I didn't find a pure CL library, and it is annoyingly not straightforward to run a SFTP command with a password on the command line. Some solutions exist and I chose lftp. It is included in Debian.

We can run:

lftp sftp://user:password@host  -e "put local-file.name; bye"

or better, with the password in an environment variable:

export LFTP_PASSWORD="just_an_example"
lftp --env-password sftp://user@host  -e "put local-file.name; bye"

In my scripts I need to handle a connection profile, and even several ones for development, so I ended up with code that I replicate from project to project, hence a new utility:

https://github.com/vindarel/lftp-wrapper

Now do:

CL-USER> (use-package :lftp-wrapper)  ;; optional, or:
CL-USER> (uiop:add-package-local-nickname :lftp :lftp-wrapper)

CL-USER> (defvar profile (make-profile-from-plist (uiop:read-file-form "CREDS.lisp-expr"))
#<PROFILE protocol: "sftp", login: "user", port: 10022, server: "prod.com", password? T>

CL-USER> (defvar command (put :cd "I/" :local-filename "data.csv"))
#<PUT cd: "I/", filename: "data.csv" {1007153883}>

CL-USER> (run profile command)
…
success!

We created a profile from credentials on file and from environment variables, we created a command object, and we executed the command for the profile.

We could wrap many more features from lftp. But I follow needs-driven development. So far, it works and it sends my files.