Type-Checking Predicates

• Predicates that check if a value is of a particular data type.

  (numberp 2)      ; t
  (numberp 'a)     ; nil
  (listp '(1 2 3)) ; t
  (functionp '+)   ; t
  

• Other predicates: atom, arrayp, char-or-string-p, consp, floatp, functionp, integerp, stringp.

Example

(defun plus-maybe (n m)
  (let ((r 0))
    (if (numberp n) (setq r (+ r n)))
    (if (numberp m) (setq r (+ r m)))
    r))
(plus-maybe 3 8) ; 11
(plus-maybe 3 'a) ; 3
(plus-maybe '(2 3 9) 4) ; 4
(plus-maybe 'a 'b) ; 0

Optional Parameters

• A function can have optional parameters as well as unlimited number of parameters.

  (defun fname (required-args
                &optional args
                &rest arg)
  

• The &optional and &rest parts are optional. If they are missing they amount to nil.
• Any arguments specified after &optional can be omitted. If they are missing, their value is nil.
• Any more arguments beside the required and optional will be collected in a list contained in the argument marked with &rest.

Example
(defun fun (a b c &optional d e &rest f) ...)

• The function must be called with at least 3 parameters. The first 3 parameters will be bound to a, b, c.
• If one or two more parameters are present, they will be bound in order to d and e.
• If more than 5 parameters are present, the extra parameters are collected in a list which is bound to f.

(defun my-make-list (length &optional init &rest endlist)
  "Creates a list by making length copies of init and appending endlist to it 
   afterwards. If the init is missing the list is filled with 0s."
  (let ((L nil))
    (setq L (if init (make-list length init)
              (make-list length 0)))
    (append L endlist)))

(my-make-list 4 2 7 8) ; (2 2 2 2 7 8)
(my-make-list 5) ; (0 0 0 0 0)
(my-make-list 3 0 1 1) ; (0 0 0 1 1)

(defun my-print (&rest L)
  "Prints any number of arguments with princ and returns true."
  (mapc 'princ L) t) ; my-print
(my-print "hello world " 1 " " 2  " n= " 4 "\n")
; hello world 1 2 n= 4
; t
(defun plus (&rest L)
  (apply '+ L)) ; plus
(plus 1 2 3) ; 6

Explicit Function Invocation

(funcall function arguments)
(apply function (list-of-arguments))

(setq f (lambda (x y) (* x y)))
; (lambda (x y) (* x y))
(funcall f 2 5) ; 10
(apply f '(2 5)) ; 10
(apply '+ '(1 2 3)) ; 6
(funcall '+ 1 2 3) ; 6