:parse_keyexp   (string keyexpression, object player)
	=> returns an object or list for the new key as defined by the
keyexpression or a string describing the error if it failed.

:eval_key       (LIST|OBJ key, testobject)
	=> returns true if the given testobject satisfies the key.

:unparse_key    (LIST|OBJ key)
	=> returns a string describing the key in english/moo-code terms.

Grammar for key expressions:

    E ::= A       
       |  E || A  
       |  E && A  
    A ::= ( E )   
       |  ! A     
       |  object  
       |  ? object  

Trigonometric/Exponential functions:

  sin(a),cos(a),tan(a) -- returns 10000*(the value of the corresponding
                       trigonometric function) angle a is in degrees.
  arctan([x,]y)        -- returns arctan(y/x) in degrees in the range -179..180.
                       x defaults to 10000.  Quadrant is that of (x,y).
  exp(x[,n])           -- calculates e^x with an nth order taylor polynomial

  combinations(n,r)    -- returns the number of combinations given n objects
                       taken r at a time.
  permutations(n,r)    -- returns the number of permutations possible given
                       n objects taken r at a time.

  div(n,d)             -- correct version of / (handles negative numbers correctly)
  mod(n,d)             -- correct version of % (handles negative numbers correctly)
  divmod(n,d)          -- {div(n,d),mod(n,d)}
  parts(n,q[,i])       -- returns a list of two elements {integer,decimal fraction}

  sqrt(x)              -- returns the largest integer n <= the square root of x
  pow(x,n)             -- returns x^n
  factorial(x)         -- returns x!

  fibonacci(n)         -- returns the 1st n fibonacci numbers in a list
  geometric(x,n)       -- returns the value of the nth order geometric series at x

  gcd(a,b)                  -- find the greatest common divisor of the two numbers
  lcm(a,b)                  -- find the least common multiple of the two numbers
  are_relatively_prime(a,b) -- return 1 if a and b are relatively prime
  is_prime(n)               -- returns 1 if the number is a prime and 0 otherwise

  random(n)                             -- returns a random number from 0..n if n > 0 or
                                        n..0 if n < 0
  random_range(n[,mean])                -- returns a random number from mean - n..mean + n
                                        with mean defaulting to 0
  simpson({a,b},{f(a),f((a+b)/2),f(b)}) -- returns the numerical approximation of
                                        an integral using simpson's rule

  AND(x,y)           -- returns x AND y
  OR(x,y)            -- returns x OR y
  XOR(x,y)           -- returns x XOR y (XOR is the exclusive-or function)
  NOT(x)             -- returns the complement of x
      All bitwise manipulation is of 32-bit values.

These routines are useful for finding out information about individual objects.

Examining everything an object has defined on it:

  all_verbs          (object)          => like it says
  all_properties     (object)          => likewise
  findable_properties(object)          => tests to see if caller can "find" them
  owned_properties   (object[, owner]) => tests for ownership

  ancestors(object[,object...])         => all ancestors
  descendants      (object)             => all descendants
  ordered_descendants(object)           => descendants, in a different order
  leaves           (object)             => descendants with no children
  branches         (object)             => descendants with children 
  isa        (object,class)             => true iff object is a descendant of class (or ==)
  property_conflicts (object,newparent) => can object chparent to newparent?
  isoneof     (object,list)             => true if object :isa class in list of parents

  contains (obj1, obj2)                  => Does obj1 contain obj2 (nested)?
  all_contents (object)                  => return all the (nested)
  contents of object locations (object)  => list of location hierarchy above object

  has_property(object,pname) => false/true   according as object.(pname) exists
  has_verb    (object,vname) => false/{#obj} according as object:(vname) exists
  has_callable_verb          => same, but verb must be callable from a program
  defines_verb               => does this object *define* this verb
  match_verb  (object,vname) => false/{location, newvname}
                               (identify location and usable name of verb)

  connected         (object) => true if object is a player and is connected

Many of the above verbs have ..._suspended versions to assist with very large object hierarchies.

The following exist:
	descendants_suspended              
	branches_suspended                 
	leaves_suspended                   
	all_properties_suspended           
	descendants_with_property_suspended

For a complete description of a given verb, do `help $perm_utils:verbname'

:controls(who,what)                   -- can who write on object what
:controls_property(who,what,propname) -- can who write on what.propname
These routines check write flags and also the wizardliness of `who'.

(these last two probably belong on $code_utils)

:apply(permstring,mods)               -- used by @chmod to apply changes
                    (e.g., +x) to a given permissions string

:caller()                             -- returns the first caller in the
                    callers() stack distinct from `this'

A sequence is a set of integers (*)
This package supplies the following verbs:

  :add      (seq,f,t)  => seq with [f..t] interval added
  :remove   (seq,f,t)  => seq with [f..t] interval removed
  :range    (f,t)      => sequence corresponding to [f..t]
  {}                   => empty sequence
  :contains (seq,n)    => n in seq
  :size     (seq)      => number of elements in seq
  :first    (seq)      => first integer in seq or E_NONE
  :firstn   (seq,n)    => first n integers in seq (as a sequence)
  :last     (seq)      => last integer in seq  or E_NONE
  :lastn    (seq,n)    => last n integers in seq (as a sequence)

  :complement(seq)        => sequence consisting of integers not in seq
  :union    (seq,seq,...) => union of all sequences
  :intersect(seq,seq,...) => intersection of all sequences
  :contract (seq,cseq)              (see `help $seq_utils:contract')
  :expand   (seq,eseq[,include])    (see `help $seq_utils:expand')
  
  :extract(seq,array)           => array[@seq]
  :for([n,]seq,obj,verb,@args)  => for s in (seq) obj:verb(s,@args); endfor

  :tolist(seq)            => list corresponding to seq
  :tostr(seq)             => contents of seq as a string
  :from_list(list)        => sequence corresponding to list
  :from_sorted_list(list) => sequence corresponding to list (assumed sorted)
  :from_string(string)    => sequence corresponding to string

The representation used works better than the usual list implementation for sets consisting of long uninterrupted ranges of integers.
For sparse sets of integers the representation is decidedly non-optimal (though it never takes more than double the space of the usual list representation).

(*) i.e., integers in the range [$minint+1..$maxint]. The implementation depends on $minint never being included in a sequence.

  i               if       i < f1
  i-(a1-f1)       if a1 <= i < f2
  i-(a1-f1+a2-f2) if a2 <= i < f3 ...

  i               if               i < f1
  i+(a1-f1)       if         f1 <= i < f2-(a1-f1)
  i+(a1-f1+a2-f2) if f2-(a1-f1) <= i < f3-(a2-f2)-(a1-f1)

 union(set, set, ...)        => union
 intersection(set, set, ...) => intersection
 intersection_preserve_case(base set, set, set, ...)
        => intersection with the case of the base set's elements preserved

 diff*erence(set1, set2, ..., setn)
        => result of removing all elements of sets 2..n from set 1.
 exclusive_or(set, set, set, ...)
        => all elements that are contained in exactly one of the sets

 contains(set1, set2, ..., setn)
        => true if and only if all of sets 2..n are subsets of set 1

 equal(set1, set2)
        => true if and only if set1 and set2 are equal