Question

Suppose I have:

import qualified Data.ByteString.Lazy as L
bs1 :: L.ByteString
bs2 :: L.ByteString

Is L.append bs1 bs2 also lazy in that this will not cause me to consume all of bs1 immediately? Similarly with L.concat and unlike L.length which I understand will cause it to consume the entire bytestring because it needs to count all the bytes.

Answer 1

A simple way of determining how lazy a function is, is to pass it partially defined values. For example, let’s define a lazy bytestring of one chunk followed by an undefined tail.

*Main> let bs1 = L.fromChunks $ B.pack [102, 111, 111] : undefined
*Main> bs1
Chunk "foo" *** Exception: Prelude.undefined

As you can see, attempting to print it throws an exception after the first chunk. Now, let’s define another lazy ByteString and try to append them.

*Main> let bs2 = L.pack [98, 97, 114]
*Main> L.append bs1 bs2
Chunk "foo" *** Exception: Prelude.undefined

L.append was able to produce the first chunk of the resulting lazy ByteString. This means that it only had to look at the first chunk of bs1 to produce the first chunk of the result, i.e. it’s as lazy as you would expect it to be.