Heresy - Haskellesque lazy-list and functional tools with a CommonLisp slant.

I've put up a new library, Heresy - I hope you find it useful.

Doc page (including some examples):
http://cl-heresy.sourceforge.net/Heresy.htm

Download: http://sourceforge.net/projects/cl-heresy/


Heresy is a list of utilities for lazy and functional programming in
Common Lisp. Function names are chosen and decorated so as to resemble
Haskell and/or CL equivalents; but to allow full import of exported
symbols into a typical namespace.

Basically, the library attempts to give the user control over the
lazy-evaluation to get planned, deterministic memory profile, where
suitable. Included is the ability to produce self-referencing lists,
and some control over the "degree" and manner of laziness in certain
list functions.

(I do NOT claim to be replicating Haskell or all Haskell idioms!)

A few functions (grouped-cdrs-by-car/, etc.) are those I found to be
just kind of handy in their own right.

I use it myself, and this is my first shot at sharing a lib so bear with
me - am sharing it in the hope it will be useful to others as well, or
to obtain comments that will help my own development.

Have fun!


License: BSD
Disclaimer: Use at own risk, I bear no responsibility, etc. etc.

TBD:

Get a mailing list for bug reports, and resolve some issues of the web
presentation/hosting.
Activate thread-safety mode and bordeaux-threads dependency.
Better document existing functions
Shrink the "cache"/link node
Activate and expose "lazy calculation" map (structurally supported but
currently not present)
Systematically incorporate more haskell or faux-CL functions (filtering
for are found to be useful/orthogonal in this context).

Matthew Lamari wrote:
> I've put up a new library, Heresy - I hope you find it useful.
>
> Doc page (including some examples):
> http://cl-heresy.sourceforge.net/Heresy.htm
>
> Download: http://sourceforge.net/projects/cl-heresy/
>
>
> Heresy is a list of utilities for lazy and functional programming in
> Common Lisp. Function names are chosen and decorated so as to resemble
> Haskell and/or CL equivalents; but to allow full import of exported
> symbols into a typical namespace.
>
> Basically, the library attempts to give the user control over the
> lazy-evaluation to get planned, deterministic memory profile, where
> suitable. Included is the ability to produce self-referencing lists,
> and some control over the "degree" and manner of laziness in certain
> list functions.
>
> (I do NOT claim to be replicating Haskell or all Haskell idioms!)
>
> A few functions (grouped-cdrs-by-car/, etc.) are those I found to be
> just kind of handy in their own right.
>
> I use it myself, and this is my first shot at sharing a lib so bear with
> me - am sharing it in the hope it will be useful to others as well, or
> to obtain comments that will help my own development.
>
> Have fun!
>
>
> License: BSD
> Disclaimer: Use at own risk, I bear no responsibility, etc. etc.
>
> TBD:
>
> Get a mailing list for bug reports, and resolve some issues of the web
> presentation/hosting.
> Activate thread-safety mode and bordeaux-threads dependency.
> Better document existing functions
> Shrink the "cache"/link node
> Activate and expose "lazy calculation" map (structurally supported but
> currently not present)
> Systematically incorporate more haskell or faux-CL functions (filtering
> for are found to be useful/orthogonal in this context).

Cool, I especially envy your name. But have you thought of embedding
haskell into lisp?
It's a latest fashion revival into the long tradition. And after
embedded prolog, qi, contextL, aspectl, erlang etc haskell is the
next logical step. I never thought of learning prolog untill I sow it
embedded in lisp. Who know people might learn haskell very soon, as
liskell (oops that's taken).

Lisp, one language to rule them all.

Slobodan

thus spoke Slobodan Blazeski <slobodan.blazeski@gmail.com>:

> Cool, I especially envy your name. But have you thought of embedding
> haskell into lisp?

I did. Basically changed all function applications to thunks with
arnesi's code walker. Works perfectly fine at the first glance, but
interfaces poorly with strict Lisp. Consider:

(lazily
(if (plusp (foobie-bletch (tharr 'foo)))
42
69))

Since the result of calling FOOBIE-BLETCH is a thunk, it must be
expanded to a strict value. But how about this?

(car (make-an-infinite-list))

Better stick with Series. There's not much fun in lazy evaluation short
of infinite streams anyway.

--
The Principle of Entropy holds that all electronic systems must
eventually decline into inert junk. This principle is unproved, and
previous attempts to accelerate the process have been cataclysmic
failures.