RECENT CHANGES TO DUCK:

86.06.13:

New device for dealing with forward references to predicates in Duck files:
(DEFER-SYNTAX-CHECKS) causes rules to be queued up and checked later,
  on the next occurrence of . . . 
(DO-SYNTAX-CHECKS) which checks all the queued rules in the order they
  were queued.
These pairs may be nested; they are suitable for using as "brackets" in files,
DEFER at the front, DO at the end, when presumably all the predicates will
be defined.

86.05.30:

New functions for manipulating ENVs.  It should no longer be
necessary to unzip in public.

(SUBSUMES p1 p2): Is p2 an instance of p1?

(SAME-UNIFY p1 p2 alist): Like UNIFY, except the alist applies
   to both p1 and p2.  The RALISTs of the envs returned will
   always be (); any bindings will appear in the LALISTs.

(ENV-ALIST env side): side is RIGHT or LEFT.  Returns a clean
   (= unzipped) alist from the env.

(ENV-SHOWS-SUBSUMPTION env side): The env is the result of
   unifying two patterns.  This function tests whether the
   one on the given side (RIGHT or LEFT) subsumed the other.

(ENVSUBST pat env side): Produce a new version of pat by substituting
   away any variables that come from the *other* side.  In their
   place will appear expressions looked up in env, including variables
   from side, and new variables if necessary.

   Example: if P1 = (FOO (F ?X) (G ?Y)), P2 = (FOO (F ?Z) ?W),
   then unifying them gives env
       E1 with left  alist ((X (ENVJUMP ?Z)))
	       right alist ((W (ENVJUMP (G ?Y))))

   Then (ENVSUBST '(BAZ ?X ?Y) E1 'RIGHT) => (BAZ ?Z ?_45), where
      ?_45 is new (because ?Y was not bound to a variable from the
      right side).
      Note that the given side (RIGHT) specifies the target variables.
      The variables in pat should be from the other side (here, LEFT);
      any other variables will all be replaced with new
      variables.
   Going the other way,
      (ENVSUBST '(BLECH ?Z ?W) E1 'LEFT) => (BLECH ?_46 (G ?Y))

86.05.29:

New functions:

(ASSERTION name fmla) : What used to be called RULE.  Note:
   obsolete syntax (RULE name pat <- body) has been flushed.

(ASSERTION-GROUP name -fmlas-): Assigns names name-1, name-2, etc.
  to the component formulas.

(ASSERTION-ADD assertion)
(ASSERTION-PREMISS assertion)
(ASSERTION-ERASE assertion)

(ASSERTION-IS-IN assertion): Tests whether it's visible in the current
   datapool.

New switch:

ERASE-REDEFINED-ASSERTIONS* (default NIL): If T, redefined assertions
   will be erased first.  In the past, their old consequences were
   left standing, and that's still the default.  (This saves time,
   and since most redefinitions are no-ops, it seems reasonable.)

86.05.28:

New syntax checker.  Allows Nisp-style variable declarations in
FORALL and EXISTS binding lists.

Switches:

SYNCHK* : If NIL, no syntax checking or Skolemization.
PROVE-DECLARATIONS*: If T, declarations in variable-binding lists
   turn into formulas of the form (IS <type> <variable>)
DECLARE-FREEVARS*: If T, undeclared free variables (distinguished
   only by question marks) are declared the first time they are
   seen.  So in (AND (FOO ?X) (BAZ ?X)), if FOO expects a NUMBER,
   and BAZ doesn't accept numbers, an error will be generated.
GUESS-DECLARATIONS*: If T, undeclared symbols do not cause errors.
   Instead, an undeclared function gets declared when first spotted
   in a construct (F a1 ... aN)
   to be of type
   (FUN obj (obj obj ... obj)), with N obj arguments.
   Undeclared constants are just ignored.
FIRST-ORDER*: If T, nothing can occur in functional position except
   a symbol denoting a function.

Default settings:
		       Duck               Logicalc
SYNCHK*                 T                   T
PROVE-DECLARATIONS*     NIL                 T
DECLARE-FREEVARS*       T                   T
GUESS-DECLARATIONS*     T                   NIL
FIRST-ORDER*            NIL                 T

Infix is now an option, initially turned off.  To toggle it,
execute (INFIX).
