{-# LANGUAGE ScopedTypeVariables #-}

import qualified Blaze.ByteString.Builder as ZB

import Criterion.Main

import qualified Data.ByteString.Char8 as S

import qualified Data.ByteString.Builder as BB

import Data.Monoid (mconcat, Monoid)

import qualified Data.Streaming.ByteString.Builder as BB

main :: IO ()

main = defaultMain [ bgroup "Data.Streaming.ByteString.Builder.toByteStringIO"

                            (benchmarks bIO b100_10000 b10000_100 b10000_10000)

                   , bgroup "Blaze.ByteString.Builder.toByteStringIO"

                            (benchmarks zIO z100_10000 z10000_100 z10000_10000)

                   , bgroup "Data.ByteString.Builder.toLazyByteString"

                            (benchmarks bLazy b100_10000 b10000_100 b10000_10000)

                   , bgroup "Blaze.ByteString.Builder.toLazyByteString"

                            (benchmarks zLazy z100_10000 z10000_100 z10000_10000)

                   ]

  where

    bIO = whnfIO . BB.toByteStringIO (const (return ()))

    zIO = whnfIO . ZB.toByteStringIO (const (return ()))

    bLazy = nf BB.toLazyByteString

    zLazy = nf ZB.toLazyByteString

    benchmarks run bld100_10000 bld10000_100 bld10000_10000 =

        [ bench' run bld100_10000 100 10000

        , bench' run bld10000_100 10000 100

        , bench' run bld10000_10000 10000 10000

        ]

    bench' :: (b -> Benchmarkable) -> b -> Int -> Int -> Benchmark

    bench' run bld' len reps = bench (show len ++ "/" ++ show reps) (run bld')

    b100_10000 = bld BB.byteString 100 10000

    b10000_100 = bld BB.byteString 10000 100

    b10000_10000 = bld BB.byteString 10000 10000

    z100_10000 = bld ZB.fromByteString 100 10000

    z10000_100 = bld ZB.fromByteString 10000 100

    z10000_10000 = bld ZB.fromByteString 10000 10000

    bld :: Monoid a => (S.ByteString -> a) -> Int -> Int -> a

    bld f len reps = mconcat (replicate reps (f (S.replicate len 'x')))