The sequence abstraction

Clojure has some unique features that make it different from other Lisps; one of them is the sequence abstraction. You can think of it as an interface that collections comply with. Clojure has a standard API of functions that you can use with sequences. Here are some examples of those functions:

• The distinct function: This function returns a sequence that includes each element of the original sequence just once:

  (def c [1 1 2 2 3 3 4 4 1 1])
  (distinct c) ;; (1 2 3 4)

• The take function: This function takes a number of elements from the original sequence:

  (take 5 c) ;; (1 1 2 2 3)

• The map function: This function applies a function to each element of a sequence and creates a new sequence with these elements:

  (map #(+ % 1) c) ;; (2 2 3 3 4 4 5 5 2 2)

The interesting part here is that these functions receive and return sequences and you can compose them together. It can be seen in the following code:

 (->> c
  (distinct)
  (take 5)
  (reverse)) ;; (4 3 2 1)

;; This is...