data Cell = StringC String
          | IntC Int
          deriving( Eq, Ord, Show )

type Row   = [Cell]
type Table = [Row]

import qualified Data.ByteString.Lazy               as L
import           Data.ByteString.Builder
import           Data.Monoid
import           Data.Foldable                        (foldMap)
import           Data.List                            (intersperse)

infixr 4 <>
(<>) :: Monoid m => m -> m -> m
(<>) = mappend

encodeUtf8CSV :: Table -> L.ByteString
encodeUtf8CSV = toLazyByteString . renderTable

renderTable :: Table -> Builder
renderTable rs = mconcat [renderRow r <> charUtf8 '\n' | r <- rs]

renderRow :: Row -> Builder
renderRow []     = mempty
renderRow (c:cs) =
    renderCell c <> mconcat [ charUtf8 ',' <> renderCell c' | c' <- cs ]

renderCell :: Cell -> Builder
renderCell (StringC cs) = renderString cs
renderCell (IntC i)     = intDec i

renderString :: String -> Builder
renderString cs = charUtf8 '"' <> foldMap escape cs <> charUtf8 '"'
  where
    escape '\\' = charUtf8 '\\' <> charUtf8 '\\'
    escape '\"' = charUtf8 '\\' <> charUtf8 '\"'
    escape c    = charUtf8 c

strings :: [String]
strings =  ["hello", "\"1\"", "λ-wörld"]

table :: Table
table = [map StringC strings, map IntC [-3..3]]

Chunk "\"hello\",\"\\\"1\\\"\",\"\206\187-w\195\182rld\"\n-3,-2,-1,0,1,2,3\n" Empty

import Criterion.Main     -- add this import to the ones above

maxiTable :: Table
maxiTable = take 1000 $ cycle table

main :: IO ()
main = defaultMain
  [ bench "encodeUtf8CSV maxiTable (original)" $
      whnf (L.length . encodeUtf8CSV) maxiTable
  ]

renderRow :: Row -> Builder
renderRow  = mconcat . intersperse (charUtf8 ',') . map renderCell

renderString :: String -> Builder
renderString cs = charUtf8 $ "\"" ++ concatMap escape cs ++ "\""
  where
    escape '\\' = "\\"
    escape '\"' = "\\\""
    escape c    = return c

data Builder Source

Builders denote sequences of bytes. They are Monoids where mempty is the zero-length sequence and mappend is concatenation, which runs in O(1).

Internally, Builders are buffer-filling functions. They are executed by a driver that provides them with an actual buffer to fill. Once called with a buffer, a Builder fills it and returns a signal to the driver telling it that it is either done, has filled the current buffer, or wants to directly insert a reference to a chunk of memory. In the last two cases, the Builder also returns a continutation Builder that the driver can call to fill the next buffer. Here, we provide the two drivers that satisfy almost all use cases. See Data.ByteString.Builder.Extra, for information about fine-tuning them.

toLazyByteString :: Builder -> ByteString Source

Execute a Builder and return the generated chunks as a lazy ByteString. The work is performed lazy, i.e., only when a chunk of the lazy ByteString is forced.

hPutBuilder :: Handle -> Builder -> IO () Source

Output a Builder to a Handle. The Builder is executed directly on the buffer of the Handle. If the buffer is too small (or not present), then it is replaced with a large enough buffer.

It is recommended that the Handle is set to binary and BlockBuffering mode. See hSetBinaryMode and hSetBuffering.

This function is more efficient than hPut . toLazyByteString because in many cases no buffer allocation has to be done. Moreover, the results of several executions of short Builders are concatenated in the Handles buffer, therefore avoiding unnecessary buffer flushes.

byteString :: ByteString -> Builder Source

Create a Builder denoting the same sequence of bytes as a strict ByteString. The Builder inserts large ByteStrings directly, but copies small ones to ensure that the generated chunks are large on average.

lazyByteString :: ByteString -> Builder Source

Create a Builder denoting the same sequence of bytes as a lazy ByteString. The Builder inserts large chunks of the lazy ByteString directly, but copies small ones to ensure that the generated chunks are large on average.

shortByteString :: ShortByteString -> Builder Source

Construct a Builder that copies the ShortByteString.

int8 :: Int8 -> Builder Source

Encode a single signed byte as-is.

word8 :: Word8 -> Builder Source

Encode a single unsigned byte as-is.

int16BE :: Int16 -> Builder Source

Encode an Int16 in big endian format.

int32BE :: Int32 -> Builder Source

Encode an Int32 in big endian format.

int64BE :: Int64 -> Builder Source

Encode an Int64 in big endian format.

word16BE :: Word16 -> Builder Source

Encode a Word16 in big endian format.

word32BE :: Word32 -> Builder Source

Encode a Word32 in big endian format.

word64BE :: Word64 -> Builder Source

Encode a Word64 in big endian format.

floatBE :: Float -> Builder Source

Encode a Float in big endian format.

doubleBE :: Double -> Builder Source

Encode a Double in big endian format.

int16LE :: Int16 -> Builder Source

Encode an Int16 in little endian format.

int32LE :: Int32 -> Builder Source

Encode an Int32 in little endian format.

int64LE :: Int64 -> Builder Source

Encode an Int64 in little endian format.

word16LE :: Word16 -> Builder Source

Encode a Word16 in little endian format.

word32LE :: Word32 -> Builder Source

Encode a Word32 in little endian format.

word64LE :: Word64 -> Builder Source

Encode a Word64 in little endian format.

floatLE :: Float -> Builder Source

Encode a Float in little endian format.

doubleLE :: Double -> Builder Source

Encode a Double in little endian format.

Conversion from Char and String into Builders in various encodings.

The ASCII encoding is a 7-bit encoding. The Char7 encoding implemented here works by truncating the Unicode codepoint to 7-bits, prefixing it with a leading 0, and encoding the resulting 8-bits as a single byte. For the codepoints 0-127 this corresponds the ASCII encoding.

char7 :: Char -> Builder Source

Char7 encode a Char.

string7 :: String -> Builder Source

Char7 encode a String.

The ISO/IEC 8859-1 encoding is an 8-bit encoding often known as Latin-1. The Char8 encoding implemented here works by truncating the Unicode codepoint to 8-bits and encoding them as a single byte. For the codepoints 0-255 this corresponds to the ISO/IEC 8859-1 encoding.

char8 :: Char -> Builder Source

Char8 encode a Char.

string8 :: String -> Builder Source

Char8 encode a String.

The UTF-8 encoding can encode all Unicode codepoints. We recommend using it always for encoding Chars and Strings unless an application really requires another encoding.

charUtf8 :: Char -> Builder Source

UTF-8 encode a Char.

stringUtf8 :: String -> Builder Source

UTF-8 encode a String.

Formatting of numbers as ASCII text.

Note that you can also use these functions for the ISO/IEC 8859-1 and UTF-8 encodings, as the ASCII encoding is equivalent on the codepoints 0-127.

Decimal encoding of numbers using ASCII encoded characters.

int8Dec :: Int8 -> Builder Source

Decimal encoding of an Int8 using the ASCII digits.

e.g.

toLazyByteString (int8Dec 42)   = "42"
toLazyByteString (int8Dec (-1)) = "-1"

int16Dec :: Int16 -> Builder Source

Decimal encoding of an Int16 using the ASCII digits.

int32Dec :: Int32 -> Builder Source

Decimal encoding of an Int32 using the ASCII digits.

int64Dec :: Int64 -> Builder Source

Decimal encoding of an Int64 using the ASCII digits.

intDec :: Int -> Builder Source

Decimal encoding of an Int using the ASCII digits.

integerDec :: Integer -> Builder Source

Decimal encoding of an Integer using the ASCII digits.

word8Dec :: Word8 -> Builder Source

Decimal encoding of a Word8 using the ASCII digits.

word16Dec :: Word16 -> Builder Source

Decimal encoding of a Word16 using the ASCII digits.

word32Dec :: Word32 -> Builder Source

Decimal encoding of a Word32 using the ASCII digits.

word64Dec :: Word64 -> Builder Source

Decimal encoding of a Word64 using the ASCII digits.

wordDec :: Word -> Builder Source

Decimal encoding of a Word using the ASCII digits.

floatDec :: Float -> Builder Source

Currently slow. Decimal encoding of an IEEE Float.

doubleDec :: Double -> Builder Source

Currently slow. Decimal encoding of an IEEE Double.

Encoding positive integers as hexadecimal numbers using lower-case ASCII characters. The shortest possible representation is used. For example,

>>> toLazyByteString (word16Hex 0x0a10)
Chunk "a10" Empty

Note that there is no support for using upper-case characters. Please contact the maintainer, if your application cannot work without hexadecimal encodings that use upper-case characters.

word8Hex :: Word8 -> Builder Source

Shortest hexadecimal encoding of a Word8 using lower-case characters.

word16Hex :: Word16 -> Builder Source

Shortest hexadecimal encoding of a Word16 using lower-case characters.

word32Hex :: Word32 -> Builder Source

Shortest hexadecimal encoding of a Word32 using lower-case characters.

word64Hex :: Word64 -> Builder Source

Shortest hexadecimal encoding of a Word64 using lower-case characters.

wordHex :: Word -> Builder Source

Shortest hexadecimal encoding of a Word using lower-case characters.

int8HexFixed :: Int8 -> Builder Source

Encode a Int8 using 2 nibbles (hexadecimal digits).

int16HexFixed :: Int16 -> Builder Source

Encode a Int16 using 4 nibbles.

int32HexFixed :: Int32 -> Builder Source

Encode a Int32 using 8 nibbles.

int64HexFixed :: Int64 -> Builder Source

Encode a Int64 using 16 nibbles.

word8HexFixed :: Word8 -> Builder Source

Encode a Word8 using 2 nibbles (hexadecimal digits).

word16HexFixed :: Word16 -> Builder Source

Encode a Word16 using 4 nibbles.

word32HexFixed :: Word32 -> Builder Source

Encode a Word32 using 8 nibbles.

word64HexFixed :: Word64 -> Builder Source

Encode a Word64 using 16 nibbles.

floatHexFixed :: Float -> Builder Source

Encode an IEEE Float using 8 nibbles.

doubleHexFixed :: Double -> Builder Source

Encode an IEEE Double using 16 nibbles.

byteStringHex :: ByteString -> Builder Source

Encode each byte of a ByteString using its fixed-width hex encoding.

lazyByteStringHex :: ByteString -> Builder Source

Encode each byte of a lazy ByteString using its fixed-width hex encoding.

Orphan instances