Usability issue

[Andre van Tonder <andre@xxxxxxxxxxxxxxxxxxx>]

I have recently had the occasion to attempt to use a (refined) version of this
SRFI to implement a nontrivial records proposal.  In the end I had to 
abandon computation-rules and use a more primitive continuation-passing
style instead
 
  (see http://groups.google.com/groups?selm=4112BD31.CA50FB3A%40het.brown.edu) 

because of the following important usability issue:

The following common patterns in these kinds of macros do not 
work:

  (syntax-bind ((x (long-computation)))
     (syntax-return 
        (begin (define f ( ....... x ......))
               (define g ( ....... x ......))
               ...))))
                        
or 

  (syntax-bind ((names (long-computation)))
     (syntax-return (emit-definitions names)))
               
where 

  (emit-definitions name ...) =
     (begin (define name ..............)
            ...))
            
The problem in both of these macros is that syntax-bind has to substitute 
x or names in its body, for which it needs the following
macro, which tests for bound equivalence of identifiers:

(define-syntax bound=
  (syntax-rules ()
    ((bound= id b kt kf)
      (letrec-syntax
          ((id (syntax-rules ()
                 ((id kt* kf*) kf*)))
           (ok (syntax-rules ()
                 ((ok kt* kf*) kt*)))
           (test (syntax-rules ()
                   ((_ b kt* kf*) (id kt* kf*))))
        (test ok kt kf))))))
          
Because the continuations are expanded in the scope of the 
letrec-syntax, some Schemes (e.g. MzScheme, but not Chez) 
regard any definitions in the result as internal.  This is in my 
opinion a conceptual error, but it is compatible with R5RS, which 
does not fix the behavior.  

Since the only way to portably define bound= is in terms of let-syntax,
this problem, unless resolved, in my view severely restricts the usability 
of this SRFI.
 
The problem can be trivially fixed in MzScheme by defining bound= 
as follows instead:

(define-syntax bound=
  (lambda (stx)
    (syntax-case stx ()
      ((_ id b kt kf)
       (if (bound-identifier=? (syntax id) (syntax b))
           (syntax kt)
           (syntax kf))))))
           
but that conflicts with the aim of making this SRFI portable, as it 
would require some implementor effort in Schemes that do not expose 
an equivalent of bound-identifier=?   What is worse, we cannot specify
the semantics of computation-rules on the basis of syntax-rules, which 
was originally my aim.  It is also likely that future refinements of 
R5RS will go the MzScheme way, which will indeed make it impossible
to define a useful bound= in terms of syntax-rules (unless  
bound= and free= are offered as primitives, which would be a simple 
but useful extension of the standard).  

I am therefore in a bit of a quandary.  I would like to be able to offer
a nontrivial example (such as the records implementation referred to above)
before completing this SRFI.  At present, this is impossible to do
portably.  





          
          
                        


------------- End Forwarded Message -------------