`clojure.core/take-last`¶

Type: function Added: Clojure 1.1 Examples: 2 Runnable: 1

([n coll])

Returns a seq of the last n items in coll. Depending on the type of coll may be no better than linear time. For vectors, see also subvec.

Examples¶

by gstamp on 2010-07-28

by tomdl89 on 2025-12-13 . May have evaluation errors.

;; take-last is rarely what you want from a pure performance perspective,
;; although for small collections, it's not worth worrying about
;; unless it's on a hot path.

;; let's make an alternative version, using drop:
(defn my-take-last [n coll]
  (drop (- (count coll) n) coll))

(require '[criterium.core :as c])
;; For lazy-sequences, where we are taking a small number of elements,
;; take-last can be faster:
(->> (c/benchmark-round-robin [(dorun (take-last    2 (map inc (range 100))))
                               (dorun (my-take-last 2 (map inc (range 100))))]
                              c/*default-benchmark-opts*)
     (map (comp first :mean)))
;; => (1.968E-6 2.613E-6)
;; So, they both take a few microseconds. Rarely important.
;; But take-last is ~25% faster

;; For lazy-sequences where we are taking a large number of elemnts,
;; the advantage disappears:
(->> (c/benchmark-round-robin [(dorun (take-last    92 (map inc (range 100))))
                               (dorun (my-take-last 92 (map inc (range 100))))]
                              c/*default-benchmark-opts*)
     (map (comp first :mean)))
;; => (2.517E-6 2.150E-6)
;; take-last is ~17% slower here. But we're still on microsecond scales.

;; For counted collections, take-last is noticeably slower:
(->> (c/benchmark-round-robin [(dorun (take-last    2 (mapv inc (range 100))))
                               (dorun (my-take-last 2 (mapv inc (range 100))))]
                              c/*default-benchmark-opts*)
     (map (comp first :mean)))
;; => (2.183E-6 1.230E-6)
;; take-last is ~77% slower here, and it only gets worse the larger collections get

;; For vectors specifically, subvec can be even faster:
(defn my-vec-take-last [n v]
  (subvec v (- (count v) n)))

(->> (c/benchmark-round-robin [(dorun (take-last        2 (mapv inc (range 100))))
                               (dorun (my-vec-take-last 2 (mapv inc (range 100))))]
                              c/*default-benchmark-opts*)
     (map (comp first :mean)))
;; => (2.075E-6 1.133E-6)
;; take-last is ~83% slower here

;; For readability, take-last communicates intent well, but for hot-paths,
;; it's worth knowing it's (sometimes significantly) slower than alternatives

Note by reborg¶

Unlike "drop-last" (but like "last"), "take-last" is not lazy:

(def bomb (take-last 1 (range))) ;; infinite evaluation, never returns
(def lazy-bomb (drop-last 1 (range))) ;; good, but don't use!

clojure.core/take-last¶

Examples¶

Note by reborg¶

See also¶

`clojure.core/take-last`¶