Aai wrote:
Hi Bulat,
That I (can) understand, but of course the main question is: is point free in (some/several/all) cases faster than the more readable lambda construction? That's to say when executed in GHCi. I noticed this behavior before (pity I haven't other examples at hand). In prog. lang. J ( http://www.jsoftware.com/index.html ) I see the same behavior difference with tacit (like point free) and explicit programming: tacit being faster in several (not all) occasions.
In general point-free will be marginally faster because: foo = \x -> ... defines foo as a constant, whereas: foo x = ... defines (foo x) to be constant for a given x. This subtle distinction makes for small differences in the runtime which add up eventually. The performance difference here is what's at stake when people talk about "the monomorphism restriction". Without a type signature to indicate otherwise, the point-free/lambda version is forced to be monomorphic because it "looks like a constant". Whereas the second version could be hiding the fact that we can't do unboxing of x, or that we need to locate type-class dictionaries based on the type of x, etc. All that said, these differences are things which should only matter in GHCi and should never affect compiled code. GHC does a lot of analysis and does eta-expansion/-reduction in order to make the compiled code optimal. If you ever notice a difference in performance from compiled code, the GHC developers would love to hear about it I'm sure. I'm less familiar with Hugs' optimizations, but you probably shouldn't notice any difference there either. In any case, you should always use whichever style is clearest. A few microseconds here or there isn't worth the extra minutes it takes to understand your own code six months from now. (And changing your algorithms or datastructures will overshadow any micro-optimizations like this anyways.) -- Live well, ~wren