Comparing
strict and lazy
Arnaud Spiwack
The sad truth
Most of the time: it doesn't even remotely matters
The happy truth
Can you spot the bug?
atomicPut :: Handle -> String -> IO ()
atomicPut h line =
withMVar lock $ \_ -> do
hPutStrLn h lineAll you've got to do is call
or :: [Bool] -> Bool
or = foldr (||) False
any :: (a -> Bool) -> [a] -> Bool
any p = or . map pApplicative functors 🤩
zipWith1 :: (a -> b) -> [a] -> [b]
zipWith2 :: (a -> b -> c) -> [a] -> [b] -> [c]
zipWith3 :: (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
zipWith4 :: (a -> b -> c -> d -> e) -> [a] -> [b] -> [c] -> [d] -> [e]
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]⁝
zipWith5 :: (a -> b -> c -> d -> e -> f) -> [a] -> [b] -> [c] -> [d] -> [e] -> [f]
zipWith5 f as bs cs ds es = f <$> as <*> bs <*> cs <*> ds <*> es(<$>) :: (a -> b) -> [a] -> [b]
(<*>) :: [a -> b] -> [a] -> [b]Matching lazy data is weird
“The answer to all questions in Haskell is ‘bottom’.”
— Simon Peyton Jones
f :: Bool -> Bool -> Int
f _ False = 1
f True False = 2
f _ _ = 3f :: T a -> U a -> Int
f (TBool b1) (UBool b2) = 0data U a where
UChar :: Char -> U Char
UBool :: Bool -> U Bool data T a where
TInt :: Int -> T Int
TBool :: Bool -> T BoolGuarded recursion
map :: (a -> b) -> [a] -> [b]
map f [] = []
map f (a:as) = f a : map f asMemory leaks
Tail recursion
length :: [a] -> Integer
length [] = 0
length (_:as) = 1 + length aslength :: [a] -> Integer
length = go 0
where
go :: Integer -> [a] -> Integer
go acc [] = acc
go acc (_:as) = go (acc+1) aslength :: [a] -> Integer
length = go 0
where
go :: Integer -> [a] -> Integer
go !acc [] = acc
go !acc (_:as) = go (acc+1) asMemory heisenbug
Observing a lazy value changes its state
This slide is intentionally left blank
Lazy IO
readFile :: FilePath -> IO StringLimitations:
Lazy IO
readFile :: FilePath -> IO Stringlines :: String -> [String]read :: Read a => String -> af :: Read a => FilePath -> IO [a]
f p = (map read . lines) <$> readFile pLimitations:
Lazy deserialisation
… { … , foo : { … }, … } …(…, Object (<thunk>, Field "foo" (Object …), <thunk>), …)Observability
traceEvent "START PureCode" $
somePureCode¿¿Where do I put
traceEvent "STOP PureCode"??
Taking laziness seriously
Laziness has a real implementation cost
— Simon Peyton Jones (2003)
Keeps you honest
“Every call-by-value language has given into the siren call of side effects.”
— Simon Peyton Jones (2003)
https://slides.com/aspiwack/hx2020
Thank you for listening
Comparing strict and lazy
By Arnaud Spiwack
Comparing strict and lazy
Strict and lazy languages are often pitted against each other but rarely honestly compared. Let’s take a step back from the slogans and examine the trade-offs between lazy and strict. Not which is best: how they compare. — Most languages are strict. Haskell is very much the odd one out here. So it is not surprising that programmers in strict language sneer at Haskell’s laziness, nor that Haskell programmers feel compelled to defend this choice. But because of the adversarial nature of this debate, it ends up with cheap slogans such as “strict languages are more efficient”, “lazy languages compose better”. This doesn’t tend to be very enlightening. After all, the most likely answer, if maybe unsatisfactory is: it depends. The choice between strictness and laziness is, at the end of the day, as most things in engineering, a trade-off. And to make an informed choice between these two technologies, we need to know what the costs and benefit of each are. My goal, is to provide tools to make such an informed decision, by sharing, based on my experience as a programmer in both lazy languages and strict languages, strengths and weaknesses of both paradigm. If your looking for me to tell you which is best, you will be disappointed. But, on the plus side, there will definitely be some production horror stories.
