Copyright	(c) Fumiaki Kinoshita 2015
License	BSD3
Maintainer	Fumiaki Kinoshita <[email protected]>
Stability	experimental
Portability	non-portable
Safe Haskell	None
Language	Haskell2010

Data.Extensible.Product

Contents

Basic operations
Lookup
Generation

Description

Synopsis

Basic operations

data h :* s where Source

The type of extensible products.

Constructors

Nil :: h :* []
Tree :: !(h x) -> (h :* Half xs) -> (h :* Half (Tail xs)) -> h :* (x : xs)

Instances

Typeable ((k -> ) -> [k] -> ) ((:*) k)
WrapForall k * Eq h xs => Eq ((:*) k h xs)
(Eq ((:) k h xs), WrapForall k Ord h xs) => Ord ((:*) k h xs)
WrapForall k * Show h xs => Show ((:*) k h xs)
WrapForall k * Monoid h xs => Monoid ((:*) k h xs)
WrapForall k * Binary h xs => Binary ((:*) k h xs)

(<:) :: h x -> (h :* xs) -> h :* (x : xs) infixr 0 Source

O(log n) Add an element to a product.

(<:*) :: forall h x xs. h x -> (h :* xs) -> h :* (x : xs) infixr 0 Source

An alias for (<:).

(*++*) :: (h :* xs) -> (h :* ys) -> h :* (xs ++ ys) infixr 0 Source

Combine products.

hhead :: (h :* (x : xs)) -> h x Source

O(1) Extract the head element.

htail :: (h :* (x : xs)) -> h :* xs Source

O(n) Extract the tail of the product. FIXME: unsafeCoerce

huncons :: forall h x xs. (h :* (x : xs)) -> (h x, h :* xs) Source

Split a product to the head and the tail.

hmap :: (forall x. g x -> h x) -> (g :* xs) -> h :* xs Source

Transform every elements in a product, preserving the order.

hmap id ≡ id
hmap (f . g) ≡ hmap f . hmap g

hmapWithIndex :: forall g h xs. (forall x. Membership xs x -> g x -> h x) -> (g :* xs) -> h :* xs Source

hmap with its indices.

htrans :: (forall x. g x -> h (t x)) -> (g :* xs) -> h :* Map t xs Source

Transform every elements in a product, preserving the order.

hzipWith :: (forall x. f x -> g x -> h x) -> (f :* xs) -> (g :* xs) -> h :* xs Source

zipWith for heterogeneous product

hzipWith3 :: (forall x. f x -> g x -> h x -> i x) -> (f :* xs) -> (g :* xs) -> (h :* xs) -> i :* xs Source

zipWith3 for heterogeneous product

hfoldMap :: Monoid a => (forall x. h x -> a) -> (h :* xs) -> a Source

Map elements to a monoid and combine the results.

hfoldMap f . hmap g ≡ hfoldMap (f . g)

htraverse :: Applicative f => (forall x. g x -> f (h x)) -> (g :* xs) -> f (h :* xs) Source

Traverse all elements and combine the result sequentially. htraverse (fmap f . g) ≡ fmap (hmap f) . htraverse g htraverse pure ≡ pure htraverse (Comp . fmap g . f) ≡ Comp . fmap (htraverse g) . htraverse f

hsequence :: Applicative f => (Comp f h :* xs) -> f (h :* xs) Source

sequence analog for extensible products

hcollect :: (Functor f, Generate xs) => (a -> h :* xs) -> f a -> Comp f h :* xs Source

The dual of htraverse

hdistribute :: (Functor f, Generate xs) => f (h :* xs) -> Comp f h :* xs Source

The dual of hsequence

Lookup

hlookup :: Membership xs x -> (h :* xs) -> h x Source

O(log n) Pick up an elemtnt.

hindex :: (h :* xs) -> Membership xs x -> h x Source

Flipped hlookup

sector :: x ∈ xs => Lens' (h :* xs) (h x) Source

O(log n) A lens for a specific element.

sectorAssoc :: Associate k v xs => Lens' (h :* xs) (h (k :> v)) Source

O(log n) A lens for a specific element.

sectorAt :: forall f h x xs. Functor f => Membership xs x -> (h x -> f (h x)) -> (h :* xs) -> f (h :* xs) Source

O(log n) A lens for a value in a known position.

Generation

class Generate xs where Source

Given a function that maps types to values, we can "collect" entities all you want.

Methods

hgenerate :: Applicative f => (forall x. Membership xs x -> f (h x)) -> f (h :* xs) Source

O(n) htabulates a product with the given function.

Instances

Generate k ([] k)
(Generate k (Half k xs), Generate k (Half k (Tail k xs))) => Generate k ((:) k x xs)

htabulate :: Generate xs => (forall x. Membership xs x -> h x) -> h :* xs Source

Pure version of hgenerate.

hmap f (htabulate g) ≡ htabulate (f . g)
htabulate (hindex m) ≡ m
hindex (htabulate k) ≡ k

class Forall c xs where Source

Guarantees the all elements satisfies the predicate.

Methods

hgenerateFor :: Applicative f => proxy c -> (forall x. c x => Membership xs x -> f (h x)) -> f (h :* xs) Source

O(n) Analogous to htabulate, but it also supplies a context c x for every elements in xs.

Instances

Forall k c ([] k)
(c x, Forall k c (Half k xs), Forall k c (Half k (Tail k xs))) => Forall k c ((:) k x xs)

htabulateFor :: Forall c xs => proxy c -> (forall x. c x => Membership xs x -> h x) -> h :* xs Source

Pure version of hgenerateFor.