Search Results

CL-INTERPOL modifies the reader so that you can have interpolation of strings similar to Perl or Unix Shell scripts. It is a text processing convenience library. It also provides various ways to insert arbitrary characters into literal strings even if your editor/IDE doesn't support them. Here's an example:
* (let ((a 42))
#?"foo: \xC4\N{Latin capital letter U with diaeresis}\nbar: ${a}")
"foo: ÄÜ
bar: 42"
It was written by Edi Weitz and now maintained by community at Github.CL-INTERPOL can also be used for HTML templating: http://paste.lisp.org/display/146518

DIFF is a simple asdf-installable Text Library which can compute unified-style or context-style diffs between two files. It also includes code to compute copy/insert deltas via the vdelta algorithm and encode those diffs in svndiff format. Other algorithms and encodings are planned for future versions. Version 0.4 includes a reader for "patch" files; an interface for applying patches is planned for future versions. Comments on the interface or wanted algorithms greatly appreciated.NOTE: Old rice.edu link broken as of 12/31/2009. Code has reappeared on github at https://github.com/froydnj/diff

The Soundex algorithm indexes words by their sound when pronounced in English, for example to account for differences in spelling.This public domain Common Lisp implementation of Soundex was originally in the JWZ tarball of the CMU AI repository.
Natural Language Processing text

The Tagger project is a revival of the Xerox Part-of-Speech (POS) Tagger program released somewhere in 1993.It is based on the hidden Markov model and requires few resources to accurately tag words.
Natural Language Processing text

An pure Common Lisp implementation of gettext runtime. gettext is an internationalization and localization (i18n) system commonly used for writing multilingual programs on Unix-like computer operating systems.

Sometimes you want to be able to parse chemical formulas in a normal, user-friendly syntax. For example, water is usually written
"H2O". This syntax is good for users, but for Lisp code, you
need a different representation. In chemical-compounds, H2O would be
represented as ((H 2) O).A more complicated molecule is glucose, C6H12O6. This is
((C 6) (H 12) (O 6)) in our internal representation. You may have
noticed that "C6H12O6" is ugly and hard to read, due to the clunky way
that plain text deals with the subscripts. Therefore, in the format
used by chemical-compounds, glucose is "C6 H12 O6", with spaces.Some chemical formulas parenthesize parts of the compound and add a
subscript. The formula "(C O2)4 H2" would be parsed as
(((C (O 2)) 4) (H 2)).The home page is
http://common-lisp.net/project/chemboy/Example
(use-package :compounds)
;; Pretty-print water to a string and return it
(with-output-to-string (s) (pprint-compound '((H 2) O) s))
; => "H2 O"
;; Parse some compounds
(parse-compound "C6 H12 O6") ; => ((C 6) (H 12) (O 6))
(parse-compound "(C O2)4 H2") ; => (((C (O 2)) 4) (H 2))
;; Calculate the number of grams per mole of some compounds.
;; This depends on the *(periodic-table) package.
(formula-weight '((C 6) (H 12) (O 6))) ; => 180.15768
(formula-weight (parse-compound "C6 H12 O6")) ; => 180.15768
;; Parse the argument if necessary.
;; This is just a trivial convenience function.
(get-compound "C6 H12 O6") ; => ((C 6) (H 12) (O 6))
(get-compound '((C 6) (H 12) (O 6))) ; => ((C 6) (H 12) (O 6))It is released under the LLGPLHow it works
On the off-chance that someone is interested in how this library works:The formula weight finding and pretty-printing are fairly easy to implement recursively, but the parsing is interesting. I had originally entertained crazy thoughts about using cl-ppcre and some regexp lunacy to parse chemical formulas. I quickly abandoned this ridiculous idea. How does one use regular expressions recursively to match things like "(C O2)4 H2"? I don't know, and I don't want to know. Instead, I used META.META is a parsing technique, not a parser. I ripped some of the basic META code from Henry Baker's paper, and found it underpowered and inconventient. After adding in some heavy macros for a lot of things (the closest I've ever come to making a domain-specific language for parsing), it became very nice. Writing parsers with META really is straightforward with the proper macros. I thank META for my code's great portability; chemical-compounds has been tested successfully on SBCL, LispWorks, Corman Lisp, and ECL.
Science

Password management for Common Lisp (web) applications. cl-password-store provides a light-weight and extendible solution to
user/password management:
safe password storage:
cleartext-free, using your choice of hash algorithm through
ironclad,
storage in an SQL database through
clsql, in a database your application
already uses anyway, or in a separate one, and using any backend
supported by clsql,
password reset mechanism with one-time tokens (suitable for mailing
to users for confirmation),
user creation optionally with confirmation tokens (suitable for
mailing to users),
(obviously) user authentication.
Users can be identified by strings or by subclassing
user-token-mixin. The code is available under LLGPL at github. For documentation check out the
API documentation.

Climacs is an Emacs-like text editor written in Common Lisp.It is a CLIM application. Its development resources are summarized at
its project page on common-lisp.net. As of July 2006, Climacs is a useful tool for writing Common Lisp code, but it does not have close integration with a REPL, debugger or inspector like SLIME. The CLIM-desktop project provides additional integration with Climacs into other applications (most notably the McCLIM Listener), but does not greatly enhance Climacs' capabilities for editing Common Lisp. Climacs can presently do parameter hinting, code evaluation, symbol completion, displaying of compiler notes and definition-editing.

Exscribe is a CL-based document authoring tool in the spirit of Manuel Serrano's Scribe.Current Exscribe features (as of version 0.94.2) include: output to HTML or PDF, good support for HTML footnotes (endnotes only on PDF backend), ok support for table-of-contents and bibliography, and most importantly, programmability.
All that in a way largely compatible with Manuel Serrano's Scribe (given a published abstraction layer).
These feature are few, but useful enough so that I (Fare Rideau) use Exscribe for all the pages I write.Currently missing (intended future) features include: a better cl-typesetting backend (work in progress), Markdown/ReST/TeX syntax in addition/complement/combination with the Scribble syntax, cl-bibtex bridge, graphics, boxes, orphans, styles, etc.Unlike most other document authoring systems, Exscribe is programmable: I casually compute content on-the-fly within documents.
However, unlike the only widespread programmable document authoring system,
namely (La)TeX, it's programmable in a decent language, namely Lisp.Exscribe is directly inspired by Manuel Serrano's Scribe, and largely compatible with it. Actually, I use Exscribe as a drop-in replacement for Scribe, within the strictures of my programming style: with a small abstraction layer, my Scribe files run with both Scribe and Exscribe, with similar output as seen with a web browser (the output of Exscribe is actually cleaner).I use Exscribe with Scribble syntax, but it is trivial to translate from your usual SEXP syntax, and there is a builtin mechanism to allow for arbitrary text filters (so you could embed a Markdown syntax within Exscribe documents).I used to use Scribe, but Scribe was discontinued in favor of the slightly incompatible Skribe. Instead of learning Skribe and migrating my documents to it, and continue to cope with a few small limitations that really annoyed me, I opted to reimplement myself a variant of Scribe. The result is Exscribe. In many ways, it's a quick and dirty hack, thrown together in a few tens of hours of intensive work. But I like the architecture of it, and though it doesn't do much, it does just what I need for the time being, and it does it exactly the way I want. When it fails, I have noone to blame but myself. All my new web pages are written with it.Exscribe currently mainly targets HTML and so currently is mainly a web authoring tool, and it can also be used as a Lisp Markup Languages. But a CL-typesetting backend is already available, and will hopefully match and surpass the HTML backend Real Soon Now(tm).At the time being, Exscribe is definitely not for non-hacker users: error checking and reporting is minimal, and documentation is almost absent. However, in its current state it is already fit for use by developers, and I'm open to collaboration to develop it. The Scribe documentation should be mostly valid, and an example that uses most of the capabilities present in Exscribe is here:
http://fare.tunes.org/files/asdf-packages/exscribe-examples.tar.gz
Bitrot has made it impossible to get the native code Scribe running anymore (one probably could if willing to invest some substantial effort in either retrocomputing or porting). However, the unstable and slow JVM version of Scribe can still be run. Exscribe on CMUCL or SBCL compiles my documents much faster (performance is less good with other implementations, but always better than the JVM Scribe on my documents).Exscribe depends on other packages: meta, fare-utils, fare-matcher, scribble and cl-launch. You will need cl-launch to run it from the unix command-line. The PDF backend uses cl-typesetting. You can also compile Exscribe with XCVB.Exscribe source code is at:
http://common-lisp.net/gitweb?p=users/frideau/exscribe.gitNote that the referred Scribe does not really have anything to do with the already established language Scribe from the early 1980's. That is why Manuel Serrano renamed it to Skribe in its new (slightly incompatible) incarnation. Though there were implementations of the old Scribe in Lisp, it didn't have a Lisp-related syntax. See Brian Reid, "Scribe: A Document Specification Language and its Compiler", Technical Report CMU-CS-81-100, 1981.document format

Flexichain is an API for editable sequences. Its primary use is in end-user applications that edit sequences of objects such as text editors (characters), word processors (characters, paragraphs, sections, etc), score editors (notes, clusters, measures, etc), though it can also be used as a stack and a double-ended queue. Project page
Topics: data structure

From the README:folio is a set of modules that make some functional programming idioms
more convenient for use in Common Lisp. The folio modules are portions
of the runtime from the new Lisp dialect Bard, packaged for convenient
use as Common Lisp libraries. As Bard's runtime matures, additional
portions may be added as folio modules.
This page is presently Uncategorized: please add appropriate
topic markers and remove this text

positional-lambda is a concise, intuitive and flexible syntax (macro) for trivial lambdas that eschews explicit (and often contextually-redundant) naming of parameter variables in favor of positional references, with support for a used or ignored &rest parameter and automatic declaration of ignored parameters when logical "gaps" are left in the positional references. Further convenience features are provided.

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

umlisp is an CLOS object-oriented interface to the Unified Medical Language System. It uses a SQL database to index and access the 15 gigabytes of text UMLS data. UMLisp is written by Kevin Rosenberg. There is an online demonstration system for browsing the UMLS at the UMLisp web site.
or at archive.org since umlisp.b9.com seems not to exist anymore.