Quickdocs

iterate

2018-02-28

Website Download

License: MIT
Categories: language extension, library

Requirements

0 None.

Required by

112

a-cl-logger A logger that sends to multiple destinations in multiple formats. Based on arnesi logger
access A library providing functions that unify data-structure access for Common Lisp: access and (setf access)
adw-charting Charting package to make pretty graphs and charts
antik
asd-generator Automatic directory scanner/generator for .asd project files.
asdf-viz Visualizes the dependencies between asdf systems / Visualize the function call graph.
bit-ops Optimized bit-vector operations
bitfield-schema SIMPLE-BIT-VECTOR low level routines and convenient eDSL over it.
buildnode Tool for building up an xml dom nicely.
caramel CSS selector-based template engine for Common Lisp
cl-arxiv-api Bindings for API of arXiv.org
cl-cffi-gtk cl-cffi-gtk is a Lisp binding to GTK+ 3 which is a library for creating graphical user interfaces.cl-cffi-gtk is licensed using the LGPL which has been adopted with a preamble that clarifies the terms for use with Lisp programs and is referred as the LLGPL. This work is based on the cl-gtk2 library which has been developed by Kalyanov Dmitry and already is a fairly complete Lisp binding to GTK+ 2.The focus of this work is to document the library more complete and to do the implementation as consistent and complete as possible. Most informations about GTK+ can be gained by reading the C documentation. Therefore, the C documentation from The GTK+ Project is included into the Lisp files to document the Lisp binding to the GTK+ library. This documentation is also available online at cl-cffi-gtk API documentation.At this time, the library is developed and tested with SBCL 1.1.9 and GTK+ 3.6.4 on a Linux system. Furthermore, the following libraries GLIB 2.36.0, Pango 1.32.5, and Cairo 1.12.4 are loaded.Examples of the usage are included in a gtk-demo and tutorial examples. Start with the tutorial available online at GTK+ 3 Tutorial for Lisp to learn how to use the library. Some more information and a gallery are available from the project website cl-cffi-gtk Project.The latest version is available from the repository at Github.GUI GTK binding
cl-closure-template This is a Common Lisp port of Google Closure Templates HTML template library. Homepage
cl-creditcard Generic interace library for talking with credit card processors.
cl-csv Facilities for reading and writing CSV format files
cl-events Events for Common Lisp
cl-factoring Integer Factoring
cl-fuse CFFI bindings to FUSE (Filesystem in user space)
cl-fuse-meta-fs CFFI bindings to FUSE (Filesystem in user space)
cl-geometry Library for two dimensional geometry.
cl-gobject-introspection Binding to GObjectIntrospection
cl-gtk2 CL-GTK2 is a Common Lisp GUI library that provides access to the Gtk+ cross-platform GUI library in idiomatic Lisp style.CL-GTK2 should portably work in most modern Lisps that support CFFI and MOP (works at least in SBCL, Clozure CL on Linux and Windows). Current version is 0.1.1 released on 2009.12.30.cl-gtk2 blog contains news on development of CL-GTK2. There is also a common-lisp.net website, with more documentation.CL-GTK2 is ASDF-installable (install the :CL-GTK2-GTK, :CL-GTK2-CAIRO and :CL-GTK2-GTKGLEXT systems).Requirements: FFI with callbacks (via CFFI) Threading (via Bordeaux-Threads) Weak references (weak hash-tables) and finalizers (via Trivial-Garbage) CLOS Metaobject Protocol (via Closer-MOP) Features: Provides Gtk+ API in a Lispy way (Almost) Complete Gtk+ API Objects and classes are mapped into CLOS objects and classes Gtk+ objects are garbage collected Error in objects' signal handlers are restartable Provides some higher-level abstractions over Gtk+ facilities: Calling code in GUI thread (call-within-main-loop, call-within-main-loop-and-wait) Displaying progress-bar for long-running code (with-progress-bar) Displaying errors (with-gtk-message-error-handler) Examples: Source code Screenshot (defun run () (let ((output *standard-output*)) (gtk:within-main-loop (let ((window (make-instance 'gtk:gtk-window :type :toplevel :window-position :center :title "Hello world!" :default-width 300 :default-height 100)) (button (make-instance 'gtk:button :label "Hello, world!")) (counter 0)) (gobject:g-signal-connect button "clicked" (lambda (b) (declare (ignore b)) (format output "Hello, world!~%") (setf (gtk:button-label button) (format nil "Hello, world! (clicked ~D times)" (incf counter))))) (gtk:container-add window button) (gtk:widget-show window :all t))))) (run) (defun demo-class-browser () (let ((output *standard-output*)) (gtk:within-main-loop (let* ((window (make-instance 'gtk:gtk-window :window-position :center :title "Class Browser" :default-width 400 :default-height 600)) (search-entry (make-instance 'gtk:entry)) (search-button (make-instance 'gtk:button :label "Search")) (scroll (make-instance 'gtk:scrolled-window :hscrollbar-policy :automatic :vscrollbar-policy :automatic)) (slots-model (make-instance 'gtk:array-list-store)) (slots-list (make-instance 'gtk:tree-view :model slots-model))) (let ((v-box (make-instance 'gtk:v-box)) (search-box (make-instance 'gtk:h-box))) (gtk:container-add window v-box) (gtk:box-pack-start v-box search-box :expand nil) (gtk:box-pack-start search-box search-entry) (gtk:box-pack-start search-box search-button :expand nil) (gtk:box-pack-start v-box scroll) (gtk:container-add scroll slots-list)) (gtk:store-add-column slots-model "gchararray" (lambda (slot) (format nil "~S" (closer-mop:slot-definition-name slot)))) (let ((col (make-instance 'gtk:tree-view-column :title "Slot name")) (cr (make-instance 'gtk:cell-renderer-text))) (gtk:tree-view-column-pack-start col cr) (gtk:tree-view-column-add-attribute col cr "text" 0) (gtk:tree-view-append-column slots-list col)) (labels ((display-class-slots (class) (format output "Displaying ~A~%" class) (loop repeat (gtk:store-items-count slots-model) do (gtk:store-remove-item slots-model (gtk:store-item slots-model 0))) (closer-mop:finalize-inheritance class) (loop for slot in (closer-mop:class-slots class) do (gtk:store-add-item slots-model slot))) (on-search-clicked (button) (declare (ignore button)) (gtk:with-gtk-message-error-handler (let* ((class-name (read-from-string (gtk:entry-text search-entry))) (class (find-class class-name))) (display-class-slots class))))) (gobject:g-signal-connect search-button "clicked" #'on-search-clicked)) (gtk:widget-show window))))) (demo-class-browser) Gtk GTK binding
cl-itertools itertools Python lib ported to CL
cl-junit-xml Small library for writing junit XML files
cl-l10n Portable CL Locale Support
cl-libxml2 cl-libxml2 is high-level wrapper around libxml2 and libxslt libraries. For details, read documentation.Features: Interfaces for tree manipulation (like cxml-stp) Interface for an HTML 4.0 non-verifying parser Specific APIs to process HTML tree, especially serialization XPath API XSLT API Custom URL resolvers XPath extension functions XSLT extension elements Translate libxml2 and libxslt errors to Lisp conditions iterate drivers for enumerate child nodes and etc. Simple and compact syntax for generating XML (xfactory)
cl-mssql cl-mssql is an interface to Microsoft SQL Server databases.License: MITHomepage: http://code.google.com/p/cl-mssql/
cl-netstrings A library for handling netstrings as described in http://cr.yp.to/proto/netstrings.txt.
cl-odesk Common Lisp bindings for oDesk API
cl-parser-combinators An implementation of parser combinators for Common Lisp
cl-pdf Common Lisp PDF Generation Library
cl-permutation A library for operating on permutations and permutation groups.
cl-plumbing A few (at least seemingly) missing stream operations in Common Lisp.
cl-primality Primality testing
cl-prolog2 Common Interface to the ISO prolog implementations from Common Lisp
cl-routes cl-routes is Common Lisp re-implementation of the Rails routes system for mapping URL's (also, see http://routes.groovie.org/) URI
cl-rrt Common Lisp implementation of RRT (Rapidily exploring Random Tree), a fast probabilistic multidimentional path-plannning algorithm.
cl-sane Lispy library bindings for sane.
cl-sat Common Lisp API to Boolean SAT Solvers
cl-sat.glucose CL-SAT instance to Glucose state-of-the-art SAT solver. This downloads the later 2014 version (2nd in the 2014 SAT competition).
cl-sqlite cl-sqlite is a library for interacting with sqlite databases through SQL.Homepage: http://common-lisp.net/project/cl-sqlite/License: Public Domain
cl-string-match Substring search and string matching, exact and inexact and other algorithms on strings and sequences. This is a mirror of the repository on SourceForge.
cl-table Hierarchical tables in Lisp
cl-tetris3d Yet another 3D Tetris clone
cl-tuples Experimental Tuple Types Facade
cl-uglify-js JavaScript compressor/beautifier on top of PARSE-JS
clml
clod Common Lisp Autodoc generator
clods-export Common Lisp OpenDocument spreadsheet export library
clsql-helper A library providing a clutch of utilities to make working with clsql easier
clsql-orm CLSQL-ORM is an library to generate clsql view-classes from existing databases, by introspecting on the "information_schema" of the running database.For more info see: Git Hub: https://github.com/AccelerationNet/CLSQL-ORM Topic: AccelerationNet
com.clearly-useful.iterate-plus iterate extensions for the sequence and iterator protocols
com.clearly-useful.protocols Simple protocol implementation for Common Lisp inspired by clojure.
crane An ORM for Common Lisp.
css-selectors An implementation of css selectors
data-table A library providing a data-table class, and useful functionality around this
datafly Lightweight database library.
diff-match-patch A Common Lisp port of Neil Fraser's library of the same name
djula An implementation of Django templates for Common Lisp.
eazy-gnuplot An intuitive CL interface to gnuplot.
eazy-process Yet Another Portable Library for Process Handling / Subshell Invokation
eazy-project Generate and Manage a Project
escalator An experimental object system for high-performance games.
esrap-liquid A Packrat / Parsing Grammar / TDPL parser for Common Lisp.
esrap-peg A wrapper around Esrap to allow generating Esrap grammars from PEG definitions
ffa Foreign friendly arrays
file-local-variable File-local variable independent from ASDF
fnv
function-cache A Simple Caching Layer for functions
generators A common lisp package providing python style generators based on delimited continuations
generic-sequences Generic sequences for Common Lisp.
group-by A Common Lisp library to help group data into trees (of various formats) based on common/shared values
gtk-cffi Interface to GTK/Glib via CFFI
hemlock Hemlock is an Emacs-like editor that comes with CMUCL (Debian users need to get the cmucl-source package). Why not take a CloserLookAtHemlock?Looking for quick instructions on GettingStartedWithHemlock?If you want to use Hemlock with an X11 server that uses magic cookies (eg, connections forwarded via ssh), and if you're using a CMUCL distribution from before summer 2002 (or so), you'll need to load the following patch: Make Old CMUCL CLX Work With Magic Cookies.See also cl-emacs, I guess.Portable hemlock. There is an attempt to free Hemlock from its CMUCL prison and port it to ANSI CL plus CLX called the Portable Hemlock. It has already been persuaded to run on OpenMCL and SBCL, and possibly others.A recent version of hemlock is available through git (based on the portable hemlock codebase):git clone git://gitorious.org/hemlock/hemlock.gitFor more, see the Hemlock wiki on gitorious.
hu.dwim.common An extended Common Lisp package to the general needs of other hu.dwim systems.
hu.dwim.def General purpose, homogenous, extensible definer macro.
inlined-generic-function MOP implementation of the fast inlinable generic functions dispatched in compile-time
inner-conditional Series of macros which optimizes out the inner conditional jumping
integral Object Relational Mapper for Common Lisp
iterate-clsql Extension for iterate to support iterate over clsql queries
jenkins Bindings for Jenkins' REST API.
l-system L-system or Lindenmayer system on lists
lisp-unit2 Common Lisp library that supports unit testing.
matlisp
modf A SETF like macro for functional programming
org-sampler Extract docstrings as Emacs org-mode files
png-read A library for reading PNG files.
prepl prepl is a REPL implementation, also known as a Lisp listener.It is written in fully portable Common Lisp (aside from minor workarounds for implementation-specific issues...), with major unportable bits being handled by external portability libraries. Downloadgit clone git://gitorious.org/prepl/prepl.gitHistoryprepl is a fork of SBCL's sb-aclrepl module.Since then, it has been ported to Clozure CL and other Lisps.Debugging capabilities have been added.Overall, PREPL does not have Allegro compatibility as a goal, although it still largely keeps its interface. UsageManual startup: (asdf:operate 'asdf:load-op 'prepl) (prepl:repl) See alsoThe Qt version of Hemlock uses PREPL in its Slave buffers. MaintainerDavid Lichteblau
print-licenses Print the licenses used by the given project and its dependencies.
qbook qbook generates HTML (or LaTeX) formatted code listings of Common Lisp source files. Comments in the source code are rendered as HTML paragraphs, text is rendered in < pre > blocks. Headings are created by preceding the text of the comment with one or more #\* chars.This is inspired by Luke Gorrie's pbook.el (which targets Emacs Lisp).The UCW documentation is an example of qbook's output. Documentation Tool
quasiquote-2.0 Writing macros that write macros. Effortless.
query-fs High-level virtual FS using CL-Fuse-Meta-FS to represent results of queries
quicksearch Quicksearch searches CL library, and outputs results at REPL.
recursive-regex Recursive regular expression parsing engine
screamer Nondeterministic programming and constraint propagation.
snakes Python style generators for Common Lisp.
spatial-trees spatial-trees is a set of dynamic index data structures for spatially-extended data. The flavors provided are, as of the 0.1 release (on 2004-12-03): R-trees, as in R-TREES: A DYNAMIC INDEX STRUCTURE FOR SPATIAL SEARCHING, Antonin Guttman, Proc. ACM SIGMOD Int. Conf. on Management of Data, 1984. Greene-trees, as in An Implementation and Performance Analysis of Spatial Data Access Methods, Diane Greene, Proc. 5th IEEE Int. Conf. on Data Engineering, 1989. R*-trees, as in The R*-tree: An Efficient and Robust Access Method for Points and Rectangles, Beckmann, Kriegel, Schneider and Seeger, Proc. ACM Int. Conf. on Management of Data, 1990 X-trees, as in The X-tree: An Index Structure for High-Dimensional Data, Berchtold, Keim and Kriegel, Proc. 22th Int. Conf. on Very Large Databases, 1996 Future work planned includes performance enhancements, incorporation of more index structures, and some work on supporting more optimal indexing when the entire set of data is known at index creation time; for more details, see the TODO file in the binary distribution.The code is licensed BSD-style, and is intended to be similar in spirit to Nathan Froyd's TREES Library. You can get this via Quicklisp.As per #lisp discussion, the new official source for this is the github repository, which is a conversion of the darcs repository.
static-dispatch Static generic function dispatch for Common Lisp.
stefil Stefil - Simple Test Framework In Lisp
submarine Submarine is a Common Lisp library that's somewhere between a PostgreSQL library an an object persistency system. It uses Postmodern to communicate with the database. The basic idea is that you create your classes in the metaclass DB-CLASS and submarine cares about creating SQL tables or, if the tables already exist, checking if they conform to the provided specification. Moreover, Submarine supports an intuitive way of expressing both one-to-many and many-to-many relations.The author of Submarine is Ryszard Szopa.The common-lisp.net webpage of the project is http://common-lisp.net/project/submarine/. Library SQL
sxql A SQL generator
symbol-munger Functions to convert between the spacing and capitalization conventions of various environments
talcl TAL in CL
trivia.balland2006 Optimizer for Trivia based on (Balland 2006)
ucw UncommonWeb : Standard Components
unit-formula Formulas with unit checking and conversion
utilities.print-items A protocol for flexible and composable printing.
verrazano Verrazano is no longer actively developed; see cl-autowrap (which uses c2ffi) or maybe SWIG.Verrazano is a FFI bindings generator targetting CFFI and UFFI. It is designed to have robust support for C and C++ header files, by using GCC-XML as its parser, and to be easily retargettable to a number of different foreign function interfaces.Homepage: http://common-lisp.net/project/fetter/
x.fdatatypes functional data collections
xarray xarray is a generalized interface for array-like objects with views.This package implements a generalized interface for array-like objects. The idea is that we should be able to index an object as(xref object 1 2 3)to retrieve or set an element. This would be easy to do it aref was a generic function, but it is not. I describe a simple interface with a few generic functions (xdims queries dimensions, xtype element type, etc), any objects that has these methods is called "xrefable".The nice part is that views on an array can also be xrefable. For an two-dimensional array *a*, (slice *a* :all 4)selects the 4th column of an array.[1] This view is also xrefable, so you can use(setf (xref (slice *a* :all 4) 2) 9)to set element 2 to 9. Changes will be made in the original array *a*, since this is a view. But for functions that just expect an array, they can use the interface (xref, xdims, etc) and not care where it is coming from.Homepage: https://github.com/tpapp/xarrayLicense: MIT Topics: language extension
xml.location This system provides a convenient interface for manipulating XML data. It is inspired by the xmltio library.
yaclml yaclml (Yet Another Common Lisp Markup Language) is an HTML generator and HTML template library. yaclml is used as the html templating backend for the ucw web framework.License: ?Homepage: http://common-lisp.net/project/bese/yaclml.htmlAccording to the yaclml website, it appears darcs is the preferred method to get current versions: darcs get http://common-lisp.net/project/bese/repos/yaclml/ Getting the output When you use the inline-html of yaclml, the rendered HTML gets printed, not returned. If you need to have it in a string, use the following: (yaclml:with-yaclml-output-to-string (<:html (<:head (<:title "Hello, world")) (<:body (<:h1 "Hello, world") (<:p "Hello, world!!!!!!"))) and you'll get a string.Using yaclml by itself If you want, you can use yaclml by itself (not with ucw, maybe with another framework, like araneida) but it seems nobody is doing that so the library is not very friendly by itself: it is not really robust (in the sense that it is very easy to generate an error by providing not-so-carefully contructed input) and there's no documentation whatsoever. That last item I'll try to fix here. Including yaclml as one of the dependecies of your package or by loading it (with (asdf:oos 'asdf:load-op :yaclml)) you can start using the yaclml-in-lisp markup, something like: (<:html (<:head (<:title "Hello, world")) (<:body (<:h1 "Hello, world") (<:p "Hello, world!!!!!!"))) That wasn't so hard, was it ? But one of the jewels of yaclml is tal. To be able to load TAL templates you need to perform the following steps. Create a generator: (defparameter *gen* (make-instance 'yaclml:file-system-generator :cachep nil :root-directories (list "/path/to/my/templates/"))) root-directories is where you will have the templates. I believe a relative path should work. For the whole run of the program one generator might be enough. When you are about to generate a page, you need to generate an environment which will have the key-value pairs that can be used inside the template: (defparameter *env* (yaclml:make-standard-environment)) That builds an empty environment. The mappings should be passed as the first parameter to make-standard-environment and according to yaclml documentation: "Each binding set can be an alist, an object, a hash table, or any object for which the a method on LOOKUP-TAL-VARIABLE has been defined." Then, we have to pick up the template itself: (defparameter *tem* (yaclml:load-tal *gen* "hello.html")) *tem* is a closure, that is, a function, that when run will return the result of "rendering" that template. It takes two parameters, a generator and an environment. If you evaluate *tem* you may get something like: # < CLOSURE (LAMBDA (IT.BESE.YACLML::ENVIRONMENT IT.BESE.YACLML::GENERATOR)) {BEB9355} > One usefull function is yaclml:template-truename which returns the name of the template being picked up (or nil if none is found). When you have various root-directories it can help you find out which template is being chosen. For example: (yaclml:template-truename *gen* "hello.html") would return /path/to/my/templates/hello.html Now we would call *tem* like this: (funcall *tem* *env* *gen*) and we would get out the page.yaclml generator tutorial: http://www.3ofcoins.net/2009/02/07/yaclml-in-pictures-part-i-html-generation/yaclml templating tutorial: http://www.3ofcoins.net/2010/01/21/yaclml-in-pictures-part-ii-templating/

Links

API Reference
Website