
- LISP Tutorial
- LISP - Home
- LISP - Overview
- LISP - Environment
- LISP - REPL
- LISP - Program Structure
- LISP - Basic Syntax
- LISP - Data Types
- Lisp Macros
- LISP - Macros
- LISP - Backquote and Comma
- LISP - Code Generation Using Macro
- LISP - Variable Capture and Hygienic macro
- LISP - Scope and Binding
- LISP - Macro Writing Style
- LISP - Macro Characters
- LISP - Read-Time Macros
- LISP - Compiler Macros
- LISP - Uses of Macros
- Lisp Functions
- LISP - Functions
- LISP - Functions vs Macros
- LISP - Calling Function using funcall
- LISP - Calling Function using apply
- LISP - Closures
- LISP - Functions as Arguments
- LISP - Functions as Return Values
- LISP - Recursion
- LISP - Built-in Functions
- Lisp Predicates
- LISP - Predicates
- LISP - Generic Data Type Predicates
- LISP - Specific Data Type Predicates
- LISP - Equality Predicates
- LISP - Numeric Predicates
- LISP - Comparison Predicates
- LISP - Logical Predicates
- LISP - List Predicates
- LISP - Custom Predicates
- LISP - Chaining Predicates
- Lisp Arrays
- LISP - Arrays
- LISP - Adjustable Arrays
- LISP - Fill Pointers in Arrays
- LISP - Specialized Arrays
- LISP - Arrays Properties
- LISP - Iterating over Arrays
- LISP - Multidimensional Arrays
- LISP - Row-Major Order
- Lisp Strings
- LISP - Strings
- LISP - String Concatenation
- LISP - String Comparison
- LISP - String Case Conversion
- LISP - String Trimmimg
- LISP - String Searching
- LISP - Getting Substring
- LISP - String Replacement
- LISP - Sorting Strings
- LISP - Merging Strings
- LISP - Accessing Characters of String
- LISP - String length
- LISP - Escape Sequences
- Lisp Sequences
- LISP - Sequences
- LISP - Accessing Element of Sequence
- LISP - Sequence length
- LISP - Getting Subsequence
- LISP - Search Element in Sequence
- LISP - Sequence Concatenation
- LISP - Reversing a Sequence
- LISP - Mapping Sequence Element
- LISP - position of Element
- LISP - Remove an Element
- LISP - Sort Sequence
- LISP - Merge Sequences
- LISP - every function
- LISP - some function
- LISP - notany function
- LISP - notevery function
- Lisp Lists
- LISP - Lists
- LISP - Accessing Elements of Lists
- LISP - Modifications to Lists
- LISP - Using mapcar on List
- LISP - Using mapc on List
- LISP - Using reduce on List
- LISP - Removing elements from List
- LISP - Reversing a List
- LISP - Sorting a List
- LISP - Searching a List
- LISP - List vs Vectors
- LISP - Matrix Multiplication
- Lisp Vectors
- LISP - Vectors
- LISP - Creating Vectors
- LISP - Accessing Elements of Vectors
- LISP - Modifications to Vectors
- LISP - Adjustable Vectors
- LISP - Specialized Vectors
- LISP - Vector Functions
- Lisp Set
- LISP - Set
- LISP - Adding elements to the Set
- LISP - Getting SubSet from a Set
- LISP - Set Difference
- LISP - Set Exclusive OR
- LISP - Set Intersection
- LISP - Set Union
- LISP - Representing Set with HashTable
- LISP - List as Set vs HashTable as Set
- Lisp Tree
- LISP - Tree
- LISP - Recursive Traversal
- LISP - Inorder Traversal
- LISP - Preorder Traversal
- LISP - Postorder Traversal
- LISP - Depth First Traversal
- LISP - Modifying Tree
- LISP - Search Tree
- LISP - Binary Tree
- Lisp Hash Table
- LISP - Hash Table
- Adding Values to Hash Table
- Removing Values from Hash Table
- Updating Values of Hash Table
- Iterating Hash Table Entries
- Searching key in HashTable
- Checking Size of HashTable
- Using Custom Equality Check
- Lisp - Input − Output
- LISP - Input − Output
- LISP - Streams
- LISP - Reading Data from Streams
- LISP - Writing Data to Streams
- LISP - File I/O
- LISP - String I/O
- LISP - Formatting with Format
- LISP - Interactive I/O
- LISP - Error Handling
- LISP - Binary I/O
- Lisp - Structures
- LISP - Structures
- LISP - Accessors and Mutators
- LISP - Structure Options
- LISP - Structure Types
- LISP - Applications and Best Practices
- Lisp - CLOS
- LISP - CLOS
- Lisp - Objects
- LISP - Class
- LISP - Slots and Accessors
- LISP - Generic Functions
- LISP - Class Precedence
- LISP - Metaobject Protocol
- LISP - Multimethods
- LISP - Multiple Inheritance
- LISP - Method Combinations
- LISP - Method Combinations
- LISP - :before Method Combination
- LISP - :primary Method Combination
- LISP - :after Method Combination
- LISP - :around Method Combination
- LISP - + Method Combination
- LISP - and Method Combination
- LISP - append Method Combination
- LISP Useful Resources
- Lisp - Quick Guide
- Lisp - Useful Resources
- Lisp - Discussion
Lisp - Lists
Lists had been the most important and the primary composite data structure in traditional LISP. Present day's Common LISP provides other data structures like, vector, hash table, classes or structures.
Lists are single linked lists. In LISP, lists are constructed as a chain of a simple record structure named cons linked together.
The cons Record Structure
A cons is a record structure containing two components called the car and the cdr.
Cons cells or cons are objects are pairs of values that are created using the function cons.
The cons function takes two arguments and returns a new cons cell containing the two values. These values can be references to any kind of object.
If the second value is not nil, or another cons cell, then the values are printed as a dotted pair enclosed by parentheses.
The two values in a cons cell are called the car and the cdr. The car function is used to access the first value and the cdr function is used to access the second value.
Example
Create a new source code file named main.lisp and type the following code in it.
main.lisp
; create and print a cons of car 1, cdr 2 (write (cons 1 2)) ; terminate printing (terpri) ; create and print a cons of car a, cdr b (write (cons 'a 'b)) ; terminate printing (terpri) ; create and print a cons of car 1, cdr nil (write (cons 1 nil)) ; terminate printing (terpri) ; create and print a cons of car 1, cdr as another cons (write (cons 1 (cons 2 nil))) ; terminate printing (terpri) ; create and print multiple cons (write (cons 1 (cons 2 (cons 3 nil)))) ; terminate printing (terpri) ; create and print multiple cons (write (cons 'a (cons 'b (cons 'c nil)))) ; terminate printing (terpri) ; create and print multiple cons (write ( car (cons 'a (cons 'b (cons 'c nil))))) ; terminate printing (terpri) ; create and print multiple cons (write ( cdr (cons 'a (cons 'b (cons 'c nil)))))
Output
When you execute the code, it returns the following result −
(1 . 2) (A . B) (1) (1 2) (1 2 3) (A B C) A (B C)
The above example shows how the cons structures could be used to create a single linked list, e.g., the list (A B C) consists of three cons cells linked together by their cdrs.
Lists in LISP
Although cons cells can be used to create lists, however, constructing a list out of nested cons function calls can't be the best solution. The list function is rather used for creating lists in LISP.
The list function can take any number of arguments and as it is a function, it evaluates its arguments.
The first and rest functions give the first element and the rest part of a list. The following examples demonstrate the concepts.
Example
Update the source code file named main.lisp and type the following code in it.
main.lisp
; create and print a list (write (list 1 2)) ; terminate printing (terpri) ; create and print a list (write (list 'a 'b)) ; terminate printing (terpri) ; create and print a list (write (list 1 nil)) ; terminate printing (terpri) ; create and print a list (write (list 1 2 3)) ; terminate printing (terpri) ; create and print a list (write (list 'a 'b 'c)) ; terminate printing (terpri) ; create and print a list an car (write (list 3 4 'a (car '(b . c)) (* 4 -2))) ; terminate printing (terpri) ; create and print a list of lists (write (list (list 'a 'b) (list 'c 'd 'e)))
Output
When you execute the code, it returns the following result −
(1 2) (A B) (1 NIL) (1 2 3) (A B C) (3 4 A B -8) ((A B) (C D E))
Example
Update the source code file named main.lisp and type the following code in it.
main.lisp
; define a function to return the list (defun my-library (title author rating availability) (list :title title :author author :rating rating :availabilty availability) ) ; call the function and print the result (write (getf (my-library "Hunger Game" "Collins" 9 t) :title))
Output
When you execute the code, it returns the following result −
"Hunger Game"
List Manipulating Functions
The following table provides some commonly used list manipulating functions.
Sr.No. | Function & Description |
---|---|
1 |
car It takes a list as argument, and returns its first element. |
2 |
cdr It takes a list as argument, and returns a list without the first element |
3 |
cons It takes two arguments, an element and a list and returns a list with the element inserted at the first place. |
4 |
list It takes any number of arguments and returns a list with the arguments as member elements of the list. |
5 |
append It merges two or more list into one. |
6 |
last It takes a list and returns a list containing the last element. |
7 |
member It takes two arguments of which the second must be a list, if the first argument is a member of the second argument, and then it returns the remainder of the list beginning with the first argument. |
8 |
reverse It takes a list and returns a list with the top elements in reverse order. |
Please note that all sequence functions are applicable to lists.
Example
Update the source code file named main.lisp and type the following code in it.
main.lisp
; create a car of a sequence (write (car '(a b c d e f))) ; terminate printing (terpri) ; create a cdr of a sequence (write (cdr '(a b c d e f))) ; terminate printing (terpri) ; create a cons (write (cons 'a '(b c))) ; terminate printing (terpri) ; create a list of lists (write (list 'a '(b c) '(e f))) ; terminate printing (terpri) ; create a list by appending lists (write (append '(b c) '(e f) '(p q) '() '(g))) ; terminate printing (terpri) ; get last car (write (last '(a b c d (e f)))) ; terminate printing (terpri) ; get reverse of the list (write (reverse '(a b c d (e f))))
Output
When you execute the code, it returns the following result −
A (B C D E F) (A B C) (A (B C) (E F)) (B C E F P Q G) ((E F)) ((E F) D C B A)
Concatenation of car and cdr Functions
The car and cdr functions and their combination allows extracting any particular element/ member of a list.
However, sequences of car and cdr functions could be abbreviated by concatenating the letter a for car and d for cdr within the letters c and r.
For example we can write cadadr to abbreviate the sequence of function calls - car cdr car cdr.
Thus, (cadadr '(a (c d) (e f g))) will return d
Example
Update the source code file named main.lisp and type the following code in it.
main.lisp
; create a cons from sequences (write (cadadr '(a (c d) (e f g)))) ; terminate printing (terpri) ; create a cons from a list (write (caar (list (list 'a 'b) 'c))) ; terminate printing (terpri) ; create a cons from a list (write (cadr (list (list 1 2) (list 3 4)))) ; terminate printing (terpri)
Output
When you execute the code, it returns the following result −
D A (3 4)