How deeply does Clojure: The Essential Reference cover repeat?

Defines arities, laziness, output types, edge cases, and a cons/lazy-seq implementation sketch.

Repeat

As explained in Clojure: The Essential Reference

repeat is a Clojure function that produces a lazy sequence containing repeated copies of a value, either indefinitely or a specified number of times.

repeat generates a lazy sequence containing repeated copies of one value. With one argument it repeats indefinitely; with a count it limits the result. section 9.2.3

Its contract is small but includes useful edge cases:

x is mandatory and may be any expression or value, including nil. section 9.2.3
n is optional; zero or a negative value produces an empty PersistentList, while a double is truncated to an integer. section 9.2.3
A nil n raises NullPointerException; the result is a sequence-compatible clojure.lang.Repeat object. section 9.2.3

Repeat values for sequential processing

(defn bang [sentence] (map str (.split #"\\s+" sentence) (repeat "!"))) (bang "Add exclamation each word") ;; ("Add!" "exclamation!" "each!" "word!") (repeat 5 1) ;; (1 1 1 1 1)

(defn repeatedly* [f] ; #1
  (lazy-seq (cons (f) (repeatedly* f))))

(defn iterate* [f x] ; #2
  (lazy-seq (cons x (iterate* f (f x)))))

(defn repeat* [x] ; #3
  (lazy-seq (cons x (repeat* x))))

(defn cycle* [coll] ; #4
  ((fn step [[x & xs]]
     (lazy-seq
       (if x
         (cons x (step xs))
         (cycle* coll)))) coll))

(defn range* [n] ; #5
  ((fn step [x]
     (lazy-seq
       (when (< x n)
         (cons x (step (inc x)))))) 0))

The recursive repeat* sketch makes infinite lazy generation concrete through cons and lazy-seq. section 9.2

How Clojure: The Essential Reference covers it

Cover of Clojure: The Essential Reference

liveBook manning.com

Read Clojure: The Essential Reference on liveBook Get the book at manning.com

Related concepts

infinite data structureproduces · An infinite data structure represents or generates an unbounded number of elements, commonly by producing them lazily rather than storing them all.
lazy listproduces · A lazy list is an immutable sequence whose elements and continuation are computed incrementally on demand, allowing finite or infinite sequences.
generatorkind of · A generator is a computational component or construct that produces data or values from inputs, representations, context, or specified constraints.
iterateequivalent to · Iterate is an operation that advances through successive values or states according to specified functions or iteration rules.
mapuses · An operation that applies a function to values in a collection or computational context, producing corresponding results while preserving the collection or context’s structure.

This explainer was generated by Manning's knowledge graph from the text of Clojure: The Essential Reference. The section links point to the parts of the book it draws on.