Introduction to Lists: Advanced

Greetings to all budding AutoLISP programmers! As we delve deeper into our journey through AutoLISP, we’re about to tackle a more intricate facet of the language: advanced list manipulations. Lists, as we’ve learned, form the core of data structures in AutoLISP. Understanding them inside-out is paramount to scripting proficiently in CAD environments. So, without further ado, let’s unlock the advanced potential of list manipulations!

Learning Outcomes

By the end of this lesson, students will be able to:

  • Utilize advanced functions to manipulate lists in various ways.
  • Construct and deconstruct lists dynamically using functions like cons and append.
  • Analyze lists to retrieve specific data points or assess their structure.
  • Implement these functions in CAD design scenarios for efficient data handling.
  • Critically evaluate when and how to use each function for optimal outcomes.

Deep Dive into Advanced List Manipulations

cons Function

Definition: The cons function constructs a new list by adding an item to the beginning of an existing list.


(cons item list)


Adding an element to the start:

(cons ‘x ‘(a b c))
; Returns: (X A B C)

The element x is added to the beginning of the list.

Nesting lists:

(cons ‘(1 2) ‘(3 4))
; Returns: ((1 2) 3 4)

The list (1 2) is added to the beginning, resulting in a nested list.

Working with empty lists:

(cons ‘x ‘())
; Returns: (X)

The cons function can be used to start a new list by adding an element to an empty list.

append Function

Definition: The append function combines two or more lists into a single list.


(append list1 list2 … listn)


Combining two lists:

(append ‘(a b) ‘(c d))
; Returns: (A B C D)

The append function combines both lists into one continuous list.

Appending multiple lists:

(append ‘(1 2) ‘(3 4) ‘(5 6))
; Returns: (1 2 3 4 5 6)

Three lists are merged into one.

Appending an empty list:

(append ‘(a b) ‘())
; Returns: (A B)

Appending an empty list doesn’t change the original list.

reverse Function

Definition: The reverse function returns a new list that’s the reverse of the given list.


(reverse list)


Reversing a list:

(reverse ‘(a b c d))
; Returns: (D C B A)

The list is returned in the opposite order.

Nested lists remain intact:

(reverse ‘((1 2) (3 4)))
; Returns: ((3 4) (1 2))

While the sublists’ order is reversed, the contents within them remain in their original order.

Reversing an empty list:

(reverse ‘())
; Returns: ()

Reversing an empty list simply returns an empty list.

last Function

Definition: The last function retrieves the last element of a list.


(last list)


Fetching the last element:

(last ‘(a b c d))
; Returns: (D)

The function returns the last element, D, wrapped in a list.

Nested lists:

(last ‘((1 2) (3 4) x))
; Returns: (X)

The final item, X, is returned.

Last item in an empty list:

(last ‘())
; Returns: ()

If the list is empty, last returns an empty list.

length Function

Definition: The length function determines the number of items in a list.


(length list)


Finding the length:

(length ‘(a b c d))
; Returns: 4

The function returns the number of elements in the list, which is 4.

Nested lists count as one element:

(length ‘((1 2) (3 4) x))
; Returns: 3

Each sublist is considered a single item.

Length of an empty list:

(length ‘()); Returns: 0

An empty list has a length of 0.

nth Function

Definition: The nth function retrieves the nth item from a list (0-based index).


(nth index list)


Accessing the third element (0-based index):

(nth 2 ‘(a b c d))
; Returns: C

Using index 2, the third element, C, is returned.

Nested lists:

(nth 1 ‘((1 2) (3 4) x))
; Returns: (3 4)

The second item, which is a sublist (3 4), is returned.

Out-of-bound index:

(nth 5 ‘(a b c))
; Returns: nil

If the index is greater than the list’s length minus one, nil is returned.

member Function

Definition: The member function checks if a particular item is a member of a list.


(member item list)


Finding an existing member:

(member ‘b ‘(a b c d))
; Returns: (B C D)

Since B is in the list, the function returns a sublist starting from that item.

Checking a non-member:

(member ‘x ‘(a b c))
; Returns: nil

If the item is not in the list, nil is returned.

Nested lists:

(member ‘(3 4) ‘((1 2) (3 4) x))
; Returns: ((3 4) X)

The function can find nested lists and return the sublist starting from that nested list.


Advanced list manipulations are a testament to the depth and flexibility of the AutoLISP language. By mastering these functionalities, you’ll be better equipped to handle intricate data structures in your CAD designs. Remember, the more you practice and experiment with these functions, the more intuitive they become. So, keep coding, keep exploring, and let the world of AutoLISP unfold its magic to you!