{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE FlexibleInstances          #-}
{-# LANGUAGE BangPatterns               #-}
{-# LANGUAGE MagicHash                  #-}

module Html.Convert
  ( Converted(..)
  , Convert(..)
  ) where

import Html.Type.Internal

import Data.Word
import Data.Proxy
import Data.String
import Data.Char (ord)
import Data.Double.Conversion.ByteString
import Numeric.Natural
import GHC.Exts
import GHC.TypeLits
import GHC.CString (unpackCString#, unpackCStringUtf8#, unpackFoldrCString#)

import qualified Data.Semigroup                   as S
import qualified Data.Monoid                      as M
import qualified Data.ByteString.Builder          as B
import qualified Data.ByteString.Builder.Prim     as BP
import qualified Data.ByteString.Builder.Internal as U
import qualified Data.Text                        as T
import qualified Data.Text.Encoding               as T
import qualified Data.Text.Lazy                   as TL
import qualified Data.Text.Lazy.Encoding          as TL

newtype Converted = Converted {Converted -> Builder
unConv :: B.Builder} deriving (Semigroup Converted
Converted
Semigroup Converted
-> Converted
-> (Converted -> Converted -> Converted)
-> ([Converted] -> Converted)
-> Monoid Converted
[Converted] -> Converted
Converted -> Converted -> Converted
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
mconcat :: [Converted] -> Converted
$cmconcat :: [Converted] -> Converted
mappend :: Converted -> Converted -> Converted
$cmappend :: Converted -> Converted -> Converted
mempty :: Converted
$cmempty :: Converted
$cp1Monoid :: Semigroup Converted
M.Monoid, b -> Converted -> Converted
NonEmpty Converted -> Converted
Converted -> Converted -> Converted
(Converted -> Converted -> Converted)
-> (NonEmpty Converted -> Converted)
-> (forall b. Integral b => b -> Converted -> Converted)
-> Semigroup Converted
forall b. Integral b => b -> Converted -> Converted
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
stimes :: b -> Converted -> Converted
$cstimes :: forall b. Integral b => b -> Converted -> Converted
sconcat :: NonEmpty Converted -> Converted
$csconcat :: NonEmpty Converted -> Converted
<> :: Converted -> Converted -> Converted
$c<> :: Converted -> Converted -> Converted
S.Semigroup)

instance IsString Converted where fromString :: String -> Converted
fromString = String -> Converted
forall a. Convert a => a -> Converted
convert

{-| Convert a type efficienctly to a renderable representation.  Add
  instances if you want use custom types in your document.

@
{\-\# LANGUAGE OverloadedStrings \#-\}
{\-\# LANGUAGE RecordWildCards   \#-\}

module Main where

import Html

import Data.Text (Text)
import Data.Monoid

data Person
  = Person
  { name :: Text
  , age :: Int
  , vegetarian :: Bool
  }

-- | This is already very efficient.
-- Wrap the Strings in Raw if you don't want to escape them.
instance Convert Person where
  convert (Person{..})
    =  convert name
    <> " is "
    <> convert age
    <> " years old and likes "
    <> if vegetarian then "oranges." else "meat."

john :: Person
john = Person {name = \"John\", age = 52, vegetarian = True}

main :: IO ()
main = print (div_ john)
@
-}
class Convert a where
  convert :: a -> Converted

instance KnownSymbol a => Convert (Proxy a) where {-# INLINE convert #-}; convert :: Proxy a -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Proxy a -> Builder) -> Proxy a -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Builder
U.byteStringCopy (ByteString -> Builder)
-> (Proxy a -> ByteString) -> Proxy a -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
forall a. IsString a => String -> a
fromString (String -> ByteString)
-> (Proxy a -> String) -> Proxy a -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Proxy a -> String
forall (n :: Symbol) (proxy :: Symbol -> *).
KnownSymbol n =>
proxy n -> String
symbolVal

instance Convert ()              where {-# INLINE convert #-}; convert :: () -> Converted
convert = Converted -> () -> Converted
forall a b. a -> b -> a
const Converted
forall a. Monoid a => a
mempty
instance Convert (Raw Char)      where {-# INLINE convert #-}; convert :: Raw Char -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Raw Char -> Builder) -> Raw Char -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Builder
B.charUtf8 (Char -> Builder) -> (Raw Char -> Char) -> Raw Char -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Raw Char -> Char
forall a. Raw a -> a
fromRaw
instance Convert (Raw String)    where {-# INLINE convert #-}; convert :: Raw String -> Converted
convert = String -> Converted
stringConvRaw (String -> Converted)
-> (Raw String -> String) -> Raw String -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Raw String -> String
forall a. Raw a -> a
fromRaw
instance Convert (Raw T.Text)    where {-# INLINE convert #-}; convert :: Raw Text -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Raw Text -> Builder) -> Raw Text -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Builder
T.encodeUtf8Builder (Text -> Builder) -> (Raw Text -> Text) -> Raw Text -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Raw Text -> Text
forall a. Raw a -> a
fromRaw
instance Convert (Raw TL.Text)   where {-# INLINE convert #-}; convert :: Raw Text -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Raw Text -> Builder) -> Raw Text -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> Builder
TL.encodeUtf8Builder (Text -> Builder) -> (Raw Text -> Text) -> Raw Text -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Raw Text -> Text
forall a. Raw a -> a
fromRaw
instance Convert (Raw B.Builder) where {-# INLINE convert #-}; convert :: Raw Builder -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Raw Builder -> Builder) -> Raw Builder -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Raw Builder -> Builder
forall a. Raw a -> a
fromRaw
instance Convert Char            where {-# INLINE convert #-}; convert :: Char -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted) -> (Char -> Builder) -> Char -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoundedPrim Char -> Char -> Builder
forall a. BoundedPrim a -> a -> Builder
BP.primBounded BoundedPrim Char
escapeUtf8
instance Convert String          where {-# INLINE convert #-}; convert :: String -> Converted
convert = String -> Converted
stringConv
instance Convert T.Text          where {-# INLINE convert #-}; convert :: Text -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted) -> (Text -> Builder) -> Text -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoundedPrim Word8 -> Text -> Builder
T.encodeUtf8BuilderEscaped BoundedPrim Word8
escape
instance Convert TL.Text         where {-# INLINE convert #-}; convert :: Text -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted) -> (Text -> Builder) -> Text -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoundedPrim Word8 -> Text -> Builder
TL.encodeUtf8BuilderEscaped BoundedPrim Word8
escape
instance Convert Int             where {-# INLINE convert #-}; convert :: Int -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted) -> (Int -> Builder) -> Int -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Builder
B.intDec
instance Convert Integer         where {-# INLINE convert #-}; convert :: Integer -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Integer -> Builder) -> Integer -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Builder
B.integerDec
instance Convert Natural         where {-# INLINE convert #-}; convert :: Natural -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Natural -> Builder) -> Natural -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Integer -> Builder
B.integerDec (Integer -> Builder) -> (Natural -> Integer) -> Natural -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Natural -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral
instance Convert Float           where {-# INLINE convert #-}; convert :: Float -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted) -> (Float -> Builder) -> Float -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Builder
U.byteStringCopy (ByteString -> Builder)
-> (Float -> ByteString) -> Float -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ByteString
toShortest (Double -> ByteString) -> (Float -> Double) -> Float -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Float -> Double
forall a b. (Real a, Fractional b) => a -> b
realToFrac
instance Convert Double          where {-# INLINE convert #-}; convert :: Double -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted)
-> (Double -> Builder) -> Double -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Builder
U.byteStringCopy (ByteString -> Builder)
-> (Double -> ByteString) -> Double -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Double -> ByteString
toShortest
instance Convert Word            where {-# INLINE convert #-}; convert :: Word -> Converted
convert = Builder -> Converted
Converted (Builder -> Converted) -> (Word -> Builder) -> Word -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word -> Builder
B.wordDec

{-# INLINE builderCString# #-}
builderCString# :: BP.BoundedPrim Word8 -> Addr# -> Converted
builderCString# :: BoundedPrim Word8 -> Addr# -> Converted
builderCString# BoundedPrim Word8
bp Addr#
addr = Builder -> Converted
Converted (Builder -> Converted) -> Builder -> Converted
forall a b. (a -> b) -> a -> b
$ BoundedPrim Word8 -> (Int -> Maybe (Word8, Int)) -> Int -> Builder
forall b a. BoundedPrim b -> (a -> Maybe (b, a)) -> a -> Builder
BP.primUnfoldrBounded BoundedPrim Word8
bp Int -> Maybe (Word8, Int)
forall a. Num a => Int -> Maybe (a, Int)
go Int
0
  where
    go :: Int -> Maybe (a, Int)
go !Int
i | Int
b Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
0 = (a, Int) -> Maybe (a, Int)
forall a. a -> Maybe a
Just (Int -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
b, Int
iInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
          | Bool
otherwise = Maybe (a, Int)
forall a. Maybe a
Nothing
      where
        !b :: Int
b = Int# -> Int
I# (Char# -> Int#
ord# (Int -> Char#
at# Int
i))
    at# :: Int -> Char#
at# (I# Int#
i#) = Addr# -> Int# -> Char#
indexCharOffAddr# Addr#
addr Int#
i#

{-# INLINE [0] stringConv #-}
stringConv :: String -> Converted
stringConv :: String -> Converted
stringConv = Builder -> Converted
Converted (Builder -> Converted)
-> (String -> Builder) -> String -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BoundedPrim Char -> String -> Builder
forall a. BoundedPrim a -> [a] -> Builder
BP.primMapListBounded BoundedPrim Char
escapeUtf8

{-# INLINE [0] stringConvRaw #-}
stringConvRaw :: String -> Converted
stringConvRaw :: String -> Converted
stringConvRaw = Builder -> Converted
Converted (Builder -> Converted)
-> (String -> Builder) -> String -> Converted
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Builder
B.stringUtf8

escapeUtf8 :: BP.BoundedPrim Char
escapeUtf8 :: BoundedPrim Char
escapeUtf8
  = (Char -> Bool)
-> BoundedPrim Char -> BoundedPrim Char -> BoundedPrim Char
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>  Char
'>' ) BoundedPrim Char
BP.charUtf8
  (BoundedPrim Char -> BoundedPrim Char)
-> (BoundedPrim Char -> BoundedPrim Char)
-> BoundedPrim Char
-> BoundedPrim Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool)
-> BoundedPrim Char -> BoundedPrim Char -> BoundedPrim Char
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'<' ) ((Char, (Char, (Char, Char))) -> BoundedPrim Char
forall a. (Char, (Char, (Char, Char))) -> BoundedPrim a
fixed4 (Char
'&',(Char
'l',(Char
't',Char
';'))))
  (BoundedPrim Char -> BoundedPrim Char)
-> (BoundedPrim Char -> BoundedPrim Char)
-> BoundedPrim Char
-> BoundedPrim Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool)
-> BoundedPrim Char -> BoundedPrim Char -> BoundedPrim Char
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'>' ) ((Char, (Char, (Char, Char))) -> BoundedPrim Char
forall a. (Char, (Char, (Char, Char))) -> BoundedPrim a
fixed4 (Char
'&',(Char
'g',(Char
't',Char
';'))))
  (BoundedPrim Char -> BoundedPrim Char)
-> (BoundedPrim Char -> BoundedPrim Char)
-> BoundedPrim Char
-> BoundedPrim Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool)
-> BoundedPrim Char -> BoundedPrim Char -> BoundedPrim Char
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'&' ) ((Char, (Char, (Char, (Char, Char)))) -> BoundedPrim Char
forall a. (Char, (Char, (Char, (Char, Char)))) -> BoundedPrim a
fixed5 (Char
'&',(Char
'a',(Char
'm',(Char
'p',Char
';')))))
  (BoundedPrim Char -> BoundedPrim Char)
-> (BoundedPrim Char -> BoundedPrim Char)
-> BoundedPrim Char
-> BoundedPrim Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool)
-> BoundedPrim Char -> BoundedPrim Char -> BoundedPrim Char
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'"' ) ((Char, (Char, (Char, (Char, Char)))) -> BoundedPrim Char
forall a. (Char, (Char, (Char, (Char, Char)))) -> BoundedPrim a
fixed5 (Char
'&',(Char
'#',(Char
'3',(Char
'4',Char
';')))))
  (BoundedPrim Char -> BoundedPrim Char)
-> (BoundedPrim Char -> BoundedPrim Char)
-> BoundedPrim Char
-> BoundedPrim Char
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Bool)
-> BoundedPrim Char -> BoundedPrim Char -> BoundedPrim Char
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
'\'') ((Char, (Char, (Char, (Char, Char)))) -> BoundedPrim Char
forall a. (Char, (Char, (Char, (Char, Char)))) -> BoundedPrim a
fixed5 (Char
'&',(Char
'#',(Char
'3',(Char
'9',Char
';')))))
  (BoundedPrim Char -> BoundedPrim Char)
-> BoundedPrim Char -> BoundedPrim Char
forall a b. (a -> b) -> a -> b
$ FixedPrim Char -> BoundedPrim Char
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded FixedPrim Char
BP.char7
  where
    {-# INLINE fixed4 #-}
    fixed4 :: (Char, (Char, (Char, Char))) -> BoundedPrim a
fixed4 (Char, (Char, (Char, Char)))
x = FixedPrim a -> BoundedPrim a
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded (FixedPrim a -> BoundedPrim a) -> FixedPrim a -> BoundedPrim a
forall a b. (a -> b) -> a -> b
$ (Char, (Char, (Char, Char))) -> a -> (Char, (Char, (Char, Char)))
forall a b. a -> b -> a
const (Char, (Char, (Char, Char)))
x (a -> (Char, (Char, (Char, Char))))
-> FixedPrim (Char, (Char, (Char, Char))) -> FixedPrim a
forall (f :: * -> *) b a. Contravariant f => (b -> a) -> f a -> f b
BP.>$<
      FixedPrim Char
BP.char7 FixedPrim Char
-> FixedPrim (Char, (Char, Char))
-> FixedPrim (Char, (Char, (Char, Char)))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7 FixedPrim Char
-> FixedPrim (Char, Char) -> FixedPrim (Char, (Char, Char))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7 FixedPrim Char -> FixedPrim Char -> FixedPrim (Char, Char)
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7

    {-# INLINE fixed5 #-}
    fixed5 :: (Char, (Char, (Char, (Char, Char)))) -> BoundedPrim a
fixed5 (Char, (Char, (Char, (Char, Char))))
x = FixedPrim a -> BoundedPrim a
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded (FixedPrim a -> BoundedPrim a) -> FixedPrim a -> BoundedPrim a
forall a b. (a -> b) -> a -> b
$ (Char, (Char, (Char, (Char, Char))))
-> a -> (Char, (Char, (Char, (Char, Char))))
forall a b. a -> b -> a
const (Char, (Char, (Char, (Char, Char))))
x (a -> (Char, (Char, (Char, (Char, Char)))))
-> FixedPrim (Char, (Char, (Char, (Char, Char)))) -> FixedPrim a
forall (f :: * -> *) b a. Contravariant f => (b -> a) -> f a -> f b
BP.>$<
      FixedPrim Char
BP.char7 FixedPrim Char
-> FixedPrim (Char, (Char, (Char, Char)))
-> FixedPrim (Char, (Char, (Char, (Char, Char))))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7 FixedPrim Char
-> FixedPrim (Char, (Char, Char))
-> FixedPrim (Char, (Char, (Char, Char)))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7 FixedPrim Char
-> FixedPrim (Char, Char) -> FixedPrim (Char, (Char, Char))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7 FixedPrim Char -> FixedPrim Char -> FixedPrim (Char, Char)
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Char
BP.char7

escape :: BP.BoundedPrim Word8
escape :: BoundedPrim Word8
escape
  = (Word8 -> Bool)
-> BoundedPrim Word8 -> BoundedPrim Word8 -> BoundedPrim Word8
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>  Char -> Word8
c2w Char
'>' ) (FixedPrim Word8 -> BoundedPrim Word8
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded FixedPrim Word8
BP.word8)
  (BoundedPrim Word8 -> BoundedPrim Word8)
-> (BoundedPrim Word8 -> BoundedPrim Word8)
-> BoundedPrim Word8
-> BoundedPrim Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool)
-> BoundedPrim Word8 -> BoundedPrim Word8 -> BoundedPrim Word8
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'<' ) ((Word8, (Word8, (Word8, Word8))) -> BoundedPrim Word8
forall a. (Word8, (Word8, (Word8, Word8))) -> BoundedPrim a
fixed4 (Char -> Word8
c2w Char
'&',(Char -> Word8
c2w Char
'l',(Char -> Word8
c2w Char
't',Char -> Word8
c2w Char
';'))))
  (BoundedPrim Word8 -> BoundedPrim Word8)
-> (BoundedPrim Word8 -> BoundedPrim Word8)
-> BoundedPrim Word8
-> BoundedPrim Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool)
-> BoundedPrim Word8 -> BoundedPrim Word8 -> BoundedPrim Word8
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'>' ) ((Word8, (Word8, (Word8, Word8))) -> BoundedPrim Word8
forall a. (Word8, (Word8, (Word8, Word8))) -> BoundedPrim a
fixed4 (Char -> Word8
c2w Char
'&',(Char -> Word8
c2w Char
'g',(Char -> Word8
c2w Char
't',Char -> Word8
c2w Char
';'))))
  (BoundedPrim Word8 -> BoundedPrim Word8)
-> (BoundedPrim Word8 -> BoundedPrim Word8)
-> BoundedPrim Word8
-> BoundedPrim Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool)
-> BoundedPrim Word8 -> BoundedPrim Word8 -> BoundedPrim Word8
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'&' ) ((Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim Word8
forall a.
(Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim a
fixed5 (Char -> Word8
c2w Char
'&',(Char -> Word8
c2w Char
'a',(Char -> Word8
c2w Char
'm',(Char -> Word8
c2w Char
'p',Char -> Word8
c2w Char
';')))))
  (BoundedPrim Word8 -> BoundedPrim Word8)
-> (BoundedPrim Word8 -> BoundedPrim Word8)
-> BoundedPrim Word8
-> BoundedPrim Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool)
-> BoundedPrim Word8 -> BoundedPrim Word8 -> BoundedPrim Word8
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'"' ) ((Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim Word8
forall a.
(Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim a
fixed5 (Char -> Word8
c2w Char
'&',(Char -> Word8
c2w Char
'#',(Char -> Word8
c2w Char
'3',(Char -> Word8
c2w Char
'4',Char -> Word8
c2w Char
';')))))
  (BoundedPrim Word8 -> BoundedPrim Word8)
-> (BoundedPrim Word8 -> BoundedPrim Word8)
-> BoundedPrim Word8
-> BoundedPrim Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word8 -> Bool)
-> BoundedPrim Word8 -> BoundedPrim Word8 -> BoundedPrim Word8
forall a.
(a -> Bool) -> BoundedPrim a -> BoundedPrim a -> BoundedPrim a
BP.condB (Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Char -> Word8
c2w Char
'\'') ((Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim Word8
forall a.
(Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim a
fixed5 (Char -> Word8
c2w Char
'&',(Char -> Word8
c2w Char
'#',(Char -> Word8
c2w Char
'3',(Char -> Word8
c2w Char
'9',Char -> Word8
c2w Char
';')))))
  (BoundedPrim Word8 -> BoundedPrim Word8)
-> BoundedPrim Word8 -> BoundedPrim Word8
forall a b. (a -> b) -> a -> b
$ FixedPrim Word8 -> BoundedPrim Word8
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded FixedPrim Word8
BP.word8
  where
    c2w :: Char -> Word8
c2w = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
ord

    {-# INLINE fixed4 #-}
    fixed4 :: (Word8, (Word8, (Word8, Word8))) -> BoundedPrim a
fixed4 (Word8, (Word8, (Word8, Word8)))
x = FixedPrim a -> BoundedPrim a
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded (FixedPrim a -> BoundedPrim a) -> FixedPrim a -> BoundedPrim a
forall a b. (a -> b) -> a -> b
$ (Word8, (Word8, (Word8, Word8)))
-> a -> (Word8, (Word8, (Word8, Word8)))
forall a b. a -> b -> a
const (Word8, (Word8, (Word8, Word8)))
x (a -> (Word8, (Word8, (Word8, Word8))))
-> FixedPrim (Word8, (Word8, (Word8, Word8))) -> FixedPrim a
forall (f :: * -> *) b a. Contravariant f => (b -> a) -> f a -> f b
BP.>$<
      FixedPrim Word8
BP.word8 FixedPrim Word8
-> FixedPrim (Word8, (Word8, Word8))
-> FixedPrim (Word8, (Word8, (Word8, Word8)))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8 FixedPrim Word8
-> FixedPrim (Word8, Word8) -> FixedPrim (Word8, (Word8, Word8))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8 FixedPrim Word8 -> FixedPrim Word8 -> FixedPrim (Word8, Word8)
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8

    {-# INLINE fixed5 #-}
    fixed5 :: (Word8, (Word8, (Word8, (Word8, Word8)))) -> BoundedPrim a
fixed5 (Word8, (Word8, (Word8, (Word8, Word8))))
x = FixedPrim a -> BoundedPrim a
forall a. FixedPrim a -> BoundedPrim a
BP.liftFixedToBounded (FixedPrim a -> BoundedPrim a) -> FixedPrim a -> BoundedPrim a
forall a b. (a -> b) -> a -> b
$ (Word8, (Word8, (Word8, (Word8, Word8))))
-> a -> (Word8, (Word8, (Word8, (Word8, Word8))))
forall a b. a -> b -> a
const (Word8, (Word8, (Word8, (Word8, Word8))))
x (a -> (Word8, (Word8, (Word8, (Word8, Word8)))))
-> FixedPrim (Word8, (Word8, (Word8, (Word8, Word8))))
-> FixedPrim a
forall (f :: * -> *) b a. Contravariant f => (b -> a) -> f a -> f b
BP.>$<
      FixedPrim Word8
BP.word8 FixedPrim Word8
-> FixedPrim (Word8, (Word8, (Word8, Word8)))
-> FixedPrim (Word8, (Word8, (Word8, (Word8, Word8))))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8 FixedPrim Word8
-> FixedPrim (Word8, (Word8, Word8))
-> FixedPrim (Word8, (Word8, (Word8, Word8)))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8 FixedPrim Word8
-> FixedPrim (Word8, Word8) -> FixedPrim (Word8, (Word8, Word8))
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8 FixedPrim Word8 -> FixedPrim Word8 -> FixedPrim (Word8, Word8)
forall (f :: * -> *) a b. Monoidal f => f a -> f b -> f (a, b)
BP.>*< FixedPrim Word8
BP.word8

{-# RULES "CONVERTED literal" forall a.
    stringConv (unpackCString# a) = builderCString# escape a #-}

{-# RULES "CONVERTED foldr literal" forall a.
    stringConv (build (unpackFoldrCString# a)) = builderCString# escape a #-}

{-# RULES "CONVERTED literal raw" forall a.
    stringConvRaw (unpackCString# a) = builderCString# (BP.liftFixedToBounded BP.word8) a #-}

{-# RULES "CONVERTED foldr literal raw" forall a.
    stringConvRaw (build (unpackFoldrCString# a)) = builderCString# (BP.liftFixedToBounded BP.word8) a #-}

{-# RULES "CONVERTED literal utf8" forall a.
    stringConv (unpackCStringUtf8# a) = convert (T.pack (unpackCStringUtf8# a)) #-}

{-# RULES "CONVERTED literal utf8 raw" forall a.
    stringConvRaw (unpackCStringUtf8# a) = convert (Raw (T.pack (unpackCStringUtf8# a))) #-}