best way to repeatedly map values from a sequence into an arg list?

Question

Sorry for the noob question, but is there an good way to destructure values from a sequence like this..

(somefunc [[a b c] [1 2 3 4 5 6 7 8 9]] (prn a b c))

..with the a b c being assigned values until the sequence exhausted and letting me call a function on the args? doseq requires a partition of the right size..

(doseq [[a b c] (partition 3 [1 2 3 4 5 6 7 8 9])] (prn a b c))

Output:

1 2 3 4 5 6 7 8 9

That does what I want, but it seems like there should be a way to do this in s straightforward way without having to specify the partition. I found a solution with loop/recur but it's a lot more code and clearly non-idiomatic. What's a good way to do this? Thanks!

Answer 1

(defn some-func
  [[a b c & rest :as all]]
  (prn a b c)
  (prn rest)
  (prn all)

user> (some-func [1 2 3 4 5 6 7])
1 2 3
(4 5 6 7)
[1 2 3 4 5 6 7]

Read more about destructing: http://java.ociweb.com/mark/clojure/article.html#Destructuring

Answer 2

(defn apply-to-three [f [a b c & rest]]
  (f a b c)
  (when rest
    (recur f rest)))

user=> (apply-to-three prn [1 2 3 4 5 6 7 8 9])
1 2 3
4 5 6
7 8 9
nil

Answer 3

Using map and partition:

(map prn (partition 3 [1 2 3 4 5 6 7 8 9]))

Answer 4

partition + map is all you need. Read about dorun, doseq and doall: http://onclojure.com/2009/03/04/dorun-doseq-doall/

user> (dorun (map #(apply prn %) (partition 3 [1 2 3 4 5 6 7 8 9])))
1 2 3
4 5 6
7 8 9
nil