On Feb 24, 2009, at 6:07 PM, David Sletten wrote:
>
> (defn kill-nil
> ([l] (kill-nil l '()))
> ([l result] (cond (nil? l) (reverse result)
> (nil? (first l)) (recur (rest l) result)
> true (recur (rest l) (cons (first l) result)))) )
>
>
I forgot to ask...
In Lisp, rather than repeatedly testing for an optional argument like
this:
(defun kill-nil (l &optional (result '()))
(cond ((endp l) (nreverse result))
((null (first l)) (kill-nil (rest l) result))
(t (kill-nil (rest l) (cons (first l) result)))) )
I would preserve the interface to the user (i.e., single arg) but
eliminate the decisions regarding the optional arg from the recursive
calls:
(defun kill-nil (l)
(labels ((kill-nil-aux (l result)
(cond ((endp l) (nreverse result))
((null (first l)) (kill-nil-aux (rest l) result))
(t (kill-nil-aux (rest l) (cons (first l)
result)))) ))
(kill-nil-aux l '())))
In the Clojure version above there doesn't seem to be any penalty
since the "recur" only occurs after the correct arity has been selected.
Is this correct? How about a more traditional recursion?
(defn kill-nil
([l] (kill-nil l '()))
([l result] (cond (nil? l) (reverse result)
(nil? (first l)) (recur (rest l) result)
true (kill-nil (rest l) (cons (first l)
result)))) )
Is there a penalty deciding which arity to use on each call?
Aloha,
David Sletten
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"Clojure" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/clojure?hl=en
-~----------~----~----~----~------~----~------~--~---
