Enter the query into the form above. You can look for specific version of a package by using @ symbol like this: gcc@10.
API method:
GET /api/packages?search=hello&page=1&limit=20
where search is your query, page is a page number and limit is a number of items on a single page. Pagination information (such as a number of pages and etc) is returned
in response headers.
If you'd like to join our channel webring send a patch to ~whereiseveryone/toys@lists.sr.ht adding your channel as an entry in channels.scm.
This package provides a portability layer for the extensible sequences standard extension to Common Lisp. Extensible sequences allow you to create your own sequence types that integrate with the rest of the functions and operations that interact with sequences.
CL-Yacc is a LALR(1) parser generator for Common Lisp, similar in spirit to AT&T Yacc, Berkeley Yacc, GNU Bison, Zebu, lalr.cl or lalr.scm.
CL-Yacc uses the algorithm due to Aho and Ullman, which is the one also used by AT&T Yacc, Berkeley Yacc and Zebu. It does not use the faster algorithm due to DeRemer and Pennello, which is used by Bison and lalr.scm (not lalr.cl).
This package provides first-class global environments for Common Lisp.
XSubseq provides functions to be able to handle "subseq"s more effieiently.
Sycamore is a fast, purely functional data structure library in Common Lisp. If features:
Fast, purely functional weight-balanced binary trees.
Leaf nodes are simple-vectors, greatly reducing tree height.
Interfaces for tree Sets and Maps (dictionaries).
Ropes.
Purely functional pairing heaps.
Purely functional amortized queue.
Trivial-features ensures that *FEATURES* is consistent across multiple Common Lisp implementations.
This library implements the base58 encoding algorithm. It's basically base64 but with a smaller alphabet (58, as in the name) that doesn't include similar looking characters, among other things. See https://github.com/bitcoin/bitcoin/blob/master/src/base58.h for a full reference.
This package holds an enhanced implementation of hooks (extension points). It works similarly to Emacs hooks with crucial improvements:
If the compiler allows it (such as SBCL), type-checking is performed at compile-time and at run-time when adding handlers to a hook.
On failure, multiple restarts are offered, such as disabling the offending handler or simply continuing to the next function.
The hook handler execution order and combination can be customized.
Anonymous functions (lambdas) can be added to hooks as handler objects. When inspecting hooks, readable names are thus exposed instead of lambda blackboxes. Handlers are compared through their names (through the mandatory name slot). A hook can not contain multiple handlers with the same name.
A special provision is taken for “setters”, handlers that are meant to set a given place to a given values. Such handler objects can be compared and identified uniquely.
This is a (currently) brief but usable wrap for SDL2_image.
This library implements special functions and has a focus on high accuracy double-float calculations using the latest algorithms.
Command-Line-Args provides a main macro (command) that wraps a defun form and creates a new function that parses the command line arguments. It has support for command-line options, positional, and variadic arguments. It also generates a basic help message. The interface is meant to be easy and non-intrusive.
April compiles a subset of the APL programming language into Common Lisp. Leveraging Lisp's powerful macros and numeric processing faculties, it brings APL's expressive potential to bear for Lisp developers. Replace hundreds of lines of number-crunching code with a single line of APL.
Common Lisp library for channel-based concurrency. In a nutshell, you create various threads sequentially executing tasks you need done, and use channel objects to communicate and synchronize the state of these threads.
CL-DOT is a Common Lisp library for generating Graphviz dot output from arbitrary Lisp data.
cl-css-lite is a library for generating CSS from an s-exp based syntax. When compiled with Parenscript loaded in the Lisp image, it also provides the same CSS generation facilities in Parenscript-generated JavaScript code.
Salza2 is a Common Lisp library for creating compressed data in the zlib, deflate, or gzip data formats, described in RFC 1950, RFC 1951, and RFC 1952, respectively.
simple-matrix is a Common Lisp library implementing some functions to work with matrices.
Parseq (pronounced parsec) is a parsing library for common lisp. It can be used for parsing lisp's sequences types: strings, vectors (e.g. binary data) and lists. Furthermore, parseq is able to parse nested structures such as trees (e.g. lists of lists, lists of vectors, vectors of strings).
Parseq uses parsing expression grammars (PEG) that can be defined through a simple interface. Extensions to the standard parsing expressions are available. Parsing expressions can be parameterised and made context aware. Additionally, the definition of each parsing expression allows the arbitrary transformation of the parsing tree.
The library is inspired by Esrap and uses a very similar interface. No code is shared between the two projects, however. The features of Esrap are are mostly included in parseq and complemented with additional, orthogonal features. Any resemblance to esrap-liquid is merely coincidental.
With static-vectors, you can create vectors allocated in static memory.
This package provides Common Lisp math and statistics routines.
cl-change-case is a library to convert strings between camelCase, PascalCase, snake_case, param-case, CONSTANT_CASE and more.
CL-UNICODE is a portable Unicode library Common Lisp, which is compatible with perl. It is pretty fast, thread-safe, and compatible with ANSI-compliant Common Lisp implementations.
My Way is a Sinatra-compatible URL routing library.
NClasses provides helper macros to help write classes, conditions, generic functions, and CLOS code in general with less boilerplate.
It's a fork of hu.dwim.defclass-star. It includes some bug fixes and extra features like type inference.