The New PAC GUI:

    - Now uses "load" file that loads all of the component files needed
      to execute the PAC.  This organizes the code by keeping the file
      sizes manageable.

    - Now allows for the specification of desired output precision for
      evaluations.  

      The definition of precision implies that the last digit can be off
      by 1.  This means that 1.2030 is in the range [1.2029, 1.2031]

      Positive precision values sets the number of digits in the
      mantissa; and option to set scientific notation exponent will come
      later.  Note that it allows negative precision values, which
      handles rounding on the left of the decimal place. (-2 precision
      for the expression sqrt(2)*1000 gives 1400)


All You Need is Lambda:

    - Recall the lambda versions of cons, first, and rest: lcons,
      lfirst, and lrest.  In the DEMO file are the new versions clcons,
      clfirst, clrest.  The c denotes that these are the curried
      versions, named after Haskell B. Curry, who worked out this
      method.

      Currying refers to the method of defining a series of function
      applications that each take only one argument, and produce another
      function to be applied to the next argument.  Curried
      lambda definitions, then, are of the form 

      (lambda (x) (lambda (y) (lambda (z) (...))))

    - lambda-defined conditional functions are specified in the DEMO
      file.  lifthen generates an if-then-else conditional structure.
      ltrue is the lambda representation of true, and lfalse is the
      lambda representation of false.


    - The lambda versions of these common functions are easily
      demonstrated to work properly by noticing the following
      properties:

      (clfirst ((clcons x) y)) --> x
				     ==> cons, first, rest behavior preserved
      (clrest ((clcons x) y)) --> y


      (((lifthen ltrue) x) y) --> x
				     ==> if-then-else behavior preserved
      (((lifthen lfalse) x) y) --> y


    - lambda-defined integers:

      Abstractly, an integer can be thought of as a function that is
      defines itself as the successor of another. One, then, is the function
      that defines itself as a successor of "something" called zero.
      See the DEMO for this notion implemented in the form of
      lambda-defined integers.

      The function lint->integer provides a readable representation of
      the abstract linteger structure.  lincrement applies a sucessor
      lambda-function to the input linteger, which itself is a series of
      successor functions, all the way down to zero.