;; Common-Lisp, The King. The Don. The Big Cheese.
(defvar common-lisp-built-in-functions
  '("*" "+" "-" "/" "/=" "1+" "1-" "<" "<=" "=" ">" ">=" "abort" "abs" "acons" "acos" "acosh"
    "add-method" "adjoin" "adjust-array" "adjustable-array-p" "allocate-instance"
    "alpha-char-p" "alphanumericp" "and" "append" "apply" "apropos" "apropos-list" "aref"
    "arithmetic-error-operands" "arithmetic-error-operation" "array-dimension"
    "array-dimensions" "array-displacement" "array-element-type"
    "array-has-fill-pointer-p" "array-in-bounds-p" "array-rank"
    "array-row-major-index" "array-total-size" "arrayp" "ash" "asin" "asinh" "assert"
    "assoc" "assoc-if" "assoc-if-not" "atan" "atanh" "atom" "bit" "bit-and" "bit-andc1"
    "bit-andc2" "bit-eqv" "bit-ior" "bit-nand" "bit-nor" "bit-not" "bit-orc1" "bit-orc2"
    "bit-vector-p" "bit-xor" "block" "boole" "both-case-p" "boundp" "break"
    "broadcast-stream-streams" "butlast" "byte" "byte-position" "byte-size" "caaaar"
    "caaadr" "caaar" "caadar" "caaddr" "caadr" "caar" "cadaar" "cadadr" "cadar" "caddar"
    "cadddr" "caddr" "cadr" "call-method" "car" "case" "catch" "ccase" "cdaaar" "cdaadr"
    "cdaar" "cdadar" "cdaddr" "cdadr" "cdar" "cddaar" "cddadr" "cddar" "cdddar" "cddddr"
    "cdddr" "cddr" "cdr" "ceiling" "cell-error-name" "cerror" "change-class" "char"
    "char-code" "char-downcase" "char-equal" "char-greaterp" "char-int" "char-lessp"
    "char-name" "char-not-equal" "char-not-greaterp" "char-not-lessp" "char-upcase"
    "char/=" "char<" "char<=" "char=" "char>" "char>=" "character" "characterp"
    "check-type" "cis" "class-name" "class-of" "clear-input" "clear-output" "close"
    "clrhash" "code-char" "coerce" "compile" "compile-file" "compile-file-pathname"
    "compiled-function-p" "compiler-macro-function" "complement" "complex" "complexp"
    "compute-applicable-methods" "compute-restarts" "concatenate"
    "concatenated-stream-streams" "cond" "conjugate" "cons" "consp" "constantly"
    "constantp" "continue" "copy-alist" "copy-list" "copy-pprint-dispatch"
    "copy-readtable" "copy-seq" "copy-structure" "copy-symbol" "copy-tree" "cos" "cosh"
    "count" "count-if" "count-if-not" "ctypecase" "decf" "declaim" "decode-float"
    "decode-universal-time" "defclass" "defconstant" "defgeneric"
    "define-compiler-macro" "define-condition" "define-method-combination"
    "define-modify-macro" "define-setf-expander" "define-symbol-macro" "defmacro"
    "defmethod" "defpackage" "defparameter" "defsetf" "defstruct" "deftype" "defun"
    "defvar" "delete" "delete-duplicates" "delete-file" "delete-if" "delete-if-not"
    "delete-package" "denominator" "deposit-field" "describe" "describe-object"
    "destructuring-bind" "digit-char" "digit-char-p" "directory" "directory-namestring"
    "disassemble" "do" "do*" "do-all-symbols" "do-external-symbols" "do-symbols"
    "documentation" "dolist" "dotimes" "dpb" "dribble" "ecase" "echo-stream-input-stream"
    "echo-stream-output-stream" "ed" "eighth" "elt" "encode-universal-time" "endp"
    "enough-namestring" "ensure-directories-exist" "ensure-generic-function" "eq" "eql"
    "equal" "equalp" "error" "etypecase" "eval" "eval-when" "evenp" "every" "exp" "export"
    "expt" "fboundp" "fceiling" "fdefinition" "ffloor" "fifth" "file-author"
    "file-error-pathname" "file-length" "file-namestring" "file-position"
    "file-string-length" "file-write-date" "fill" "fill-pointer" "find"
    "find-all-symbols" "find-class" "find-if" "find-if-not" "find-method" "find-package"
    "find-restart" "find-symbol" "finish-output" "first" "flet" "float" "float-digits"
    "float-precision" "float-radix" "float-sign" "floatp" "floor" "fmakunbound"
    "force-output" "format" "formatter" "fourth" "fresh-line" "fround" "ftruncate"
    "funcall" "function" "function-keywords" "function-lambda-expression" "functionp"
    "gcd" "gensym" "gentemp" "get" "get-decoded-time" "get-dispatch-macro-character"
    "get-internal-real-time" "get-internal-run-time" "get-macro-character"
    "get-output-stream-string" "get-properties" "get-setf-expansion"
    "get-universal-time" "getf" "gethash" "go" "graphic-char-p" "handler-bind"
    "handler-case" "hash-table-count" "hash-table-p" "hash-table-rehash-size"
    "hash-table-rehash-threshold" "hash-table-size" "hash-table-test"
    "host-namestring" "identity" "if" "ignore-errors" "imagpart" "import" "in-package"
    "incf" "initialize-instance" "input-stream-p" "inspect" "integer-decode-float"
    "integer-length" "integerp" "interactive-stream-p" "intern" "intersection"
    "invalid-method-error" "invoke-debugger" "invoke-restart"
    "invoke-restart-interactively" "isqrt" "keywordp" "labels" "lambda" "last" "lcm" "ldb"
    "ldb-test" "ldiff" "length" "let" "let*" "lisp-implementation-type"
    "lisp-implementation-version" "list" "list*" "list-all-packages" "list-length"
    "listen" "listp" "load" "load-logical-pathname-translations" "load-time-value"
    "locally" "log" "logand" "logandc1" "logandc2" "logbitp" "logcount" "logeqv"
    "logical-pathname" "logical-pathname-translations" "logior" "lognand" "lognor"
    "lognot" "logorc1" "logorc2" "logtest" "logxor" "long-site-name" "loop" "loop-finish"
    "lower-case-p" "machine-instance" "machine-type" "machine-version" "macro-function"
    "macroexpand" "macroexpand-1" "macrolet" "make-array" "make-broadcast-stream"
    "make-concatenated-stream" "make-condition" "make-dispatch-macro-character"
    "make-echo-stream" "make-hash-table" "make-instance" "make-instances-obsolete"
    "make-list" "make-load-form" "make-load-form-saving-slots" "make-package"
    "make-pathname" "make-random-state" "make-sequence" "make-string"
    "make-string-input-stream" "make-string-output-stream" "make-symbol"
    "make-synonym-stream" "make-two-way-stream" "makunbound" "map" "map-into" "mapc"
    "mapcan" "mapcar" "mapcon" "maphash" "mapl" "maplist" "mask-field" "max" "member"
    "member-if" "member-if-not" "merge" "merge-pathnames" "method-combination-error"
    "method-qualifiers" "min" "minusp" "mismatch" "mod" "muffle-warning"
    "multiple-value-bind" "multiple-value-call" "multiple-value-list"
    "multiple-value-prog1" "multiple-value-setq" "name-char" "namestring" "nbutlast"
    "nconc" "nintersection" "ninth" "no-applicable-method" "no-next-method" "not"
    "notany" "notevery" "nreconc" "nreverse" "nset-difference" "nset-exclusive-or"
    "nstring-capitalize" "nstring-downcase" "nstring-upcase" "nsublis" "nsubst"
    "nsubst-if" "nsubst-if-not" "nsubstitute" "nsubstitute-if" "nsubstitute-if-not"
    "nth" "nth-value" "nthcdr" "null" "numberp" "numerator" "nunion" "oddp" "open"
    "open-stream-p" "or" "output-stream-p" "package-error-package" "package-name"
    "package-nicknames" "package-shadowing-symbols" "package-use-list"
    "package-used-by-list" "packagep" "pairlis" "parse-integer" "parse-namestring"
    "pathname" "pathname-device" "pathname-directory" "pathname-host"
    "pathname-match-p" "pathname-name" "pathname-type" "pathname-version" "pathnamep"
    "peek-char" "phase" "plusp" "pop" "position" "position-if" "position-if-not" "pprint"
    "pprint-dispatch" "pprint-exit-if-list-exhausted" "pprint-fill" "pprint-indent"
    "pprint-linear" "pprint-logical-block" "pprint-newline" "pprint-pop" "pprint-tab"
    "pprint-tabular" "prin1" "prin1-to-string" "princ" "princ-to-string" "print"
    "print-not-readable-object" "print-object" "print-unreadable-object" "probe-file"
    "proclaim" "prog" "prog*" "prog1" "prog2" "progn" "progv" "provide" "psetf" "psetq"
    "push" "pushnew" "quote" "random" "random-state-p" "rassoc" "rassoc-if"
    "rassoc-if-not" "rational" "rationalize" "rationalp" "read" "read-byte" "read-char"
    "read-char-no-hang" "read-delimited-list" "read-from-string" "read-line"
    "read-preserving-whitespace" "read-sequence" "readtable-case" "readtablep" "realp"
    "realpart" "reduce" "reinitialize-instance" "rem" "remf" "remhash" "remove"
    "remove-duplicates" "remove-if" "remove-if-not" "remove-method" "remprop"
    "rename-file" "rename-package" "replace" "require" "rest" "restart-bind"
    "restart-case" "restart-name" "return" "return-from" "revappend" "reverse" "room"
    "rotatef" "round" "row-major-aref" "rplaca" "rplacd" "sbit" "scale-float" "schar"
    "search" "second" "set" "set-difference" "set-dispatch-macro-character"
    "set-exclusive-or" "set-macro-character" "set-pprint-dispatch"
    "set-syntax-from-char" "setf" "setq" "seventh" "shadow" "shadowing-import"
    "shared-initialize" "shiftf" "short-site-name" "signal" "signum"
    "simple-bit-vector-p" "simple-condition-format-arguments"
    "simple-condition-format-control" "simple-string-p" "simple-vector-p" "sin" "sinh"
    "sixth" "sleep" "slot-boundp" "slot-exists-p" "slot-makunbound" "slot-missing"
    "slot-unbound" "slot-value" "software-type" "software-version" "some" "sort"
    "special-operator-p" "sqrt" "stable-sort" "standard-char-p" "step" "store-value"
    "stream-element-type" "stream-error-stream" "stream-external-format" "streamp"
    "string" "string-capitalize" "string-downcase" "string-equal" "string-greaterp"
    "string-left-trim" "string-lessp" "string-not-equal" "string-not-greaterp"
    "string-not-lessp" "string-right-trim" "string-trim" "string-upcase" "string/="
    "string<" "string<=" "string=" "string>" "string>=" "stringp" "sublis" "subseq"
    "subsetp" "subst" "subst-if" "subst-if-not" "substitute" "substitute-if"
    "substitute-if-not" "subtypep" "svref" "sxhash" "symbol-function" "symbol-macrolet"
    "symbol-name" "symbol-package" "symbol-plist" "symbol-value" "symbolp"
    "synonym-stream-symbol" "tagbody" "tailp" "tan" "tanh" "tenth" "terpri" "the" "third"
    "throw" "time" "trace" "translate-logical-pathname" "translate-pathname"
    "tree-equal" "truename" "truncate" "two-way-stream-input-stream"
    "two-way-stream-output-stream" "type-error-datum" "type-error-expected-type"
    "type-of" "typecase" "typep" "unbound-slot-instance" "unexport" "unintern" "union"
    "unless" "unread-char" "untrace" "unuse-package" "unwind-protect"
    "update-instance-for-different-class" "update-instance-for-redefined-class"
    "upgraded-array-element-type" "upgraded-complex-part-type" "upper-case-p"
    "use-package" "use-value" "user-homedir-pathname" "values" "values-list" "vector"
    "vector-pop" "vector-push" "vector-push-extend" "vectorp" "warn" "when"
    "wild-pathname-p" "with-accessors" "with-compilation-unit"
    "with-condition-restarts" "with-hash-table-iterator" "with-input-from-string"
    "with-open-file" "with-open-stream" "with-output-to-string"
    "with-package-iterator" "with-simple-restart" "with-slots"
    "with-standard-io-syntax" "write" "write-byte" "write-char" "write-line"
    "write-sequence" "write-string" "write-to-string" "y-or-n-p" "yes-or-no-p" "zerop")

  "A set of extra functions to add to the function face.")

(defvar common-lisp-built-in-types
  '("arithmetic-error" "array" "array-rank" "array-total-size" "atom" "base-char"
    "base-string" "bignum"  "bit" "bit-vector" "boolean" "broadcast-stream"
    "built-in-class" "cell-error" "char-code" "character" "class" "compiled-function" "complex" "concatenated-stream"
    "condition" "cons" "control-error" "division-by-zero" "double-float" "echo-stream"
    "end-of-file" "error" "extended-char" "file-error" "file-stream" "fixnum" "float" "float-digits"
    "float-radix" "floating-point-inexact" "floating-point-invalid-operation"
    "floating-point-overflow" "floating-point-underflow" "function" "generic-function"
    "hash-table" "integer" "keyword" "list" "logical-pathname" "long-float" "method" "method-combination" "null"
    "number" "package" "package-error" "parse-error" "pathname" "print-not-readable"
    "program-error" "random-state" "ratio" "rational" "reader-error" "readtable" "real"
    "restart" "sequence" "serious-condition" "short-float" "signed-byte" "simple-array" "simple-base-string"
    "simple-bit-vector" "simple-condition" "simple-error" "simple-string"
    "simple-type-error" "simple-vector" "simple-warning" "single-float" "standard-char"
    "standard-class" "standard-generic-function" "standard-method" "standard-object"
    "storage-condition" "stream" "stream-error" "string" "string-stream"
    "structure-class" "structure-object" "style-warning" "symbol" "synonym-stream" "t"
    "two-way-stream" "type-error" "unbound-slot" "unbound-variable"
    "undefined-function" "vector" "warning")

  "A set of extra types to add to the type face.")

(defvar common-lisp-built-in-variables
  '("**" "***" "*break-on-signals*" "*compile-file-pathname*"
    "*compile-file-truename*" "*compile-print*" "*compile-verbose*" "*debug-io*"
    "*debugger-hook*" "*default-pathname-defaults*" "*error-output*" "*features*"
    "*gensym-counter*" "*load-pathname*" "*load-print*" "*load-truename*"
    "*load-verbose*" "*macroexpand-hook*" "*modules*" "*package*" "*print-array*"
    "*print-base*" "*print-case*" "*print-circle*" "*print-escape*" "*print-gensym*"
    "*print-length*" "*print-level*" "*print-lines*" "*print-miser-width*"
    "*print-pprint-dispatch*" "*print-pretty*" "*print-radix*" "*print-readably*"
    "*print-right-margin*" "*query-io*" "*random-state*" "*read-base*"
    "*read-default-float-format*" "*read-eval*" "*read-suppress*" "*readtable*"
    "*standard-input*" "*standard-output*" "*terminal-io*" "*trace-output*" "++"
    "+++" "//" "///" "array-dimension-limit" "array-rank-limit"
    "array-total-size-limit" "boole-1" "boole-2" "boole-and" "boole-andc1" "boole-andc2"
    "boole-c1" "boole-c2" "boole-clr" "boole-eqv" "boole-ior" "boole-nand" "boole-nor"
    "boole-orc1" "boole-orc2" "boole-set" "boole-xor" "call-arguments-limit"
    "char-code-limit" "double-float-epsilon" "double-float-negative-epsilon"
    "internal-time-units-per-second" "lambda-list-keywords" "lambda-parameters-limit"
    "least-negative-double-float" "least-negative-long-float"
    "least-negative-normalized-double-float" "least-negative-normalized-long-float"
    "least-negative-normalized-short-float" "least-negative-normalized-single-float"
    "least-negative-short-float" "least-negative-single-float"
    "least-positive-double-float" "least-positive-long-float"
    "least-positive-normalized-double-float" "least-positive-normalized-long-float"
    "least-positive-normalized-short-float" "least-positive-normalized-single-float"
    "least-positive-short-float" "least-positive-single-float" "long-float-epsilon"
    "long-(forward-line  )oat-negative-epsilon" "most-negative-double-float" "most-negative-fixnum"
    "most-negative-long-(forward-line  )oat" "most-negative-short-float"
    "most-negative-single-float" "most-positive-double-float" "most-positive-fixnum"
    "most-positive-long-float" "most-positive-short-float"
    "most-positive-single-float" "multiple-values-limit" "nil" "pi"
    "short-float-epsilon" "short-float-negative-epsilon" "single-float-epsilon"
    "single-float-negative-epsilon" "t")

   "A set of extra variables to add to the symbol face.")

(defvar common-lisp-cffi-functions
  '("callback" "close-foreign-library" "convert-from-foreign"
    "convert-into-foreign-memory" "convert-to-foreign" "defbitfield" "defcallback"
    "defcenum" "defcfun" "defcstruct" "defctype" "defcunion" "defcvar"
    "define-c-struct-wrapper" "define-foreign-library" "define-foreign-type"
    "define-parse-method" "define-translation-method" "expand-from-foreign"
    "expand-into-foreign-memory" "expand-to-foreign" "expand-to-foreign-dyn"
    "foreign-alloc" "foreign-aref" "foreign-array-alloc" "foreign-array-free"
    "foreign-array-to-lisp" "foreign-bitfield-symbol-list" "foreign-bitfield-symbols"
    "foreign-bitfield-value" "foreign-enum-keyword" "foreign-enum-keyword-list"
    "foreign-enum-value" "foreign-free" "foreign-funcall" "foreign-funcall-pointer"
    "foreign-funcall-pointer-varargs" "foreign-funcall-varargs"
    "foreign-library-loaded-p" "foreign-library-name" "foreign-library-pathname"
    "foreign-library-type" "foreign-slot-count" "foreign-slot-names"
    "foreign-slot-offset" "foreign-slot-pointer" "foreign-slot-type"
    "foreign-slot-value" "foreign-string-alloc" "foreign-string-free"
    "foreign-string-to-lisp" "foreign-symbol-pointer" "foreign-type-alignment"
    "foreign-type-size" "free-converted-object" "free-translated-object"
    "get-callback" "get-var-pointer" "inc-pointer" "incf-pointer"
    "lisp-array-to-foreign" "lisp-string-to-foreign" "list-foreign-libraries"
    "load-foreign-library" "make-pointer" "make-shareable-byte-vector" "mem-aptr"
    "mem-aref" "mem-ref" "null-pointer" "null-pointer-p" "pointer-address" "pointer-eq"
    "pointerp" "reload-foreign-libraries" "translate-camelcase-name"
    "translate-from-foreign" "translate-into-foreign-memory"
    "translate-name-from-foreign" "translate-name-to-foreign" "translate-to-foreign"
    "translate-underscore-separated-name" "translation-forms-for-class"
    "use-foreign-library" "with-foreign-array" "with-foreign-object"
    "with-foreign-objects" "with-foreign-pointer" "with-foreign-pointer-as-string"
    "with-foreign-slots" "with-foreign-string" "with-foreign-strings"
    "with-pointer-to-vector-data")

  "A set of extra functions from Lisp's CFFI to add to the function face.")

(defvar common-lisp-cffi-variables
  '("*built-in-float-types*" "*built-in-foreign-types*" "*built-in-integer-types*"
    "*darwin-framework-directories*" "*default-foreign-encoding*"
    "*foreign-library-directories*" "*other-builtin-types*")

  "A set of extra variables from Lisp's CFFI to add to the symbol face.")

(defvar common-lisp-alexandria-functions
 '("alist-hash-table" "alist-plist" "appendf" "assoc-value" "binomial-coefficient"
   "circular-list" "circular-list-p" "circular-tree-p" "clamp" "coercef" "compose"
   "conjoin" "copy-array" "copy-file" "copy-hash-table" "copy-sequence" "copy-stream"
   "count-permutations" "cswitch" "curry" "define-constant" "delete-from-plist"
   "delete-from-plistf" "deletef" "destructuring-case" "destructuring-ccase"
   "destructuring-ecase" "disjoin" "doplist" "emptyp" "ends-with" "ends-with-subseq"
   "ensure-car" "ensure-cons" "ensure-function" "ensure-functionf" "ensure-gethash"
   "ensure-list" "ensure-symbol" "eswitch" "extremum" "factorial" "featurep" "first-elt"
   "flatten" "format-symbol" "gaussian-random" "hash-table-alist" "hash-table-keys"
   "hash-table-plist" "hash-table-values" "if-let" "ignore-some-conditions" "iota"
   "last-elt" "lastcar" "length=" "lerp" "make-circular-list" "make-gensym"
   "make-gensym-list" "make-keyword" "map-combinations" "map-derangements" "map-iota"
   "map-permutations" "map-product" "maphash-keys" "maphash-values" "mappend" "maxf"
   "mean" "median" "minf" "multiple-value-compose" "multiple-value-prog2"
   "named-lambda" "nconcf" "negative-double-float-p" "negative-fixnum-p"
   "negative-float-p" "negative-integer-p" "negative-long-float-p"
   "negative-rational-p" "negative-real-p" "negative-short-float-p"
   "negative-single-float-p" "non-negative-double-float-p" "non-negative-fixnum-p"
   "non-negative-float-p" "non-negative-integer-p" "non-negative-long-float-p"
   "non-negative-rational-p" "non-negative-real-p" "non-negative-short-float-p"
   "non-negative-single-float-p" "non-positive-double-float-p"
   "non-positive-fixnum-p" "non-positive-float-p" "non-positive-integer-p"
   "non-positive-long-float-p" "non-positive-rational-p" "non-positive-real-p"
   "non-positive-short-float-p" "non-positive-single-float-p" "nreversef"
   "nth-value-or" "nunionf" "of-type" "once-only" "parse-body"
   "parse-ordinary-lambda-list" "plist-alist" "plist-hash-table"
   "positive-double-float-p" "positive-fixnum-p" "positive-float-p"
   "positive-integer-p" "positive-long-float-p" "positive-rational-p"
   "positive-real-p" "positive-short-float-p" "positive-single-float-p"
   "proper-list-length" "proper-list-p" "random-elt" "rassoc-value" "rcurry"
   "read-file-into-byte-vector" "read-file-into-string"
   "read-stream-content-into-byte-vector" "read-stream-content-into-string"
   "remove-from-plist" "remove-from-plistf" "removef" "required-argument" "reversef"
   "rotate" "sequence-of-length-p" "set-equal" "setp" "shuffle" "simple-parse-error"
   "simple-program-error" "simple-reader-error" "simple-style-warning"
   "standard-deviation" "starts-with" "starts-with-subseq" "subfactorial" "switch"
   "symbolicate" "type=" "unionf" "unwind-protect-case" "variance" "when-let"
   "when-let*" "whichever" "with-gensyms" "with-input-from-file" "with-output-to-file"
   "with-unique-names" "write-byte-vector-into-file" "write-string-into-file" "xor")

 "Functions from the Common-Lisp package Alexandira.")

(defvar common-lisp-serapeum-functions
  '("->" "@" "add-hook" "and-let*" "append1" "array-index-row-major" "ascii-char-p"
    "assocadr" "assocdr" "assort" "assure" "assuref" "batches" "bcond" "bestn" "bits"
    "blankp" "block-compile" "bound-value" "box" "callf" "callf2" "capped-fork"
    "capped-fork2" "car-safe" "case-failure" "case-let" "case-of" "case-using" "ccase-of"
    "cdr-safe" "char-case" "char-ecase" "chomp" "class-name-of" "class-name-safe"
    "clear-queue" "collapse-whitespace" "collecting" "comment" "concat" "cond-every"
    "cond-let" "ctypecase-of" "date-leap-year-p" "deconstruct" "def" "defalias"
    "defcondition" "defconst" "defconstructor" "define-case-macro" "define-do-macro"
    "define-post-modify-macro" "define-train" "define-values" "defloop" "defmethods"
    "defplace" "defstruct-read-only" "defsubst" "defunion" "defunit" "defvar-unbound"
    "delete-from-hash-table" "delq" "deltas" "deq" "destructuring-case-of"
    "destructuring-ccase-of" "destructuring-ecase-of" "dict" "dict*" "dictq"
    "dispatch-case" "dispatch-case-let" "distinct" "do-each" "do-hash-table" "do-splits"
    "drop" "drop-while" "dsu-sort" "dsu-sort-new" "dynamic-closure" "ecase-let"
    "ecase-of" "econd" "econd-let" "efface" "eif" "eif-let" "ellipsize" "enq" "ensure"
    "ensure-vector" "ensure2" "eq*" "eql*" "equal*" "equalp*" "escape" "etypecase-of"
    "eval-always" "eval-and-compile" "eval-if-constant" "example" "expand-macro"
    "expand-macro-recursively" "extrema" "fbind" "fbind*" "fbindrec" "fbindrec*" "fdec"
    "file-size" "file=" "filter" "filter-map" "filterf" "finc" "find-class-safe"
    "find-external-symbol" "find-keyword" "firstn" "fixnump" "flip" "flip-hash-table"
    "float-precision-contagion" "fmt" "fnil" "fork" "fork2" "frequencies" "front" "gcp"
    "gcs" "get-unix-time" "grow" "growf" "halves" "hash-fold" "hash-table-function"
    "hash-table-predicate" "hash-table-set" "heap-extract" "heap-extract-all"
    "heap-extract-maximum" "heap-insert" "heap-maximum" "hook" "hook2" "href"
    "href-default" "ignoring" "in" "inconsistent-graph-constraints" "intersperse"
    "interval" "invalid-number-reason" "invalid-number-value" "juxt" "keep" "leaf-map"
    "leaf-walk" "length<" "length<=" "length>" "length>=" "letrec" "letrec*" "lines"
    "local" "local*" "longer" "longest" "lret" "lret*" "make" "make-hash-table-function"
    "make-heap" "make-octet-vector" "map-tree" "mapcar-into" "mapconcat"
    "maphash-return" "mapply" "match-of" "maybe-invoke-restart" "memq" "merge-tables"
    "monitor" "mvfold" "mvfoldr" "mvlet" "mvlet*" "nand" "nest" "nix" "nlet" "no" "nor"
    "nstring-invert-case" "nstring-upcase-initials" "nsubseq" "nth-arg" "nth-best"
    "nth-best!" "nthrest" "nub" "occurs" "occurs-if" "octet-vector-p" "octet-vector="
    "octets" "of-length" "once" "only-elt" "op" "opf" "ordering" "package-exports"
    "package-name-keyword" "package-names" "pad-end" "pad-start" "pairhash"
    "parse-float" "parse-leading-keywords" "parse-number" "parse-positive-real-number"
    "parse-real-number" "partial" "partition" "partition-declarations" "partitions"
    "path-join" "plist-keys" "plist-values" "pop-assoc" "pophash" "powerset" "prod"
    "proper-subtype-p" "proper-supertype-p" "prune" "prune-if" "qappend" "qconc" "qlen"
    "qlist" "queue" "queue-empty-p" "queuep" "random-in-range" "range" "rassocar" "ravel"
    "read-eval-prefix" "receive" "remove-hook" "repeat-sequence" "reshape" "reshuffle"
    "round-to" "run-hook-with-args" "run-hook-with-args-until-failure"
    "run-hook-with-args-until-success" "run-hooks" "runs" "same-case-p" "scan" "select"
    "selector" "seq=" "sequencep" "set-hash-table" "shape" "shrink" "shrinkf" "single"
    "slice" "sort-new" "sort-values" "split-sequence" "split-sequence-if"
    "split-sequence-if-not" "stable-sort-new" "string$=" "string*=" "string+"
    "string-case" "string-contains-p" "string-count" "string-ecase" "string-gensym"
    "string-invert-case" "string-join" "string-prefix-p" "string-replace"
    "string-replace-all" "string-suffix-p" "string-token-p" "string-upcase-initials"
    "string^=" "string~=" "sum" "summing" "supertypep" "swaphash" "synchronized" "take"
    "take-while" "throttle" "time-since" "time-until" "tokens" "toposort" "trampoline"
    "tree-case" "tree-ecase" "trim-whitespace" "true" "typecase-of" "unbits" "unbox"
    "undisplace-array" "unique-name" "universal-to-unix" "unix-to-universal" "unoctets"
    "unsplice" "vect" "vector=" "vref" "walk-tree" "whitespacep" "with-collector"
    "with-collectors" "with-read-only-vars" "with-standard-input-syntax" "with-string"
    "with-string-dispatch" "with-subtype-dispatch" "with-thunk" "with-type-dispatch"
    "with-vector-dispatch" "word-wrap" "words" "write-file-into-stream"
    "write-stream-into-file" "~>" "~>>")

  "A set of extra functions from serapeum to add to the function face.")

(use-package sly
  :init
  (defvar inferior-lisp-program "sbcl")
  (setq sly-lisp-implementations
        `((sbcl (,(executable-find "sbcl")))
          (ccl (,(executable-find "ccl")))
          (ecl (,(executable-find "ecl")))
          (abcl (,(executable-find "abcl")))
          (clisp (,(executable-find "clisp")))))
  (setq sly-mrepl-history-file-name (concat dryad-cache-dir "sly-mrepl-history")
        sly-kill-without-query-p t
        sly-net-coding-system 'utf-8-unix
        ;; Change this to `sly-simple-completions' for simple completion
        sly-complete-symbol-function 'sly-flex-completions)
  (sp-with-modes '(sly-mrepl-mode)
    (sp-local-pair "'" "'" :actions nil)
    (sp-local-pair "`" "`" :actions nil))

  :config
  (font-lock-add-keywords
   'lisp-mode
   `((,(regexp-opt common-lisp-built-in-functions 'symbols) . font-lock-function-name-face)))

  (font-lock-add-keywords
   'lisp-mode
   (mapcar (lambda (name) (cons name 'font-lock-type-face))
           common-lisp-built-in-types))

  (font-lock-add-keywords
   'lisp-mode
   (mapcar (lambda (name) (cons name 'font-lock-variable-name-face))
           common-lisp-built-in-variables))

  (font-lock-add-keywords
   'lisp-mode
   `((,(regexp-opt common-lisp-cffi-functions 'symbols) . font-lock-function-name-face)))

  (font-lock-add-keywords
   'lisp-mode
   (mapcar (lambda (name) (cons name 'font-lock-variable-name-face))
           common-lisp-cffi-variables))

  (font-lock-add-keywords
   'lisp-mode
   `((,(regexp-opt common-lisp-alexandria-functions 'symbols) . font-lock-function-name-face)))

  (font-lock-add-keywords
   'lisp-mode
   `((,(regexp-opt common-lisp-serapeum-functions 'symbols) . font-lock-function-name-face)))

  (load (expand-file-name "~/quicklisp/slime-helper.el"))

  (defun common-lisp-cleanup-sly-maybe ()
    "Kill processes and leftover buffers when killing the last sly buffer."
    (unless (cl-loop for buf in (delq (current-buffer) (buffer-list))
                     if (and (buffer-local-value 'sly-mode buf)
                             (get-buffer-window buf))
                     return t)
      (dolist (conn (sly--purge-connections))
        (sly-quit-lisp-internal conn 'sly-quit-sentinel t))
      (let (kill-buffer-hook kill-buffer-query-functions)
        (mapc #'kill-buffer
              (cl-loop for buf in (delq (current-buffer) (buffer-list))
                       if (buffer-local-value 'sly-mode buf)
                       collect buf)))))

  (defun common-lisp-init-sly ()
    "Attempt to auto-start sly when opening a lisp buffer."
    (cond ((or (temp-buffer-p (current-buffer))
               (sly-connected-p)))
          ((executable-find inferior-lisp-program)
           (let ((sly-auto-start 'always))
             (sly-auto-start)
             (add-hook 'kill-buffer-hook #'common-lisp-cleanup-sly-maybe nil t)))
          ((message "WARNING: Couldn't find `inferior-lisp-program' (%s)"
                    inferior-lisp-program))))
  (add-hook 'sly-mode-hook #'common-lisp-init-sly)

  (defun common-lisp-refresh-sly-version (version conn)
    "Update `sly-protocol-version', which will likely be incorrect or nil due to
    an issue where `load-file-name' is incorrect."
    (unless sly-protocol-version
      (setq sly-protocol-version (sly-version nil (locate-library "sly.el"))))
    (advice-remove #'sly-check-version #'common-lisp-refresh-sly-version))
  (advice-add #'sly-check-version :before #'common-lisp-refresh-sly-version))

;; Note these contrib packages only work with SBCL and CCL, and /maybe/ ABCL
(use-package sly-macrostep
  :after sly
  :config
  (with-eval-after-load 'sly
    (sly-enable-contrib 'sly-macrostep)))

;; Working with ASDF files
(use-package sly-asdf
  :after sly
  :config
  (add-to-list 'sly-contribs 'sly-asdf #'append)
  (with-eval-after-load 'sly
    (sly-enable-contrib 'sly-asdf)))

;; NAMED-READTABLES support for Sly
(use-package sly-named-readtables
  :after sly
  (with-eval-after-load 'sly
    (sly-enable-contrib 'sly-named-readtables)))

(use-package sly-repl-ansi-color
  :after sly
  :init
  (add-to-list 'sly-contribs 'sly-repl-ansi-color nil #'eq))