Arrays in Lisp

Our first example demonstrates how to work with arrays in Lisp. Arrays are sequences of elements with a fixed size.

(defun main ()
  ;; Here we create an array 'a' that will hold exactly 5 integers.
  ;; By default, an array is initialized with nil values.
  (let ((a (make-array 5 :initial-element 0)))
    (format t "emp: ~a~%" a)

    ;; We can set a value at an index using setf, and get a value with aref.
    (setf (aref a 4) 100)
    (format t "set: ~a~%" a)
    (format t "get: ~a~%" (aref a 4))

    ;; The length function returns the length of an array.
    (format t "len: ~a~%" (length a))

    ;; Use this syntax to declare and initialize an array in one line.
    (let ((b #(1 2 3 4 5)))
      (format t "dcl: ~a~%" b))

    ;; In Lisp, we don't have a direct equivalent to Go's [...] syntax,
    ;; but we can create arrays with initial contents easily.
    (let ((b (vector 1 2 3 4 5)))
      (format t "dcl: ~a~%" b))

    ;; To create an array with specific indices set, we can use make-array with :initial-contents
    (let ((b (make-array 5 :initial-contents '(100 0 0 400 500))))
      (format t "idx: ~a~%" b))

    ;; Array types are one-dimensional, but you can create multi-dimensional arrays.
    (let ((twoD (make-array '(2 3) :initial-element 0)))
      (dotimes (i 2)
        (dotimes (j 3)
          (setf (aref twoD i j) (+ i j))))
      (format t "2d: ~a~%" twoD))

    ;; You can create and initialize multi-dimensional arrays at once too.
    (let ((twoD #2A((1 2 3) (1 2 3))))
      (format t "2d: ~a~%" twoD))))

;; Call the main function
(main)

When you run this program, you should see output similar to:

emp: #(0 0 0 0 0)
set: #(0 0 0 0 100)
get: 100
len: 5
dcl: #(1 2 3 4 5)
dcl: #(1 2 3 4 5)
idx: #(100 0 0 400 500)
2d: #2A((0 1 2) (1 2 3))
2d: #2A((1 2 3) (1 2 3))

In Lisp, arrays are typically printed in the form #(v1 v2 v3 ...) for one-dimensional arrays and #2A((v11 v12 v13) (v21 v22 v23)) for two-dimensional arrays.

Note that Lisp arrays are zero-indexed, just like in many other programming languages. The make-array function is used to create arrays with a specified size and optional initial values. The vector function can be used to create one-dimensional arrays with initial values.

For multi-dimensional arrays, we use nested lists to specify the dimensions and initial values. The #2A reader macro is used to create two-dimensional arrays inline.

Lisp provides powerful array manipulation capabilities, and you can perform various operations on arrays using built-in functions and macros.

Switch in Lisp

Slices in Lisp

Learn X By Example

Title here

Arrays in Lisp