Am Mi., 1. Juli 2020 um 00:39 Uhr schrieb John Cowan <xxxxxx@ccil.org>:
>
> My sense is that people still think this is too underspecified to be useful.  I do think Dybvig's bitwise strategy is better than the original SRFI's, but it doesn't solve the semantic issues.
>
> I'm wondering if it's worthwhile my investing more time in it.

I think so, so I would put the SRFI at least on hold. I think the
upshot of the discussions here and in the previous attempt, SRFI 102,
is that the arity of a procedure is only well-defined through the
syntactic form (lambda or case-lambda or primitive) that has produced
the procedure and is not a property of the behavior of the procedure.

Thus it makes sense to put SRFI 191 on hold and to discuss attaching
properties to procedures first. On top of such an idea (if it looks
realizable) one can implement arity inspection and doc strings.

A simple, incomplete approach could be:

(import (rename (scheme base) (lambda scheme-lambda)))

(define *prop-table* (make-weak-hash-table ...))

(define (procedure-set-property! proc key value) ...)

(property-set-property! car 'arity arity-of-car) ...

(define-syntax lambda
  (syntax-rules ()
    ((_ formals . body)
      (let ((proc (scheme-lambda formals . body)))
        (procedure-set-property! proc 'arity (formals->arity 'formals))
        (procedure-set-property! proc 'doc (body->doc 'body))
        proc))))

Such an implementation will be portable but will also be horribly
inefficient so one has to see whether a native implementation does not
oppose certain optimizations.

Marc