{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE PackageImports #-}
{-# LANGUAGE QuasiQuotes #-}
import Criterion ( bench, bgroup, env, nf )
import Criterion.Main ( defaultMain )
import qualified Data.ByteString as B
import qualified Data.Text as T
import qualified "string-interpolate" Data.String.Interpolate as SI
import qualified "interpolate" Data.String.Interpolate.IsString as I
-- import "Interpolation" Data.String.Interpolation as N
import "formatting" Formatting ( (%) )
import qualified "formatting" Formatting as F
import qualified "formatting" Formatting.ShortFormatters as F
import "interpolatedstring-perl6" Text.InterpolatedString.Perl6 as P
import Test.QuickCheck
--------------------------------------------------------------------------------
-- Interpolating Strings
--------------------------------------------------------------------------------
stringSI :: String -> String
stringSI str = [SI.i|A fine day to die, #{str}.|]
stringI :: String -> String
stringI str = [I.i|A fine day to die, #{str}.|]
stringF :: String -> String
stringF = F.formatToString ("A fine day to die, " % F.s % ".")
-- stringN :: String -> String
-- stringN s = [str|A fine day to die, $s$.|]
stringP :: String -> String
stringP str = [qc|A fine day to die, {str}.|]
--------------------------------------------------------------------------------
-- Interpolating Text
--------------------------------------------------------------------------------
textSI :: T.Text -> T.Text
textSI t = [SI.i|A fine day to die, #{t}.|]
textI :: T.Text -> T.Text
textI t = [I.i|A fine day to die, #{t}.|]
textF :: T.Text -> T.Text
textF = F.sformat ("A fine day to die, " % F.st % ".")
-- textN :: T.Text -> T.Text
-- textN t = [str|A fine day to die, $t$.|]
textP :: T.Text -> T.Text
textP t = [qc|A fine day to die, {t}.|]
--------------------------------------------------------------------------------
-- Interpolating ByteString
--------------------------------------------------------------------------------
byteStringSI :: B.ByteString -> B.ByteString
byteStringSI b = [SI.i|A fine day to die, #{b}.|]
byteStringI :: B.ByteString -> B.ByteString
byteStringI b = [I.i|A fine day to die, #{b}.|]
-- byteStringN :: B.ByteString -> B.ByteString
-- byteStringN b = [str|A fine day to die, $b$.|]
byteStringP :: B.ByteString -> B.ByteString
byteStringP b = [qc|A fine day to die, {b}.|]
--------------------------------------------------------------------------------
-- Multiple String interpolations
--------------------------------------------------------------------------------
multiStringSI :: (Int, String, Bool) -> String
multiStringSI (x, y, z) = [SI.i| foo #{x} bar #{y} baz #{z} quux |]
multiStringI :: (Int, String, Bool) -> String
multiStringI (x, y, z) = [I.i| foo #{x} bar #{y} baz #{z} quux |]
multiStringF :: (Int, String, Bool) -> String
multiStringF (x, y, z) =
F.formatToString (" foo " % F.d % " bar " % F.s % " baz " % F.sh % " quux ") x y z
-- multiStringN :: (Int, String, Bool) -> String
-- multiStringN (x, y, z) = [str| foo $:x$ bar $y$ baz $:z$ quux |]
multiStringP :: (Int, String, Bool) -> String
multiStringP (x, y, z) = [qc| foo {x} bar {y} baz {z} quux |]
--------------------------------------------------------------------------------
-- Multiple Text interpolations
--------------------------------------------------------------------------------
multiTextSI :: (Int, T.Text, Bool) -> T.Text
multiTextSI (x, y, z) = [SI.i| foo #{x} bar #{y} baz #{z} quux |]
multiTextI :: (Int, T.Text, Bool) -> T.Text
multiTextI (x, y, z) = [I.i| foo #{x} bar #{y} baz #{z} quux |]
multiTextF :: (Int, T.Text, Bool) -> T.Text
multiTextF (x, y, z) =
F.sformat (" foo " % F.d % " bar " % F.st % " baz " % F.sh % " quux ") x y z
-- multiTextN :: (Int, T.Text, Bool) -> T.Text
-- multiTextN (x, y, z) = [str| foo $:x$ bar $y$ baz $:z$ quux |]
multiTextP :: (Int, T.Text, Bool) -> T.Text
multiTextP (x, y, z) = [qc| foo {x} bar {y} baz {z} quux |]
--------------------------------------------------------------------------------
-- Multiple ByteString interpolations
--------------------------------------------------------------------------------
multiByteStringSI :: (Int, B.ByteString, Bool) -> B.ByteString
multiByteStringSI (x, y, z) = [SI.i| foo #{x} bar #{y} baz #{z} quux |]
multiByteStringI :: (Int, B.ByteString, Bool) -> B.ByteString
multiByteStringI (x, y, z) = [I.i| foo #{x} bar #{y} baz #{z} quux |]
-- multiByteStringN :: (Int, B.ByteString, Bool) -> B.ByteString
-- multiByteStringN (x, y, z) = [str| foo $:x$ bar $y$ baz $:z$ quux |]
multiByteStringP :: (Int, B.ByteString, Bool) -> B.ByteString
multiByteStringP (x, y, z) = [qc| foo {x} bar {y} baz {z} quux |]
main :: IO ()
main = defaultMain $
[ bgroup "Small Strings Bench" $
[ bench "string-interpolate" $ nf stringSI "William"
, bench "interpolate" $ nf stringI "William"
, bench "formatting" $ nf stringF "William"
-- , bench "Interpolation" $ nf stringN "William"
, bench "interpolatedstring-perl6" $ nf stringP "William"
]
, bgroup "Small Text Bench" $
[ bench "string-interpolate" $ nf textSI "William"
, bench "interpolate" $ nf textI "William"
, bench "formatting" $ nf textF "William"
-- , bench "Interpolation" $ nf textN "William"
, bench "interpolatedstring-perl6" $ nf textP "William"
]
, bgroup "Small ByteString Bench" $
[ bench "string-interpolate" $ nf byteStringSI "William"
, bench "interpolate" $ nf byteStringI "William"
-- "formatting" doesn't support ByteStrings.
-- , bench "Interpolation" $ nf byteStringN "William"
, bench "interpolatedstring-perl6" $ nf byteStringP "William"
]
, bgroup "Multiple Interpolations String Bench" $
[ bench "string-interpolate" $ nf multiStringSI (42, "CATALLAXY", True)
, bench "interpolate" $ nf multiStringI (42, "CATALLAXY", True)
, bench "formatting" $ nf multiStringF (42, "CATALLAXY", True)
-- , bench "Interpolation" $ nf multiStringN (42, "CATALLAXY", True)
, bench "interpolatedstring-perl6" $ nf multiStringP (42, "CATALLAXY", True)
]
, bgroup "Multiple Interpolations Text Bench" $
[ bench "string-interpolate" $ nf multiTextSI (42, "CATALLAXY", True)
, bench "interpolate" $ nf multiTextI (42, "CATALLAXY", True)
, bench "formatting" $ nf multiTextF (42, "CATALLAXY", True)
-- , bench "Interpolation" $ nf multiTextN (42, "CATALLAXY", True)
, bench "interpolatedstring-perl6" $ nf multiTextP (42, "CATALLAXY", True)
]
, bgroup "Multiple Interpolations ByteString Bench" $
[ bench "string-interpolate" $ nf multiByteStringSI (42, "CATALLAXY", True)
, bench "interpolate" $ nf multiByteStringI (42, "CATALLAXY", True)
-- "formatting" doesn't support ByteStrings.
-- , bench "Interpolation" $ nf multiByteStringN (42, "CATALLAXY", True)
, bench "interpolatedstring-perl6" $ nf multiByteStringP (42, "CATALLAXY", True)
]
, env largeishText $ \ ~t -> bgroup "Largeish Text Bench" $
[ bench "string-interpolate" $ nf textSI t
, bench "interpolate" $ nf textI t
, bench "formatting" $ nf textF t
-- , bench "Interpolation" $ nf textN t
, bench "interpolatedstring-perl6" $ nf textP t
]
, env largeishByteString $ \ ~bs -> bgroup "Largeish ByteString Bench" $
[ bench "string-interpolate" $ nf byteStringSI bs
, bench "interpolate" $ nf byteStringI bs
-- "formatting" doesn't support ByteStrings.
-- , bench "Interpolation" $ nf byteStringN bs
, bench "interpolatedstring-perl6" $ nf byteStringP bs
]
]
largeishText :: IO T.Text
largeishText =
generate $ T.pack <$> Prelude.take 100000 <$> infiniteListOf arbitrary
largeishByteString :: IO B.ByteString
largeishByteString =
generate $ B.pack <$> Prelude.take 100000 <$> infiniteListOf arbitrary