Question

Ive got two two functions which act on byte strings. The first one is a bytestring version of the cycle function in Data.List and the second function rotates the bytestring.

When I read a file and send its input to the rotateBytes function, it outputs a quotation mark and then I need to press Control-C to manually stop the function. Is this a bug in my code or a bug in ghc? How can it be fixed?

import qualified Data.ByteString as B

-- Cycle function for binary data
cycleBytes :: B.ByteString -> B.ByteString 
cycleBytes xs 
    | B.null xs = error "cycleBytes: empty list"
    | otherwise = xs' where xs' = xs `B.append` xs'

-- Rotate function for binary data
rotateBytes :: B.ByteString -> Int -> B.ByteString
rotateBytes xs n = B.take (B.length xs) $! B.drop (B.length xs + n) $! cycleBytes xs

Using the function is currently like this:

*Main> B.readFile "test.dat" >>= (\x -> return $ rotateBytes x 3)
"
^CInterrupted.

Answer 1

ByteString isn’t lazy so can’t cope with the infinite answer from cycleBytes. (The " you’re getting is because when printing the result, it can lazily get the first character of output without worrying about the rest, but then tries to calculate the infinite ByteString it gets from cycleBytes before printing anything else. Infinity and strict evaluation don’t mix.)

1. Import Data.ByteString.Lazy instead (and use fromIntegral on your n, because it wants Int64 not Int; You might want to use Lazy ByteStrings for enormous amounts of data, so you the library needs a length parameter that allows this.)
2. or (better) reduce n mod B.length xs and just use B.append xs xs instead of infinitely many.

Solution 1 looks like

import qualified Data.ByteString.Lazy as B

-- Cycle function for binary data
cycleBytes :: B.ByteString -> B.ByteString 
cycleBytes xs 
    | B.null xs = error "cycleBytes: empty list"
    | otherwise = xs' where xs' = xs `B.append` xs'


-- Rotate function for binary data
rotateBytes :: B.ByteString -> Int -> B.ByteString
rotateBytes xs n = B.take (B.length xs) 
                 $ B.drop (B.length xs + fromIntegral n) 
                 $ cycleBytes xs

If test.dat contained Hello Mum! this would calculate Chunk "lo Mum!" (Chunk "Hel" Empty), because it’s lazily constructed and will only get combined if it’s forced.

Solution 2 looks like

rotateBytes :: B.ByteString -> Int -> B.ByteString
rotateBytes xs n = 
    let len = B.length xs
        n' = n `mod` len in
     B.take len $! B.drop n' $! B.append xs xs

Solution 2 is better partly because you get to keep everything strict (which I assume you were trying to do), but doesn’t have cycleBytes.

Ben Millwood suggests replacing this with something along the lines of

rotateBytes :: B.ByteString -> Int -> B.ByteString
rotateBytes xs n = 
    let n' = n `mod` B.length xs 
        (beginning,end) = B.splitAt n' xs in
    B.append end beginning

which reads more clearly. take, drop and splitAt are all O(1) in ByteString, so it doesn’t make much difference for efficiency, but the splitAt does feel cleaner.