A generic operator system connects the application of a generic procedure on
multiple arguments to the "appropriate" procedure for those specific arguments
based on type predicates.

Our problem is to take an individual object (/not/ in the object-oriented
sense of the word, but in the s-expression sense of the word) and determine
the set of procedures which /could/ be applied to it based on type predicates
and present these options interactively to the user in a useful manner.

Lookup for an individual object is O([number of operators]) and O([number
of predicates per operators]). Memoization could save time here if needed.

We will consider and demonstrate this system in the domains of a) the R5RS
Scheme builtin types and procedures and b) the scmutils types and special
procedures for mathematics and physics. Our "range" for these domains will
be an interactive REPL environment (or just text interaction?) and a GTK 
graphical user interface.

Other domains this system could be applied to include:
    random correctness or unit testing of complex systems
    automatically generated generic user interfaces

Related problems (which could be covered by this work?):
    chaining procedures (eg if f maps A->B and g maps B->C, then gof maps
        A->C which might be what we want

----------------

To try and/or think about:

* GUI
* image processing
* memoization
* graph-search predicate satisfaction (keep reiterating until predicate sat.)
* randomized testing
* introduction of constants as 0-arity generics?
* generic predicates
* find and play with other existing generic dispatch systems (SFRIs? xml?)

-----------------
GUI Spec/vision

A basic GUI would take a single object and display the named operators which
could act on it as a list with a button for each; clicking the button would
evaluate that operator and pop up a new window with the text/pp result.

One generalization would be to have the popup result be a list of named 
operators which could act on that object.

Another generalization would be to allow multiple objects and show their 
possible combinations for each operator (maybe with a pull down menu?)

Another generalization would be to show higher-arity operators with a text box
that the user could enter in values for. This could be done even without any
initial object! Just show the possibilities.

The search for operators could be filtered some how so only interesting
operators are displayed; it could also be done as a continuation so that the
first 10 would be displayed, then there would be a button to view the next 10
operators (eg, turn the search problem into a stream).


-----------

* predicate satisfaction search
* predicate could be "this is a simple equation"
* data un-corruption: have a validity predicate