wisp literal array syntax for Guile, a good idea?

[Arne Babenhauserheide]

Hi,

Wisp¹ as general syntax is pretty much done. The releases this year only
provided bug fixes and additional examples. A procedure definition looks
like this:

define : hello who
    format #f "Hello ~a!\n"
                   . who

From experience with building tools with Wisp² I am pretty happy with
its syntax; it feels like a sweet spot between minimal syntax-overhead
and producing easily readable code (leaning a bit more towards minimal
syntax-overhead than readable/sweet).

But there is one Guile-specific feature where it is lacking: When
defining a procedure in Guile, you can add properties by creating a
literal array as line — or as second line if the first line is a literal
string that then serves as documentation. This can be used to define
tests.³ Then a full fledged Hello World! looks like this:

define : hello who
    . "Say hello to WHO"
    . #((tests
           (test-equal "Hello World!\n"
                      (hello "World"))))
    format #f "Hello ~a!\n"
                   . who

And this is all and nice, but it prevents using indentation-based syntax
for the properties. This would be no problem if I could simply make an
array with non-literal syntax — i.e. (list->array (list (list tests
(list test-eqv ...)))) — but Guile property syntax requires a literal
array.

Therefore I created a reader-extension⁴ which allows creating literal
arrays with indentation-based syntax using the hash-extension ##:

define : hello who
    . "Say hello to WHO"
    ##
        tests
            test-equal "Hello World!\n"
                       hello "World"
    format #f "Hello ~a!\n"
                   . who

To my eyes this looks reasonably nice, and it allows using arbitrary
arrays. It uses the conventional #-extension common to Scheme which
avoids adding more constructs, and internally it just passes
## a b c
to the wisp paren-restructuring code as
(#\# a b c)
which then becomes
#(a b c)
as used in similar fashion for the other special paren-prefixes
("'" "," "#'", ...).

But it feels strange to add specialized syntax here. I would rather want
something more general — something which does not feel like opening a
can of worms of more and more syntax elements which could crop in. It
feels like straying from the path of simplicity.

Therefore I’d like to ask you for comments. Do you have ideas how this
could be made more elegant? Or is this intrinsic complexity of the
Scheme or Guile literal array prefix (and the other paren-prefixes)
which I cannot escape with wisp?

Best wishes,
Arne

¹: Wisp website: http://www.draketo.de/english/wisp

²: Wisp examples (tools with wisp):
   
https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/examples/

³: This doctest syntax is built on SRFI-64 and implemented in
   
<https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/examples/doctests.w>
   and
   
<https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/examples/doctests.scm>

⁴: The code for the reader extension consists of a single line in the reader:
       read-hash-extend #\# : λ (chr port) #\#
   
<https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/wisp-reader.w#wisp-reader.w-39>
   eight lines in the clean parser (currently mostly a hack)
   
<https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/wisp-scheme.w#wisp-scheme.w-689>
   and some special cases in the bootstrap parser and wisp->lisp converter 
which operates on bare strings
   
<https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/wisp-guile.w#wisp-guile.w-513>
   
<https://bitbucket.org/ArneBab/wisp/src/e80659fcc896ab04fbcd0a2d78e0dc25fef474a0/wisp-guile.w#wisp-guile.w-567>
-- 
Unpolitisch sein
heißt politisch sein
ohne es zu merken

signature.asc
Description: PGP signature