> I tend to favor ((if x y z) foo) over (if x (y foo) (z foo)) because it avoids
> redundancy and localizes the choice. Apparently, that's a pessimising
> choice and I now don't feel like I have much intuition at all about how
> things will perform.
My recommendation is to write nice code, unless you are writing a hot
spot that is critical for the application. 99% of the time the program
is just waiting for user input or read data from the disk or
something, so write nice and idiomatic code that is easy to maintain.
*IF* you really need speed, try to avoid "((whatever) ...)". In many
situations, the optimizer can rewrite it under the hood. For example
((let (...) ... z) ...) is rewritten to (let (...) ... (z ...)), so
they are equivalent after optimizations. The second expression has
many advantages:
- If z is a Racket primitive, then the function z can use the JIT
implementation, that is faster that the C implementation. Also, some
of the primitives can be reduced at compile time, for example (list?
x) can be reduced to #t or #f if the optimizer can figure out the type
of x.
- If z is defined in Racket with a lambda, then the optimizer may
inline it. So it will avoid the function call, and the constants can
be propagated and many internal expressions can be reduced. If it's a
recursive functions, it may be inlined a few times, that has a similar
effect of a loop unrolling. (I think this is what is happening in your
example.)
The problem with ((if X Y Z) a b c) is that it's more complicated.
It's not possible to reduce it automatically to (if X (Y a b c) (Z a b
c)) because a, b or c may be big expressions and this will duplicate a
lot of code, or produce wrong results if one of them is something like
'(1 2 3).
An alternative os to reduce it to
(let ([X_ X] [a_ a] [b_ b] [c_ c])
(if X_ (Y a_ b_ c_) (Z a_ b_ c_))
but this only is correct if Y and Z are simple expressions, for
example Y may be a mutable variable that is changed in c, or Y may be
an expression that changes the value of c, or ...
But I think that there are a few easy usual cases of ((if ...) ...)
that can be reduced. I have to think about them to try to get most of
them and don't forget any of the corner cases that are incorrect.
For now, *IF* you need speed, then check the details by hand and use
(if X (Y a b c) (Z a b c)), but perhaps in a future version of Racket
this optimization can be automatic.
Gustavo
PS: Another general recommendation: Try to avoid set!, because most of
the optimizations are disabled for mutable variables.
--
You received this message because you are subscribed to the Google Groups
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
