Actually now that I've thought about it, you couldn't mimic non-strict 
evaluation with lazy apply, so that's not a use-case. All you could provide 
is left-to-right argument non-strictness which is not sufficient. W.r.t. 
your example,  you can force evaluation the first 3 args, but you can't, 
say, force the evaluation of only the 3rd argument like in Haskell.

I use apply to leverage list processing functions to massage input to 
functions that are generally non-seq-ey. If a function is intended to 
operate on lazy sequences, it seems to me that you would pass those 
sequences in as explicit arguments, in the same manner as all the Clojure 
seq operations.

Again, we don't have the machinery to mimic non-strict evaluation so I 
don't think building functions that behave in this halfways-non-strict 
manner is obvious design. I'd like to see a function that depends on the 
left-to-right-non-strictness that lazy apply provides.

-- 
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

Reply via email to