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 library contains a collection of machine learning algorithms for online linear classification written in Common Lisp.
clingon is a command-line option parsing library for Common Lisp. Its features include:
Support for subcommands
Support for command aliases
Support for short and long options
Related options may be grouped into categories
Short options may be collapsed into a single argument, as in
-xyzLong options support the notations
--long-opt argand--long-opt=argAutomatic generation of help/usage information for commands and subcommands
Out-of-the-box support for
--versionand--helpSupport for various kinds of options including string, integer, boolean, switch, enum, list, counter, filepath, etc.
Subcommands can look up global options defined in parent commands
Support for required options
Options can be initialized via environment variables
Single interface for creating options using
CLINGON:MAKE-OPTIONGenerate documentation for your command-line application
Support for
pre-hookandpost-hookactions for commands, which allow invoking functions before and after the respective handler of the command is executedSupport for Bash and Zsh completions
Extensibility, so if you don't find something you need you can extend it by developing a new option kind, or even a new mechanism for initializing options, e.g., by looking up an external key/value store
The purpose of this library is to provide a collection of implementations of trees.
In contrast to existing libraries such as cl-containers, it does not impose a particular use for the trees. Instead, it aims for a stratified design, allowing client code to choose between different levels of abstraction.
As a consequence of this policy, low-level interfaces are provided where the concrete representation is exposed, but also high level interfaces where the trees can be used as search trees or as trees that represent sequences of objects.
cl-inotify uses cl-cffi to provide a Common Lisp interface to the Linux inotify API.
ORG-SAMPLER allows using Lisp docstrings and reflection to make org-mode text for inclusion into a larger document.
Inquisitor is a cross-implementation library providing encoding/end-of-line detection and external-format abstraction for Common Lisp.
cl-num-utils implements simple numerical functions for Common Lisp, including:
num=, a comparison operator for floatssimple arithmeric functions, like
sumandl2normelementwise operations for arrays
intervals
special matrices and shorthand for their input
sample statistics
Chebyshev polynomials
univariate rootfinding
MAP-BIND is a macro that allows visual grouping of variables with their corresponding values in calls to mapping operators when using an inline LAMBDA.
This library allows you to implement and enforce proper finalization of compile-time constructs while building Lisp source files.
It produces two systems: asdf-finalizers and list-of.
Alloy is a user interface toolkit. It is defined through a set of protocols that allow for a clear interface, as well as a standardised way to integrate Alloy into a target backend.
This package provides a safer variant of READ secure against internbombing, excessive input and macro characters.
CL-Ledger is a Common Lisp port of the Ledger double-entry accounting system.
This is a Common Lisp utilities library originating from the Zombie Raptor game engine project.
Funds provides portable, purely functional data structures in Common Lisp. It includes tree based implementations for Array, Hash, Queue, Stack, and Heap.
Utility library for handling bit vectors, bit vector arithmetic, and universal integer type conversions between bit-vectors, byte-vectors, octals, decimals, and hexadecimal notation.
This package provides a grab bag of miscellaneous Common Lisp utilities.
A client for the Stripe payment API.
This library provides a tiny Common Lisp wrapper around setlocale(3) and can be used in conjunction with other FFI wrappers like cl-charms.
Antik provides a foundation for scientific and engineering computation in Common Lisp. It is designed not only to facilitate numerical computations, but to permit the use of numerical computation libraries and the interchange of data and procedures, whether foreign (non-Lisp) or Lisp libraries. It is named after the Antikythera mechanism, one of the oldest examples of a scientific computer known.
cl-random is a library for generating random draws from various commonly used distributions, and for calculating statistical functions, such as density, distribution and quantiles for these distributions.
This package provides a PEM (Privacy-Enhanced Mail) parser for Common Lisp.
Py4CL is a bridge between Common Lisp and Python, which enables Common Lisp to interact with Python code. It uses streams to communicate with a separate python process, the approach taken by cl4py. This is different to the CFFI approach used by burgled-batteries, but has the same goal.
This lisp library handles physical quantities which consist of
value / magnitude
uncertainty / error
unit
where the type of the value can be any subtype of real. For the uncertainty, both absolute and relative values are possible. Combinations of lisp symbols or strings are used to describe units. User defined units including abbreviations and prefixes are supported. Error propagation and unit checking is performed for all defined operations.
This Common Lisp library provides a series data structure much like a sequence, with similar kinds of operations. The difference is that in many situations, operations on series may be composed functionally and yet execute iteratively, without the need to construct intermediate series values explicitly. In this manner, series provide both the clarity of a functional programming style and the efficiency of an iterative programming style.