https://github.com/fare/lisp-interface-library

LIL: abstract interfaces and supporting concrete data-structures in Common Lisp
https://github.com/fare/lisp-interface-library

Last synced: 17 days ago
JSON representation

LIL: abstract interfaces and supporting concrete data-structures in Common Lisp

• Host: GitHub
• URL: https://github.com/fare/lisp-interface-library
• Owner: fare
• Created: 2012-06-12T00:29:52.000Z (over 12 years ago)
• Default Branch: master
• Last Pushed: 2023-07-28T15:35:47.000Z (over 1 year ago)
• Last Synced: 2024-12-09T22:25:40.895Z (about 2 months ago)
• Language: Common Lisp
• Size: 546 KB
• Stars: 145
• Watchers: 25
• Forks: 17
• Open Issues: 6
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
lisp-interface-library

======================

LIL: abstract interfaces and concrete data structures in Common Lisp

 * Home Page:

	

 * We wrote an article explaining about our library for ILC'2012:

	

 * A PDF of a slightly corrected version of the article is here:

	

 * An HTML of that version of the article is here:

	

 * A short introduction on our "Interface-Passing Style" of programming, is also at:

	

 * Manual: I have never worked on a manual, nor on a tutorial.

   For a quick introduction to how things work, look at the tests in [test/](test/)

   for a few examples.

   Then docstrings and source code can get you somewhat further.

   A manual or a tutorial would be a great contribution to this library.

Features

--------

 * LIL nicely combines ad-hoc polymorphism (CLOS-powered object oriented programming)

   and parametric polymorphism (as in ML functors, C++ templates, etc.).

   To our knowledge, only scalaz matches the expressiveness of LIL.

 * LIL sports both pure (persistent, immutable) and

   stateful (ephemeral, mutable) variants

   of data structures in Interface-Passing Style.

   This variants are in the respective packages PURE and STATEFUL;

   a common core is shared in package INTERFACE, covering read-only operations;

   automatic transforms allow bridging from stateful to pure and back.

 * LIL supports data structures in traditional Object-Oriented Style,

   in both stateful (the usual Object-Oriented kind) and pure variants,

   in the respective packages POSH and CLASSY.

   There too, automatic transforms to go from Interface-Passing Style to

   traditional Object-Oriented Style and back.

Building it

-----------

LIL needs to be built using [ASDF](https://common-lisp.net/project/asdf/) 3.1 or later:

Indeed, LIL notably relies on ASDF 3.1's `package-inferred-system`.

whereby instead of dependencies being listed in a central .asd file,

each source file has a defpackage form from which the dependencies are deduced.

While we think it's a great way to write Lisp code,

you don't have to use it in your own code to use LIL.

LIL also depends on

[fare-utils](https://gitlab.common-lisp.net/frideau/fare-utils),

[fare-memoization](https://gitlab.common-lisp.net/frideau/fare-memoization),

[closer-mop](http://cliki.net/closer-mop),

[alexandria](https://gitlab.common-lisp.net/alexandria/alexandria).

Using it

--------

See [test/pure-map.lisp](test/pure-map.lisp) and [test/stateful-map.lisp](test/stateful-map.lisp)

for examples of how to use LIL.

Unhappily, no one is working on documentation at this time.