> Could you and Ciprian work together on coming up with a proposed format
> that would satisfy your combined goals?  The idea would be to encode all
> the information your code is already able to extract, in addition to the
> manually added category information, while being extensible to support
> the more detailed type information, for example, that Ciprian
> envisions.  There's no need to specify exactly how that detailed type
> information, etc. would be encoded — just how a place would be held in
> the format so that it could be added later.

Well, the current procedure definitions look like this:

     (symbol
       (name "make-list")
       (procedure
         (arg "n")
         (arg "fill" optional)
         (return "list")))

A naive version would just append the argument types (Ciprian will have
better ones):

     (symbol
       (name "make-list")
       (procedure
         (arg "n" nonnegative-integer)
         (arg "fill" optional T)
         (return "list" (list-type-length T n))))

Ciprian's version separates all combinations of required and optional
arguments so that each combination is a separate arglist. Because there
can be interdependencies between arguments. E.g.:

    (make-vector
      (type constructor)
      (export scheme:base)
      (signature
        ((range-length-zero) -> vector-empty)
        ((range-length-zero any) -> vector-empty)
        ((range-length-not-zero) -> vector-not-empty)
        ((range-length-not-zero any) -> vector-not-empty)))

That doesn't have arg names but they can be added next to the types.

The "breaking down" of all different combinations of optional arguments
would be the key difference between our approaches. It would be possible
to generate a broken-down version from the traditional Lisp version, or
vice versa. Specifying really precise types is easier when using the
broken-down versions. But the traditional Lisp versions map 1:1 to the
look in the SRFIs and will probably be more often referenced in the near
future (e.g. what Schemers would be used to seeing in an Emacs help popup).

Ciprian, what's your current feeling about what the best place would be
to store your type signatures? Would you like to have them in the same
metadata file or a different one?

Also, would the type signatures affect syntax definitions, or would
those be done in traditional Lisp style?