11

Can someone please explain or give some resources on how function composition works in relation to laziness?

For example how does filter (/='W') . map toUpper $ "justaword" work in Haskell compared to it's counterpart in erlang which is not lazy?

Adi
  • 562
  • 7
  • 18

1 Answers1

15

Every time another character is demanded (or notification of end), the next character - if any - is mapped to uppercase, that is compared to 'W', delivered if unequal.

filter (/= 'W') . map toUpper $ "justaword"
~> filter (/= 'W') (toUpper 'j' : map toUpper "ustaword")
~> filter (/= 'W') ('J' : map toUpper "ustaword")
~> 'J' : filter (/= 'W') (map toUpper "ustaword")

Now the first character is available, so for queries like null or functions like take 1, no further work is done. If more characters are demanded by the consumer, they will be produced one by one until the end of the string is reached.

Example:

Prelude Data.Char> take 10 . filter (/= 'W') . map toUpper $ repeat 't'
"TTTTTTTTTT"

repeat produces an infinite list, but as long as only a finite part is consumed, the computation finishes in finite time. However, take 10 . filter (/= 'W') . map toUpper $ repeat 'w' would not terminate, since none of the produced characters passes the filter to reach the take 10.

Daniel Fischer
  • 181,706
  • 17
  • 308
  • 431
  • Thank you for the great respone :) Is it possible to write this code in strict language (without simulating laziness)? Or in a strict languege the list will be traversed two times, once for map and once for filter, starting from the beginnig? – Adi Jan 27 '12 at 11:45
  • 1
    @Adi: yes, there will be two list traversals. map will return a new intermediate list, which is passed to filter, which will pass over than and return yet another list – newacct Jan 27 '12 at 11:56
  • 5
    In a strict (eager, rather) language, one would have to simulate laziness to obtain the same behaviour. Some languages make that easier than others, I'd much rather do that in erlang or F# than in C (and that although I know C, but hardly any erlang or F# :). Whether there are two traversals or one in an eager language depends on the compiler. In principle, the filter and the map can be fused, but in general the compiler would need to prove the purity of the mapped function and the filter predicate to be able to do that. So I expect two traversals in most cases, the proof is hard. – Daniel Fischer Jan 27 '12 at 12:00
  • 1
    Thank you, Daniel Fishcer. I'm eternally grateful :) – Adi Jan 27 '12 at 12:17
  • 2
    A note for the interested: Python's generators exist largely to allow this sort of lazy processing. – Marcin Jan 27 '12 at 12:20
  • Similarly, many Scala data structures provide a `.view` method to allow this kind of lazy processing. – Dan Burton Jan 27 '12 at 14:12