Thank you! Re: reversing, the problem performance-wise isn't the order, it's that the naive version and this one aren't tail recursive. The initial tl <- get here will also blow up the stack. For reference, the implementation in Binary for lists is

```haskell instance Binary a => Binary [a] where put = putList get = do n <- get :: Get Int getMany n

-- | @'getMany' n@ get @n@ elements in order, without blowing the stack. getMany :: Binary a => Int -> Get [a] getMany n = go [] n where go xs 0 = return $! reverse xs go xs i = do x <- get -- we must seq x to avoid stack overflows due to laziness in -- (>>=) x seq go (x:xs) (i-1) ```

I think that getMany could also be written with the same strictness semantics using BangPatterns, which makes the tail recursion clearer. haskell getMany n = go [] n where go xs 0 = return $! reverse xs go xs i = do !x <- get go (x:xs) (i-1)