TO DO:
  - Make other para actions use p-threads.
  - Make exceptions work with p-threads.
  - Make it so that flows with local inputs can't be called directly
    from a para block.
  - It turns out we need three levels of parallelizability for
    methods:
        1) flow - no side effects even to members.
	2) ?? - side effects on members only.
	3) to - general side effects.
    What to name #2?   I'm tempted to make it
        1) flow
	2) to - side effects on members only
	3) clob - general side effects (clobbering time)
    Hmm.  Actually I'm not so wild about that.   How about
       1) flow  2) para 3) to
  - ?Create 'serial' function - that is gauranteed only to be 
    executed by one thread at a time.  Can be called from a flow.
  - Implement lists.
  - Implementing trees.
  - Rework code generator so that a type is kept alongside the
    data on the expression stack.
  - ?Prevent memory leakage in expressions that don't get assigned to anything
    (including function calls).
  - Prevent memory leak when casting string or object to bit.

TO CONSIDER:

  - Rip out reference counting.  Put in "coalesce and copy on 
    return" style memory management that makes heavy use of stack.

-----------
DONE
  - Make para do actions use p-threads.
  - Defining exceptions, and implementing exception chaining.
  - Implement case statement.
  - Add 'loco' parameter types to flow functions.  These reference
    local objects in the caller, so it's ok to return references
    to them.
  - Check that can call a function taking an object with a tuple
    and that it all works ok. [Nope, it doesn't...]  Fixing this.
  - Add "new" keyword, and use it for dynamically creating things
    in calls to functions and assigns to objects of parent type.
  - ?Read-only and private variables.
        Make it so that class.new() is only legal way to
	make something with private or read-only var.
  - Allow paths in includes and imports.  Make it so that the names
    are quoted.
  - Add "import module [as xxx] statement, and then let you use
    things from the module as xxx.callFunc(), xxx.useVar,
    xxx.type var1,var2. Etc.
  - Add word use analyser and xml parser to docs.
  - Make strings immutable.  Implement a mutable dyString class.
  - Beefing up string class.
  - Adding htmlFetch library.
  - More file i/o.
  - Let people access keys as well as values in a for or para ... do.
    Syntax would be
         for (key:val in collection)
	      print("$key $val");
  - Allow variable substitutions in constant strings.  Things like
       print("Hello $name, are you $(verb)ing now?");
  - Way to call parent methods in an object.  (An automatically
    declared parent variable to go with the automatically declared
    self variable.)
  - Test exceptions in classes.  (Make sure they don't free up 
    self!).
  - Exceptions.
  - Make it for (el in collection) rather than foreach (el in collection).
    Distinguish from for ( ;; ) by presence of 'in'?
  - Make it so don't need trailing ';' before a '}'
  - Adding named parameters.
  - optional init() method.
  - Do a sort function (need function pointer?)
  - Function pointers.
  - Interfaces.
  - implement para actions argmin and argmax.
  - implement dimensioning of multi-dimensional arrays as in:
      array[8] of array[8] of square checkerboard;
  - Implement 1 to 8 notation (here specifying numbers between 1 and 8, 
    not including 8).
  - Implement ++ and maybe -- (as a statement, not an expression).
  - In para do, allow writing to element, which will be kept.  As in
      array[8] of int a = (1,2,3,4,5,6,7,8)
      para (i in a) do
          i = i*i
      print(a)
    > (1,4,9,16,25,36,49,64)
  - Implement array.append pseudo-method.
  - Eliminate need for type in constructs like
       (type element in collection)
  - Implement "para into" statement.  Actually did this as
    para (el in collection) action.
  - Doing parallel checking for para and flow statements.
  - blessPara - Makes sure that there are no writes
	outside of local variables and i/o pameters, either direct or indirect.
  - blessFlow - Make sure there are no reads or writes outside
        of local variables and input/output parameters.
-------work in 2005-------
  - Reconsider where reference counting is done.  In particular
    what if instead of bumping the refcount when it goes on the
    expression stack, have system where strings and objects are
    created with a ref-count of zero, and assignment bumps the
    ref-count, and objects are de-ref-counted when they are
    removed from the stack (which for local variables occurs
    when they go out of scope).
       I played around with this for a couple of hours.  It seemed
    to actually improve the code little if any, and since there were
    still a few bugs to fix with the reimplementation I backed out
    the change.
  - Changing it so that a pf_ is prepended to all global
    symbols created by paraFlow to avoid name conflicts
    with the C libraries.
  - Make it so don't need 'self' to reference class members and 
    methods inside a method of same class.
  - Make single quotes mean literal ascii character values.
  - make tuple.pfh work right (variables not right).
  - Test default initializations across modules.
  - Make classes declared in another module work.
  - make pfh file include closing paren in :
	to fibonacci ( int iterations ) into ( long f;
	to factorial ( int n ) into ( float f;
  - Make testProg/broken/oneIntoClass.pf work.
  - Working on multiple modules.
  - Getting raw keyboard input.
  - Rename f.print and f.scan to something else.  read/write?  
    readVar/writeVar? put/get?   
  - Allow nil as a value for initializing and objects.
  - Allowing print to go to file.
  - Adding scan (to go with print).
  - Making print not die on circular links.
  - Allowing static variables inside of a function.
  - Adding default parameters to class initialization.
  - Adding default parameters to function calls.  
  - Fix bug where this construct doesn't work:
	    class keyVal
	       {
	       int key;
	       string val;
	       }
	    keyVal kv = (1, "one");
	    kv.val.upper();
    but
    	    string s = "hello";
	    s.upper()
    does work.
  - Implement += for strings and arrays.
  - Make array of var work.
  - Make sure that assigning a typed variable from a var variable
    does the right thing.
  - Get the quote to markers to work.
  - Make foreach where the collection is a member variable work.
  - Decided against letting assignments return a value, since
    the foreach var in funcCall() removes most of the need.  
  - Make foreach result in funcCall work.
  - make L work in numerical constants,
  - Make it ok to have extra trailing comma in an initialization
    before a ).
  - Making virtual functions happen.
  - Yank out constant type optimization in pfType, particularly
    in coerceType routine.
  - Sort the _pf_base_info table before writing it.
  - Make it so that during runtime the typeId's of subparts
    of collected ID's are filled in.  Currently they are often
    zero, which results in memory leakage when freeing arrays
    of objects.  This might be best accomplished by some
    sort of transitive closure either when the compiler
    writes out the type table, or when the runtime reads it
    in.
  - Put command line arguments into an array of strings the
    user can access.  Maybe commandLine[] or args[]?
  - Make foreach work on dirs.
  - Implementing dir objects.  Consider another name.
  - Allow classes to be made without initialization.  Perhaps
    () will create an instance that's filled with zero.
  - Implementing the rest of inheritance.
  - Making it so can allocate an array separate from initializing it.
  - Making it convenient to add library functions and classes.
Put in some way to do file i/o.
get test.pf to work on stuff like:
	(int x, int y) = unitCircle(3)
Test against all easy and oneFile test cases.

Add use of elements of array/tree/dir.
Implement proper strings, and allow strings to be added together.
Consider allowing strings to be added to number with the result
   being a string.

Code generator:
    Get started.
   o - Make pptIndex work on arrays.
   o - Put in cleanup of objects.
   	x - Inc ref count when put var on stack.
	x - Dec ref count when leave scope.
	x - Dec ref count of old value when var reassigned.
   o - Make array and structure assignments (as opposed to
       initializations) from tuples work.
   o - Make pptDot work on classes.
   o - put out code for methods.

Type system:
    Integrate pfSingleTypes into type system.
    Write out subset of types that can be used
        during run time.

Runtime system:
   o - Implement _pf_xxx_array_from_tuple.
   o - Change pfStack type to _pf_stack and otherwise restrict
       run-time name space to things that start _pf_.
   o - Put in cleanup of objects.
   o - Figure out alignment system that C is using in structures
       at during initialization phase, and then store this in
       the base type table.

  - Somehow allow  both ((1,2),(3,4)) and (pt1, pt2)
    initializations in _pf_class_from_tuple.
    (Currently it does (pt1,pt2) which is safe in
    case where the underlying structure contains a self
    reference, as a linked-list node will.  It used
    to do ((1,2),(3,4)) which was nicer in some senses.
    In other senses really want to even do ((1,2),pt2).
    Currently these are all flattened by the time
    pf_class_from_tuple gets to them.

    Perhaps resolve by passing a string describing this
    to _pf_class_from_tuple.   It could be as so:
        ((1,2),(3,4))  ->  ((xx)(xx))
        (pt1,pt2)  ->  (xx)
	((1,2),pt2) -> ((xx)x)
	(pt1,(1,2)) -> (x(xx))
    I wonder if this raises deeper issues about printing 
    though.  Since reciprocal references are handy,
    need some way to break the print function out of
    loops.  Need some method of expressing that a
    structure has already been seen.  How about labeling
    each node in the induced parse tree :
        ((12)(34))  
	ABCD EFG
    that is each paren or number gets a label.  Then
    when you're pointing back to some data already seen
    you put in the label instead of the value.  A
    singly-linked list of 4 elements might look like so:
        (x(x(x(x0)))  1 2 3 4
	ABCDEFGHI
    And a circular list of 4 as so:
        (x(x(x(xy)))  1 2 3 A
	ABCDEFGHI
  - Get (xx(xx)(xxx)) type tuple heirarchy definitions to work
    with arrays as well as classes.


UCSC Vacation Days for Working on ParaFlow
   Feb 2, 2006
   Feb 6, 2006
   Feb 7, 2006
   Feb 10, 2006
   Feb 13, 2006
   Feb 14, 2006
   Feb 15, 2006
   Feb 16, 2006
   Feb 17, 2006
   Feb 22, 2006
   Feb 24, 2006
   Feb 27, 2006
   March 1, 2006



Empire of Debt.
