
Tests
-----

- Perl Inline::SLang::Struct_Type objects to S-Lang structs:
    Leak memory (converting the other way seems okay [is this really
    true/supported?])

- S-Lang Assoc types to perl:
    add support for arrays

- check that S-Lang "opaque" variables passed through Perl and back to
  S-Lang still exist once the perl variable that referenced them
  has called it's DESTROY method.

S-Lang to Perl
--------------

- Should Structs use a tied hash? We would disallow creation
    of fields and provide method to list the order of the
    fields?

  - improve the support of 1D & 2D arrays
  - add support for nD arrays
  - use PDL

 Variables:
  - do we want to allow access to S-Lang variables (ie have them
    bound to a perl 'lvalue' routine)?

Perl to S-Lang
--------------

 - array and assoc arrays are the major sticking points.
   Difficulty is what happens if given ("1.0", "1") since
   this could be an array of strings or numbers [and, thanks to
   Perl's DWIMery, it's both]

   Let's try and use tied hash/arrays

General
-------

 - decide how to handle errors.
   Perhaps should install an error handler to allow
   _sl_eval to return the message in $@ than being printed to STDERR?

 - how do we support PDL? Should there be an option to convert
   arrays using one of:
     plain perl, return as a single 'string', as a piddle

 - improve documentation

Compilation
-----------

If a user says

  use Inline 'SLang' => <<'EOS1';
  ..
  EOS1

  use Inline 'SLang' => <<'EOS2';
  ..
  EOS2

perhaps with some configuration changes in between,
do we create 2 files, and does the second one include those
functions bound from the first code (EOS1) ?

Configuration
-------------

 - S-Lang has support for byte-compiled code. The module could
   save the byte-compiled code instead of (or as well as) the
   text version of the code. It may provide a slight performance
   gain when loading?
   Have decided not to try and support this, since it would mean
   more-complicated build()/load() routines for a (I'm guessing)
   effectively negligible speed increase

