Lets say I have a for loop in Java:
for(Foo foo : foos){ do_something() }
Now lets say I want to translate this list iteration to idiomatic clojure. Whats the best way? I want to return something I can use like an iterator over the foos collection.
(doseq [foo foos]
(do-something))
is the idiomatic Clojure equivalent of your Java snippet.
As for returning an iterator, Clojure's collections are all Iterable and seqable, so you can iterate over them in the idiomatic way in both Clojure and Java.
my $func = _build_iterator(); while( my $next_val = $func->() ) { do_something( $next_val) } what is the clojure way to do this?(defmethod scan [java.lang.String java.lang.String] [table start-key end-key] (let [scan (Scan. (Bytes/toBytes start-key) (Bytes/toBytes end-key))] (let [scanner (.getScanner table scan)] (doseq [result scanner] (prn (Bytes/toString (.getRow result)) (get-to-map result)))))) I want to return an iterator that unwraps the row key and return a suitable value like nil when exhausted
This is wrong. I'm keeping this around so that it provides useful information for others though
(dorun (map (constantly (do-something)) foos))
Here's the definition of map and here's the definition of constantly.
In summary, this will call do-something for each element in foos. constantly will ignore anything you pass in and just do what you tell it to.
map is lazy -- you'd have to wrap it in dorun to ensure the effects actually take place. doall is another possibility, but it will hold onto the head of the sequence, which is undesirable here.
(map (constantly (do-something)) ...) will only (do-something) once, before the iteration even begins. You'd need something like (map (fn [_] (do-something)) ...) instead.(fn [_] ...)), it's certainly possible to force the lazy seq in the caller of map, but why do it if the whole point of iterating is to produce some effects while throwing away the result? That delegates the responsibility for making sure the effects happen in a timely manner -- in fact, that they happen at all -- to the caller, which feels a bit fragile. Plus doseq is likely to perform somewhat better, since it does away with the lazy seq allocation altogether (whereas map will always construct it; dorun then throws it away piece by piece).