Lisp

• Pragmatic Parsing in Common Lisp - ACM Lisp Pointers 4, 2 (Apr/Jun 1991), 3-15.

• CLiki: Case sensitivity

  The common misconception is that Common Lisp is case insensitive. This is not true - symbols in Common Lisp are case sensitive.

  By default, the Common Lisp reader is case-converting: all unescaped characters in a symbol name get upper-cased. This gives the practical effect of making it seem as though symbol case doesn't matter. This is desirable behavior for interfacing with other case-insensitive languages (such as Fortran), but a pain to interface with case-sensitive ones (such as C).

  Luckily the behavior of the reader can be customized via readtable-case.

  The one that might seem to be most useful for having case-sensitive symbols at first glance is :preserve, however remember that all code read in with the default setting (:upcase) is in upper-case, as are all the standard Common Lisp symbols (this is defined by the standard), so this means you will need to spell out all CL and external symbols IN ALL UPPERCASE. To make this less annoying, the :invert readtable-case is the most practical: all-lowercase symbol names become uppercase, all-uppercase become lowercase, and mixed-case stays mixed-case (the important part for case sensitivity). The Lisp printer outputs symbol names correctly this way by default. The only problem now becomes inconsistent spelling of a symbol in all lowercase or all uppercase in old code that expects case conversion. But otherwise you can get case sensitivity for your software by setting readtable-case to :invert today.

• [2025-08-17 Sun] - the CL condition still baffles me - it is deeply expressive but I find it difficult to use. This might just be because there's nothing nearly as capable in other langs I've used.
• serious-condition implies the need for user input, signaled with error instead of signal or warn.
• CLHS style recommendations CLHS: Section 9.1.3.1
  • uppercase first letter, use complete sentences and correct punctuation.
  • don't prefix the message with things like 'Error: ' or even a newline. That's the job of the condition reporter
  • it is permissible to embed newlines in messages (just not before or after)
  • Avoid use of the #\Tab character
  • Don't mention the containing function. That's the job of the debugger

• quick tip for reader macros - don't forget importance of the . syntactic sugar

  '(foo . #.(list 1 2 3))
  

  FOO

  1

  2

  3

  (let ((a (list 1 2 3)))
    (equalp
     `(0 . ,a)
     ;; OR
     `(0 ,@a)))
  

  T
  

(let ((list-fmt "~@{~a ~^~}"))
  (format nil list-fmt) ;; ""
  (format nil list-fmt 1 2 3))

1 2 3 

• Note that the extension mechanism (~/foo/) is clunky - the character / isn't allowed in the function designator.
• The core includes an annotation system (WIP [2026-01-05 Mon])
  • annotations are similar to format directives, just with a different prefix character - usually % (emacs style).
  • annotations are expanded as early as possible into a FORMAT control-string

• 5.2.1. Named Functions

Most of the so-called iteration control clauses start with the loop keyword for, or its synonym as,2 followed by the name of a variable. What follows after the variable name depends on the type of for clause.

The subclauses of a for clause can iterate over the following:

,* Ranges of numbers, up or down, by specified intervals ,* The individual items of a list ,* The cons cells that make up a list ,* The elements of a vector, including subtypes such as strings and bit vectors ,* The pairs of a hash table ,* The symbols in a package ,* The results of repeatedly evaluating a given form

A single loop can have multiple for clauses with each clause naming its own variable. When a loop has multiple for clauses, the loop terminates as soon as any for clause reaches its end condition. For instance, the following loop:

(loop for item in list for i from 1 to 10 do (something))

will iterate at most ten times but may stop sooner if list contains fewer than ten items.

The Parts of a LOOP

You can do the following in a LOOP:

,* Step variables numerically and over various data structures ,* Collect, count, sum, minimize, and maximize values seen while looping ,* Execute arbitrary Lisp expressions ,* Decide when to terminate the loop ,* Conditionally do any of these

Additionally, LOOP provides syntax for the following:

,* Creating local variables for use within the loop ,* Specifying arbitrary Lisp expressions to run before and after the loop proper

The basic structure of a LOOP is a set of clauses, each of which begins with a loop keyword.1 How each clause is parsed by the LOOP macro depends on the keyword. Some of the main keywords, which you saw in Chapter 7, are for, collecting, summing, counting, do, and finally.

Iterating over a hash table or package is slightly more complicated because hash tables and packages have different sets of values you might want to iterate over–the keys or values in a hash table and the different kinds of symbols in a package. Both kinds of iteration follow the same pattern. The basic pattern looks like this:

(loop for var being the things in hash-or-package …)

For hash tables, the possible values for things are hash-keys and hash-values, which cause var to be bound to successive values of either the keys or the values of the hash table. The hash-or-package form is evaluated once to produce a value, which must be a hash table.

To iterate over a package, things can be symbols, present-symbols, and external-symbols, which cause var to be bound to each of the symbols accessible in a package, each of the symbols present in a package (in other words, interned or imported into that package), or each of the symbols that have been exported from the package. The hash-or-package form is evaluated to produce the name of a package, which is looked up as if by FIND-PACKAGE or a package object. Synonyms are also available for parts of the for clause. In place of the, you can use each; you can use of instead of in; and you can write the things in the singular (for example, hash-key or symbol).

Finally, since you'll often want both the keys and the values when iterating over a hash table, the hash table clauses support a using subclause at the end of the hash table clause.

(loop for k being the hash-keys in h using (hash-value v) …) (loop for v being the hash-values in h using (hash-key k) …)

Both of these loops will bind k to each key in the hash table and v to the corresponding value. Note that the first element of the using subclause must be in the singular form.4

If none of the other for clauses supports exactly the form of variable stepping you need, you can take complete control over stepping with an equals-then clause. This clause is similar to the binding clauses in a DO loop but cast in a more Algolish syntax. The template is as follows:

(loop for var = initial-value-form [ then step-form ] …)

As usual, var is the name of the variable to be stepped. Its initial value is obtained by evaluating initial-value-form once before the first iteration. In each subsequent iteration, step-form is evaluated, and its value becomes the new value of var. With no then part to the clause, the initial-value-form is reevaluated on each iteration to provide the new value. Note that this is different from a DO binding clause with no step form.

The step-form can refer to other loop variables, including variables created by other for clauses later in the loop. For instance:

(loop repeat 5 for x = 0 then y for y = 1 then (+ x y) collect y) ==> (1 2 4 8 16)

However, note that each for clause is evaluated separately in the order it appears. So in the previous loop, on the second iteration x is set to the value of y before y changes (in other words, 1). But y is then set to the sum of its old value (still 1) and the new value of x. If the order of the for clauses is reversed, the results change.

(loop repeat 5 for y = 1 then (+ x y) for x = 0 then y collect y) ==> (1 1 2 4 8)

Often, however, you'll want the step forms for multiple variables to be evaluated before any of the variables is given its new value (similar to how DO steps its variables). In that case, you can join multiple for clauses by replacing all but the first for with and. You saw this formulation already in the LOOP version of the Fibonacci computation in Chapter 7. Here's another variant, based on the two previous examples:

(loop repeat 5 for x = 0 then y and y = 1 then (+ x y) collect y) ==> (1 1 2 3 5)

• The possible verbs are collect, append, nconc, count, sum, maximize, and minimize. Also available as synonyms are the present participle forms: collecting, appending, nconcing, counting, summing, maximizing, and minimizing.
• As an extra bit of syntactic sugar, within the first loop clause, after the test form, you can use the variable it to refer to the value returned by the test form. For instance, the following loop collects the non-NIL values found in some-hash when looking up the keys in some-list: (loop for key in some-list when (gethash key some-hash) collect it)

Systems are not part of the ANSI CL spec. They are classes defined by the ASDF package.

A system is a collection of Lisp files that together constitute an application or a library, and that should therefore be managed as a whole. A system definition describes which source files make up the system, what the dependencies among them are, and the order they should be compiled and loaded in.

– Defining Systems

• There are some other adhoc solutions out there but nothing that caught steam. If you want to work with the rest of the CL ecosystem you basically need to use ASDF.

• CLHS: Function SHADOW
• :intern
  The symbols named by the argument symbol-names are found or created in the package being defined. The :intern option interacts with the :use option, since inherited symbols can be used rather than new ones created.

It is recommended that the entire package definition is put in a single place, and that all the package definitions of a program are in a single file. This file can be loaded before loading or compiling anything else that depends on those packages. Such a file can be read in the COMMON-LISP-USER package, avoiding any initial state issues.

• SBCL supports some additions to defpackage (:lock and :implement) - uiop and our own defpkg supports even more (:recycle, etc)
• SBCL Package Locks

• :implement
  

  Each package has a list of associated implementation packages. A locked package, and the symbols whose home package it is, can be modified without violating package locks only when *package* is bound to one of the implementation packages of the locked package.

  Unless explicitly altered by defpackage, sb-ext:add-implementation-package, or sb-ext:remove-implementation-package each package is its own (only) implementation package.

• Package-local nicknames
  • Package-local nicknames in Common Lisp - a semishitpost about PLNs by phoe

• Quicklisp is the defacto standard
• ASDF compatibility is assumed
• Package and System namespace separation is a problem

• Andersen, Chang, and Felleisen (2017) from the PLT guys at NEU - Racket

• Compiler Tower (Guile Reference Manual)

A Unix shell embedded in scheme

• scsh.net

Declarative package configuration for Emacs.

• single macro
• NOT a package manager
• isolates package configuration and loading
• use-package#Keyword extensions

(require 'widget)

(eval-when-compile
  (require 'wid-edit))

(defvar widget-example-repeat)

(defun widget-example ()
  "Create the widgets from the Widget manual."
  (interactive)
  (switch-to-buffer "*Widget Example*")
  (kill-all-local-variables)
  (make-local-variable 'widget-example-repeat)
  (let ((inhibit-read-only t))
    (erase-buffer))
  (remove-overlays)
  (widget-insert "Here is some documentation.\n\n")
  (widget-create 'editable-field
         :size 13
         :format "Name: %v " ; Text after the field!
         "My Name")
  (widget-create 'menu-choice
         :tag "Choose"
         :value "This"
         :help-echo "Choose me, please!"
         :notify (lambda (widget &rest ignore)
               (message "%s is a good choice!"
                    (widget-value widget)))
         '(item :tag "This option" :value "This")
         '(choice-item "That option")
         '(editable-field :menu-tag "No option" "Thus option"))
  (widget-create 'editable-field
         :format "Address: %v"
         "Some Place\nIn some City\nSome country.")
  (widget-insert "\nSee also ")
  (widget-create 'link
         :notify (lambda (&rest ignore)
               (widget-value-set widget-example-repeat
                         '("En" "To" "Tre"))
               (widget-setup))
         "other work")
  (widget-insert
   " for more information.\n\nNumbers: count to three below\n")
  (setq widget-example-repeat
    (widget-create 'editable-list
               :entry-format "%i %d %v"
               :notify
               (lambda (widget &rest ignore)
             (let ((old (widget-get widget
                        ':example-length))
                   (new (length (widget-value widget))))
               (unless (eq old new)
                 (widget-put widget ':example-length new)
                 (message "You can count to %d." new))))
               :value '("One" "Eh, two?" "Five!")
               '(editable-field :value "three")))
  (widget-insert "\n\nSelect multiple:\n\n")
  (widget-create 'checkbox t)
  (widget-insert " This\n")
  (widget-create 'checkbox nil)
  (widget-insert " That\n")
  (widget-create 'checkbox
         :notify (lambda (&rest ignore) (message "Tickle"))
         t)
  (widget-insert " Thus\n\nSelect one:\n\n")
  (widget-create 'radio-button-choice
         :value "One"
         :notify (lambda (widget &rest ignore)
               (message "You selected %s"
                    (widget-value widget)))
         '(item "One") '(item "Another One.")
         '(item "A Final One."))
  (widget-insert "\n")
  (widget-create 'push-button
         :notify (lambda (&rest ignore)
               (if (= (length
                   (widget-value widget-example-repeat))
                  3)
                   (message "Congratulation!")
                 (error "Three was the count!")))
         "Apply Form")
  (widget-insert " ")
  (widget-create 'push-button
         :notify (lambda (&rest ignore)
               (widget-example))
         "Reset Form")
  (widget-insert "\n")
  (use-local-map widget-keymap)
  (widget-setup))

widget-example

Emacs can display text in several different styles, called faces. Each face can specify various face attributes, such as the font, height, weight, slant, foreground and background color, and underlining or overlining. Most major modes assign faces to the text automatically, via Font Lock mode.

(describe-function 'list-faces-display)

list-faces-display is an interactive native-comp-function in
‘faces.el’.

It is bound to C-<down-mouse-2> <df>.
It can also be invoked from the menu: Edit → Text Properties.

(list-faces-display &optional REGEXP)

Inferred type: (function (&optional t) boolean)

List all faces, using the same sample text in each.
The sample text is a string that comes from the variable
‘list-faces-sample-text’.

If REGEXP is non-nil, list only those faces with names matching
this regular expression.  When called interactively with a prefix
argument, prompt for a regular expression using ‘read-regexp’.

  Probably introduced at or before Emacs version 19.17.

A “face” is a collection of graphical attributes for displaying text: font, foreground color, background color, optional underlining, etc. Faces control how Emacs displays text in buffers, as well as other parts of the frame such as the mode line.

• Emacs Auto-Insert Text in New Files
• autoinsert
• hippie expand usually replaces dabbrev-expand
  • hippie-expand-try-function-list
• executable-insert / executable-set-magic
• abbrevs
• dabbrevs
  • dynamic abbrevs - write a few chars and expand something you wrote earlier
• tempo

• skeleton

  (describe-function 'skeleton-insert)
  

  skeleton-insert is an autoloaded native-comp-function in
  ‘skeleton.el’.
  
  (skeleton-insert SKELETON &optional REGIONS STR)
  
  Insert the complex statement skeleton SKELETON describes very concisely.
  
  With optional second argument REGIONS, wrap first interesting point
  (‘_’) in skeleton around next REGIONS words, if REGIONS is positive.
  If REGIONS is negative, wrap REGIONS preceding interregions into first
  REGIONS interesting positions (successive ‘_’s) in skeleton.
  
  An interregion is the stretch of text between two contiguous marked
  points.  If you marked A B C [] (where [] is the cursor) in
  alphabetical order, the 3 interregions are simply the last 3 regions.
  But if you marked B A [] C, the interregions are B-A, A-[], []-C.
  
  The optional third argument STR, if specified, is the value for the
  variable ‘str’ within the skeleton.  When this is non-nil, the
  interactor gets ignored, and this should be a valid skeleton element.
  
  When done with skeleton, but before going back to ‘_’-point, add
  a newline (unless ‘skeleton-end-newline’ is nil or ‘_’-point is at end
  of line), and run the hook ‘skeleton-end-hook’.
  
  SKELETON is made up as (INTERACTOR ELEMENT ...).  INTERACTOR may be nil if
  not needed, a prompt-string or an expression for complex read functions.
  
  If ELEMENT is a string or a character it gets inserted (see also
  ‘skeleton-transformation-function’).  Other possibilities are:
  
          \n	go to next line and indent according to mode, unless
                  this is the first/last element of a skeleton and point
                  is at bol/eol
          _	interesting point, interregion here
          -	interesting point, no interregion interaction, overrides
                  interesting point set by _
          >	indent line (or interregion if > _) according to major mode
          @	add position to ‘skeleton-positions’
          &	do next ELEMENT if previous moved point
          |	do next ELEMENT if previous didn’t move point
          -NUM	delete NUM preceding characters (see ‘skeleton-untabify’)
          resume:	skipped, continue here if quit is signaled
          nil	skipped
  
  After termination, point will be positioned at the last occurrence of -
  or at the first occurrence of _ or at the end of the inserted text.
  
  Note that \n as the last element of the skeleton only inserts a
  newline if not at eol.  If you want to unconditionally insert a newline
  at the end of the skeleton, use "\n" instead.  Likewise with \n
  as the first element when at bol.
  
  Further elements can be defined via ‘skeleton-further-elements’.
  ELEMENT may itself be a SKELETON with an INTERACTOR.  The user is prompted
  repeatedly for different inputs.  The SKELETON is processed as often as
  the user enters a non-empty string.  C-g terminates skeleton insertion, but
  continues after ‘resume:’ and positions at ‘_’ if any.  If INTERACTOR in
  such a subskeleton is a prompt-string which contains a ".. %s .." it is
  formatted with ‘skeleton-subprompt’.  Such an INTERACTOR may also be a list
  of strings with the subskeleton being repeated once for each string.
  
  Quoted Lisp expressions are evaluated for their side-effects.
  Other Lisp expressions are evaluated and the value treated as above.
  Note that expressions may not return t since this implies an
  endless loop.  Modes can define other symbols by locally setting them
  to any valid skeleton element.  The following local variables are
  available:
  
          str	first time: read a string according to INTERACTOR
                  then: insert previously read string once more
          help	help-form during interaction with the user or nil
          input	initial input (string or cons with index) while reading str
          v1, v2	local variables for memorizing anything you want
  
    Probably introduced at or before Emacs version 22.1.
  
  

  (define-skeleton local-variables-section
   "Insert a local variables section.  Use current comment syntax if any."
   (completing-read "Mode: " obarray
         (lambda (symbol)
           (if (commandp symbol)
           (string-match "-mode$" (symbol-name symbol))))
         t)
   '(save-excursion
      (if (re-search-forward page-delimiter nil t)
    (error "Not on last page")))
   comment-start "Local Variables:" comment-end \n
   comment-start "mode: " str
   & -5 | '(kill-line 0) & -1 | comment-end \n
   ( (completing-read (format "Variable, %s: " skeleton-subprompt)
           obarray
           (lambda (symbol)
             (or (eq symbol 'eval)
             (custom-variable-p symbol)))
           t)
     comment-start str ": "
     (read-from-minibuffer "Expression: " nil read-expression-map nil
            'read-expression-history) | _
     comment-end \n)
   resume:
   comment-start "End:" comment-end \n)
  

• History of Lisp

  The project of defining M-expressions precisely and compiling them or at least translating them into S-expressions was neither finalized nor explicitly abandoned. It just receded into the indefinite future, and a new generation of programmers appeared who preferred internal notation to any FORTRAN-like or ALGOL-like notation that could be devised.