New Lisp dialect: TXR Lisp.

[Kaz Kylheku]

Hi Gnumancers,

Since around August 2009, I've been developing a language called TXR 
which consists of:

* a pattern language (the TXR Pattern Language) for matching whole text 
documents/streams and scraping their contents.

* an original Lisp dialect called TXR Lisp.

page: https://www.nongnu.org/txr/index.html
doc:  https://www.nongnu.org/txr/txr-manpage.html
git   http://www.kylheku.com/cgit/txr/

TXR is offered under the two-clause BSD license.

A few days ago, I put out version 195, which is what it looks like it 
means: the one hundred ninety-fifth public release. (Semantic 
versioning!)

Originally, TXR was just the pattern language. It sprouted the Lisp 
dialect, and much of the development has been in that area.

TXR Lisp's basic political alignment is with ancient tradition: lists 
are terminated by the symbol nil, which is also Boolean false. It is a 
Lisp-2. However, it supports Lisp-1-style evaluation also under the dwim 
operator, which sugared by [ ... ] notation. This shift to an 
alternative evaluation is deeply integrated into the expander.

TXR Lisp has various goodies such as: exception handling, an OOP system 
(not CLOS-like; single dispatch, single inheritance), syntactic places, 
reasonably rich I/O with a format function, string interpolation, 
built-in lazy lists, buffers, delimited continuations, a Lisp-ified 
implementation of Awk, a package system, and a really great FFI.  
Numerous POSIX interfaces are included in the library.

There is an interactive listener, with command persistent command 
history, decent editing (visual copy and paste, undo) with a great 
multi-line mode.

Recently I developed a virtual machine and compiler for TXR Lisp.

TXR Lisp makes list operations generic over vectors, strings and 
user-defined sequences. For instance (car "abc") returns #\a, and (cdr 
"z") yields nil.

It has numerous primitives for working with lazy lists. There are lazy 
strings and The OOP system supports lazy objects.

There are nice ways to index sequences. For instance (swap [a 2..5] [b 
10..19]) will do what it looks like: exchange the given sub-ranges of 
sequences a and b in place, even though they are of different length.

Objects other than functions are callable, with useful semantics.

The OOP system supports a mechanism called "equivalence substitution" 
which allows objects to be used as custom hash keys without the 
programmer having to write a hashing function.

TXR is documented by a thorough user manual which takes the form of one 
giant man page that converts to about a 640 page PDF as well as a 
hyper-linked HTML document hosted online.

Cheers ...