Starting with emacs version 22, sequences of numbers can be generated using the
<code>number-sequence</code> function.

  (number-sequence 4)
                                 => (4)

  (number-sequence 1 9)
                                 => (1 2 3 4 5 6 7 8 9)

  (number-sequence 1 16 2)
                                 => (1 3 5 7 9 11 13 15)



For earlier versions of emacs,
here are some small hacks to create a list of integers, in a given range.

Here is a recursive solution:

  (defun int-list (x y)
  "Returns a list of integers in the range of x and y."
    (setq list
          (cond ((< x y) (new-int-list y x ())
                 t (new-int-list x y ())))))

  (defun new-int-list (x y list)
    (let ((mylist list))
      (setq list (add-to-int-list x y list))
      (if (equal mylist list)
          list
        (new-int-list x (- y 1) list))))

  (defun add-to-int-list (x y list)
    (cond ((<= x y)
           (append (list y) list))
          (t list)))

Here is a more compact recursive sollution:

  (defun int-list (x y &rest list)
    "Returns a list of integers in the range of x and y."
    (let ((i (min x y)) (j (max x y)))
      (if (= i j)
          (append (list j) (car list))
        (int-list i (- j 1) (append (list j) (car list))))))

Here's a shorter way:

 (defun int-list (x y)
   (let (list)
     (dotimes (i (1+ (- y x)))
       (push (+ x i) list))
     (nreverse list)))

Here is the same, modified to support y > x:

  (defun int-list (i j)
  "Returns a list of integers in the range of x and y."
     (let ((x (min i j))
           (y (max i j)))
       (let (list)
         (dotimes (i (1+ (- y x)))
           (push (+ x i) list))
         (nreverse list))))

Lets play golf:

    (require 'cl)
    (defun int-list (x y)
      (loop for i from (min x y) to (max x y) collecting i))


----
CategoryCode