This package provide a Common Lisp library for .zip-file reading and writing.

It can sometimes be useful to be able to parse chemical compounds in a user-friendly syntax into easy-to-manipulate s-expressions. You also want to be able to go in reverse. You could probably write your own parser — or you could just install the chemical-compounds package.

Common Lisp already has major 2 namespaces, function namespace and value namespace (or variable namespace), but there are actually more — e.g., class namespace. This library offers macros to deal with symbols from any namespace.

Coalton is a dialect of ML embedded in Common Lisp. It emphasizes practicality and interoperability with Lisp, and is intended to be a DSL that allows one to gradually make their programs safer.

This Common Lisp library implements the quoted-printable encoding as described in RFC 2045 (see http://tools.ietf.org/html/rfc2045).

This piece of code sets up some reader macros that make it simpler to input string literals which contain backslashes and double quotes This is very useful for writing complicated docstrings and, as it turns out, writing code that contains string literals that contain code themselves.

SLY is a fork of SLIME, an IDE backend for Common Lisp. It also features a completely redesigned REPL based on Emacs's own full-featured comint-mode, live code annotations, and a consistent interactive button interface. Everything can be copied to the REPL. One can create multiple inspectors with independent history.

Parse INI formatted files into a Common Lisp list structure.

This package provides a Common Lisp ASDF system auto-loading extension.

Transducers are an ergonomic and extremely memory-efficient way to process a data source. Data source refers to simple collections like lists or vectors, but also potentially large files or generators of infinite data.

This library is a collection of functions and macros for manipulating Common Lisp arrays and performing numerical calculations with them.

This package provides the LOCAL-TIME extensions for the cl-postgres ASDF system of postmodern.

CLACHE provides a general caching facility for Common Lisp. The API is similar to the standard hash-table interface.

Common Lisp comes with quite some functions to compare objects for equality, yet none is applicable in every situation and in general this is hard, as equality of objects depends on the semantics of operations on them. As consequence, users find themselves regularly in a situation where they have to roll their own specialized equality test.

This module provides one of many possible equivalence relations between standard Common Lisp objects. However, it can be extended for new objects through a simple CLOS protocol. The rules when two objects are considered equivalent distinguish between mutating and frozen objects. A frozen object is promised not to be mutated in the future in a way that operations on it can notice the difference.

We have chosen to compare mutating objects only for identity (pointer equality), to avoid various problems. Equivalence for frozen objects on the other hand is established by recursing on the objects' constituent parts and checking their equivalence. Hence, two objects are equivalent under the OBJECT= relation, if they are either identical, or if they are frozen and structurally equivalent, i.e. their constituents are point-wise equivalent.

Since many objects are potentially mutable, but are not necessarily mutated from a certain point in their life time on, it is possible to promise to the equivalence relation that they remain frozen for the rest of their life time, thus enabling coarser equivalence than the often too fine-grained pointer equality.

This package provides Python style generators for Common Lisp. It also includes a port of itertools.

cl-incless implements print-object methods for many standard classes.

This is a Common Lisp kernel for Jupyter along with a library for building Jupyter kernels, based on Maxima-Jupyter which was based on cl-jupyter.

This package provides a functionality augmenting Hunchentoot error pages and logs with request and session information.

CL-octet-streams is a library implementing in-memory octet streams for Common Lisp. It was inspired by the trivial-octet-streams and cl-plumbing libraries.

Calispel is a Common Lisp library for thread-safe message-passing channels, in the style of the occam programming language, also known as communicating sequential processes (CSP). See https://en.wikipedia.org/wiki/Communicating_sequential_processes.

Calispel channels let one thread communicate with another, facilitating unidirectional communication of any Lisp object. Channels may be unbuffered, where a sender waits for a receiver (or vice versa) before either operation can continue, or channels may be buffered with flexible policy options.

Because sending and receiving on a channel may block, either operation can time out after a specified amount of time.

A syntax for alternation is provided (like ALT in occam, or Unix select()): given a sequence of operations, any or all of which may block, alternation selects the first operation that doesn't block and executes associated code. Alternation can also time out, executing an "otherwise" clause if no operation becomes available within a set amount of time.

Calispel is a message-passing library, and as such leaves the role of threading abstractions and utilities left to be filled by complementary libraries such as Bordeaux-Threads and Eager Future.

This package provides a common lisp CFFI wrapper for the SciPy version of Cephes special functions.

cl-mysql is a Common Lisp implementation of a MySQL wrapper.

This package provides a library for parsing MIME types, in the spirit of http://code.google.com/p/mimeparse/, with a Common Lisp flavor.

Dissect is a small Common Lisp library for introspecting the call stack and active restarts.