Right padding a sequence

(defn rpad-seq
  [s n x]
  (if (< (count s) n)
    (seq (apply conj (vec s) (replicate (- n (count s)) x)))
      s))


=> (rpad-seq (list "a" "b" "c") 10 "d")
("a" "b" "c" "d" "d" "d" "d" "d" "d" "d")


Thanks to Mr Purcell for the refactor below:

(defn rpad-seq [s n x]
  (take n (concat s (repeat x))))

If anyone knows if there's a standard clojure API function that does this (or knows how to refactor this to be more idiomatic) please do.

An alternative implementation is:

(defn rpad-seq [s n x](concat s %28repeat %28- n %28count s%29%29 x%29))

Or, without needing to count s:

(defn rpad-seq [s n x]
  (take n (concat s (repeat x))))

purcell, much nicer.

Clojure's awesome.

Awesome, thanks chaps.

And my Clojure learning continues :)

try (take 10 (lazy-cat a (repeat "d")))
assuming a is your list. use lazy-cat to produce a lazy collection, and use take to get as many as you need.

in function form, it'd be (defn rpad-seq [s n x](take n %28lazy-cat s %28repeat x%29%29)

concat is lazy in recent versions of Clojure, so the lazy-cat formulation is pretty much equivalent to that above. It's definitely important to be aware of when seqs are and are not lazy.

precisely why I tend to use lazy-cat, it's a reminder that lazy is at work.

or not at work, as the case may be!

Any programming language that has a function called lazy-cat is cool with me