Clojure noob, here. I'm very excited to be learning about this language and
becoming a part of this community :) I'm writing a function that works
well, but seems just a bit wrong to me, stylistically speaking. I was
hoping I could get some guidance from you all.
Here's the code:
(defn get-if
"Gets the value of a map if exactly one key matches a predicate,
otherwise nil"
([m predicate?] (get-if nil m predicate?))
([found m predicate?]
(if-let [e (first m)]
(let [pred (predicate? (key e))]
(if (not (and pred found))
(recur (if pred (val e) found) (rest m) predicate?))
found))))
This has gone through a few revisions to get it as concise as possible, but
here are my questions/remarks:
1. Is it idiomatic to use if-let to move through a collection the way I
have? In my experience with lispy languages, recursion over sequences tend
to take the form (if (null item) accumlated-value (recur-over-rest)).
This if-let form turns that on its head, which looks a little backwards at
first to me, but it saves a level of indentation which is generally
preferable in my experience.
2. The main part of this code that's bugging me is the let form, which
is a total hack to keep from testing (predicate? (key e)) twice. Even
still, I have to test the truthiness of pred twice; once in the (not
(and ...)) form and once again in the if of the recur form. I feel like
a clever use of (and ...) or (or ...) would save me here, but I haven't
come upon a solution using those forms yet.
3. In general, when using recursion and multiple arities to get a
result, is there an order that is preferred for the extra recursion
accumulation values? Here I have [m predicate?] and [found m predicate?]
versions of the function, but after looking at it for so long I think it
might be more natural to put found as the last argument, as in [m
predicate? found], but I'm wondering if there's a standard to follow
with things like this.
4. When passing functions as arguments, as I have here with the
predicate? function, is there a standard naming convention? I used a
question mark here, but would predicate be preferable, or even simply f?
5. Is writing this function even necessary? I didn't see a function that
serves the same purpose in the standard libraries, but I'm very new and
could easily have missed something!
I know that's a lot to ask for such a short segment of code. Feel free to
answer as many/few of these questions as you'd like, as any help would be
greatly appreciated (though, if you're going to answer one, I think point
#2 is the most important) :)
Thanks in advance, fellow clojurians!
--
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
---
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to clojure+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
