TextShow.Data.Tuple

TextShow instances for tuple types.

Since: 2

Orphan instances

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 ()

Since: 2

Methods

showbPrec :: Int -> () -> Builder

showb :: () -> Builder

showbList :: [()] -> Builder

showtPrec :: Int -> () -> Text

showt :: () -> Text

showtList :: [()] -> Text

showtlPrec :: Int -> () -> Text

showtl :: () -> Text

showtlList :: [()] -> Text

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 => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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) => 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) => 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, 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 (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, 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