Issue: FUNCTION-COMPOSITION (Version 1)

[Jim McDonald <edsel!jlm@labrea.stanford.edu>]

The following is a sketch of some other possibly useful operators.
Maybe some kind soul out there will adopt them and make a real
proposal to add them. 

Note that the notions of permutation-vector are actually just a
first stab--one might really want some lambda-list -> lambda-list
operator that understands &optional, &key, &rest, etc.  It might
also be useful to have an operator that permitted deletion or
repetition of arguments.  

I think the caveat about redefinition of the given function should
be added to the existing proposal and apply to all the composition 
functions. 

   COMMUTE function                                    [Function]

    Returns a function whose value is the same as that of the
    given function applied to the same arguments with the first
    two interchanged.

   PERMUTE function argument-permutation
           &optional value-permutation                 [Function]

    Returns a function whose values are a permutation of the
    values which would be returned by an application of the given
    function to a permutation of its arguments.

    If argument-permutation is NIL, the effect is as if all 
    arguments were passed to the given function without being
    permuted.  If it is non-NIL, it must be a sequence of integers
    containing a permutation of an initial subset of the natural 
    numbers, and the effect is as if each argument, at position i,
    is first moved to position (elt argument-permutation i) before
    the given function is called.  

    If values-permutation is NIL, the effect is as if values were
    returned from the given function without being permuted.  If 
    it is non-NIL, it must be a sequence containing a permutation
    of an initial subset of the natural numbers, and the effect is
    as if each value, at position j, is first moved to position 
    (elt value-permutation j) before the result function returns. 

    Note that in practice such argument and value movement could
    be implicit in the behavior of the result function, and the
    given function might never be called.  Hence subsequent 
    redefinitions of the given function may have unpredictable 
    effects on the behavior of the result function.

Examples:

   (FUNCALL #'(LAMBDA (X Y) (CONS Y X)) 1 2)
   ==
   (FUNCALL (COMMUTE #'CONS) 1 2) 
   =>
   (2 . 1)


   (FUNCALL #'(LAMBDA (A B C D E F) (LIST C B A F E D)) 11 22 33 44 55 66)
   ==
   (FUNCALL (PERMUTE #'LIST #(2 1 0 5 4 3)) 10 11 12 13 14 15 16)
   =>
   '(12 11 10 16 15 14)


   (FUNCALL #'(LAMBDA (I J)
                (MULTIPLE-VALUE-BIND (Q R) 
                    (TRUNCATE I J)
                  (VALUES R Q)))
            10 3)
   ==
   (FUNCALL (PERMUTE #'TRUNCATE nil '(1 0)) 10 3)
   =>
   1
   3