Copyright (C) 2000-2012 |
GNU Info (cl)Type PredicatesType Predicates =============== The "CL" package defines a version of the Common Lisp `typep' predicate. - Function: typep object type Check if OBJECT is of type TYPE, where TYPE is a (quoted) type name of the sort used by Common Lisp. For example, `(typep foo 'integer)' is equivalent to `(integerp foo)'. The TYPE argument to the above function is either a symbol or a list beginning with a symbol. * If the type name is a symbol, Emacs appends `-p' to the symbol name to form the name of a predicate function for testing the type. (Built-in predicates whose names end in `p' rather than `-p' are used when appropriate.) * The type symbol `t' stands for the union of all types. `(typep OBJECT t)' is always true. Likewise, the type symbol `nil' stands for nothing at all, and `(typep OBJECT nil)' is always false. * The type symbol `null' represents the symbol `nil'. Thus `(typep OBJECT 'null)' is equivalent to `(null OBJECT)'. * The type symbol `real' is a synonym for `number', and `fixnum' is a synonym for `integer'. * The type symbols `character' and `string-char' match integers in the range from 0 to 255. * The type symbol `float' uses the `floatp-safe' predicate defined by this package rather than `floatp', so it will work correctly even in Emacs versions without floating-point support. * The type list `(integer LOW HIGH)' represents all integers between LOW and HIGH, inclusive. Either bound may be a list of a single integer to specify an exclusive limit, or a `*' to specify no limit. The type `(integer * *)' is thus equivalent to `integer'. * Likewise, lists beginning with `float', `real', or `number' represent numbers of that type falling in a particular range. * Lists beginning with `and', `or', and `not' form combinations of types. For example, `(or integer (float 0 *))' represents all objects that are integers or non-negative floats. * Lists beginning with `member' or `member*' represent objects `eql' to any of the following values. For example, `(member 1 2 3 4)' is equivalent to `(integer 1 4)', and `(member nil)' is equivalent to `null'. * Lists of the form `(satisfies PREDICATE)' represent all objects for which PREDICATE returns true when called with that object as an argument. The following function and macro (not technically predicates) are related to `typep'. - Function: coerce object type This function attempts to convert OBJECT to the specified TYPE. If OBJECT is already of that type as determined by `typep', it is simply returned. Otherwise, certain types of conversions will be made: If TYPE is any sequence type (`string', `list', etc.) then OBJECT will be converted to that type if possible. If TYPE is `character', then strings of length one and symbols with one-character names can be coerced. If TYPE is `float', then integers can be coerced in versions of Emacs that support floats. In all other circumstances, `coerce' signals an error. - Special Form: deftype name arglist forms... This macro defines a new type called NAME. It is similar to `defmacro' in many ways; when NAME is encountered as a type name, the body FORMS are evaluated and should return a type specifier that is equivalent to the type. The ARGLIST is a Common Lisp argument list of the sort accepted by `defmacro*'. The type specifier `(NAME ARGS...)' is expanded by calling the expander with those arguments; the type symbol `NAME' is expanded by calling the expander with no arguments. The ARGLIST is processed the same as for `defmacro*' except that optional arguments without explicit defaults use `*' instead of `nil' as the "default" default. Some examples: (deftype null () '(satisfies null)) ; predefined (deftype list () '(or null cons)) ; predefined (deftype unsigned-byte (&optional bits) (list 'integer 0 (if (eq bits '*) bits (1- (lsh 1 bits))))) (unsigned-byte 8) == (integer 0 255) (unsigned-byte) == (integer 0 *) unsigned-byte == (integer 0 *) The last example shows how the Common Lisp `unsigned-byte' type specifier could be implemented if desired; this package does not implement `unsigned-byte' by default. The `typecase' and `check-type' macros also use type names. Note: Conditionals. Note: Assertions. The `map', `concatenate', and `merge' functions take type-name arguments to specify the type of sequence to return. Note: Sequences. automatically generated by info2www version 1.2.2.9 |