Sequences in LISP

In Lisp, the ordered set of elements is represented by sequences. All the functionality we use in sequences is applied on vectors and lists which are two of the subtypes of sequences.

Creating a Sequence:

The generic function for creating a Sequence in Lisp is:

;The generic function for creating a Sequence in Lisp make-sequence type size &key:default-element

Note:

In the above syntax, type represents the type 
of sequence and size represents the size of the sequence.
The :default-element sets all the elements in the 
sequence initialised to the given value

Example 1:

; Creating a vector of size 6 with 2 
; as the default element of type fixnum or integer
(write (make-sequence '(vector fixnum) 
 6  :initial-element 2))

Output:

Generic Functions on Sequences:

In Lisp, we have a lot of generic functions which can be applied to vectors and lists.

Standard Sequence Function Keyword Arguments:

Since now we are familiar with the generic and standard sequence functions let us now implement these in some examples.

Finding Length and Element in Sequences:

As we discussed the generic functions, we can easily find the length and a particular element in a sequence. Recall that length was used to find the length whereas we will use the elt function to find a particular element.

Example 2:

; Finding the length of a vector and element at an index

(setq x (vector 'kishan 'rohan 'vishal 'sarthak))
(write (length x))
(terpri)
(write (elt x 3))

Output:

Note:

Indexing in Lisp is also zero-based.

Modifying Sequences in Lisp:

For performing any modification in a sequence we have some pre-defined functions for removing, counting, searching, and filtering.

Example 3:

; Sequence Modification Functions

(write (count 8 '(2 8 8 8 8 3 8 1 6 8 9)))
(terpri)
(write (remove 5 '(1 5 6 7 4 5)))
(terpri)
(write (substitute 0 9 '(1 5 6 7 8 9 2 7 3 4 5)))
(terpri)
(write (find 6 '(1 5 6 7 8 2 9 5)))
(terpri)
(write (position 9 '(1 7 5 6 8 9 5)))

Output:

Also, we can do Conditional Modification that is we can put some conditions and perform operations on the list. 

Example 4:

; Conditional Modification

(write (delete-if #'oddp '(1 2 3 4 5 6)))
(terpri)
(write (delete-if #'evenp '(1 2 3 4 5 6)))
(terpri)
(write (remove-if #'evenp '(1 2 3 4 5 6) :count 2 :from-end t))
(terpri)
(setq x (vector 'apple 'apple 'apple 'guava))
(fill x 'mango :start 0 :end 2)
(write x)

Output:

Sorting and Merging Sequences in Lisp:

Lisp provides us with operations with which we can sort a sequence and also can merge sequences together. The functions sort and merge do the operations respectively.

• Sorting Sequences: For sorting, we use the sort function, the order is provided after the list so as to sort in some specific manner.

Example 5:

; Sorting Sequences
; A) Ascending Order
(write (sort '(8 7 6 5 3 4 1 2) #'<))
(terpri)

; B) Descending Order
(write (sort '(1 2 3 4 6 5 7 9 8) #'>))
(terpri)

Output:

• Merging Sequences: For merging sequences we use the merge function, the order is provided after the list so as to merge them in some specific manner.

Example 6:

; Merging Sequences
; A) Merging Vectors
(write (merge 'vector #(1 3 5) #(2 4 6) #'<))
(terpri)

; B) Merging Lists
(write (merge 'list #(1 3 5) #(2 4 6) #'<))
(terpri)

Output:

• Sequence Predicates: These are the functions that iterate over the sequence and test the boolean predicates. Hence the first argument is always a predicate to them while the remaining arguments are sequences. They return T(true) else nil(false). Examples: every, some, not many, and not every.
  • every: Returns true if all elements follow the condition or not.
  • some: Returns true if some elements follow the condition or not.
  • not any:  Returns true if no element follows the condition.
  • not every: Returns true if some element does not follow the condition.

 Example 7:

;Sequence Predicates in Lisp

(write (some #'evenp #(2 4 6 7)))
(terpri)
(write (every #'evenp #(2 4 6 8 10 13 14)))
(terpri)
(write (notany #'evenp #(2 4 6 8 10)))
(terpri)
(write (notevery #'evenp #(2 4 6 8 10 13)))
(terpri)

Output:

• Mapping Sequences: In Lisp, we have the map function which provides us with the functionality with which we can apply some operations on multiple sequences and return a single new sequence. 

Example 9:

;Map function on two different sequences

(write (map 'vector #'+ #(1 2 3 9) #(5 6 7 10)))

Output: