Hi All:
First of all thanks for the replies to my last post the clojure
community is great!
I've been trying to find a succinct way to do the following. Given
two sequences, product a new sequence which takes items from the first
sequence unless null in which case it will take an item from the
second, until the first sequence is exhausted. If nil is encountered
in the first sequence and the second sequence is exhaused, nil will be
returned:
e.g. user> (nil-coalesce (nil 1 2 3 nil nil) (4 5))
(4 1 2 3 5 nil)
I ended up with a scheme like natural recursion. I see two
drawbacks. The result (presumably empty) must be passed in and the
recursion will stack overflow for large sequences. I guess trampoline
would fix this, but that seems a bit of a dirty trick and workaround
until Java 7 gives us proper tail calls. Anyway I looked at partition
and interleave but without a predicate, I don't see how to make either
of these work. Anyone have a more elegant solution?
(defn nil-coalesce [result maybe-nil replacements]
(if (empty? maybe-nil)
(if (empty? replacements)
result
nil)
(let [x (first maybe-nil) xs (rest maybe-nil)]
(if (nil? x)
(recur (conj result (first replacements)) xs (rest
replacements))
(recur (conj result x) xs replacements)))))
--
You received this message because you are subscribed to the Google
Groups "Clojure" group.
To post to this group, send email to clojure@googlegroups.com
Note that posts from new members are moderated - please be patient with your
first post.
To unsubscribe from this group, send email to
clojure+unsubscr...@googlegroups.com
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
