(The code on this page is intended to be illustrative and informative, not rigorous or performant.)

⚓ Thin wrappers » typep

Please see enhanced-typep for a much better approach.

(arrayp object)

(typep object 'array)

(atom object)

(typep object 'atom)

(function only)

(bit-vector-p object)

(typep object 'bit-vector)

(characterp object)

(typep object 'character)

(compiled-function-p object)

(typep object 'compiled-function)

(complexp object)

(typep object 'complex)

(consp object)

(typep object 'cons)

(floatp object)

(typep object 'float)

(functionp object)

(typep object 'function)

(hash-table-p object)

(typep object 'hash-table)

(integerp object)

(typep object 'integer)

(keywordp object)

(typep object 'keyword)

(listp object)

(typep object 'list)

(null object)

(typep object 'null)

(function only)

(numberp object)

(typep object 'number)

(packagep object)

(typep object 'package)

(pathnamep object)

(typep object 'pathname)

(rationalp object)

(typep object 'rational)

(readtablep object)

(typep object 'readtable)

(realp object)

(typep object 'real)

(simple-bit-vector-p object)

(typep object 'simple-bit-vector)

(simple-string-p object)

(typep object 'simple-string)

(simple-vector-p object)

(typep object 'simple-vector)

(standard-char-p object)

(typep (the character character) 'standard-char)

(streamp object)

(typep object 'stream)

(stringp object)

(typep object 'string)

(symbolp object)

(typep object 'symbol)

(vectorp object)

(typep object 'vector)

⚓ Thin wrappers » Conses

⚓ Thin wrappers » Conses » nth

(first list)

(nth 0 list)

(second list)

(nth 1 list)

(third list)

(nth 2 list)

(fourth list)

(nth 3 list)

(fifth list)

(nth 4 list)

(sixth list)

(nth 5 list)

(seventh list)

(nth 6 list)

(eighth list)

(nth 7 list)

(ninth list)

(nth 8 list)

(tenth list)

(nth 9 list)

⚓ Thin wrappers » Conses » car and cdr

(caar list)

(car (car list))

(cadr list)

(car (cdr list))

(caaar list)

(car (car (car list)))

(caadr list)

(car (car (cdr list)))

(cadar list)

(car (cdr (car list)))

(caddr list)

(car (cdr (cdr list)))

(caaaar list)

(car (car (car (car list))))

(caaadr list)

(car (car (car (cdr list))))

(caadar list)

(car (car (cdr (car list))))

(caaddr list)

(car (car (cdr (cdr list))))

(cadaar list)

(car (cdr (car (car list))))

(cadadr list)

(car (cdr (car (cdr list))))

(caddar list)

(car (cdr (cdr (car list))))

(cadddr list)

(car (cdr (cdr (cdr list))))

(cdar list)

(cdr (car list))

(cddr list)

(cdr (cdr list))

(cdaar list)

(cdr (car (car list)))

(cdadr list)

(cdr (car (cdr list)))

(cddar list)

(cdr (cdr (car list)))

(cdddr list)

(cdr (cdr (cdr list)))

(cdaaar list)

(cdr (car (car (car list))))

(cdaadr list)

(cdr (car (car (cdr list))))

(cdadar list)

(cdr (car (cdr (car list))))

(cdaddr list)

(cdr (car (cdr (cdr list))))

(cddaar list)

(cdr (cdr (car (car list))))

(cddadr list)

(cdr (cdr (car (cdr list))))

(cdddar list)

(cdr (cdr (cdr (car list))))

(cddddr list)

(cdr (cdr (cdr (cdr list))))

⚓ Thin wrappers » Conses » Misc

(butlast list n)

(ldiff list (last list n))

(unless list is a dotted list and n is 0)

(acons key datum alist)

(cons (cons key datum) alist)

(getf plist indicator default)

(multiple-value-bind (ignored value tail)
    (get-properties plist (list indicator))
  (if tail value default))

(remprop x y)

(remf (symbol-plist x) y)

(set symbol value)

(setf (symbol-value symbol) value)

(nth n list)

(car (nthcdr n list))

(nreconc list tail)

(nconc (nreverse list) tail)

(revappend list tail)

(nconc (reverse list) tail)

(push item place)

(setf place (cons item place))

(basically)

(pushnew item place)

(setf place (adjoin item place))

(basically)

(pop place)

(prog1 (car place)
  (setf place (cdr place)))

(basically)

(member 2 '(1 2 3))

(member-if (lambda (element)
             (eql element 2))
           '(1 2 3))

(member-if-not #'numberp '(1 "two" 3))

(member-if (complement #'numberp) '(1 "two" 3))

(assoc 2 '((1 . "one") (2 . "two") (3 . "three")))

(find-if (lambda (entry)
           (and entry
                (eql (car entry) 2)))
         '((1 . "one") (2 . "two") (3 . "three")))

(rassoc "two" '((1 . "one") (2 . "two") (3 . "three"))
        :test #'string=)

(rassoc-if (lambda (value)
             (string= value "two"))
           '((1 . "one") (2 . "two") (3 . "three")))

(rassoc-if-not #'characterp
               '((1 . "one") (2 . "two") (3 . "three")))

(rassoc-if (complement #'characterp)
           '((1 . "one") (2 . "two") (3 . "three")))

subst

TODO

nsubst

TODO

subst-if-not

TODO

nsubst-if-not

TODO

⚓ Thin wrappers » Sequences

count

TODO

count-if-not

TODO

find

TODO

find-if-not

TODO

position

TODO

position-if-not

TODO

remove

TODO

remove-if-not

TODO

delete

TODO

delete-if-not

TODO

substitute

TODO

substitute-if-not

TODO

nsubstitute

TODO

nsubstitute-if-not

TODO

(copy-seq sequence)

(subseq sequence 0)

(fill sequence item)

(nsubstitute-if item (constantly t) sequence)

(vector (foo) (bar) (baz))

(make-array 3 :initial-contents (list (foo) (bar) (baz)))

⚓ Thin wrappers » Conditionals

(when condition
  (foo)
  (bar))

(if condition
    (progn
      (foo)
      (bar))
    nil)

(unless condition
  (foo)
  (bar))

(when (not condition)
  (foo)
  (bar))

(cond
  (condition-1 (foo) (bar))
  (condition-2 (baz) (quux)))

(if condition-1
    (progn (foo) (bar))
    (if condition-2
        (progn (baz) (quux))
        nil))

(and (foo) (bar) (baz))

(let ((var1 (foo)))
  (when var1
    (let ((var2 (bar)))
      (when var2
        (baz)))))

(or (foo) (bar) (baz))

(let ((var1 (foo)))
  (if var1
      var1
      (let ((var2 (bar)))
        (if var2
            var2
            (baz)))))

(case (foo)
  (key1
   (bar)
   (baz))
  ((key2 key3)
   (quux)))

(let ((key (foo)))
  (cond
    ((eql key 'key1)
     (bar)
     (baz))
    ((member key '(key2 key3))
     (quux))))

(ccase (foo)
  (key1
   (bar)
   (baz))
  ((key2 key3)
   (quux)))

TODO

(ecase (foo)
  (key1
   (bar)
   (baz))
  ((key2 key3)
   (quux)))

(let ((key (foo)))
  (case key
    (key1
     (bar)
     (baz))
    ((key2 key3)
     (quux))
    (t
     (error 'type-error
            :datum key
            :expected-type '(member key1 key2 key3)))))

(typecase (foo)
  (type1
   (bar)
   (baz))
  (type2
   (quux)))

(let ((key (foo)))
  (cond
    ((typep key 'type1)
     (bar)
     (baz))
    ((typep key 'type2)
     (quux))))

(ctypecase (foo)
  (type1
   (bar)
   (baz))
  (type2
   (quux)))

TODO

(etypecase (foo)
  (type1
   (bar)
   (baz))
  (type2
   (quux)))

(typecase (foo)
  (type1
   (bar)
   (baz))
  (type2
   (quux))
  (t
   (error 'type-error
          :datum key
          :expected-type '(or type1 type2))))

(not generalized-boolean)

(if generalized-boolean nil t)

handler-case

TODO

restart-case

TODO

⚓ Thin wrappers » Streams

(with-open-file (stream filename)
  (write-line (read-line stream)))

(with-open-stream (stream (open filename))
  (write-line (read-line stream)))

(with-open-stream (stream (make-string-input-stream "foo bar"))
  (values (read stream) (read stream)))

(let ((stream (make-string-input-stream "foo bar")))
  (unwind-protect (values (read stream) (read stream))
    (close stream)))

(read-from-string "(1 2)")

(let (index)
  (values (with-input-from-string (stream "(1 2)" :index index)
            (read stream))
          index))

(write-string foo stream)

(write-sequence (the string foo) stream)

(write-line "foo")

(prog1 (write-string "foo") (terpri))

(with-input-from-string (stream "foobar" :start 0 :end 3)
  (read-line stream))

(with-open-stream (stream (make-string-input-stream "foobar" 0 3))
  (read-line stream))

(with-output-to-string (stream)
  (princ "foo" stream))

(with-open-stream (stream (make-string-output-stream))
  (princ "foo" stream)
  (get-output-stream-string stream))

(write-to-string object)

(with-output-to-string (stream)
  (write object :stream stream))

(prin1-to-string object)

(with-output-to-string (stream)
  (prin1 object stream))

(princ-to-string object)

(with-output-to-string (stream)
  (princ object stream))

(pprint "foo")

(progn
  (terpri)
  (write "foo" :escape t :pretty t)
  (values))

(prin1 "foo")

(write "foo" :escape t)

(print "foo")

(let ((object "foo"))
  (terpri)
  (prin1 object)
  (write-char #\Space)
  object)

(princ "foo")

(write "foo" :escape nil :readably nil)

(terpri)

(write-char #\Newline)

⚓ Thin wrappers » Accessor-specializing

(bit bit-array i j k)

(aref (the (array bit) bit-array) i j k)

(sbit bit-array i j k)

(aref (the (simple-array bit) bit-array) i j k)

(char string index)

(aref (the string string) index)

(schar simple-string 0)

(aref (the simple-string simple-string) 0)

(svref simple-vector 0)

(aref (the simple-vector simple-vector) 0)

⚓ Thin wrappers » Math

(1+ number)

(+ number 1)

(1- number)

(- number 1)

(incf place 42)

(setf place (+ place 42))

(basically)

(decf place 42)

(setf place (- place 42))

(basically)

(evenp integer)

(if (integerp integer)
    (zerop (mod integer 2))
    (error 'type-error
           :datum integer
           :expected-type 'integer))

(oddp integer)

(not (evenp integer))

(logbitp k n)

(ldb-test (byte 1 k) n)

(logtest x y)

(not (zerop (logand x y)))

(mask-field bytespec integer)

(logand integer (dpb -1 bytespec 0))

(signum number)

(if (zerop number)
    number
    (/ number (abs number)))

(minusp real)

(< real 0)

(zerop number)

(= number 0)

(plusp real)

(> real 0)

(phase number)

(atan (imagpart number)
      (realpart number))

⚓ Thin wrappers » Conditions and restarts

warn

TODO

error

TODO

(function only)

cerror

TODO

abort

(invoke-restart 'abort)

(function only)

continue

(let ((restart (find-restart 'continue)))
  (when restart
    (invoke-restart restart)))

(function only)

muffle-warning

(invoke-restart 'muffle-warning)

(function only)

use-value

TODO

store-value

TODO

ignore-errors

TODO

with-simple-restart

TODO

⚓ Thin wrappers » Misc

(apply function :foo bar keys)

(apply function (list* :foo bar keys))

(tip)

(typep foo '(cons (eql symbol)))

(and (consp foo)
     (eq (car foo) 'symbol))

(tip)

(alphanumericp character)

(or (alpha-char-p character)
    (not (null (digit-char-p character))))

(array-dimension array dimension)

(nth dimension (array-dimensions array))

(except dimension must be less than the rank of array)

(array-rank array)

(length (array-dimensions array))

(array-total-size array)

(reduce #'* (array-dimensions array))

(char= char1 char2)

(= (char-int char1) (char-int char2))

(character object)

(coerce object 'character)

(constantly t)

(lambda (&rest args)
  (declare (ignore args))
  t)

(copy-symbol symbol)

(make-symbol (symbol-name symbol))

(declaim (optimize safety))

(eval-when (:compile-toplevel :load-toplevel :execute)
  (proclaim '(optimize safety)))

defgeneric

TODO

(mostly)

(defparameter *var* value)

(progn
  (declaim (special *var*))
  (setf (symbol-value '*var*) value)
  '*var*)

(mostly?)

(defvar *var* value)

(progn
  (declaim (special *var*))
  (unless (boundp '*var*)
    (setf (symbol-value '*var*) value))
  '*var*)

(mostly?)

(defun my-function ())

(setf (fdefinition 'my-function) (lambda ()))

(mostly)

(find-all-symbols "SYMBOL")

(delete-duplicates
 (mapcan (lambda (package)
           (let ((found (find-symbol "SYMBOL" package)))
             (when found
               (list found))))
         (list-all-packages)))

(funcall function (foo) (bar) (baz))

(apply function (list (foo) (bar) (baz)))

(get-decoded-time)

(decode-universal-time (get-universal-time))

(in-package #:foo)

(eval-when (:compile-toplevel :load-toplevel :execute)
  (let ((package (find-package '#:foo)))
    (if package
        (setf *package* package)
        (error [...]))))

(integer-length integer)

(ceiling (log (if (minusp integer)
                  (- integer)
                  (1+ integer))
              2))

(lambda ())

#'(lambda ())

(multiple-value-list form)

(multiple-value-call #'list form)

prog

TODO

(prog1 (foo)
  (bar))

(let ((value (foo)))
  (bar)
  value)

(prog2 (foo) (bar)
  (baz))

(progn
  (foo)
  (let ((value (bar)))
    (baz)
    value))

(return (foo))

(return-from nil (foo))

(values-list list)

(apply #'values list)

with-accessors

TODO

with-slots

TODO