On Jun 19, 9:02 pm, Aaron Cohen <aa...@assonance.org> wrote:
> On Sat, Jun 19, 2010 at 11:22 PM, Mike Meyer
> <mwm-keyword-googlegroups.620...@mired.org> wrote:
>
> > "Rob Lachlan" <robertlach...@gmail.com> wrote:
>
> >>Actually, Mike, your two functions work just fine. (Equal branch).
> >>Mind you I checked that out over two hours ago, so this information
> >>might be out of date.
>
> >>Rob
>
> >>On Jun 19, 6:59 pm, Mike Meyer <mwm-keyword-googlegroups.
>
> > Ok, why does this work but the fact fail? Or does the fact example still
> > fail on that build?
>
> > The fact that this requires explanation is a pretty good argument the fact
> > behavior.
>
> >> (defn fact [n]
> >> (loop [n n r 1]
> >> (if (zero? n)
> >> r
> >> (recur (dec n) (* r n)))))
>
> (The quoting in this thread is getting out-of-hand, everyone please
> reply on the bottom)
>
> The difference between your examples and the fact examples is that
>
> (inc prim) -> prim
>
> while
>
> (* prim boxed) -> boxed
>
> In the fact example, the type of n as an initializer in the loop
> statement is unknown at compile time and thus must be boxed. The fact
> that you need to know that, is very much what some people are arguing
> against.
>
> The choices are to do either:
>
> (loop [n n r (num 1)]
>
> or
>
> (loop [n (long n) r 1]
Or this! (on the new equal branch)
user=> (defn fact [n]
(loop [n n r 1.0]
(if (zero? n)
r
(recur (dec n) (* r n)))))
#'user/fact
user=> (fact 5)
120.0
user=> (fact 5N)
120.0
:) Not sure I understand why completely since I don't entirely
understand the interaction of the Clojure code, LispReader.java, and
Numbers.java, but it seems a double multiplied by anything returns a
double now. A long will be returned by multiplication only if both
arguments are long, unless you ask for auto-promoting multiplication,
in which case it always returns a Number object. If one of the
arguments to multiplication is an Object and the other a long, it
returns a Number object --- I suppose because if the Object turns out
to be a Double rather than a Long, then it has to return a Double
rather than a Long object?
So it seems like it's not enough to see a literal and think it's
initializing the variable r to be a primitive, but you'd need to know
what kind of primitive it is (long or double?), and what effect it has
on the return value of the functions they are arguments to. Eg, by
looking at Numbers.java, I figured to try making r double so to force
* to return double.
This is all in "theory," of course. Whether you think it matters day-
to-day is something else. On that note, my own code works fine on the
new equal branch.
It does concern me a little bit that to really understand what a
function or loop/recur will do, it seems I'd have to know the kind of
primitive type that the variables are initialized to, or that the
functions I call might return...
Carson
PS: how come everyone is calling throw-on-overflow "unsafe" now?
hmm...
>
> Either option will make (* r n) return a primitive or boxed value of
> the appropriate type. Both versions will overflow and throw an
> exception at (fact 21).
>
> To have a fact that works for large numbers you need:
>
> (defn fact [n]
> (loop [n n r (num 1)]
> (if-not (pos? n)
> r
> (recur (dec n) (*' r n)))))
>
> Most of the versions posted so far were broken for negative n by the way.
--
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
