Paul Rubin schrieb:
> André Thieme <[EMAIL PROTECTED]> writes:
>> def nif(num, pos, zero, neg):
>> if num > 0:
>> return pos
>> else:
>> if num == 0:
>> return zero
>> else:
>> return neg
>
> def nif(num, pos, zero, neg):
> return (neg, zero, pos)[cmp(num, 0)+1]
That is a nice idea. I can do the same in Lisp, but have to do it
without syntactic sugar which makes it longer, characterwise:
(defun nif2 (num pos zero neg)
(nth (1+ (truncate (signum num)))
(list pos zero neg)))
What Python has is cmp. That is doing what truncate+signum do in
Lisp. So that makes the biggest difference. Another one is that Lisps
signum keeps the datatype:
cmp(5.3, 0) => 1
(signum 5.3) => 1.0
Or also with complex numbers [syntax #C(real, img)]:
(signum #C(10 4)) => #C(0.9284767 0.37139067)
Anyway, from the complexity the Lisp version is a bit better.
The Python version has 11 tokens:
return, tuple-reference, comma, neg, zero, pos, +, 1, cmp, num, 0
and the Lisp version has only 9:
nth, 1+, truncate, signum, num, list, pos, zero, neg
(I didn't count the function head, because both have the same
token count).
>> The messages were printed in each case.
>> To stop that I need lazy evaluation:
>> CL-USER> (mapcar #'(lambda (x)
>> (funcall
>> (nif x
>> #'(lambda () (p))
>> #'(lambda () (z))
>> #'(lambda () (n)))))
>> '(0 2.5 -8))
>
> in Python:
>
> def lazy_nif(num, pos, zero, neg):
> return (neg, zero, pos)[cmp(num, 0)+1]() # the () at the end means
> funcall
>
> map(lambda x: lazy_nif(x, p, z, n), (0, 2.5, -8))
We could do the same in Lisp:
(defun lazy-nif (num pos zero neg)
(funcall (nth (1+ (truncate (signum num)))
(list pos zero neg))))
Here the token count is 12py vs 10cl.
CL-USER> (mapcar #'(lambda (x) (lazy-nif2 x #'p #'z #'n))
'(0 2.5 -8))
"no no"
"very negative"
"very positive"
("zero" "negative" "positive")
But there is a disadvantage:
>>> lazy_nif(0, "p", "z", "n")
Traceback (most recent call last):
File "<stdin>", line 1, in ?
File "<stdin>", line 2, in lazy_nif
TypeError: 'str' object is not callable
I don't know how I can fix that. Maybe you could tell me.
In Lisp I would just go with the macro. That works for all cases.
> "nif" is even cleaner in Haskell, if I have this right:
>
> nif x p z n | (x < 0) = n
> | (x == 0) = z
> | (x > 0) = p
>
> All Haskell evaluation is automatically lazy, so no lambdas etc. needed.
Yes, that was what I already supposed.
Do you also know how I can "deactivate" lazyness?
André
--
--
http://mail.python.org/mailman/listinfo/python-list
