This file contains a list of stuff I'm working on or want to work on for
Libretto.  If anyone wants to help out with any of this stuff, I'd be glad
to accept contributions -- please contact me so I don't duplicate your
effort.

I've realised that my plans about what will get written and released when
seem to mean very little in real terms, so I've pretty much given up
mentioning version numbers for the features in here.


* More vector/array types.  I'm going to deprecate Darray pretty soon -- the
  interface is confusing and doesn't match the rest of Libretto.  (Every
  other container parametrises on a user-supplied `void *' value, but Darray
  copies a user-specified number of bytes from a supplied address.)  So I'll
  create types Sarray and Marray (single-dimensional and multi-dimensional
  array).  (The Marray container will have variadic indexing functions for
  maximal convenience.)  The Darray code will be left in Libretto but
  unmaintained (except for bug fixes) until such time as I destructively
  change other interfaces.

  19980614: I've started the Sarray type.  Shouldn't take too long to
  complete, as much of the code can be grabbed wholesale from the Darray
  module.


* Easy-to-use regexes for Autostr and friends (my goal is that they be as
  easy as those in Emacs Lisp).  These will be based on the POSIX/Single
  Unix regex facilities, or possibly the GNU rx library -- I'm not about to
  implement a regex matcher myself.

  19980205: This is pretty much done, and partly tested.  However, I need to
  decide what I'm going to do about multi-threading (at the moment the
  module preserves global state), so it's not in 1.7.

  19980406: The design for the interface to remove global state is nearly
  finished.  Expect regexes shortly after the final 2.0.

  19980524: OK, I've done (most of) that.  But now I want to rewrite for
  additional flexibility of regex syntax, as well as which regex library to
  use.  This means a unifying interface for POSIX and GNU regexes to begin
  with, either or both of which can be compiled in to Libretto.  Later I
  want to add Perl regexes.  So this has been delayed again.

  19980813: At least I've created the feature mechanism that programs will
  need if I allow the installer to choose one or more of POSIX, GNU and Perl 
  regexes.  So again, this looks promising for the next release.


* A type Ucharset: a simple type to store sets of unsigned characters.  Should
  be space- and time-efficient for this comparatively simple and common
  set-like requirement.  (I want it for phonological expressions, for
  example.)  Has to support find_{first,next}_{one,zero}() operations, as
  well as the normal things.  (That is, you have to be able to iterate over
  characters present in or absent from the set.)

  19980524: I'll probably cancel this.  The Bitset module (see below) is now 
  fairly close to being finished, and will (I suspect) be efficient enough
  for this case to be usable.


* New types for red-black balanced trees, AVL balanced trees, and maybe even
  non-binary trees.


* A skip list type, if I decide it's sufficiently worth while.  I've already
  written some code, but I'm not very happy with it.  I'm also not convinced
  that it will offer anything much better than the existing Chain or Darray.


* A worthwhile hashing type.  fhash_t is simply not good enough for anything
  real, and so has not been included in the 1.5 release.  I'm also
  considering building a special hashing type which uses an Autostr as the
  key, rather than a generic type.

  19980613: I've been offered some hash table code, but haven't yet had
  chance to look at it properly.


* Consider Bitset: a `set' that can hold integers of arbitrary sizes.
  Possible implementations include:

  Have a space requirement of MAX_STORED_VALUE-MIN_STORED_VALUE+1 bits per
  integer; this means we store all values contiguously, like Ucharset, but
  it can grow, and must also hold an offset value.  Problems: inflexible --
  likely to fail on `add 0 to the set; add 2**31 to the set'.

  Have a space requirement of one int per int stored -- that is, do it as an 
  Autobuf of ints.  Problems: slow -- it's difficult to determine whether a
  given int is in the set.

  Probably best to go for some sort of hybrid approach: store a `linked
  list' (more likely a darray) of things which hold an offset and a bit
  string.

  19980524: This is well on the way.  Expect it in 2.2.


* Bit strings as well as `bitsets' (sets of integers) would be nice.  I
  don't really have any thoughts on how to implement this nicely, though.


* Consider providing an Autowstr (based on wchar_t) and Autombstr (based on
  multi-byte characters.  This may well be delayed until I start using glibc
  2 (which AFAIK is the first glibc to really do locales properly;
  certainly, the <limits.h> I have defines MB_LEN_MAX as 1).  This may also
  want the same sort of code re-use facilities as the printf/scanf stuff
  (see other item).


* A better manual.  Currently, it's little more than a reference to the
  functions provided; I'd like some more text about how in general to use
  the containers (possibly including some elementary material on data
  structures) with some useful real-life examples.  I'd also like better
  indexing.
