(alpha-char-p function-documentation "
Args: (char)
Returns T if CHAR is alphabetic; NIL otherwise.")
(bit type-documentation "
A bit is either integer 0 or 1. Bit is not supported by euslisp.")
(bit function-documentation "
Args: (bit-array &rest indexes)
Returns the bit of BIT-ARRAY specified by INDEXes.")
(bit-vector-p function-documentation "
Args: (x)
Returns T if X is a bit-vector; NIL otherwise.")
(char-bit function-documentation "
Args: (char name)
Returns T if the specified bit attribute of CHAR is 'on'; NIL otherwise.
Returns always NIL in KCL, since KCL characters have no bit attributes.")
(char-greaterp function-documentation "
Args: (char &rest more-chars)
Returns T if the character codes of CHARs are in decreasing order; NIL
otherwise.  For lower-case characters, codes of corresponding upper-case
characters are used.")
(char-int function-documentation "
Args: (char)
Returns the font, bits, and code attributes as an integer.  Equivalent to
CHAR-CODE in KCL.")
(compiler:compile function-documentation "
Args: (name &optional (definition nil) &key (leave-gazonk nil))
If DEFINITION is NIL, NAME must be the name of a not-yet-compiled function.
In this case, COMPILE compiles the function, installs the compiled function as
the global function definition of NAME, and returns NAME.  If DEFINITION is
non-NIL, it must be a lambda expression and NAME must be a symbol.  COMPILE
compiles the lambda expression, installs the compiled function as the function
definition of NAME, and returns NAME.  There is only one exception for this:
If NAME is NIL, then the compiled function is not installed but is simply
returned as the value of COMPILE.  In any case, COMPILE creates temporary
files whose filenames begin with \"gazonk\".  By default, i.e. if LEAVE-GAZONK
is not supplied or is NIL, these files are automatically deleted after
compilation.")
(count function-documentation "
Args: (item sequence
       &key (key #'identity) (test #'eql) test-not
            (start 0) (end (length sequence)) (from-end nil))
Returns the number of elements in SEQUENCE satisfying TEST with ITEM as the
first argument.")
(directory function-documentation "
Args: (filespec)
Returns a list of full pathnames of all those files that match FILESPEC.
FILESPEC may be a symbol, a string, a pathname, or a file stream.")
(*eval-when-compile* variable-documentation "
KCL specific.
The KCL compiler evaluates all top-level forms if the value of this variable
is non-NIL.  If the value is NIL, the compiler evaluates as few top-level
forms as necessary.  Note the compiler always evaluates DEFMACRO forms.")
(every function-documentation "
Args: (predicate sequence &rest more-sequences)
Returns T if every elements of SEQUENCEs satisfy PREDICATE; NIL otherwise.")
(hash-table-p function-documentation "
Args: (x)
Returns T if X is a hash-table object; NIL otherwise.")
(in-package function-documentation "
Args: (package-name &key (nicknames nil) (use '(lisp)))
Makes the package named PACKAGE-NAME as the current package.  If such a
package does not exist, then creates one by passing all args to MAKE-PACKAGE.
Otherwise, adds the specified nicknames and packages to the nickname list and
use list of the package.  NICKNAMES must be a list consisting of strings and
symbols.  USE must be a list consisting of package objects and package names
(either string or symbol).")
(last function-documentation "
Args: (list)
Returns the last cons that constitute LIST.  Returns NIL if LIST is NIL.")
(list type-documentation "
As a type specifier, 'list' is used to specify the type consisting of NIL and
cons objects.  In our ordinary life with Lisp, however, a list is either NIL
or a cons whose cdr is a list, and is notated by its elements surrounded with
parentheses.
The backquote macro is sometimes useful to construct a complicated list
structure.  When evaluating `(...)
	,form embeds the value of FORM,
	,@form and ,.form embed all elements of the list value of FORM,
	and other things embed itself
into the structure at their position.  For example,
	`(a b ,c d e) expands to (list* 'a 'b c '(d e))
	`(a b ,@c d e) expands to (list* 'a 'b (append c '(d e)))
	`(a b ,.c d e) expands to (list* 'a 'b (nconc c '(d e)))")
(list function-documentation "
Args: (&rest args)
Returns a list of the args.")
(make-list function-documentation "
Args: (length &key (initial-element nil))
Creates and returns a list of the specified LENGTH, whose elements are all the
value of INITIAL-ELEMENT.")
(notevery function-documentation "
Args: (predicate sequence &rest more-sequences)
Returns T if at least one of the elements in SEQUENCEs does not satisfy
PREDICATE; NIL otherwise.")
(print function-documentation "
Args: (object &optional (stream *standard-output*))
Outputs a newline character, and then PRIN1s OBJECT.  Returns OBJECT.
Equivalent to
	(PROGN (TERPRI STREAM)
	       (WRITE OBJECT :STREAM STREAM :ESCAPE T))")
(remove function-documentation "
Args: (item sequence
       &key (key #'identity) (test #'eql) test-not
            (start 0) (end (length sequence))
            (count most-positive-fixnum) (from-end nil))
Returns a copy of SEQUENCE with those elements equal to ITEM (in the sense of
TEST) removed.")
(rest function-documentation "
Args: (x)
Equivalent to CDR.")
(sbit function-documentation "
Args: (simple-bit-array &rest subscripts)
Returns the specified bit in SIMPLE-BIT-ARRAY.")
(string-right-trim function-documentation "
Args: (char-bag string)
Returns a copy of STRING with the specified characters removed from the right
end.  CHAR-SPEC must be a sequence of characters.")
(subst function-documentation "
Args: (new old tree &key (key #'identity) (test #'eql) test-not)
Substitutes NEW for subtrees of TREE that match OLD and returns the result.
The original TREE is not destroyed.")
(with-input-from-string function-documentation "
Syntax: (with-input-from-string (var string-form {keyword value}*)
           {decl}* {form}*)
Evaluates FORMs with VAR bound to a string input stream from the string that
is the value of STRING-FORM.  The stream is automatically closed on exit.
Possible keywords are :INDEX, :START, and :END.")
