Data.WorldPeace.Product

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

Documentation

>>> -- :set -XDataKinds

data Product (f :: u -> *) (as :: [u]) 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 a2), Show (Product f as)) => Show (Product f (a2 ': as))

Show Cons values.

Defined in Data.WorldPeace.Product

Methods

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

show :: Product f (a2 ': as) -> String

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

Show (Product f ([] :: [u]))

Show Nil values.

Defined in Data.WorldPeace.Product

Methods

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

show :: Product f [] -> String

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

class ToProduct (tuple :: *) (f :: u -> *) (as :: [u]) | f as -> tuple where

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

Methods

toProduct :: tuple -> Product f as

Convert a tuple into a Product. See tupleToProduct for examples.

Instances

ToProduct (f a) (f :: u -> Type) (a ': ([] :: [u]) :: [u])

Convert a single value into a Product.

Defined in Data.WorldPeace.Product

Methods

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

ToProduct (f a, f b) (f :: u -> Type) (a ': (b ': ([] :: [u])) :: [u])

Convert a tuple into a Product.

Defined in Data.WorldPeace.Product

Methods

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

ToProduct (f a, f b, f c) (f :: u -> Type) (a ': (b ': (c ': ([] :: [u]))) :: [u])

Convert a 3-tuple into a Product.

Defined in Data.WorldPeace.Product

Methods

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

ToProduct (f a, f b, f c, f d) (f :: u -> Type) (a ': (b ': (c ': (d ': ([] :: [u])))) :: [u])

Convert a 4-tuple into a Product.

Defined in Data.WorldPeace.Product

Methods

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

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.

Methods

toOpenProduct :: tuple -> OpenProduct as

Instances

ToOpenProduct a (a ': ([] :: [Type]))

Convert a single value into an OpenProduct.

Defined in Data.WorldPeace.Product

Methods

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

ToOpenProduct (a, b) (a ': (b ': ([] :: [Type])))

Convert a tuple into an OpenProduct.

Defined in Data.WorldPeace.Product

Methods

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

ToOpenProduct (a, b, c) (a ': (b ': (c ': ([] :: [Type]))))

Convert a 3-tuple into an OpenProduct.

Defined in Data.WorldPeace.Product

Methods

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

ToOpenProduct (a, b, c, d) (a ': (b ': (c ': (d ': ([] :: [Type])))))

Convert a 4-tuple into an OpenProduct.

Defined in Data.WorldPeace.Product

Methods

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

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

Turn a tuple into an OpenProduct.

Examples

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