An n-ary product.

The product is parameterized by a type constructor f and indexed by a type-level list xs. The length of the list determines the number of elements in the product, and if the i-th element of the list is of type x, then the i-th element of the product is of type f x.

The constructor names are chosen to resemble the names of the list constructors.

Two common instantiations of f are the identity functor I and the constant functor K. For I, the product becomes a heterogeneous list, where the type-level list describes the types of its components. For K a, the product becomes a homogeneous list, where the contents of the type-level list are ignored, but its length still specifies the number of elements.

In the context of the SOP approach to generic programming, an n-ary product describes the structure of the arguments of a single data constructor.

Examples:

I 'x'    :* I True  :* Nil  ::  NP I       '[ Char, Bool ]
K 0      :* K 1     :* Nil  ::  NP (K Int) '[ Char, Bool ]
Just 'x' :* Nothing :* Nil  ::  NP Maybe   '[ Char, Bool ]

A product of products.

This is a 'newtype' for an NP of an NP. The elements of the inner products are applications of the parameter f. The type POP is indexed by the list of lists that determines the lengths of both the outer and all the inner products, as well as the types of all the elements of the inner products.

A POP is reminiscent of a two-dimensional table (but the inner lists can all be of different length). In the context of the SOP approach to generic programming, a POP is useful to represent information that is available for all arguments of all constructors of a datatype.

Unwrap a product of products.

Specialization of hpure.

The call pure_NP x generates a product that contains x in every element position.

Example:

>>> pure_NP [] :: NP [] '[Char, Bool]
"" :* [] :* Nil
>>> pure_NP (K 0) :: NP (K Int) '[Double, Int, String]
K 0 :* K 0 :* K 0 :* Nil

Specialization of hpure.

The call pure_POP x generates a product of products that contains x in every element position.

Specialization of hcpure.

The call cpure_NP p x generates a product that contains x in every element position.

Specialization of hcpure.

The call cpure_NP p x generates a product of products that contains x in every element position.

Construct a homogeneous n-ary product from a normal Haskell list.

Returns Nothing if the length of the list does not exactly match the expected size of the product.

Specialization of hap.

Applies a product of (lifted) functions pointwise to a product of suitable arguments.

Specialization of hap.

Applies a product of (lifted) functions pointwise to a product of suitable arguments.

Obtain the head of an n-ary product.

Since: 0.2.1.0

Obtain the tail of an n-ary product.

Since: 0.2.1.0

The type of projections from an n-ary product.

Compute all projections from an n-ary product.

Each element of the resulting product contains one of the projections.

Specialization of hliftA.

Specialization of hliftA.

Specialization of hliftA2.

Specialization of hliftA2.

Specialization of hliftA3.

Specialization of hliftA3.

Specialization of hmap, which is equivalent to hliftA.

Specialization of hmap, which is equivalent to hliftA.

Specialization of hzipWith, which is equivalent to hliftA2.

Specialization of hzipWith, which is equivalent to hliftA2.

Specialization of hzipWith3, which is equivalent to hliftA3.

Specialization of hzipWith3, which is equivalent to hliftA3.

Specialization of hcliftA.

Specialization of hcliftA.

Specialization of hcliftA2.

Specialization of hcliftA2.

Specialization of hcliftA3.

Specialization of hcliftA3.

Specialization of hcmap, which is equivalent to hcliftA.

Specialization of hcmap, which is equivalent to hcliftA.

Specialization of hczipWith, which is equivalent to hcliftA2.

Specialization of hczipWith, which is equivalent to hcliftA2.

Specialization of hczipWith3, which is equivalent to hcliftA3.

Specialization of hczipWith3, which is equivalent to hcliftA3.

Lift a constrained function operating on a list-indexed structure to a function on a list-of-list-indexed structure.

This is a variant of hcliftA.

Specification:

hcliftA' p f xs = hpure (fn_2 $ \ AllDictC -> f) ` hap ` allDict_NP p ` hap ` xs

Instances:

hcliftA' :: All2 c xss => proxy c -> (forall xs. All c xs => f xs -> f' xs) -> NP f xss -> NP f' xss
hcliftA' :: All2 c xss => proxy c -> (forall xs. All c xs => f xs -> f' xs) -> NS f xss -> NS f' xss

Like hcliftA', but for binary functions.

Like hcliftA', but for ternay functions.

Specialization of hcliftA2'.

Specialization of hcollapse.

Example:

>>> collapse_NP (K 1 :* K 2 :* K 3 :* Nil)
[1,2,3]

Specialization of hcollapse.

Example:

>>> collapse_POP (POP ((K 'a' :* Nil) :* (K 'b' :* K 'c' :* Nil) :* Nil) :: POP (K Char) '[ '[(a :: *)], '[b, c] ])
["a", "bc"]

(The type signature is only necessary in this case to fix the kind of the type variables.)

Specialization of hsequence'.

Specialization of hsequence'.

Specialization of hsequence.

Example:

>>> sequence_NP (Just 1 :* Just 2 :* Nil)
Just (I 1 :* I 2 :* Nil)

Specialization of hsequence.

Example:

>>> sequence_POP (POP ((Just 1 :* Nil) :* (Just 2 :* Just 3 :* Nil) :* Nil))
Just (POP ((I 1 :* Nil) :* ((I 2 :* (I 3 :* Nil)) :* Nil)))

Catamorphism for NP.

This is a suitable generalization of foldr. It takes parameters on what to do for Nil and :*. Since the input list is heterogeneous, the result is also indexed by a type-level list.

Since: 0.2.3.0

Constrained catamorphism for NP.

The difference compared to cata_NP is that the function for the cons-case can make use of the fact that the specified constraint holds for all the types in the signature of the product.

Since: 0.2.3.0

Anamorphism for NP.

In contrast to the anamorphism for normal lists, the generating function does not return an Either, but simply an element and a new seed value.

This is because the decision on whether to generate a Nil or a :* is determined by the types.

Since: 0.2.3.0

Constrained anamorphism for NP.

Compared to ana_NP, the generating function can make use of the specified constraint here for the elements that it generates.

Since: 0.2.3.0

Specialization of htrans.

Since: 0.3.1.0

Specialization of htrans.

Since: 0.3.1.0

Specialization of hcoerce.

Since: 0.3.1.0

Specialization of hcoerce.

Since: 0.3.1.0

Specialization of hfromI.

Since: 0.3.1.0

Specialization of hfromI.

Since: 0.3.1.0

Specialization of htoI.

Since: 0.3.1.0

Specialization of htoI.

Since: 0.3.1.0