Question

I’m reading through ‘A Gentle Introduction to Haskell,’ and early on it uses this example, which works fine in GHC and horribly in my brain:

initial                 = 0 next resp               = resp process req             = req+1  reqs                    = client initial resps resps                   = server reqs  server          (req:reqs)   = process req : server reqs client initial ~(resp:resps) = initial : client (next resp) resps 

And the calling code:
take 10 reqs

How I’m seeing it, is reqs is called, yielding a call to client with args 0 and resps. Thus wouldn’t resps now need to be called… which in turn calls reqs again? It all seems so infinite… if someone could detail how it’s actually working, I’d be most appreciative!

Answer 1

I find that it’s usually worthwhile to work out the behavior of small Haskell programs by hand. The evaluation rules are quite simple. The key thing to remember is that Haskell is non-strict (aka lazy): expressions are evaluated only when needed. Laziness is the reason seemingly infinite definitions can yield useful results. In this case, using take means we will only need the first 10 elements of the infinite list reqs: they are all we ‘need’.

In practical terms, ‘need’ is generally driven by pattern matches. E.g., a list expression will generally be evaluated up to the point where we can distinguish between [] and (x:xs) before function application. (Note that a ‘~‘ preceding a pattern , as in the definition of client, makes it lazy (or irrefutable): a lazy pattern won’t force its argument until the whole expression is forced.)

Remembering that take is:

take 0 _      = [] take n (x:xs) = x : take (n-1) xs 

The evaluation of take 10 reqs looks like:

take 10 reqs        -- definition of reqs     = take 10 (client initial resps)       -- definition of client [Note: the pattern match is lazy]     = take 10 (initial : (\ resp:resps' -> client (next resp) resps')                               resps)       -- definition of take     = initial : take 9 ((\ resp:resps' -> client (next resp) resps')                              resps)       -- definition of initial     = 0 : take 9 ((\ resp:resps' -> client (next resp) resps')                        resps)       -- definition of resps     = 0 : take 9 ((\ resp:resps' -> client (next resp) resps')                        (server reqs))       -- definition of reqs     = 0 : take 9 ((\ resp:resps' -> client (next resp) resps')                        (server (client initial resps)))       -- definition of client     = 0 : take 9 ((\ resp:resps' -> client (next resp) resps')                        (server (initial : {- elided... -}))       -- definition of server     = 0 : take 9 ((\ resp:resps' -> client (next resp) resps')                        (process initial : server {-...-}))       -- beta reduction      = 0 : take 9 (client (next (process initial)) (server {-...-})       -- definition of client      = 0 : take 9 (next (process initial) : {-...-})       -- definition of take      = 0 : next (process initial) : take 8 {-...-}       -- definition of next      = 0 : process initial : take 8 {-...-}       -- definition of process      = 0 : initial+1 : take 8 {-...-}       -- definition of initial      = 0 : 1 : take 8 {-...-}       -- and so on...