*** Put stuff that is not started in this file ***
*** For bugs see bugs.txt                      ***

* Create menus for the game

* Clean up documentation
  - Add more blank lines in .lsp and .nw source
  - Add forward references for early stuff that were made before the later stuff

* Fix the interfaces for enumerated types and enumerated functions to
  make them like sets: taking an old address, returning a new address
  and not modifying their argument

* Easier interface to testing framework

* write tests for:
  - sets
  - function-quotient
  - pairs
  - strings
  - eval
  - current type function for type-sums

* Make Max functions out of all the functions in the interfaces that are defined 
  so far.  Use builtins as needed.
  - List of all functions to make into max functions follows, with comments

addr
ADDR-TYPE - Done - Unneeded - It must take an object as argument, but
  objects are sum types so they have CURRENT-TYPE
ADDR-EQUAL - Done (untested)
MAKE-ADDRESS - reflection on enumerated types, make explicit like
  FUNCTION-IMPLEMENTATION
MAKE-TYPE - given some definition of a type using Max data structures,
  return a max type - ...long way off
TYPE-SUM - Prereq - takes arbitrary number of args - needs a collection without uniqueness
MAKE-SUM-CONSTRUCTOR - Done
GET-CONSTRUCTORS - Done
CURRENT-TYPE - See ADDR-TYPE
TYPE-PRODUCT - Prereq - requires Max lists
PRODUCT-TYPES - Prereq - returns a list
MAKE-PRODUCT-ADDR - Prereq - takes a list
PRODUCT-VALUES - Prereq - returns a list

adventure - Later

boolean
nullary functions returning TRUE and FALSE: Done
boolean identity: Done
NOT: Done
AND, OR - Done
XOR, etc - Later

catalog
GET-PUBLIC-FUNCTIONS - Done
GET-PUBLIC-TYPES - Done
PUBLIC-INTERFACE - Done

eval

function
MAKE-FUNCTION - creating enumerated functions from a set of tuples
  could be done easily, do later
FUNCTION-IMPLEMENTATION: reflection - retrieve max data structures that
  can be passed back to make-function
DOMAIN, CODOMAIN - Done
FUNCTION-APPLY - Don't do - Doesn't exist in Max design - Use function-source instead
FUNCTION-QUOTIENT - Done

name
NAMES - Done

pointer
DEREF - needs type sums for the return value
CHANGE-PTR - type products needed
MAKE-PTR - type products needed

relation
SELECT - Done
PROJECT - Needs addressing for the member types of a product type, do
  after product operations above
UPDATE - Done
DELETE - Done

set
Max function MAKE-EMPTY-SET - Done
Max constructor MAKE-SET requires Object - Deleted
Max functions SET-ADD [Done], SET-MEMBER, MAPSET, SET-UNION, SET-INTERSECT,
SET-DIFF, SET-REMOVE, SET-SUBSET, SET-EQUAL - Done

string
MAKE-STRING - needs some sort of character type, plus a sequence type; not urgent
CONCATENATE - Done

Pointers stuff:
* Change implementation of pointers to use a Max function.
  (Meanwhile, making pointers actually work again, and creating tests for 
  them)
  - DEREF can be a Max function since type sums are implemented
* Make pointers use data sources and sinks
  Pointers currently use a hash value inside the enumerated type.
  The pointer contains a SINK- which has an entry in SWITCHBOARD pointing at
  the data source that is feeding the pointer.
  The pointer provides a SOURCE- for reading it.
  The purpose of a pointer is to provide an address- 
* Make all pointers restricted pointers
  (since they can restrict to Objects, which is no restriction)

* Make Max functions out of all the functions in the interfaces for
  types and functions.  Or, if some of these have side effects, make 
  continuations of them.
  The Max function version of some functions should take Max tuples:
  - FUNCTION-APPLY should take a Max tuple of <function, argument>
  - MAKE-FUNCTION should take a set of max tuples as its 3rd argument
  - FUNCTION-CHANGE should take a tuple of <argument, result>

* Work on text adventure game (should be able to walk around, pick up 
  items, drop them, list inventory, and examine items and locations)

* Add more operations to strings
  - Use strings to actually label stuff, name and document stuff 
    internally

* Verify all hash tables use the correct comparison (EQ, EQUALP, etc.)
  for the data that might be stored in them