----------------------------------------------------------------------
          isa-mode -- GNU Emacs support for Isabelle

                    IDEAS and DREAMS 
----------------------------------------------------------------------


Please feel free to send me more ideas and suggestions to add to this
list, or - even better - offers to implement something from it!

					     - David Aspinall.
					       (da@dcs.ed.ac.uk)


====================                      

* A simple useful addition would be a function isa-copy-interactive-line
  which could be used to step through interactive proofs in a file.
  Presently this can be done by mouse/cursor, but it is 
  unnecessarily tedious.  This could be linked in with the
  "proof" buffer (see below) in a function isa-replay-proof which
  grabs a proof (interactive or non-interactive) from an ML
  file into a fresh proof buffer and begins replaying it.

* LOGIC.el files for customization per-logic.

* Handling files and buffers that may be loaded into an
  interaction session (using comint source file fns).

* Really need logic-name and root-logic-name, the latter used for
  rule tables, provers, etc.  Also, user logics should be provided
  for in a better way.

* Need a way of specifying logic-specific tactics/provers and
  rule lists along with rules:
  Add isa-ml-boundp (val) and isa-ml-type (val &optional noerror)
  to allow rule lists and tactics in ruletables: for rule lists
  delete surrounding "[]" and for tactics insert 
  "by (<tactic> %s)" or just "by <tactic>" depending on type.
  Might also be good to handle qualified names in ruletables.

* Could tidy up handling of tracting - should we grab into
  proofstate instead of using the Isabelle buffer?  Put
  prompting into the minibuffer?

* texinfo documentation 
     - instructions for using isa-mode
     - a version of the reference manual on-line?

* Recording interactive proofs - Listener.  
  I'm not convinced of the usefulness of the Listener buffer - a
  complete history of commands is a bit too general really,
  particularly when it is available in the Isabelle buffer, by
  paging backwards or using the comint history mechanism.  A
  better idea would be to have a *proof* buffer which accumulates
  commands since the most recent "goal".  The push_proof commands
  could be watched for to manage several such buffers.  Commands
  issued to Isabelle which don't affect/reference the proofstate
  could be appended to a "proof preamble" (e.g. making lists of
  rules, simpsets, etc).  Won't be perfectly automatic.  Have
  extract-interactive-proof, extract-batch-proof to create *proof*
  buffers from regions of ML files, and command
  replay-proof-command to step through each command in an
  interactive proof.

* Goalify could do with improving: it should be a bit more
  flexible, permitting proofs starting with "goal ...", and even
  not ending with result (might prompt for rule name).  Also,
  shouldn't use replace-regexp - means undo doesn't work properly.

* Bells and whistles: icon bitmaps, colours, more extents, etc,
  etc...  Also be good to extentify/highlight completed proofs
  somehow, or annotate in some way.  Also, implement "intelligent"
  filtering.

* Is behaviour of tactic,etc shortcuts annoyingly inconsistent?  -
  should assume, resolve prems, etc, wait for RET to submit input?
  Another possibility is to use the minibuffer for input in tactic-entering
  functions: (or editing the current line of ML) if the tactic
  menus become accessible from the Proof State buffer, the
  Isabelle buffer itself would become only of esoteric interest.
  (for "advanced" use).

* Minibuffer and temporary buffer for tracing.

* Templates in theory mode aren't worth much.  Input from
  minibuffer?  Flash stuff in Lucid, like CS1?  (not worth it,
  really...)

* Ruletable option for filtering of resolvable rules to
  highlight only those applicable in the current proofstate.

* Conversion from all this horrible elisp into ML !!?
  (eXene, Poly/ML for X)...  - or perhaps not.

* Integration with the pretty printer to allow special bit-maps
  for non-ASCII characters...

* What's the state of art in other theorem prover interfaces?
  Which things could be done usefully and easily inside Emacs and
  which not?



