TextShow.Data.Tuple

TextShow instances for tuple types.

Since: 2

Orphan instances

TextShow ()

Since: 2

Methods

showbPrec :: Int -> () -> Builder

showb :: () -> Builder

showbList :: [()] -> Builder

showtPrec :: Int -> () -> Text

showt :: () -> Text

showtList :: [()] -> Text

showtlPrec :: Int -> () -> Text

showtl :: () -> Text

showtlList :: [()] -> Text

TextShow1 Solo

Since: 3.9.3

Methods

liftShowbPrec :: (Int -> a -> Builder) -> ([a] -> Builder) -> Int -> Solo a -> Builder

liftShowbList :: (Int -> a -> Builder) -> ([a] -> Builder) -> [Solo a] -> Builder

TextShow2 (,)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a -> Builder) -> ([a] -> Builder) -> (Int -> b -> Builder) -> ([b] -> Builder) -> Int -> (a, b) -> Builder

liftShowbList2 :: (Int -> a -> Builder) -> ([a] -> Builder) -> (Int -> b -> Builder) -> ([b] -> Builder) -> [(a, b)] -> Builder

TextShow a => TextShow (a)

Since: 3.9.3

Methods

showbPrec :: Int -> (a) -> Builder

showb :: (a) -> Builder

showbList :: [(a)] -> Builder

showtPrec :: Int -> (a) -> Text

showt :: (a) -> Text

showtList :: [(a)] -> Text

showtlPrec :: Int -> (a) -> Text

showtl :: (a) -> Text

showtlList :: [(a)] -> Text

TextShow a => TextShow1 ((,) a)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, a0)] -> Builder

TextShow a => TextShow2 ((,,) a)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b -> Builder) -> ([b] -> Builder) -> Int -> (a, a0, b) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b -> Builder) -> ([b] -> Builder) -> [(a, a0, b)] -> Builder

(TextShow a, TextShow b) => TextShow (a, b)

Since: 2

Methods

showbPrec :: Int -> (a, b) -> Builder

showb :: (a, b) -> Builder

showbList :: [(a, b)] -> Builder

showtPrec :: Int -> (a, b) -> Text

showt :: (a, b) -> Text

showtList :: [(a, b)] -> Text

showtlPrec :: Int -> (a, b) -> Text

showtl :: (a, b) -> Text

showtlList :: [(a, b)] -> Text

(TextShow a, TextShow b) => TextShow1 ((,,) a b)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, a0)] -> Builder

(TextShow a, TextShow b) => TextShow2 ((,,,) a b)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c) => TextShow (a, b, c)

Since: 2

Methods

showbPrec :: Int -> (a, b, c) -> Builder

showb :: (a, b, c) -> Builder

showbList :: [(a, b, c)] -> Builder

showtPrec :: Int -> (a, b, c) -> Text

showt :: (a, b, c) -> Text

showtList :: [(a, b, c)] -> Text

showtlPrec :: Int -> (a, b, c) -> Text

showtl :: (a, b, c) -> Text

showtlList :: [(a, b, c)] -> Text

(TextShow a, TextShow b, TextShow c) => TextShow1 ((,,,) a b c)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, a0)] -> Builder

(TextShow a, TextShow b, TextShow c) => TextShow2 ((,,,,) a b c)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d) => TextShow (a, b, c, d)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d) -> Builder

showb :: (a, b, c, d) -> Builder

showbList :: [(a, b, c, d)] -> Builder

showtPrec :: Int -> (a, b, c, d) -> Text

showt :: (a, b, c, d) -> Text

showtList :: [(a, b, c, d)] -> Text

showtlPrec :: Int -> (a, b, c, d) -> Text

showtl :: (a, b, c, d) -> Text

showtlList :: [(a, b, c, d)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d) => TextShow1 ((,,,,) a b c d)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d) => TextShow2 ((,,,,,) a b c d)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e) => TextShow (a, b, c, d, e)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e) -> Builder

showb :: (a, b, c, d, e) -> Builder

showbList :: [(a, b, c, d, e)] -> Builder

showtPrec :: Int -> (a, b, c, d, e) -> Text

showt :: (a, b, c, d, e) -> Text

showtList :: [(a, b, c, d, e)] -> Text

showtlPrec :: Int -> (a, b, c, d, e) -> Text

showtl :: (a, b, c, d, e) -> Text

showtlList :: [(a, b, c, d, e)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e) => TextShow1 ((,,,,,) a b c d e)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e) => TextShow2 ((,,,,,,) a b c d e)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f) => TextShow (a, b, c, d, e, f)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f) -> Builder

showb :: (a, b, c, d, e, f) -> Builder

showbList :: [(a, b, c, d, e, f)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f) -> Text

showt :: (a, b, c, d, e, f) -> Text

showtList :: [(a, b, c, d, e, f)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f) -> Text

showtl :: (a, b, c, d, e, f) -> Text

showtlList :: [(a, b, c, d, e, f)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f) => TextShow1 ((,,,,,,) a b c d e f)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f) => TextShow2 ((,,,,,,,) a b c d e f)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g) => TextShow (a, b, c, d, e, f, g)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g) -> Builder

showb :: (a, b, c, d, e, f, g) -> Builder

showbList :: [(a, b, c, d, e, f, g)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g) -> Text

showt :: (a, b, c, d, e, f, g) -> Text

showtList :: [(a, b, c, d, e, f, g)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g) -> Text

showtl :: (a, b, c, d, e, f, g) -> Text

showtlList :: [(a, b, c, d, e, f, g)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g) => TextShow1 ((,,,,,,,) a b c d e f g)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g) => TextShow2 ((,,,,,,,,) a b c d e f g)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h) => TextShow (a, b, c, d, e, f, g, h)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h) -> Builder

showb :: (a, b, c, d, e, f, g, h) -> Builder

showbList :: [(a, b, c, d, e, f, g, h)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h) -> Text

showt :: (a, b, c, d, e, f, g, h) -> Text

showtList :: [(a, b, c, d, e, f, g, h)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h) -> Text

showtl :: (a, b, c, d, e, f, g, h) -> Text

showtlList :: [(a, b, c, d, e, f, g, h)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h) => TextShow1 ((,,,,,,,,) a b c d e f g h)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h) => TextShow2 ((,,,,,,,,,) a b c d e f g h)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, h, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i) => TextShow (a, b, c, d, e, f, g, h, i)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> Builder

showb :: (a, b, c, d, e, f, g, h, i) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> Text

showt :: (a, b, c, d, e, f, g, h, i) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i) -> Text

showtl :: (a, b, c, d, e, f, g, h, i) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i) => TextShow1 ((,,,,,,,,,) a b c d e f g h i)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i) => TextShow2 ((,,,,,,,,,,) a b c d e f g h i)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j) => TextShow (a, b, c, d, e, f, g, h, i, j)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> Builder

showb :: (a, b, c, d, e, f, g, h, i, j) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i, j)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> Text

showt :: (a, b, c, d, e, f, g, h, i, j) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i, j)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i, j) -> Text

showtl :: (a, b, c, d, e, f, g, h, i, j) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i, j)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j) => TextShow1 ((,,,,,,,,,,) a b c d e f g h i j)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j) => TextShow2 ((,,,,,,,,,,,) a b c d e f g h i j)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k) => TextShow (a, b, c, d, e, f, g, h, i, j, k)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> Builder

showb :: (a, b, c, d, e, f, g, h, i, j, k) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> Text

showt :: (a, b, c, d, e, f, g, h, i, j, k) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k) -> Text

showtl :: (a, b, c, d, e, f, g, h, i, j, k) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i, j, k)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k) => TextShow1 ((,,,,,,,,,,,) a b c d e f g h i j k)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k) => TextShow2 ((,,,,,,,,,,,,) a b c d e f g h i j k)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l) => TextShow (a, b, c, d, e, f, g, h, i, j, k, l)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Builder

showb :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Text

showt :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l) -> Text

showtl :: (a, b, c, d, e, f, g, h, i, j, k, l) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i, j, k, l)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l) => TextShow1 ((,,,,,,,,,,,,) a b c d e f g h i j k l)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, l, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l) => TextShow2 ((,,,,,,,,,,,,,) a b c d e f g h i j k l)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, l, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, l, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l, TextShow m) => TextShow (a, b, c, d, e, f, g, h, i, j, k, l, m)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Builder

showb :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Text

showt :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Text

showtl :: (a, b, c, d, e, f, g, h, i, j, k, l, m) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l, TextShow m) => TextShow1 ((,,,,,,,,,,,,,) a b c d e f g h i j k l m)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l, TextShow m) => TextShow2 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m)

Since: 2

Methods

liftShowbPrec2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0) -> Builder

liftShowbList2 :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> (Int -> b0 -> Builder) -> ([b0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, a0, b0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l, TextShow m, TextShow n) => TextShow (a, b, c, d, e, f, g, h, i, j, k, l, m, n)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Builder

showb :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Text

showt :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Text

showtl :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)] -> Text

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l, TextShow m, TextShow n) => TextShow1 ((,,,,,,,,,,,,,,) a b c d e f g h i j k l m n)

Since: 2

Methods

liftShowbPrec :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0) -> Builder

liftShowbList :: (Int -> a0 -> Builder) -> ([a0] -> Builder) -> [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, a0)] -> Builder

(TextShow a, TextShow b, TextShow c, TextShow d, TextShow e, TextShow f, TextShow g, TextShow h, TextShow i, TextShow j, TextShow k, TextShow l, TextShow m, TextShow n, TextShow o) => TextShow (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)

Since: 2

Methods

showbPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Builder

showb :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Builder

showbList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Builder

showtPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Text

showt :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Text

showtList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Text

showtlPrec :: Int -> (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Text

showtl :: (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o) -> Text

showtlList :: [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)] -> Text