Google
 

Trailing-Edge - PDP-10 Archives - mit_emacs_170_teco_1220 - info/maclisp-commands.info
Click info/maclisp-commands.info to see without markup as text/plain
There are no other files named maclisp-commands.info in the archive.

File: Maclisp-Commands, Node: Top, Up: (Languages)Maclisp

atom            SUBR 1 arg
     The atom predicate is nil if its argument is a dotted-pair  or  a
     list,  and t if it is any kind of atomic object such as a number,
     a character string, or an atomic symbol.

fixp            SUBR 1 arg
     The fixp predicate returns t if its argument is  a  fixnum  or  a
     bignum, otherwise nil.

floatp          SUBR 1 arg
     The  floatp  predicate returns t if its argument is a flonum, nil
     if it is not.


numberp         SUBR 1 arg
     The numberp predicate returns t if its argument is a number,  nil
     if it is not.


typep           SUBR 1 arg
     typep  is  a general type-predicate.  It returns an atomic symbol
     describing the type of its argument, chosen from the list
               (fixnum flonum bignum list symbol string random)


eval            LSUBR 1 or 2 args
     (eval x) evaluates x, just as if it had  been  typed  in  at  top
     level, and returns the result.  Note that since eval is an lsubr,
     its argument actually will be evaluated twice.


apply           LSUBR 2 or 3 args
     (apply f y) applies the function f to the list  of  arguments  y.
     Unless  f  is  an  fsubr  or  fexpr such as 'cond' or 'and' which
     evaluates its arguments in a funny way, the arguments in the list
     y are used without being evaluated.
     Examples:
         (setq f '+) (apply f '(1 2 3)) => 6
         (setq f '-) (apply f '(1 2 3)) => -4
          (apply 'cons '((+ 2 3)  4))  =>
               ((+ 2 3) .  4) not (5 . 4)
     (apply f y p) works like apply with 2 arguments except  that  the
     application  is  done in the binding environment specified by the
     "a-list" pointer p.


function                FSUBR
     Function  is  like  quote except that its argument is a function.
     It is used when passing a functional argument.  Example:
     (f00 x (function (lambda (p q)
                         (cond ((numberp q) p)
                               ((numberp p) q)
                         ;or any other random function in here
                               (t (cons p q)) )))
               y)
     calls f0 with 3 arguments, the second of which is  the  function
     defined by the lambda-expression.
     Note:  quote  and  function  are  completely  equivalent  in  the
     interpreter.  The compiler sometimes needs function  to  tell  it
     that a lambda-expression is a function to be compiled rather than
     a constant.


comment             FSUBR
     comment  ignores  its  arguments  and  returns  the atomic symbol
     comment.  Used in commenting code.  ; is preferred.

prog2           LSUBR 2 or more args
     Prog2  evaluates  its  arguments  from  left  to  right, like any
     lsubr, and returns the value of its second argument.
     Examples:
         (prog2 (do-this) (do-that))         ;get 2  things evaluated
         (setq x (prog2 nil y
                         (setq y x)))        ;parallel assignment.
                                             ;exchanges x and  y.


progn           LSUBR 1 or more args
     progn essentially evaluates all of its arguments and returns  the
     value  of the last one.  Although lambda-expressions, prog-forms,
     do-forms, cond-forms and  iog-forms  all  use  progn  implicitly,
     there  are occasions upon which one needs to evaluate a number of
     forms for side-effects when not in these forms. progn serves this
     purpose. Example:
          (progn (setq a 1) (cons a '(stuff))) => (1 stuff)


arg             SUBR 1 arg
     (arg nil), when evaluated inside a lexpr,  gives  the  number  of
     arguments supplied to that lexpr.
     (arg  i),  when  evaluated inside a lexpr, gives the value of the
     i'th argument to the lexpr.  i must be a fixnum in this case.  It
     is  an  error  if  i is less than 1 or greater than the number of
     arguments supplied to the lexpr.  Example:
     (defun foo nargs            ; define a lexpr foo.
         (print (arg nil))       ; print the number of args supplied.
         (print (arg 2))         ; print the second argument.
         (+ (arg 1) (arg 3)))    ; return the sum of 1st and 3rd args.


setarg          SUBR 2 args
     Setarg is used only inside  a  lexpr.   (setarg  i  x)  sets  the
     lexpr's  i'th argument to x.  i must be greater than zero and not
     greater than the number of arguments passed to the lexpr.   After
     (setarg i x) has been done, (arg i) will return x.

listify         SUBR 1 arg
     listify  is a function which efficiently manufactures a list of n
     of the arguments of a lexpr.  With  a  positive  argument  n,  it
     returns  a  list  of  the first n arguments of the lexpr.  With a
     negative argment n, it  returns  a  list  of  the  last  (abs  n)
     arguments of the lexpr.


funcall         LSUBR 1 or more args
     (funcall f a1 a2 ... an) calls the function f with the  arguments
     a1, a2, ..., an.  It is similar to apply except that the seperate
     arguments  are given to funcall, rather than a list of arguments.
     If f is an expr, a lexpr, a subr, or an lsubr, the arguments  are
     not  re-evaluated.   If  f  is  a fexpr or an fsubr there must be
     exactly one argument.  f may not be a macro.
     Example:
     (setq cons 'plus)
     (cons 1 2) => (1 . 2)
     (funcall cons 1 2) => 3

cdr             SUBR 1 arg
     Note: the cdr of an atomic symbol is its property list.

assoc           SUBR 2 args
     (assoc x y) looks up x in the association list  (list  of  dotted
     pairs)  y.  The value is the first dotted pair whose car is equal
     to x, or nil if there is none such.
     Examples:
          (assoc 'r '((a . b) (c . d) (r . x) (s . y) (r . z)))
               =>  (r . x)
          (assoc 'fooo '((foo . bar) (zoo . goo))) => nil

assq            SUBR 2 args
     Assq  is like assoc except that the comparison uses eq instead of
     equal.


sassoc          SUBR 3 args
     (sassoc x y z) is like (assoc x y) except that if x is not  found
     in  y,  instead of returning nil sassoc calls the function z with
     no arguments.


sassq           SUBR 3 args
     (sassq x y z) is like (assq x y) except that if x is not found in
     y, instead of returning nil sassq calls the function  z  with  no
     arguments.


length          SUBR 1 arg
     Length  returns the length of its argument, which must be a list.
     The length of a list is the number of  top-level  conses  in  it.
     The  warning  about dotted lists given under last applies also to
     length.


member          SUBR 2 args
     (member x y) returns nil if x is not a  member  of  the  list  y.
     Otherwise,  it  returns the portion of y beginning with the first
     occurrence of x.  The comparison is made by equal.  y is searched
     on the top level only.  Example:
               (member 'x '(1 2 3 4)) => nil
               (member 'x '(a (x y) c x d e x f)) => (x d e x f)

memq            SUBR 2 args
     Memq  is like member, except eq is used for the comparison.

sxhash          SUBR 1 arg
     Sxhash computes a hash code of an S-expression, and returns it as
     a fixnum which may be positive or nagative.  A property of sxhash
     is that (equal x y) implies  (=  (sxhash  x)  (sxhash  y)).   The
     number  returned  by  sxhash is some possibly large number in the
     range allowed by fixnums.  It is guaranteed that:
     1) sxhash for an atomic symbol will always be positive.
     2) sxhash of any particular expression  will  be  constant  in  a
     particular implementation for all time.
     3)  Two  different  implementations  may hash the same expression
     into different values.
     4) sxhash of any object of type random will be zero.
     5) sxhash of a fixnum will = that fixnum.


cons            SUBR 2 args
        This is a primitive function to construct a  new  dotted  pair
     whose  car  is  the  first argument to cons, and whose cdr is the
     second argument to cons.  Thus the following identities hold:
         (eq (car (cons x y)) x) => t
         (eq (cdr (cons x y)) y) => t
     Examples:
         (cons 'a 'b) => (a . b)
         (cons 'a (cons 'b (cons 'c nil))) => (a b c)
         (cons 'a '(b c d e f)) => (a b c d e f)


ncons           SUBR 1 arg
     (ncons x) = (cons x nil) = (list x)


xcons           SUBR 2 args
     xcons ("exchange cons") is like cons except  that  the  order  of
     arguments is reversed.
     Example:
         (xcons 'a 'b) => (b . a)


list            LSUBR 0 or more args
     list  constructs  and  returns  a  list  of  the  values  of  its
     arguments.
     Example:
        (list 3 4 'a (car '(b . c)) (+ 6 -2)) => (3 4 a b 4)

append          LSUBR 0 or more args
     The arguments to append are lists.  The result is a list which is
     the concatenation  of  the  arguments.   The  arguments  are  not
     changed (cf nconc).  For example,
          (append '(a b c) '(d e f) nil '(g)) => (a b c d e f g)


subst           SUBR 3 args
     (subst  x  y  z) substitutes x for all occurrences of y in z, and
     returns the modified z.  The original z is  unchanged,  as  subst
     recursively  copies  all  of  z  replacing elements eq to y as it
     goes.  If x and y are nil, z is completely  copied,  which  is  a
     convenient way to copy arbitrary list structure.
     Example:
        (subst 'Tempest 'Hurricane
               '(Shakespeare wrote (The Hurricane)))
          => (Shakespeare wrote (The Tempest))


sublis          SUBR 2 args
     sublis makes substitutions for atomic symbols in an S-expression.
     The  first  argument  to  sublis  is a list of dotted pairs.  The
     second argument is an S-expression.   The  return  value  is  the
     S-expression  with  atoms  that  are  the  car  of  a dotted pair
     replaced by the cdr of that dotted pair.   The  argument  is  not
     modified  - new conses are created where necessary and only where
     necessary, so the newly created structure shares as much  of  its
     substructure  as  possible  with  the  old.   For  example, if no
     successful substitutions are made, the result is eq  to  sublis's
     second argument.
     Example:
         (sublis '((x . 100) (z . zprime))
                 '(plus x (minus g z x p) 4))
            => (plus 100 (minus g zprime 100 p) 4)

rplaca          SUBR 2 args
     (rplaca x y) changes the car of x to y and returns (the modified)
     x.  Example:
         (setq x '(a b c))
         (rplaca x 'd) => (d b c)
        Now x => (d b c)


rplacd          SUBR 2 args
     (rplacd x y) changes the cdr of x to y and returns (the modified)
     x.  Example:
         (setq x '(a b c))
         (rplacd x 'd) => (a . d)
        Now x => (a . d)


nconc           LSUBR 0 or more args
     nconc  takes  lists as arguments.  It returns a list which is the
     arguments concatenated  together.   The  arguments  are  changed,
     rather than copied. (cf. append)
     Example:
               (nconc '(a b c) '(d e f)) => (a b c d e f)
     Note that the constant (a b c) has been changed to (a b c d e f).
     If  this  form is evaluated again, it will yield (a b c d e f d e
     f).


nreverse                SUBR 1 arg
     nreverse reverses its argument, which  should  be  a  list.   The
     argument  is  destroyed  by  rplacd's  all  through the list (cf.
     reverse).
     Example:
               (nreverse '(a b c)) => (c b a)


delete          LSUBR 2 or 3 args
     (delete x y) returns the list y with all top-level occurrences of
     x  removed.  Equal is used for the comparison.  The argument y is
     actually modified (rplacd'ed) when instances  of  x  are  spliced
     out.
     (delete  x  y  n)  is  like  (delete x y) except only the first n
     instances of x are deleted.  n is allowed to be zero.   If  n  is
     greater  than  the  number  of  occurences  of x in the list, all
     occurrences of x in the list will be deleted.
     Example:  (delete 'a '(b a c (a b) d a e)) => (b c (a b) d e)


delq            LSUBR 2 or 3 args
     delq is the same as  delete  except  that  eq  is  used  for  the
     comparison instead of equal.



prog            FSUBR
     prog is the "program"  function.  It provides temporary variables
     and the ability to do "go-tos."
        The  first  thing  in  a prog is a list of temporary variables
     <var>.  Each variable has  its  value  saved  when  the  prog  is
     entered  and  restored  when the prog is left.  The variables are
     initialized to nil when the prog is entered, thus they  are  said
     to be "bound to nil" by the prog.
        The rest of a prog is the body.  An item in the body may be an
     atomic symbol which is a <tag> or a non-atomic <statement>.
        prog,  after  binding  the  temporary variables, evaluates its
     body sequentially.  <tag>s are skipped  over;   <statement>s  are
     evaluated but the values are ignored.  If  the end of the body is
     reached,   prog  returns  nil.   If (return x) is evaluated, prog
     stops evaluating its body and returns the value  of  x.   If  (go
     tag)  is  seen, prog  jumps to the part of the body labelled with
     the tag.  The argument to 'go' is  not  evaluated  unless  it  is
     non-atomic.


setq            FSUBR
     setq  is  used  to  assign  values to variables (atomic symbols.)
     setq  takes  its  arguments  in   pairs,   and   processes   them
     sequentially,  left  to  right.  The first member of each pair is
     the variable, the second is the value.  The  value  is  evaluated
     but the variable is not.  The value of the variable is set to the
     value  specified.   You  must  not setq the special atomic-symbol
     constants t and nil.  The value returned  by  setq  is  the  last
     value assigned, i.e. the value of its last argument.
     Example:  (setq x (+ 1 2 3) y (cons x nil))
        returns (6) and gives x a value of 6 and y a value of (6).
     Note  that  the  first  assignment is processed before the second
     assignment is done, resulting in the second use of x getting  the
     value assigned in the first pair of the setq.


set             SUBR 2 args
     Set  is  like  setq  except that the first argument is evaluated;
     also set only takes one pair of arguments.   The  first  argument
     must  evaluate to an atomic symbol, whose value is changed to the
     value of the second argument.   Set  returns  the  value  of  its
     second argument.  Example:
         (set (cond ((predicate) 'atom1) (t 'atom2))
               'stba)
     evaluates  to  stba  and  gives  either atom1 or atom2 a value of
     stba.


boundp          SUBR 1 arg
     The argument to boundp must be an atomic symbol.   If  it  has  a
     value, cons of nil with that value is returned.  Otherwise nil is
     returned.  Example:
        (boundp 't) => (nil . t)   ;since the value of t is t

definedp                SUBR 1 arg
     This  predicate returns t if its argument (a symbol) has a value,
     and nil otherwise.

makunbound      SUBR 1 arg
     The argument to makunbound must be an atomic symbol.   Its  value
     is  removed  and it becomes undefined, which is the initial state
     for atomic symbols.


get             SUBR 2 args
     (get  x  y)  gets x's y-property.  x can be an atomic symbol or a
     disembodied property list.   The  value  of  x's  y  property  is
     returned,  unless  x  has  no  y-property  in  which  case nil is
     returned.


getl            SUBR 2 args
     (getl x  y) is like get except that y is  a  list  of  properties
     rather  than just a single property.   Getl searches x's property
     list until a property in the list y is found.  The portion of x's
     property list beginning with this property is returned.  The  car
     of  this is the property name and the cadr is what get would have
     returned.  Getl returns nil if none of the properties in y appear
     on the property list of x.


putprop         SUBR 3 args
     (putprop x y z) gives x a  z-property of  y and  returns  y.    x
     may  an  atomic  symbol  or a disembodied property list.  This is
     like defprop except that  the  arguments  are  evaluated.   After
     somebody does (putprop x y z), (get x z) will return  y.


defprop         FSUBR
     (defprop x y z) gives x a z-property of y.  The arguments are not
     evaluated.


remprop         SUBR 2 args
     (remprop  x  y) removes x's y-property, by splicing it out of x's
     property list.  The value is t if x had a y-property, nil  if  it
     didn't.   x  may  be  an  atomic symbol or a disembodied property
     list.  Example:

samepnamep      SUBR 2 args
     The arguments to samepnamep must evaluate to atomic symbols or to
     character  strings.  The result is t if they have the same pname,
     nil otherwise.  The pname of a character string is considered  to
     be the string itself.
     Examples:
         (samepnamep 'xyz (maknam '(x y z))) => t
         (samepnamep 'xyz (maknam '(w x y))) => nil
         (samepnamep 'x "x") => t

alphalessp      SUBR 2 args
     (alphalessp  x  y),  where x and y evaluate to atomic symbols  or
     character strings, returns t if the pname of x occurs earlier  in
     alphabetical  order  than  the  pname  of  y.   The   pname  of a
     character  string   is  considered  to  be   the  string  itself.
     Examples:
               (alphalessp 'x 'x1) => t
               (alphalessp 'z 'q) => nil
               (alphalessp "x" 'y) => t


getchar         SUBR 2 args
     (getchar  x  n),  where  x is an atomic symbol and n is a number,
     returns the nth character of x's pname, where n = 1  selects  the
     first  character.   The  character  is  returned  as  a character
     object.  nil is returned if n is out of bounds.


maknam          SUBR 1 arg
     Maknam takes as its argument a list of characters, like readlist,
     and  returns  an uninterned atom whose pname is determined by the
     list of characters.  Example:
               (maknam '(a b 60 d)) => ab0d

gensym          LSUBR 0 or more args
     gensym creates and returns a new  atomic  symbol,  which  is  not
     interned  on the obarray (is not recognized by read.)  The atomic
     symbol's pname is of the form <prefix><number>, e.g. g0001.   The
     <number> is incremented each time.
     If  gensym  is given arguments, a numeric argument is used to set
     the <number>.  The pname of an atomic-symbol argument is used  to
     set the <prefix>.  E.g. (gensym 'foo 40) => f0032
     Note  that the <number> is in decimal and always four digits, and
     the <prefix> is always one character.

args            LSUBR 1 or 2 args
     (args 'f) determines the number of arguments expected by f.  If f
     wants  n arguments, args returns (nil . n).  If f can take from m
     to n arguments, args returns (m . n).  If f  is  an  fsubr  or  a
     lexpr, expr, or fexpr, the results are meaningless.


defun           FSUBR
     defun is used for defining functions.  The general form is:
               (defun <name> <optional-type>
                      ( <lambda-variable>...)
                      <body>...)
     however, <name> and <type> may be interchanged.   <type>  may  be
     expr,  fexpr,  or  macro.   If  it  is  omitted, expr is assumed.
     Examples:
     (defun addone (x) (1+ x))     ;defines an expr
     (defun quot fexpr (x) (car x))          ;defines a fexpr
     (defun fexpr quot (x) (car x))          ;is the same
     (defun zzz expr x
         (foo (arg 1)(arg 2)))     ;this is how you define a lexpr.
     Note:  the functions defprop and putprop may  also  be  used  for
     defining functions.


bigp            SUBR 1 arg
     The predicate bigp returns its argument if  that  argument  is  a
     bignum, and nil otherwise.

smallnump               SUBR 1 arg
     The  smallnump  predicate  returns its argument if it is a fixnum
     (as opposed to a bignum or a flonum), nil otherwise.


zerop           SUBR 1 arg
     The zerop predicate returns t if its argument is fixnum  zero  or
     flonum  zero.   (There  is no bignum zero.)  Otherwise it returns
     nil.


plusp           SUBR 1 arg
     The plusp predicate returns t if its argument is strictly greater
     than zero, nil if it is zero or  negative.  It is  an   error  if
     the argument is  not a number.


minusp          SUBR 1 arg
     The  minusp  predicate  returns  t  if its argument is a negative
     number, nil if it is a non-negative number.  It is  an  error  if
     the argument is not a number.


oddp            SUBR 1 arg
     The  oddp  predicate  returns t if its argument is an odd number,
     otherwise nil.  The argument must be a fixnum or a bignum.


signp           FSUBR
     The signp predicate is used to test the sign of a number.  (signp
     c x) returns t if x's sign satisfies the test c, nil if  it  does
     not.   x is evaluated but c is not.  It is an error if x is not a
     number.  c can be one of the following:
               l         means     x<0
               le          "       x<0
               e           "       x=0
               n           "       x/=0
               ge          "       x>0
               g           "       x>0
     Examples:
         (signp le -1) => t
         (signp n 0) => nil

=               SUBR 2 args
     (= x y) is t if x and y are numerically equal.  x and y  must  be
     both fixnums or both flonums.


greaterp                LSUBR 2 or more args
     Greaterp compares its arguments, which must be numbers, from left
     to right.  If any argument is not greater than the next, greaterp
     returns  nil.   But  if  the  arguments  to greaterp are strictly
     decreasing, the result is t.


>               SUBR 2 args
     (> x y) is t if x is strictly greater than y, and nil  otherwise.
     x and y must be both fixnums or both flonums.


lessp           LSUBR 2 or more args
     Lessp compares its arguments, which must be numbers, from left to
     right.   If any argument is not less than the next, lessp returns
     nil.  But if the arguments to lessp are strictly increasing,  the
     result is t.


<               SUBR 2 args
     (<  x y) is t if x is strictly less than y, and nil otherwise.  x
     and y must be both fixnums or both flonums.


max             LSUBR 1 or more args
     Max returns the largest of its arguments, which must be numbers.


min             LSUBR 1 or more args
     Min returns the smallest of its arguments, which must be numbers.


fix             SUBR 1 arg
     (fix x) converts x to a fixnum  or  a  bignum  depending  on  its
     magnitude.  Examples:
               (fix 7.3) => 7
               (fix -1.2) => -2


float           SUBR 1 arg
     (float x) converts x to a flonum.  Example:
               (float 4) => 4.0


abs             SUBR 1 arg
     (abs  x)  =>  |x|, the absolute value of the number x.


minus           SUBR 1 arg
     Minus returns the negative of its argument, which can be any kind
     of number.


plus            LSUBR 0 or more args
     Plus returns the sum of its arguments, which may be any  kind  of
     numbers.


+               LSUBR 0 or more args
     +  returns  the  sum  of  its  arguments.   The arguments must be
     fixnums, and the result is always a fixnum.  Overflow is ignored.
     Examples:
               (+  2 6 -1) => 7
               (+ 3) => 3          ;trivial case
               (+) => 0            ;identity element


+$              LSUBR 0 or more args
     +$ returns the sum of  its  arguments.   The  arguments  must  be
     flonums and the result is always a flonum.  Examples:
               (+$ 4.1 3.14) => 7.24
               (+$  2.0 1.5  -3.6)  => -0.1
               (+$ 2.6) => 2.6               ;trivial case
               (+$)  => 0.0                  ;identity element


add1            SUBR 1 arg
     (add1 x) => x + 1.  x may be any kind of number.


1+              SUBR 1 arg
     (1+  x)  =>  x+1.   x  must  be a fixnum.  The result is always a
     fixnum.  Overflow is ignored.


1+$             SUBR 1 arg
     (1+$ x) => x+1.0.  x must be a flonum.  The result  is  always  a
     flonum.


difference      LSUBR 1 or more args
     difference  returns  its  first  argument  minus  the rest of its
     arguments.  It works for any kind of numbers.


-               LSUBR 0 or more args
     This is the fixnum-only subtraction function.  It does not detect
     overflows.
     (-) => 0, the identity element
     (- x) =>  the negative of x.
     (- x y) =>  x  -  y.
     (- x y z) => x - y - z
     etc.

-$              LSUBR 0 or more args
     This is the flonum-only subtraction function.
     (-$) =>  0.0, the identity element
     (-$ x)  => the negation  of x.
     (-$ x y) => x - y.
     (-$ x y z) => x - y  -  z.
     etc.

*dif            SUBR 2 args
     This is an obsolete arithmetic difference function.
     (*dif x y) => x - y.


sub1            SUBR 1 arg
     (sub1 x) => x-1.  X may be any kind of number.


1-              SUBR 1 arg
     (1- x) => x-1.  x must be a  fixnum.   The  result  is  always  a
     fixnum and overflow is not detected.


1-$             SUBR 1 arg
     (1-$ x) => x-1.0.  x must be a flonum.


times           LSUBR 0 or more args
     Times  returns  the  product  of its arguments.  It works for any
     kind of numbers.


*               LSUBR 0 or more args
     * returns the product of its arguments.  The  arguments  must  be
     fixnums.   Th  result  is  always  a  fixnum.   Overflow  is  not
     detected.  Examples:
               (* 4 5 -6) => -120.
               (* 3) => 3          ;trivial case
               (*) => 1            ;identity element


*$              LSUBR 0 or more args
     *$ returns the product of its arguments.  The arguments  must  be
     flonums and the result is always a flonum.  Examples:
               (*$ 3.0 2.0 4.0) => 24.0
               (*$ 6.1) => 6.1     ;trivial case
               (*$) => 1.0         ;identity element


quotient                LSUBR 1 or more args
     Quotient  returns its first argument divided by  the  rest of its
     arguments.  The arguments may any kind of number.    (cf.  /  and
     /$) Examples:
         (quotient 3 2)  => 1      ;fixnum division truncates
         (quotient 3 2.0) =>  1.5  ;but flonum division does not..
         (quotient 6.0 1.5  2.0) => 2.0

//              LSUBR 0 or more args
     This is the fixnum-only division function.  The arguments must be
     fixnums  and  the  result  of  the  division  is  truncated to an
     integer and returned  as a fixnum.  Note that the  name  of  this
     function  must  be   typed   in  as  //, since LISP uses /  as an
     escape character.
     (//) => 1, the identity element.
     (//  x) => the fixnum reciprocal of x, which is 0 if  |x| >  1.
     (// x  y) => x/y.
     (// x  y z) =>  (x/y)/z.
     etc.


//$             LSUBR 0 or more args
     This is the flonum-only division function.   Note  that the  name
     of  this  function must be typed in as  //$, since LISP uses / as
     an escape  character.
     (//$) => 1.0, the identity element
     (//$ x) => the  reciprocal of x.
     (//$ x y) => x/y
     (//$ x y z) => (x/y)/z.
     etc.


remainder               SUBR 2 args
     (remainder x y) => the remainder of the division of x by y.   The
     sign  of  the  remainder is the same as the sign of the dividend.
     The arguments must be fixnums or bignums.


        SUBR 2 args
     (x y) returns the remainder of x divided by y, with the sign of
     x.  x and y must be fixnums.  Examples:
               (5 2) => 1
               (65. -9.) => 2
               (-65. 9.) => -2


gcd             SUBR 2 args
     (gcd x y) => the  greatest  common  divisor  of  x  and  y.   The
     arguments must be fixnums or bignums.


expt            SUBR 2 args
                   y
     (expt x y) = x
     The  exponent  y  may  be  a bignum if the base x is 0, 1, or -1;
     otherwise y must be a fixnum.  x may be any kind of number.


sqrt            SUBR 1 arg
     (sqrt x) => a flonum which is the square root of the number x.


isqrt           SUBR 1 arg
     (isqrt x) => a fixnum which is the square root of x, truncated to
     an integer.


exp             SUBR 1 arg
                x
     (exp x) = e


log             SUBR 1 arg
     (log x) = ln x, the natural log of x.


sin             SUBR 1 arg
     (sin x) gives the trigonometric sine of x.  x is in  radians.   x
     may be a fixnum or a flonum.


cos             SUBR 1 arg
     (cos  x)  returns  the cosine of x.  x is in radians.  x may be a
     fixnum or a flonum.


atan            LSUBR 1 or 2 args
     (atan x) returns the arctangent of x, in radians.  x and y may be
     fixnums or flonums.  (atan x y) returns the arctangent of x/y, in
     radians.  y may be 0 as long as x is not also 0.


random          LSUBR 0 or 1 arg
     (random) returns a random fixnum.
     (random nil) restarts the random sequence at its beginning.
     (random x), where x is a fixnum, returns a random fixnum  between
     0 and x-1 inclusive.


ascii           SUBR 1 arg
     (ascii  x), where x is a number, returns the character object for
     the ascii code x.
     Examples:
        (ascii 101) => A
        (ascii 56) => /.


explode         SUBR 1 arg
     (explode  x)  returns  a  list  of  characters,  which  are   the
     characters  that would have been typed out if (prin1 x) was done,
     including slashes for special characters but not including  extra
     newlines  inserted  to  prevent  characters  from running off the
     right margin.  Each  character  is  represented  by  a  character
     object.
     Example:
          (explode '(+ 1x 3)) => ( /( + /  // /1  x /  /3 /) )
               ;;Note the presence of slashified spaces in this list.


explodec                SUBR 1 arg
     (explodec   x)  returns  a  list  of  characters  which  are  the
     characters that would have been typed out if (princ x) was  done,
     not  including extra newlines inserted to prevent characters from
     running  off  the  right  margin.   Special  characters  are  not
     slashified.  Each character is represented by a character object.
     Example:
         (explodec '(+  1x 3)) => ( /( + /  /1 x /  /3 /) )


exploden                SUBR 1 arg
     (exploden   x)  returns  a  list  of  characters  which  are  the
     characters that would have been typed out if (princ x) was  done,
     not including extra newlines inserted to prevent lines characters
     from  running  off  the right margin.  Special characters are not
     slashified.  Each character is represented by a number  which  is
     the ascii code for that character.  cf. explodec.  Example:
         (exploden '(+ 1x 3)) => (50 53 40 61 170 40 63 51)


flatc           SUBR 1 arg
     Flatc returns the length of its argument in characters, if it was
     printed out without slashifying special characters.  (flatc x) is
     the same as (length (explodec x)).


flatsize                SUBR 1 arg
     Flatsize  returns the length of its argument in characters, if it
     was printed out with special characters slashified.  (flatsize x)
     is the same as (length (explode x)).


readlist                SUBR 1 arg
     The argument to readlist is a list of characters.  The characters
     may  be  represented  either  as  numbers  (ascii  codes)  or  as
     character objects.  The characters in the list are assembled into
     an  S-expression as if they had been typed into read (See chapter
     12 for a description of read.)  If macro characters are used, any
     calls to read, readch, tyi, or tyipeek  in  the  macro  character
     functions  take their input from readlists's argument rather than
     from an I/O device or a file.
     Examples:
         (readlist '(a b c)) => abc
         (readlist '( /( p r 151 n t /  /' f o o /) ))
               => (print (quote foo))
     ;;Note the use of the slashified special characters  left  paren,
     space, quote, right paren in the argument to readlist.

*array          LSUBR 3 or more args
     (*array x y b1 b2 ... bn) defines x to be an n-dimensional array.
     The  first  subscript may range from 0 to b1-1, the second from 0
     to b2-1, etc.  If y is t a normal array is created; if y  is  nil
     an "ungarbage-collected" array is created.


array           FSUBR
     (array x y b1 b2 ... bn) is like (*array x y b1 b2 ... bn) except
     that x is not evaluated.  The other arguments are evaluated.


*rearray                LSUBR 1 or more args
     *rearray is used to redefine the dimensions of an array.
     (*rearray  x)  gets rid of the array x.  x is evaluated - it must
     evaluate to an atomic symbol.  The value is t if it was an array,
     nil if it was not.
     (*rearray x type dim1 dim2 ... dimn) is like (*array x type  dim1
     dim2  ...  dimn)  except  that  the  contents  of  the previously
     existing array named x are copied into the new array named x.


store           FSUBR
     The first argument to store must be a subscripted reference to an
     array.  The second argument is  evaluated  and  stored  into  the
     referenced  cell  of  the  array.   Store  evaluates  its  second
     argument before its first argument.
     Examples:
         (store (data i j) (plus i j))
        (store (sine-values (fix (*$ x 100.0)))
               (sin x))


arraydims               SUBR 1 arg
     (arraydims 'x), where x is an array, returns a list of  the  type
     and  bounds  of  x.   Thus if x was defined by (array x t 10 20),
     (arraydims 'x) => (t 10 20)


bltarray                SUBR 2 args
     Bltarray is used to copy one array into another.
     (bltarray x y) moves  the  contents  of  the  array  x  into  the
     contents of the array y.  If x is bigger than y, it is truncated.
     If x is smaller than y, the rest of y is unchanged.  x and y must
     evaluate to atomic symbols which have array properties.


fillarray               SUBR 2 args
     (fillarray <array> <list>) fills the array with consecutive items
     from the list; thus fillarray could have been defined by:
     (defun fillarray (a x)
         (do ((x x (cdr x)) ((n 0 (1+ n)))
             ((null x))
               (store (a n) (car x))
          ))
     If  the  array is too short to contain all the items in the list,
     the extra items are ignored.  (This is not reflected in the  LISP
     definition  above.)   If  the  list  is  too short to fill up the
     array, the last element of the list is used to fill each  of  the
     remaining  slots  in  the  array.  An additional flaw in the LISP
     definition is that fillarray will work with arrays of  more  than
     one  dimension,  filling the array in row-major order.  fillarray
     returns its first argument.


listarray               SUBR 1 arg
     (listarray  <array-name>)  takes  the  elements  of   the   array
     specified  by  <array-name> and returns them as the elements of a
     list.  The length of the list is the size of the  array  and  the
     elements  are  present  in the list in the same order as they are
     stored in the array, starting with the zeroth element.


map                 LSUBR 2 or more args
     The  first  argument  to  map  is  a  function, and the remaining
     arguments are lists.  Map "goes down"  the  lists,  applying  the
     function  to  the  lists each time.  The value returned by map is
     its second argument.  Map stops as soon as one of  the  lists  is
     exhausted.  Example:
     (map '(lambda (x y z) (print (list x y z)))
          '(1 2 3 4) '(a b c d e) '(+ - * |))
     prints
     ((1 2 3 4) (a b c d e) (+ - * |))
     ((2 3 4) (b c d e) (- * |))
     ((3 4) (c d e) (* |))
     ((4) (d e) (|))
     and returns (1 2 3 4).


mapc            LSUBR 2 or more args
     Mapc  is  just  like  map  except that the function is applied to
     successive elements  of  the  lists  rather  than  to  the  lists
     themselves.  Thus the example given under map would print
     (1 a +)
     (2 b -)
     (3 c *)
     (4 d |)
     and return (1 2 3 4)


mapcar          LSUBR 2 or more args
     Mapcar is like mapc except that the return value is a list of the
     results  of  each  application of the function.  Thus the example
     given with mapc would return, not (1 2 3 4), but
     ((1 a +) (2 b -) (3 c *) (4 d |))


maplist         LSUBR 2 or more args
     Maplist is like map except that the return value is a list of the
     results of each application of the function.   Thus  the  example
     given with map would return, not (1 2 3 4), but
     (((1 2 3 4) (a b c d e) (+ - * |)) ((2 3 4) (b c d e) (- * |))
      ((3 4) (c d e) (* |)) ((4) (d e) (|)))


mapcan          LSUBR 2 or more args
     Mapcan  is  like  mapcar  except  that the values returned by the
     function are nconc'ed together instead of being listed  together.
     Thus the example would return
     (1 a + 2 b - 3 c * 4 d |)


mapcon          LSUBR 2 or more args
     Mapcon  is  like  maplist  except that the values returned by the
     function are nconc'ed together instead of being listed  together.
     This  can  have  disastrous effects on the arguments to mapcon if
     one is not careful.  The example would return
     ((1 2 3 4) (a b c d e) (+ - * |) (2 3 4) (b c d e) (- * |)
      (3 4) (c d e) (* |) (4) (d e) (|))


sort            SUBR 2 args
        The first argument to  sort  is  an  S-expression  array,  the
     second a predicate of two arguments.  The domain of the predicate
     must include all objects in the array; thus if the array contains
     only  atomic  symbols,  the  predicate  need only apply to atomic
     symbols, but  if  the  array  also  contains  S-expressions,  the
     predicate must apply to them also.  The predicate should take two
     arguments,  and  return non-nil if and only if the first argument
     is strictly less than the second  (in  some  appropriate  sense).
     The  sort  function  proceeds  to  sort the contents of the array
     under the ordering imposed by  the  predicate,  and  returns  its
     first   argument.    Note   that   since  sorting  requires  many
     comparisons, and thus many calls to the predicate,  sorting  will
     be  much  faster  if  the predicate is a compiled function rather
     than interpreted.
     Example:  (defun mostcar (x)
         (cond ((atom x) x)
               ((mostcar (car x)))))
     (sort fooarray
           (function (lambda (x y)
               (alphalessp (mostcar x) (mostcar y)))))
     If fooarray contained these items before the sort:
     (tokens (the lion sleeps tonight))
     (carpenters (close to you))
     ((rolling stones) (brown sugar))
     ((beach boys) (i get around))
     (beatles (i want to hold your hand))
     then after the sort fooarray would contain:
     ((beach boys) (i get around))
     (beatles (i want to hold your hand))
     (carpenters (close to you))
     ((rolling stones) (brown sugar))
     (tokens (the lion sleeps tonight))


sortcar         SUBR 2 args
        sortcar is exactly like sort,  but  the  items  in  the  array
     should  all  be  non-atomic.   sortcar takes the car of each item
     before handing two items to the predicate.  Thus  sortcar  is  to
     sort as mapcar is to maplist.


     (status  date)  returns  a  3-list indicating the current date as
     (year-1900. month-number day)
     (status daytime) returns a 3-list of the 24-hour time of  day  as
     (hour minute second).
     (status  time)  is  the same as (time), the number of seconds the
     system has been up.
     (status  runtime)  is  the  same  as  (runtime),  the  number  of
     microseconds of cpu time that has been used.
     (status  system x) returns a list of the system properties of the
     atomic symbol x, which is evaluated.  This list may contain subr,
     fsubr, macro, or lsubr if x is a  function,  and  value  if  this
     atomic symbol is a system variable.
     (status  uname)  returns  an  atomic  symbol  whose  pname is the
     current user's name.  In the Multics implementation  this  is  in
     the  format  User.Project; the dot will be slashified if print is
     used to display this.
     (status udir) returns the name of the user's directory.   In  the
     ITS  implementation  this  is  the  same  as  the  user's name as
     returned by (status uname).  In the Multics  implementation  this
     is the user's default working directory.
     (status lispversion) returns the version number of lisp.
               lisp environment "foo bar"


sysp            SUBR 1 arg
     The sysp predicate takes an atomic symbol as an argument.  If the
     atomic  symbol is the name of a system function (and has not been
     redefined), sysp returns the type of function  (subr,  lsubr,  or
     fsubr).  Otherwise sysp returns nil.
     Examples:
         (sysp 'foo) => nil
         (sysp 'car) => subr
         (sysp 'cond) => fsubr


runtime         SUBR no args
     (runtime)  returns the number of microseconds of cpu time used so
     far by the process in which  LISP  is  running.   The  difference
     between   two   values  of  (runtime)  indicates  the  amount  of
     computation that was done between the two calls to runtime.


time            SUBR no args
     (time) returns the time that the system has been up, in  seconds.
     (As a flonum.)


sleep           SUBR 1 arg
     (sleep  n) causes a real-time delay of n seconds, then returns n.
     n may be a fixnum or a flonum.
     lisp  is  (mapc 'eval errlist), which allows the user programs to
     start up.


quit            SUBR no args
     (quit)  causes the lisp subsystem to remove itself and return  to
     its caller.  The current environment is lost.  (cf. save).


namelist                SUBR 1 arg
     Namelist  converts  its  argument  to  a  namelist.  Omitted or *
     components in the argument produce *'s in the result.


namestring      SUBR 1 arg
     Namestring converts its argument from a namelist to a namestring.
     It is the opposite of namelist.


shortnamestring SUBR 1 arg
     shortnamestring is just like namestring except that there  is  no
     mention of directory or device in the resulting string.  Example:
               (shortnamestring '(abc d e)) => "d.e"


names           LSUBR 1 or 2 args
     (names f), where f is a file object, gets f's namelist.
     (names  nil)  gets the default namelist.  In Multics MACLISP, the
     default namelist is initially set to
                         (<working-directory> . *)
     when lisp is entered.
     In ITS MACLISP, the default namelist is initially set to
                               (<udir> . *)
     when lisp is entered, where <udir> is the name by which the  user
     logged in.
     (names nil x) sets the default namelist to x and returns x.


open            LSUBR 1 or two args
     OPEN takes one or two arguments.  It may take a namelist, namestring,
     short namestring, or file-object as the first argument.  It takes an
     optional list of modes as the second, or a single atom if there is only
     one mode.  The most important modes are IN and OUT, the default is IN
     except in the case of the file-object, in which case it defaults to the
     mode it was opened in in the first place.
     (open <file or namelist or namestring> <mode>)


close           SUBR 1 arg
     (close  x),  where  x is a file, closes x and returns t.  If x is
     already closed nothing happens,  otherwise  the  file  system  is
     directed to return x to a quiescent state.

read            LSUBR 0 to 2 args
     This is the S-expression input function.
     (read) reads an S-expression from the default input source.
     (read f), where f is a file or nil meaning the terminal, reads an
     S-expression from f.  During the reading, infile and ^q are bound
     so that evaluation of (read) within  a  macro-character  function
     will read from the correct input source.
     (read  x),  where  x  is  not  a file and not nil, passes x as an
     argument to the end-of-file function of the input source  if  the
     end  of  the  file is reached.  Usually this means that read will
     return x if there are no more S-expressions in the file.
     (read t) suppresses the calling of the  end-of-file  function  if
     the end of the file is reached.  Instead, read just returns t.
     (read  x  f)  or (read f x) specifies the end-of-file value x and
     selects the input source f.


readch          LSUBR 0 to 2 args
     Readch reads in one character and  returns  a  character  object.
     The arguments are the same as for read.


readline                LSUBR 0 to 2 args
     readline  reads  in  a  line  of  text,  strips  off  the newline
     character or characters at the end, and returns it in the form of
     a character string.  The arguments are the same as for read.  The
     main use for readline is reading in file names typed by the  user
     at his terminal in response to a question.


tyi             LSUBR 0 to 2 args
     Tyi  inputs one character and returns a fixnum which is the ascii
     code for that character.  The arguments are the same as for read.


tyipeek         LSUBR 0 or 1 arg
     (tyipeek) is like (tyi) except that the character is  not  eaten;
     it  is  still in the input stream where the next call to an input
     function will find it.  Thus (= (tyipeek) (tyi)) is  t.   If  the
     end  of  the  file is reached, tyipeek returns 3, (the ascii code
     for "end of text.") The end of file function is not called.
     (tyipeek n), where  n  is  a  fixnum  <  200  octal,  skips  over
     characters of input until one is reached with an ascii code of n.
     That character is not eaten.
     (tyipeek  n),  where  n  is  a  fixnum  >  1000 octal, skips over
     characters of input until one is reached whose syntax  bits  from
     the readtable, logically anded with (lsh n -9.), are nonzero.
     (tyipeek t) skips over characters of input until the beginning of
     an  S-expression  is reached.  Splicing macro characters, such as
     ";" comments, are not considered to begin an object.  If  one  is
     encountered,  its associated function is called as usual (so that
     the text of the comment  can  be  gobbled  up  or  whatever)  and
     tyipeek continues scanning characters.


prin1           LSUBR 1 or 2 args
     (prin1  x)  outputs x  to the current output destination(s), in a
     form suitable for reading back in.
     (prin1 x  f) outputs x on the file f, or the  terminal  if  f  is
     nil.


print           LSUBR 1 or 2 args
     Print  is  like  prin1  except  that  the output is preceded by a
     newline and followed by a space.  This  is  the  output  function
     most often used.
     (print x) prints x to the default output destinations.
     (print  x  f)  prints x to the file f, or to the terminal if f is
     nil.


princ           LSUBR 1 or 2 args
     Princ is  like prin1  except  that  special  characters  are  not
     slashified and strings are  not quoted.
     (princ x) outputs x to  the current output destination(s).
     (princ x f) outputs x to the file f, or the terminal if f is nil.


tyo             LSUBR 1 or 2 args
     (tyo  n)  types  out  the  character whose ascii code is n on the
     current output destination(s).
     (tyo n f) types out the character whoe ascii code  is  n  on  the
     file  f  or  on  the terminal if f is nil.  Tyo returns its first
     argument.


terpri          LSUBR 0 or 1 arg
     (terpri) sends a newline to the current output destination(s).
     (terpri x) sends a newline to x, where x may be an output file or
     nil meaning the terminal.

cursorpos               LSUBR 0 or 2 args
     The  cursorpos  function  is  used  to manipulate the cursor on a
     display terminal.
     With no arguments it returns the dotted  pair  (line  .  column),
     where  line is the line number, starting from 0 at the top of the
     screen, and column is the column position, starting from 0 at the
     left edge of the screen.  If the terminal being  used  is  not  a
     display  terminal  with  this  type  of  cursor,  nil is returned
     instead.
     With two arguments, (cursorpos line  column)  moves  the  display
     cursor  to  the  indicated  position  and  returns  t  if  it was
     successful, or nil if the terminal was incapable of doing this.


listen          SUBR no args
     (listen) returns a fixnum which is non-zero if there is any input
     that has been typed in on the terminal but has not yet been read.

deletef         SUBR 1 arg
     (deletef x), where x specifies a file, deletes  that  file.   The
     return  value  is the namelist of the file actually deleted, i.e.
     x mergef'ed over the defaults.


rename          SUBR 2 args
     (rename x y), where x and y are namelists or namestrings, renames
     the file  specified  by  (mergef  x  (names  nil))  to  the  name
     specified  by  (mergef y x (names nil)).  The directory part of y
     is ignored; a file may not be renamed onto a different device  or
     directory.   The  return value is the namelist of the new name of
     the file.


clear-input     SUBR 1
     (clear-input  x),  where x is a file or nil meaning the terminal,
     causes any input that has been received from the device  but  has
     not  yet been read to be thrown away, if that makes sense for the
     particular device involved.


force-output            SUBR 1
     (force-output x), where x is a file or nil meaning the  terminal,
     causes any buffered output to be immediately sent to the device.