

1. Reference-chains (with "the" or "the-object") entered into Slime
   REPL (or anywhere else outside of a define-object context) should
   still provide an enriched-decoded-arglist in the mini-buffer, iff
   the global gdl:self is bound (which it typically will be, if
   someone is typing reference chains at Slime REPL). 

   In that case, the global gdl:self should be the starting class for
   any reference chains.

   example:


   GDL-USER> (make-self 'robot-drawing)
   #<ROBOT-DRAWING #x302004739C4D>
   GDL-USER> (the 

    Now the mini-buffer should show completions of "(the ..." based
    on the fact that self is an instance of robot-drawing.


    N.B. self is not declared special in Gendl currently. It probably
    should be, but I am not sure what would be the ramifications of
    doing this. Needs to be investigated (on my end).  For now it
    should be left as-is and not declared special with defparameter or
    defvar.


2. Within the-child and the-object, glime was incorrectly picking up
   the messages-in-this-form as well as the messages from the :type of
   the current child object. This has been fixed for now by binding
   *message-locators* to simply '(messages-from-classes) in
   compute-enriched-decoded-arglist for the-object and the-child. I'm
   not sure if this is the best way to go about this, because there is
   another case where messages-in-this-form should not be included
   (see (3) below).

3. In reference-chains after the first message, i.e. 

     (the foo ...)  

   it is still picking up messages-in-this-form. At that point it
   should only be picking up messages-from-classes for the class-of
   (the foo) [if any].


4. Sequence (quantified) objects are still showing up for "(the ..."
   and they should only show up for "(the (..." [i.e. they should
   behave like Functions]

    example:

   (define-object frob ()
   
    :objects ((baz :type 'box
                   :sequence (:size 10))))

   ;; compile above form. Now do 
 
    (make-self 'frob)
    (the ... 

   Typing "(the ..." should not include baz

   Typing "(the (..."  _should_ include baz. 



5. a. "(the-object foo (evaluate ... "  should work identically to 
      "(the-object foo ..." except symbols should show up as keywords. 

   b. "(the-object foo ((evaluate ... "  should work identically to 
      "(the-object foo (..." except symbols should show up as keywords. 



 Thinking ahead to v 0.3:
 ========================

 Things to start thinking about for future: What are some good
 places/contexts to start pulling up and presenting the
 docstrings (i.e. the message-remarks) for
 input-slots/computed-slots/functions etc?  (so far we haven't done
 anything with message-remarks). And how about best ways to
 specify/interrogate/present documentation for individual arguments to
 GDL Functions? (currently they are documented using a tortured
 convention within the doc-string, which has to be kept manually in
 sync with the actual lambda list --- it would be nice to be able to
 have the documentation embedded right there in the lambda list along
 with the args --- borrowing some meta-data ideas from Clojure
 perhaps?)


