Slices in Lisp

(defun main ()
  ;; Unlike arrays, lists in Lisp are not typed by their elements
  ;; An empty list is represented by nil
  (let ((s nil))
    (format t "uninit: ~a ~a ~a~%" s (null s) (= (length s) 0)))

  ;; To create an empty list with non-zero length, we can use make-list
  (let ((s (make-list 3)))
    (format t "emp: ~a len: ~a~%" s (length s)))

  ;; We can set and get elements just like with arrays
  (let ((s (list "a" "b" "c")))
    (format t "set: ~a~%" s)
    (format t "get: ~a~%" (nth 2 s)))

  ;; length returns the length of the list as expected
  (format t "len: ~a~%" (length '("a" "b" "c")))

  ;; In Lisp, we use the append function to add elements to a list
  (let ((s '("a" "b" "c")))
    (setf s (append s '("d")))
    (setf s (append s '("e" "f")))
    (format t "apd: ~a~%" s))

  ;; Lists can be copied using the copy-list function
  (let* ((s '("a" "b" "c" "d" "e" "f"))
         (c (copy-list s)))
    (format t "cpy: ~a~%" c))

  ;; Lisp supports slicing with the subseq function
  (let ((s '("a" "b" "c" "d" "e" "f")))
    (format t "sl1: ~a~%" (subseq s 2 5))
    (format t "sl2: ~a~%" (subseq s 0 5))
    (format t "sl3: ~a~%" (subseq s 2)))

  ;; We can declare and initialize a list in a single line
  (let ((t '("g" "h" "i")))
    (format t "dcl: ~a~%" t))

  ;; Lisp has built-in functions for list comparison
  (let ((t1 '("g" "h" "i"))
        (t2 '("g" "h" "i")))
    (when (equal t1 t2)
      (format t "t1 == t2~%")))

  ;; Lists can be composed into multi-dimensional data structures
  (let ((two-d (loop for i from 0 to 2
                     collect (loop for j from 0 to i
                                   collect (+ i j)))))
    (format t "2d: ~a~%" two-d)))

(main)

In Lisp, we use lists as the primary data structure, which are similar to slices in Go. Here are some key differences and adaptations:

Lisp lists are not typed by their elements, unlike Go slices.
We use nil to represent an empty list, which is equivalent to both nil and an empty slice in Go.
Instead of make, we use make-list to create a list of a specific length.
The append function in Lisp is used to add elements to a list, similar to Go’s append.
Lisp uses subseq for slicing, which is analogous to Go’s slice notation.
For equality comparison, we use the equal function instead of a separate package like slices.Equal in Go.
Multi-dimensional lists in Lisp can be created using nested loops, similar to the 2D slice example in Go.

When you run this program, it will produce output similar to the Go version, demonstrating the various operations on lists in Lisp.

Note that Lisp doesn’t have a built-in concept of capacity for lists, so we’ve omitted that part of the example. Also, Lisp’s dynamic nature means we don’t need to explicitly declare types for our lists.

Arrays in Lisp

Maps in Lisp

Learn X By Example

Title here

Slices in Lisp