Wish list for features in MACL 2.0

[John M. Canning <jc@cvl.umd.edu>]

  Here's some requests for features in MACL 2.0 (or 2.1 if 2.0 is now
fixed in cement).

  I would love to have a function that returns the arglist of a function as
a list of symbols.  Currently, I use ccl::arglist-to-stream and then read
the stream to create a list of symbols.  This is rather cumbersome.  Also,
could structure access functions have a uniform arglist?  In MACL 1.3.2, the
access functions for the first nine fields of a structure get an argument
list of (arg-1) while the fields after the ninth get (structure-name).  To
illustrate:

? (defstruct q f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11)
? (dolist (func '(q-f1 q-f2 q-f3 q-f4 q-f5 q-f6 q-f7 q-f8 q-f9 q-f10 q-f11))
    (format t "~&~A: " func)
    (ccl::arglist-to-stream func t))
Q-F1: arg-1 
Q-F2: arg-1 
Q-F3: arg-1 
Q-F4: arg-1 
Q-F5: arg-1 
Q-F6: arg-1 
Q-F7: arg-1 
Q-F8: arg-1 
Q-F9: arg-1 
Q-F10: Q 
Q-F11: Q 
NIL

  It would be much more convenient to have uniform arglists for all the
fields.  I prefer the (structure-name) form, even though it is redundant.
If there are special forms other than defstruct that automatically produce
similar functions, I would hope that their arglists are uniform too.
It would also be convenient if Edit Definition and Option-. could find the
the defstruct form when given the access functions (in the same way that
global variables can find their defvar forms).

  It would be nice to have control over the output routines that chop output
lines to fit within the width of the destination fred window.  I would like to
be able to chop the output only at whitespace (i.e. only insert newlines next
to other whitespace characters) so that when I highlight such text and
evaluate it, it reads back the same way that it was written.
For example, in a really narrow listener window:

? '(foo bar baz booze)
(FOO BAR B
AZ BOOZE)

If you now highlight the result and evaluate it in another expression, e.g.
? (length '(FOO BAR B AZ BOOZE))
5

it gives a different result than what would be expected.  You can use the
listener's asterisk variables to get the exact result, but that's only good for
the last 3 results and you get the entire result instead of being able to 
highlight a portion of the result.

  This chopping function would also be very useful for justifying text in fred
windows in the way that emacs justifies text in text mode.  The function takes
a set of text lines (a string) and inserts and removes spaces, tabs and
newlines to fit the text within the width of the buffer (and preserves the
indenation of each line).

  Probably the most useful improvement would be a way to return a value (or
values) from a frame on the backtrace stack.  It is really frustrating to
run a large program for several hours (or even days), get stuck in an error,
and not be able to restart the program from where it stopped.  One way to do
this would be to make every lisp error a continuable error where the user
could type a form to evaluate for the result of the function that caused the
error.  An even more useful solution would be to add a similar function to
the menu of functions that the inspector pops up when you double click on a
function in the Stack Backtrace window.  The stack would have to be unwound
to the specified frame and the given value put on the stack as the return
value.

  I hope some of these suggestions, appear in 2.0.  They would really help.

           - John Canning