I can only answer the questions to the best of my understanding, here goes:
On 9 October 2015 at 17:00, Rob Stewart
Here are my questions: what exactly is the call overhead of a non-inlned Haskell function? What additional runtime work needs to happen when calling to a non-inlined function? Specifically what other GHC optimisations are possible only if function inlining happens first? Can anyone provide a simple example where 1) a function is not inlined, versus 2) when that function is inlined, which demonstrates two things: 1) a GHC report of the additional optimisations that were applied because of inlining and 2) shorter program runtime as a result of inlining.
An example of optimizations becoming available after inlining:
listAdd1 = map (+1)
listAdd2 = map (+2)
listAdd3 = listAdd2 . listAdd1
-- From the RHS of listAdd3
listAdd2 . listAdd1
== map (+2) . map (+1)
== map ((+2) . (+1)) -- List fusion. Also works for types other
than lists (see the talk [1] for more)
== map (\x -> (+2) ((+1) x)) -- Inline the composition dot-operator (.)
== map (\x -> (+2) (x + 1))
== map (\x -> x + 3)
== map (+3)
-- The order and the final result might not be the same, but it will be
operationally equivalent.
-- This prevents having to iterate over the whole list twice.
On 9 October 2015 at 17:00, Rob Stewart
As Don Stewart nicely explains on SO http://stackoverflow.com/a/5889784/1526266 , we should always use newtype when we have only a single constructor which has a single field. His example is this:
data Book = Book Int Int newtype Book = Book (Int, Int)
With newtype, the `Book` construct is guaranteed to be erased at compile time, to have the same representation as `(Int,Int)`. How to I measure the memory space costs of having `Book Int Int` hanging around at runtime, as opposed to just `(Int,Int)`? How many bytes does it cost to store `Book 4 5`? How many bytes does it cost to store `(4,5)` ? Can I ask GHC to tell me how many bytes the storage of each object would require? Or more generally, would looking at GHC Core for all my data structures inform me of the memory space costs for each of them?
I don't think it's possible to look into GHC's memory. Simon Marlow's book [2] explains laziness very well, but even he (he wrote the GHC runtime) says that there is no way to see the actual structure of memory usage. [1]: http://www.techcast.com/events/bigtechday6/odeon-1130/?q=odeon-1130 [2]: http://amzn.com/1449335942 -- Regards Sumit Sahrawat