Servant.Checked.Exceptions.Internal.Product

This module defines an open product type. This is used in the case-analysis handler for the open sum type.

Documentation

>>> -- :set -XDataKinds

data Product f as where

An extensible product type. This is similar to Union, except a product type instead of a sum type.

Constructors

Nil :: Product f '[]

Cons :: !(f a) -> Product f as -> Product f (a ': as)

Instances

(Show (f a1), Show (Product a f as)) => Show (Product a f ((:) a a1 as))

Methods

showsPrec :: Int -> Product a f ((a ': a1) as) -> ShowS

show :: Product a f ((a ': a1) as) -> String

showList :: [Product a f ((a ': a1) as)] -> ShowS

Show (Product u f ([] u))

Methods

showsPrec :: Int -> Product u f [u] -> ShowS

show :: Product u f [u] -> String

showList :: [Product u f [u]] -> ShowS

class ToProduct tuple f as | f as -> tuple where

This type class provides a way to turn a tuple into a Product.

Minimal complete definition

toProduct

Methods

toProduct :: tuple -> Product f as

Instances

ToProduct u (f a) f ((:) u a ([] u))

Methods

toProduct :: f -> Product (f a) ((u ': a) [u]) as

ToProduct u (f a, f b) f ((:) u a ((:) u b ([] u)))

Methods

toProduct :: f -> Product (f a, f b) ((u ': a) ((u ': b) [u])) as

ToProduct u (f a, f b, f c) f ((:) u a ((:) u b ((:) u c ([] u))))

Methods

toProduct :: f -> Product (f a, f b, f c) ((u ': a) ((u ': b) ((u ': c) [u]))) as

ToProduct u (f a, f b, f c, f d) f ((:) u a ((:) u b ((:) u c ((:) u d ([] u)))))

Methods

toProduct :: f -> Product (f a, f b, f c, f d) ((u ': a) ((u ': b) ((u ': c) ((u ': d) [u])))) as

tupleToProduct :: ToProduct t f as => t -> Product f as

Turn a tuple into a Product.

>>> tupleToProduct (Identity 1, Identity 2.0) :: Product Identity '[Int, Double]
Cons (Identity 1) (Cons (Identity 2.0) Nil)

type OpenProduct = Product Identity

Product Identity is used as a standard open product type.

class ToOpenProduct tuple as | as -> tuple where

ToOpenProduct gives us a way to convert a tuple to an OpenProduct. See tupleToOpenProduct.

Minimal complete definition

toOpenProduct

Methods

toOpenProduct :: tuple -> OpenProduct as

Instances

ToOpenProduct a ((:) * a ([] *))

Methods

toOpenProduct :: a -> OpenProduct ((* ': a) [*])

ToOpenProduct (a, b) ((:) * a ((:) * b ([] *)))

Methods

toOpenProduct :: (a, b) -> OpenProduct ((* ': a) ((* ': b) [*]))

ToOpenProduct (a, b, c) ((:) * a ((:) * b ((:) * c ([] *))))

Methods

toOpenProduct :: (a, b, c) -> OpenProduct ((* ': a) ((* ': b) ((* ': c) [*])))

ToOpenProduct (a, b, c, d) ((:) * a ((:) * b ((:) * c ((:) * d ([] *)))))

Methods

toOpenProduct :: (a, b, c, d) -> OpenProduct ((* ': a) ((* ': b) ((* ': c) ((* ': d) [*]))))

tupleToOpenProduct :: ToOpenProduct t as => t -> OpenProduct as

Turn a tuple into an OpenProduct.

For example, turn a triple into an OpenProduct:

>>> tupleToOpenProduct (1, 2.0, "hello") :: OpenProduct '[Int, Double, String]
Cons (Identity 1) (Cons (Identity 2.0) (Cons (Identity "hello") Nil))

Turn a single value into an OpenProduct:

>>> tupleToOpenProduct 'c' :: OpenProduct '[Char]
Cons (Identity 'c') Nil