module Data.Fmt.Code (
    v,

    -- * Character encodings
    c,
    c7,
    c8,
    s,
    s7,
    s8,

    -- * Ascii float encodings
    e,
    f,
    g,

    -- * Decimal encodings
    d,
    hhd,
    hd,
    ld,
    lld,
    u,
    hhu,
    hu,
    lu,
    llu,

    -- * Hexadecimal encodings
    x,
    hhx,
    hx,
    hx',
    lx,
    lx',
    llx,
    llx',

    -- * Binary encodings
    b,
    b',
    hhb,
    hb,
    hb',
    lb,
    lb',
    llb,
    llb',
) where

import Data.ByteString (ByteString)
import qualified Data.ByteString.Builder as BL
import qualified Data.ByteString.Lazy.Char8 as BL
import Data.Fmt
import Data.Int
import Data.Word
import qualified Numeric as N

{- $setup
 >>> import Text.Printf
 >>> :load Data.Fmt
-}

{- | Encode a loggable value.

 Semantics are similar to 'ByteString.Printf.printf':

 >>> Text.Printf.printf "%v" 42 :: String
 "42"
 >>> runLogFmt v 42
 "42"
-}
{-# INLINE v #-}
v :: ToLogStr a => Fmt1 LogStr s a
v :: forall a s. ToLogStr a => Fmt1 LogStr s a
v = (a -> LogStr) -> Fmt1 LogStr s a
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 a -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr

-- Character encodings

-------------------------

-- | Format a character.
{-# INLINE c #-}
c :: IsString m => Fmt1 m s Char
c :: forall m s. IsString m => Fmt1 m s Char
c = (Char -> m) -> Fmt1 m s Char
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 (String -> m
forall a. IsString a => String -> a
fromString (String -> m) -> (Char -> String) -> Char -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> String
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure)

-- | ASCII encode a 'Char'.
{-# INLINE c7 #-}
c7 :: Fmt1 LogStr s Char
c7 :: forall s. Fmt1 LogStr s Char
c7 = (Char -> LogStr) -> Fmt1 LogStr s Char
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Char -> LogStr) -> Fmt1 LogStr s Char)
-> (Char -> LogStr) -> Fmt1 LogStr s Char
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Char -> Builder) -> Char -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Builder
BL.char7

-- | Latin-1 (ISO/IEC 8859-1) encode a 'Char'.
{-# INLINE c8 #-}
c8 :: Fmt1 LogStr s Char
c8 :: forall s. Fmt1 LogStr s Char
c8 = (Char -> LogStr) -> Fmt1 LogStr s Char
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Char -> LogStr) -> Fmt1 LogStr s Char)
-> (Char -> LogStr) -> Fmt1 LogStr s Char
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Char -> Builder) -> Char -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Builder
BL.char8

-- | Format a showable value.
{-# INLINE s #-}
s :: (IsString m, Show a) => Fmt1 m s a
s :: forall m a s. (IsString m, Show a) => Fmt1 m s a
s = (a -> m) -> Fmt1 m s a
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 (String -> m
forall a. IsString a => String -> a
fromString (String -> m) -> (a -> String) -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show)

-- | ASCII encode a 'String'.
{-# INLINE s7 #-}
s7 :: Fmt1 LogStr s String
s7 :: forall s. Fmt1 LogStr s String
s7 = (String -> LogStr) -> Fmt1 LogStr s String
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((String -> LogStr) -> Fmt1 LogStr s String)
-> (String -> LogStr) -> Fmt1 LogStr s String
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (String -> Builder) -> String -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Builder
BL.string7

-- | Latin-1 (ISO/IEC 8859-1) encode a 'String'.
{-# INLINE s8 #-}
s8 :: Fmt1 LogStr s String
s8 :: forall s. Fmt1 LogStr s String
s8 = (String -> LogStr) -> Fmt1 LogStr s String
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((String -> LogStr) -> Fmt1 LogStr s String)
-> (String -> LogStr) -> Fmt1 LogStr s String
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (String -> Builder) -> String -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Builder
BL.string8

-- Floating point

-------------------------

{- | Format a floating point number to a given number of digits of precision.

 Semantics are similar to 'ByteString.Printf.printf':

 >>> Text.Printf.printf "%.5e" pi :: String
 "3.14159e0"
 >>> runLogFmt (e 5) pi
 "3.14159e0"
-}
e :: (IsString m, RealFloat a) => Int -> Fmt1 m s a
e :: forall m a s. (IsString m, RealFloat a) => Int -> Fmt1 m s a
e Int
prec = (a -> m) -> Fmt1 m s a
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((a -> m) -> Fmt1 m s a) -> (a -> m) -> Fmt1 m s a
forall a b. (a -> b) -> a -> b
$ String -> m
forall a. IsString a => String -> a
fromString (String -> m) -> (a -> String) -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> String -> String) -> String -> a -> String
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
N.showEFloat (Maybe Int -> a -> String -> String)
-> Maybe Int -> a -> String -> String
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int
forall a. a -> Maybe a
Just Int
prec) []

{- | Format a floating point number to a given number of digits of precision.

 Semantics are similar to 'ByteString.Printf.printf':

 >>> Text.Printf.printf "%.5f" maximal32 :: String
 "340282330000000000000000000000000000000.00000"
 >>> runLogFmt (f 5) maximal32
 "340282330000000000000000000000000000000.00000"
-}
f :: (IsString m, RealFloat a) => Int -> Fmt1 m s a
f :: forall m a s. (IsString m, RealFloat a) => Int -> Fmt1 m s a
f Int
prec = (a -> m) -> Fmt1 m s a
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((a -> m) -> Fmt1 m s a) -> (a -> m) -> Fmt1 m s a
forall a b. (a -> b) -> a -> b
$ String -> m
forall a. IsString a => String -> a
fromString (String -> m) -> (a -> String) -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> String -> String) -> String -> a -> String
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
N.showFFloat (Maybe Int -> a -> String -> String)
-> Maybe Int -> a -> String -> String
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int
forall a. a -> Maybe a
Just Int
prec) []

{- | Format a floating point number to a given number of digits of precision.

 Semantics are similar to 'ByteString.Printf.printf':

 >>> Text.Printf.printf "%.5g" maximal32 :: String
 "3.40282e38"
 >>> runLogFmt (g 5) maximal32
 "3.40282e38"
-}
g :: (IsString m, RealFloat a) => Int -> Fmt1 m s a
g :: forall m a s. (IsString m, RealFloat a) => Int -> Fmt1 m s a
g Int
prec = (a -> m) -> Fmt1 m s a
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((a -> m) -> Fmt1 m s a) -> (a -> m) -> Fmt1 m s a
forall a b. (a -> b) -> a -> b
$ String -> m
forall a. IsString a => String -> a
fromString (String -> m) -> (a -> String) -> a -> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> String -> String) -> String -> a -> String
forall a b c. (a -> b -> c) -> b -> a -> c
flip (Maybe Int -> a -> String -> String
forall a. RealFloat a => Maybe Int -> a -> String -> String
N.showGFloat (Maybe Int -> a -> String -> String)
-> Maybe Int -> a -> String -> String
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int
forall a. a -> Maybe a
Just Int
prec) []

-- Decimal encodings

-------------------------

-- | Decimal encoding of an 'Int' using the ASCII digits.
{-# INLINE d #-}
d :: Fmt1 LogStr s Int
d :: forall s. Fmt1 LogStr s Int
d = (Int -> LogStr) -> Fmt1 LogStr s Int
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Int -> LogStr) -> Fmt1 LogStr s Int)
-> (Int -> LogStr) -> Fmt1 LogStr s Int
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Int -> Builder) -> Int -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Builder
BL.intDec

{- | Decimal encoding of an 'Int8' using the ASCII digits.

 e.g.

 > toLazyByteString (int8Dec 42)   = "42"
 > toLazyByteString (int8Dec (-1)) = "-1"
-}
{-# INLINE hhd #-}
hhd :: Fmt1 LogStr s Int8
hhd :: forall s. Fmt1 LogStr s Int8
hhd = (Int8 -> LogStr) -> Fmt1 LogStr s Int8
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Int8 -> LogStr) -> Fmt1 LogStr s Int8)
-> (Int8 -> LogStr) -> Fmt1 LogStr s Int8
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Int8 -> Builder) -> Int8 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int8 -> Builder
BL.int8Dec

-- | Decimal encoding of an 'Int16' using the ASCII digits.
{-# INLINE hd #-}
hd :: Fmt1 LogStr s Int16
hd :: forall s. Fmt1 LogStr s Int16
hd = (Int16 -> LogStr) -> Fmt1 LogStr s Int16
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Int16 -> LogStr) -> Fmt1 LogStr s Int16)
-> (Int16 -> LogStr) -> Fmt1 LogStr s Int16
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Int16 -> Builder) -> Int16 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int16 -> Builder
BL.int16Dec

-- | Decimal encoding of an 'Int32' using the ASCII digits.
{-# INLINE ld #-}
ld :: Fmt1 LogStr s Int32
ld :: forall s. Fmt1 LogStr s Int32
ld = (Int32 -> LogStr) -> Fmt1 LogStr s Int32
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Int32 -> LogStr) -> Fmt1 LogStr s Int32)
-> (Int32 -> LogStr) -> Fmt1 LogStr s Int32
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Int32 -> Builder) -> Int32 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int32 -> Builder
BL.int32Dec

-- | Decimal encoding of an 'Int64' using the ASCII digits.
{-# INLINE lld #-}
lld :: Fmt1 LogStr s Int64
lld :: forall s. Fmt1 LogStr s Int64
lld = (Int64 -> LogStr) -> Fmt1 LogStr s Int64
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Int64 -> LogStr) -> Fmt1 LogStr s Int64)
-> (Int64 -> LogStr) -> Fmt1 LogStr s Int64
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Int64 -> Builder) -> Int64 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int64 -> Builder
BL.int64Dec

-- | Decimal encoding of a 'Word' using the ASCII digits.
{-# INLINE u #-}
u :: Fmt1 LogStr s Word
u :: forall s. Fmt1 LogStr s Word
u = (Word -> LogStr) -> Fmt1 LogStr s Word
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word -> LogStr) -> Fmt1 LogStr s Word)
-> (Word -> LogStr) -> Fmt1 LogStr s Word
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word -> Builder) -> Word -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Builder
BL.wordDec

-- | Decimal encoding of a 'Word8' using the ASCII digits.
{-# INLINE hhu #-}
hhu :: Fmt1 LogStr s Word8
hhu :: forall s. Fmt1 LogStr s Word8
hhu = (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word8 -> LogStr) -> Fmt1 LogStr s Word8)
-> (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word8 -> Builder) -> Word8 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder
BL.word8Dec

-- | Decimal encoding of a 'Word16' using the ASCII digits.
{-# INLINE hu #-}
hu :: Fmt1 LogStr s Word16
hu :: forall s. Fmt1 LogStr s Word16
hu = (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word16 -> LogStr) -> Fmt1 LogStr s Word16)
-> (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word16 -> Builder) -> Word16 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Builder
BL.word16Dec

-- | Decimal encoding of a 'Word32' using the ASCII digits.
{-# INLINE lu #-}
lu :: Fmt1 LogStr s Word32
lu :: forall s. Fmt1 LogStr s Word32
lu = (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word32 -> LogStr) -> Fmt1 LogStr s Word32)
-> (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word32 -> Builder) -> Word32 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Builder
BL.word32Dec

-- | Decimal encoding of a 'Word64' using the ASCII digits.
{-# INLINE llu #-}
llu :: Fmt1 LogStr s Word64
llu :: forall s. Fmt1 LogStr s Word64
llu = (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word64 -> LogStr) -> Fmt1 LogStr s Word64)
-> (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word64 -> Builder) -> Word64 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Builder
BL.word64Dec

-- Hexadecimal encodings
--------------------

-- | Shortest hexadecimal encoding of a 'Word' using lower-case characters.
{-# INLINE x #-}
x :: Fmt1 LogStr s Word
x :: forall s. Fmt1 LogStr s Word
x = (Word -> LogStr) -> Fmt1 LogStr s Word
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word -> LogStr) -> Fmt1 LogStr s Word)
-> (Word -> LogStr) -> Fmt1 LogStr s Word
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word -> Builder) -> Word -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Builder
BL.wordHex

-- | Shortest hexadecimal encoding of a 'Word8' using lower-case characters.
{-# INLINE hhx #-}
hhx :: Fmt1 LogStr s Word8
hhx :: forall s. Fmt1 LogStr s Word8
hhx = (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word8 -> LogStr) -> Fmt1 LogStr s Word8)
-> (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word8 -> Builder) -> Word8 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder
BL.word8Hex

-- | Encode a 'Word8' using 2 nibbles (hexadecimal digits).
{-# INLINE hhx' #-}
hhx' :: Fmt1 LogStr s Word8
hhx' :: forall s. Fmt1 LogStr s Word8
hhx' = (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word8 -> LogStr) -> Fmt1 LogStr s Word8)
-> (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word8 -> Builder) -> Word8 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder
BL.word8HexFixed

-- | Shortest hexadecimal encoding of a 'Word16' using lower-case characters.
{-# INLINE hx #-}
hx :: Fmt1 LogStr s Word16
hx :: forall s. Fmt1 LogStr s Word16
hx = (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word16 -> LogStr) -> Fmt1 LogStr s Word16)
-> (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word16 -> Builder) -> Word16 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Builder
BL.word16Hex

-- | Encode a 'Word16' using 4 nibbles.
{-# INLINE hx' #-}
hx' :: Fmt1 LogStr s Word16
hx' :: forall s. Fmt1 LogStr s Word16
hx' = (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word16 -> LogStr) -> Fmt1 LogStr s Word16)
-> (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word16 -> Builder) -> Word16 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Builder
BL.word16HexFixed

-- | Shortest hexadecimal encoding of a 'Word32' using lower-case characters.
{-# INLINE lx #-}
lx :: Fmt1 LogStr s Word32
lx :: forall s. Fmt1 LogStr s Word32
lx = (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word32 -> LogStr) -> Fmt1 LogStr s Word32)
-> (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word32 -> Builder) -> Word32 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Builder
BL.word32Hex

-- | Encode a 'Word32' using 8 nibbles.
{-# INLINE lx' #-}
lx' :: Fmt1 LogStr s Word32
lx' :: forall s. Fmt1 LogStr s Word32
lx' = (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word32 -> LogStr) -> Fmt1 LogStr s Word32)
-> (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word32 -> Builder) -> Word32 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Builder
BL.word32HexFixed

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

 Semantics are similar to 'Text.Printf.printf':

 >>> Text.printf "%s: %llx" "Val" (-7) :: String
 "Val: fffffffffffffff9"
 >>> printf (s % ": " % llx) "Val" (-7)
 "Val: fffffffffffffff9"
-}
{-# INLINE llx #-}
llx :: Fmt1 LogStr s Word64
llx :: forall s. Fmt1 LogStr s Word64
llx = (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word64 -> LogStr) -> Fmt1 LogStr s Word64)
-> (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word64 -> Builder) -> Word64 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Builder
BL.word64Hex

-- | Encode a 'Word64' using 16 nibbles.
{-# INLINE llx' #-}
llx' :: Fmt1 LogStr s Word64
llx' :: forall s. Fmt1 LogStr s Word64
llx' = (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word64 -> LogStr) -> Fmt1 LogStr s Word64)
-> (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word64 -> Builder) -> Word64 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Builder
BL.word64HexFixed

-- Binary encodings
--------------------

-- | Format a lazy byte string.
b :: Fmt1 LogStr s BL.ByteString
b :: forall s. Fmt1 LogStr s ByteString
b = (ByteString -> LogStr) -> Fmt1 LogStr s ByteString
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ByteString -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr
{-# INLINE b #-}

{- | Format a strict byte string.

 @ 'fmap' (. 'Data.ByteString.pack') 't'' :: 'Fmt1' 'Data.ByteString.Builder.Builder' s 'String' @
-}
b' :: Fmt1 LogStr s ByteString
b' :: forall s. Fmt1 LogStr s ByteString
b' = (ByteString -> LogStr) -> Fmt1 LogStr s ByteString
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ByteString -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr
{-# INLINE b' #-}

-- | Encode a 'Word8' as-is
{-# INLINE hhb #-}
hhb :: Fmt1 LogStr s Word8
hhb :: forall s. Fmt1 LogStr s Word8
hhb = (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word8 -> LogStr) -> Fmt1 LogStr s Word8)
-> (Word8 -> LogStr) -> Fmt1 LogStr s Word8
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word8 -> Builder) -> Word8 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Builder
BL.word8

-- | Encode a 'Word16' using little-endian format.
{-# INLINE hb #-}
hb :: Fmt1 LogStr s Word16
hb :: forall s. Fmt1 LogStr s Word16
hb = (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word16 -> LogStr) -> Fmt1 LogStr s Word16)
-> (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word16 -> Builder) -> Word16 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Builder
BL.word16LE

-- | Encode a 'Word16' using big-endian format.
{-# INLINE hb' #-}
hb' :: Fmt1 LogStr s Word16
hb' :: forall s. Fmt1 LogStr s Word16
hb' = (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word16 -> LogStr) -> Fmt1 LogStr s Word16)
-> (Word16 -> LogStr) -> Fmt1 LogStr s Word16
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word16 -> Builder) -> Word16 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word16 -> Builder
BL.word16BE

-- | Encode a 'Word32' using little-endian format.
{-# INLINE lb #-}
lb :: Fmt1 LogStr s Word32
lb :: forall s. Fmt1 LogStr s Word32
lb = (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word32 -> LogStr) -> Fmt1 LogStr s Word32)
-> (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word32 -> Builder) -> Word32 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Builder
BL.word32LE

-- | Encode a 'Word32' using big-endian format.
{-# INLINE lb' #-}
lb' :: Fmt1 LogStr s Word32
lb' :: forall s. Fmt1 LogStr s Word32
lb' = (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word32 -> LogStr) -> Fmt1 LogStr s Word32)
-> (Word32 -> LogStr) -> Fmt1 LogStr s Word32
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word32 -> Builder) -> Word32 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word32 -> Builder
BL.word32BE

{- | Encode a 'Word64' using little-endian format.

 Semantics are similar to 'Tebt.Printf.printf':

 >>> Text.printf "%s: %llb" "Val" (-7) :: String
 "Val: fffffffffffffff9"
 >>> printf (s % ": " % llb) "Val" (-7)
 "Val: fffffffffffffff9"
-}
{-# INLINE llb #-}
llb :: Fmt1 LogStr s Word64
llb :: forall s. Fmt1 LogStr s Word64
llb = (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word64 -> LogStr) -> Fmt1 LogStr s Word64)
-> (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word64 -> Builder) -> Word64 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Builder
BL.word64LE

-- | Encode a 'Word64' using big-endian format.
{-# INLINE llb' #-}
llb' :: Fmt1 LogStr s Word64
llb' :: forall s. Fmt1 LogStr s Word64
llb' = (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a m s. (a -> m) -> Fmt1 m s a
fmt1 ((Word64 -> LogStr) -> Fmt1 LogStr s Word64)
-> (Word64 -> LogStr) -> Fmt1 LogStr s Word64
forall a b. (a -> b) -> a -> b
$ Builder -> LogStr
forall msg. ToLogStr msg => msg -> LogStr
toLogStr (Builder -> LogStr) -> (Word64 -> Builder) -> Word64 -> LogStr
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word64 -> Builder
BL.word64BE