**//Predicates//**

Simple functions that return ''T'' or ''NIL''. They have no side effects.

''EQ''

Tests if to arguments are the same symbol, accepts only symbols or ''NIL''.

<code lisp>
>(eq 'pi 'user::pi)
T

>(eq 'nil ())    ; NIL, 'NIL, () and '() are all EQ
T
</code>

''EQUAL''

Tests if two things are the same, is case and type senstive. 

<code lisp>
>(equal "aa" "AA")
NIL

>(equal 1 1.0)   ; different type
NIL            
</code>

''NOT''

Logical not. Accepts single argument.

<code lisp>
>(not 13)
NIL

>(not '())    
T
</code>

''ATOM''

Tests if the argument is an atom.

<code lisp>
>(atom 13)
T

>(atom nil)    ; NIL is an atom (and list)
T

>(atom '())    ; this is still NIL  
T

>(atom '(a b)) ; this is list  
NIL
</code>

''CONSP''

Tests if the argument is a cons cell.

<code lisp>
>(consp '())       ; NIL is not cons
NIL

>(consp '(a b))
T
</code>

''LISTP''

Tests if the argument is a list, that means cons-cell or nil.

<code lisp>
>(listp nil)          ; NIL is a list (and atom)
T

>(listp '(a b))
T

>(listp (cons 'a 'b)) ; this is conscell with B in cdr, improper list
T
</code>

''PROPER-LIST-P''

Tests if the argument is a proper list. Proper list means list ending with ''NIL'' in the cdr of the last cons cell. Improper list might be dotted, or even cyclic.

<code lisp>
>(proper-list-p (cons 'a 'b)) ; this is conscell with B in cdr, improper list
NIL
</code>

''SYMBOLP''

Tests if the argument is a symbol. All versions of NIL are symbol. 

<code lisp>
>(symbolp 'a)          ; symbol A
T

>(symbolp 13)
NIL

>(symbolp nil)          ; symbol NIL
T
</code>

''STRINGP''

Tests if the argument is a string. 

<code lisp>
>(stringp "hello")          
T

>(stringp 'hello) 
NIL
</code>

''NUMBERP''

Tests if the argument is a number (integer or float). 

<code lisp>
>(numberp pi)          
T

>(numberp (/ 10 5))
T

>(numberp (/ 10 0))
;Division by zero.
NIL
</code>

''INTEGERP''

Tests if the argument is a integer number. 

<code lisp>
>(integerp (/ 10 5))     ; integer division
T

>(integerp (/ 10 5.0))   ; poisoned by float 5.0
NIL
</code>

''ZEROP''

Tests if the argument is number zero. 

<code lisp>
>(zerop (- 10 10))     
T

>(zerop nil)
;Applying ZEROP on non-numeric data type!
NIL
</code>

''ODDP''

Tests if the argument is an odd integer. 

<code lisp>
>(oddp 3)     
T

>(oddp 3.0) 
;Applying ODDP on non-integral number!
NIL
</code>

''EVENP''

Tests if the argument is an even integer. 

<code lisp>
>(evenp 2)     
T

>(evenp 0)     
T
</code>

''FUNCTIONP''

Tests if the argument is a function object. 

<code lisp>
>(functionp #'+)     
T
</code>

''PACKAGEP''

Tests if the argument is a package object. 

<code lisp>
>(packagep *package*)
T
</code>

''BOUNDP''

Expects symbol as argument. Tests if the symbol has value binding.

<code lisp>
>(boundp 'pi)
T
</code>

''FBOUNDP''

Expects symbol as argument. Tests if the symbol has function or macro binding.

<code lisp>
>(fboundp '+)
T

>(fboundp 'if)    ; also works for special forms
T
</code>

''SPECIAL-OPERATOR-P''

Expects symbol as argument. Tests if the symbol represents special operator.

<code lisp>
>(special-operator-p '+)     ; ordinary function
NIL

>(special-operator-p 'if)    ; special operator IF
T
</code>