I think so, so I would put the SRFI at least on hold.
SRFIs don't work like that. Either they are finalized, or withdrawn, or they still are under discussion or being implemented or being edited. So the best option here is withdrawal.
I therefore request withdrawal of SRFI 191.
Thus it makes sense to put SRFI 191 on hold and to discuss attaching
properties to procedures first.
Well, that's something I'd like to have (indeed, I'd like to be able to attach properties to any object with a few exceptions like numbers, characters, the eof-object, and ().)
But there's a saying: procedures are just poor man's objects (which is how they are implemented in Java and Scala), but then again objects are just poor man's procedures. In CL there's a concept of funcallable objects, and one way we could implement such a thing is to have a way of wrapping the body of a procedure so that its local variables, or some of them, are visible and settable from the outside.
Since procedures are opaque, that means we set up the procedure so that it can be called with a set of magic arguments that are guaranteed to be different (in the sense of eq?) from any arguments the procedure would normally have. (It's easy to create these as pairs or unique mutable strings, e.g.) One set of magic arguments would be for accessing the local variables, the other would be for setting them.
At the user level, a callable object type is defined by syntax specifying the type name, the fields, and their accessors and mutators. When you create a callable object, you get to specify its procedural behavior as well as the initial values of its fields.
Unfortunately, callable object types cannot have predicates that recognize them, since you cannot divide procedures into different types that react differently to predicates. Which is why they are *poor man's* objects.
I haven't worked this out in detail, but it should be portably implementable.
Comments?
Such an implementation will be portable
Well, if the system has weak hash tables, which are not yet standardized, though ephemerons, the main building block for them, are standardized.