sop-core-0.5.0.2: True Sums of Products

Safe Haskell | None
Language | Haskell2010

Data.SOP.Classes

Contents

- Generalized applicative functor structure
  - Generalized `pure`
  - Generalized `<*>`
  - Derived functions
- Collapsing homogeneous structures
- Folding and sequencing
  - Derived functions
- Indexing into sums
- Applying all injections
- Expanding sums to products
- Transformation of index lists and coercions

Description

Classes for generalized combinators on SOP types.

In the SOP approach to generic programming, we're predominantly concerned with four structured datatypes:

      NP  :: (k -> Type) -> ( [k]  -> Type)   -- n-ary product
      NS  :: (k -> Type) -> ( [k]  -> Type)   -- n-ary sum
      POP :: (k -> Type) -> ([[k]] -> Type)   -- product of products
      SOP :: (k -> Type) -> ([[k]] -> Type)   -- sum of products

All of these have a kind that fits the following pattern:

      (k -> Type) -> (l -> Type)

These four types support similar interfaces. In order to allow reusing the same combinator names for all of these types, we define various classes in this module that allow the necessary generalization.

The classes typically lift concepts that exist for kinds ``Type`` or ``Type` -> `Type`` to datatypes of kind `(k -> `Type`) -> (l -> `Type`)`. This module also derives a number of derived combinators.

The actual instances are defined in Data.SOP.NP and Data.SOP.NS.

Synopsis

- class HPure (h :: (k -> Type) -> l -> Type) where
  - hpure :: forall (xs :: l) f. SListIN h xs => (forall (a :: k). f a) -> h f xs
  - hcpure :: forall c (xs :: l) proxy f. AllN h c xs => proxy c -> (forall (a :: k). c a => f a) -> h f xs
- newtype ((f :: k -> Type) -.-> (g :: k -> Type)) (a :: k) = Fn {
  - apFn :: f a -> g a
  }
- fn :: forall {k} f (a :: k) f'. (f a -> f' a) -> (f -.-> f') a
- fn_2 :: forall {k} f (a :: k) f' f''. (f a -> f' a -> f'' a) -> (f -.-> (f' -.-> f'')) a
- fn_3 :: forall {k} f (a :: k) f' f'' f'''. (f a -> f' a -> f'' a -> f''' a) -> (f -.-> (f' -.-> (f'' -.-> f'''))) a
- fn_4 :: forall {k} f (a :: k) f' f'' f''' f''''. (f a -> f' a -> f'' a -> f''' a -> f'''' a) -> (f -.-> (f' -.-> (f'' -.-> (f''' -.-> f'''')))) a
- type family Same (h :: (k1 -> Type) -> l1 -> Type) :: (k2 -> Type) -> l2 -> Type
- type family Prod (h :: (k -> Type) -> l -> Type) :: (k -> Type) -> l -> Type
- class (Prod (Prod h) ~ Prod h, HPure (Prod h)) => HAp (h :: (k -> Type) -> l -> Type) where
  - hap :: forall (f :: k -> Type) (g :: k -> Type) (xs :: l). Prod h (f -.-> g) xs -> h f xs -> h g xs
- hliftA :: forall {k} {l} h (xs :: l) f f'. (SListIN (Prod h) xs, HAp h) => (forall (a :: k). f a -> f' a) -> h f xs -> h f' xs
- hliftA2 :: forall {k} {l} h (xs :: l) f f' f''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hliftA3 :: forall {k} {l} h (xs :: l) f f' f'' f'''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs
- hmap :: forall {k} {l} h (xs :: l) f f'. (SListIN (Prod h) xs, HAp h) => (forall (a :: k). f a -> f' a) -> h f xs -> h f' xs
- hzipWith :: forall {k} {l} h (xs :: l) f f' f''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hzipWith3 :: forall {k} {l} h (xs :: l) f f' f'' f'''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs
- hcliftA :: forall {k} {l} h c (xs :: l) proxy f f'. (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs
- hcliftA2 :: forall {k} {l} h c (xs :: l) proxy f f' f''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hcliftA3 :: forall {k} {l} h c (xs :: l) proxy f f' f'' f'''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs
- hcmap :: forall {k} {l} h c (xs :: l) proxy f f'. (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs
- hczipWith :: forall {k} {l} h c (xs :: l) proxy f f' f''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hczipWith3 :: forall {k} {l} h c (xs :: l) proxy f f' f'' f'''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs
- type family CollapseTo (h :: (k -> Type) -> l -> Type) x
- class HCollapse (h :: (k -> Type) -> l -> Type) where
  - hcollapse :: forall (xs :: l) a. SListIN h xs => h (K a :: k -> Type) xs -> CollapseTo h a
- class HTraverse_ (h :: (k -> Type) -> l -> Type) where
  - hctraverse_ :: forall c (xs :: l) g proxy f. (AllN h c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> h f xs -> g ()
  - htraverse_ :: forall (xs :: l) g f. (SListIN h xs, Applicative g) => (forall (a :: k). f a -> g ()) -> h f xs -> g ()
- class HAp h => HSequence (h :: (k -> Type) -> l -> Type) where
  - hsequence' :: forall (xs :: l) f (g :: k -> Type). (SListIN h xs, Applicative f) => h (f :.: g) xs -> f (h g xs)
  - hctraverse' :: forall c (xs :: l) g proxy f f'. (AllN h c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> h f xs -> g (h f' xs)
  - htraverse' :: forall (xs :: l) g f f'. (SListIN h xs, Applicative g) => (forall (a :: k). f a -> g (f' a)) -> h f xs -> g (h f' xs)
- hcfoldMap :: forall {k} {l} h c (xs :: l) m proxy f. (HTraverse_ h, AllN h c xs, Monoid m) => proxy c -> (forall (a :: k). c a => f a -> m) -> h f xs -> m
- hcfor_ :: forall {k} {l} h c (xs :: l) g proxy f. (HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> h f xs -> (forall (a :: k). c a => f a -> g ()) -> g ()
- hsequence :: forall {l} h (xs :: l) f. (SListIN h xs, SListIN (Prod h) xs, HSequence h, Applicative f) => h f xs -> f (h I xs)
- hsequenceK :: forall {k} {l} h (xs :: l) f a. (SListIN h xs, SListIN (Prod h) xs, Applicative f, HSequence h) => h (K (f a) :: k -> Type) xs -> f (h (K a :: k -> Type) xs)
- hctraverse :: forall {l} h c (xs :: l) g proxy f. (HSequence h, AllN h c xs, Applicative g) => proxy c -> (forall a. c a => f a -> g a) -> h f xs -> g (h I xs)
- hcfor :: forall {l} h c (xs :: l) g proxy f. (HSequence h, AllN h c xs, Applicative g) => proxy c -> h f xs -> (forall a. c a => f a -> g a) -> g (h I xs)
- class HIndex (h :: (k -> Type) -> l -> Type) where
  - hindex :: forall (f :: k -> Type) (xs :: l). h f xs -> Int
- type family UnProd (h :: (k -> Type) -> l -> Type) :: (k -> Type) -> l -> Type
- class UnProd (Prod h) ~ h => HApInjs (h :: (k -> Type) -> l -> Type) where
  - hapInjs :: forall (xs :: l) (f :: k -> Type). SListIN h xs => Prod h f xs -> [h f xs]
- class HExpand (h :: (k -> Type) -> l -> Type) where
  - hexpand :: forall (xs :: l) f. SListIN (Prod h) xs => (forall (x :: k). f x) -> h f xs -> Prod h f xs
  - hcexpand :: forall c (xs :: l) proxy f. AllN (Prod h) c xs => proxy c -> (forall (x :: k). c x => f x) -> h f xs -> Prod h f xs
- class ((Same h1 :: (k2 -> Type) -> l2 -> Type) ~ h2, (Same h2 :: (k1 -> Type) -> l1 -> Type) ~ h1) => HTrans (h1 :: (k1 -> Type) -> l1 -> Type) (h2 :: (k2 -> Type) -> l2 -> Type) where
  - htrans :: forall c (xs :: l1) (ys :: l2) proxy f g. AllZipN (Prod h1) c xs ys => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> h1 f xs -> h2 g ys
  - hcoerce :: forall (f :: k1 -> Type) (g :: k2 -> Type) (xs :: l1) (ys :: l2). AllZipN (Prod h1) (LiftedCoercible f g) xs ys => h1 f xs -> h2 g ys
- hfromI :: forall {l1} {k2} {l2} h1 (f :: k2 -> Type) (xs :: l1) (ys :: l2) h2. (AllZipN (Prod h1) (LiftedCoercible I f) xs ys, HTrans h1 h2) => h1 I xs -> h2 f ys
- htoI :: forall {k1} {l1} {l2} h1 (f :: k1 -> Type) (xs :: l1) (ys :: l2) h2. (AllZipN (Prod h1) (LiftedCoercible f I) xs ys, HTrans h1 h2) => h1 f xs -> h2 I ys

# Generalized applicative functor structure

## Generalized `pure`

class HPure (h :: (k -> Type) -> l -> Type) where #

A generalization of `pure` or `return` to higher kinds.

Methods

hpure :: forall (xs :: l) f. SListIN h xs => (forall (a :: k). f a) -> h f xs #

Corresponds to `pure` directly.

Instances:

    hpure, pure_NP  :: SListI  xs  => (forall a. f a) -> NP  f xs
    hpure, pure_POP :: SListI2 xss => (forall a. f a) -> POP f xss

hcpure :: forall c (xs :: l) proxy f. AllN h c xs => proxy c -> (forall (a :: k). c a => f a) -> h f xs #

A variant of `hpure` that allows passing in a constrained argument.

Calling ``hcpure` f s` where `s :: h f xs` causes `f` to be applied at all the types that are contained in `xs`. Therefore, the constraint `c` has to be satisfied for all elements of `xs`, which is what ``AllN` h c xs` states.

Instances:

    hcpure, cpure_NP  :: (All  c xs ) => proxy c -> (forall a. c a => f a) -> NP  f xs
    hcpure, cpure_POP :: (All2 c xss) => proxy c -> (forall a. c a => f a) -> POP f xss

#### Instances

Instances details

HPure (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hpure :: forall (xs :: [[k]]) f. SListIN (POP :: (k -> Type) -> [[k]] -> Type) xs => (forall (a :: k). f a) -> POP f xs # hcpure :: forall c (xs :: [[k]]) proxy f. AllN (POP :: (k -> Type) -> [[k]] -> Type) c xs => proxy c -> (forall (a :: k). c a => f a) -> POP f xs #
HPure (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hpure :: forall (xs :: [k]) f. SListIN (NP :: (k -> Type) -> [k] -> Type) xs => (forall (a :: k). f a) -> NP f xs # hcpure :: forall c (xs :: [k]) proxy f. AllN (NP :: (k -> Type) -> [k] -> Type) c xs => proxy c -> (forall (a :: k). c a => f a) -> NP f xs #

## Generalized `<*>`

newtype ((f :: k -> Type) -.-> (g :: k -> Type)) (a :: k) infixr 1 #

Lifted functions.

Constructors

Fn |
Fields apFn :: f a -> g a

fn :: forall {k} f (a :: k) f'. (f a -> f' a) -> (f -.-> f') a #

Construct a lifted function.

Same as `Fn`. Only available for uniformity with the higher-arity versions.

fn_2 :: forall {k} f (a :: k) f' f''. (f a -> f' a -> f'' a) -> (f -.-> (f' -.-> f'')) a #

Construct a binary lifted function.

fn_3 :: forall {k} f (a :: k) f' f'' f'''. (f a -> f' a -> f'' a -> f''' a) -> (f -.-> (f' -.-> (f'' -.-> f'''))) a #

Construct a ternary lifted function.

fn_4 :: forall {k} f (a :: k) f' f'' f''' f''''. (f a -> f' a -> f'' a -> f''' a -> f'''' a) -> (f -.-> (f' -.-> (f'' -.-> (f''' -.-> f'''')))) a #

Construct a quarternary lifted function.

type family Same (h :: (k1 -> Type) -> l1 -> Type) :: (k2 -> Type) -> l2 -> Type #

Maps a structure to the same structure.

#### Instances

Instances details

type Same (POP :: (k1 -> Type) -> [[k1]] -> Type) # |
Instance details Defined in Data.SOP.NP type Same (POP :: (k1 -> Type) -> [[k1]] -> Type) = POP :: (k2 -> Type) -> [[k2]] -> Type
type Same (SOP :: (k1 -> Type) -> [[k1]] -> Type) # |
Instance details Defined in Data.SOP.NS type Same (SOP :: (k1 -> Type) -> [[k1]] -> Type) = SOP :: (k2 -> Type) -> [[k2]] -> Type
type Same (NP :: (k1 -> Type) -> [k1] -> Type) # |
Instance details Defined in Data.SOP.NP type Same (NP :: (k1 -> Type) -> [k1] -> Type) = NP :: (k2 -> Type) -> [k2] -> Type
type Same (NS :: (k1 -> Type) -> [k1] -> Type) # |
Instance details Defined in Data.SOP.NS type Same (NS :: (k1 -> Type) -> [k1] -> Type) = NS :: (k2 -> Type) -> [k2] -> Type

type family Prod (h :: (k -> Type) -> l -> Type) :: (k -> Type) -> l -> Type #

Maps a structure containing sums to the corresponding product structure.

#### Instances

Instances details

type Prod (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NP type Prod (POP :: (k -> Type) -> [[k]] -> Type) = POP :: (k -> Type) -> [[k]] -> Type
type Prod (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS type Prod (SOP :: (k -> Type) -> [[k]] -> Type) = POP :: (k -> Type) -> [[k]] -> Type
type Prod (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NP type Prod (NP :: (k -> Type) -> [k] -> Type) = NP :: (k -> Type) -> [k] -> Type
type Prod (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS type Prod (NS :: (k -> Type) -> [k] -> Type) = NP :: (k -> Type) -> [k] -> Type

class (Prod (Prod h) ~ Prod h, HPure (Prod h)) => HAp (h :: (k -> Type) -> l -> Type) where #

A generalization of `<*>`.

Methods

hap :: forall (f :: k -> Type) (g :: k -> Type) (xs :: l). Prod h (f -.-> g) xs -> h f xs -> h g xs #

Corresponds to `<*>`.

For products (`NP`) as well as products of products (`POP`), the correspondence is rather direct. We combine a structure containing (lifted) functions and a compatible structure containing corresponding arguments into a compatible structure containing results.

The same combinator can also be used to combine a product structure of functions with a sum structure of arguments, which then results in another sum structure of results. The sum structure determines which part of the product structure will be used.

Instances:

    hap, ap_NP  :: NP  (f -.-> g) xs  -> NP  f xs  -> NP  g xs
    hap, ap_NS  :: NP  (f -.-> g) xs  -> NS  f xs  -> NS  g xs
    hap, ap_POP :: POP (f -.-> g) xss -> POP f xss -> POP g xss
    hap, ap_SOP :: POP (f -.-> g) xss -> SOP f xss -> SOP g xss

#### Instances

Instances details

HAp (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hap :: forall (f :: k -> Type) (g :: k -> Type) (xs :: [[k]]). Prod (POP :: (k -> Type) -> [[k]] -> Type) (f -.-> g) xs -> POP f xs -> POP g xs #
HAp (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hap :: forall (f :: k -> Type) (g :: k -> Type) (xs :: [[k]]). Prod (SOP :: (k -> Type) -> [[k]] -> Type) (f -.-> g) xs -> SOP f xs -> SOP g xs #
HAp (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hap :: forall (f :: k -> Type) (g :: k -> Type) (xs :: [k]). Prod (NP :: (k -> Type) -> [k] -> Type) (f -.-> g) xs -> NP f xs -> NP g xs #
HAp (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hap :: forall (f :: k -> Type) (g :: k -> Type) (xs :: [k]). Prod (NS :: (k -> Type) -> [k] -> Type) (f -.-> g) xs -> NS f xs -> NS g xs #

## Derived functions

hliftA :: forall {k} {l} h (xs :: l) f f'. (SListIN (Prod h) xs, HAp h) => (forall (a :: k). f a -> f' a) -> h f xs -> h f' xs #

A generalized form of `liftA`, which in turn is a generalized `map`.

Takes a lifted function and applies it to every element of a structure while preserving its shape.

Specification:

    hliftA f xs = hpure (fn f) ` hap ` xs

Instances:

    hliftA, liftA_NP  :: SListI  xs  => (forall a. f a -> f' a) -> NP  f xs  -> NP  f' xs
    hliftA, liftA_NS  :: SListI  xs  => (forall a. f a -> f' a) -> NS  f xs  -> NS  f' xs
    hliftA, liftA_POP :: SListI2 xss => (forall a. f a -> f' a) -> POP f xss -> POP f' xss
    hliftA, liftA_SOP :: SListI2 xss => (forall a. f a -> f' a) -> SOP f xss -> SOP f' xss

hliftA2 :: forall {k} {l} h (xs :: l) f f' f''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs #

A generalized form of `liftA2`, which in turn is a generalized `zipWith`.

Takes a lifted binary function and uses it to combine two structures of equal shape into a single structure.

It either takes two product structures to a product structure, or one product and one sum structure to a sum structure.

Specification:

    hliftA2 f xs ys = hpure (fn_2 f) ` hap ` xs ` hap ` ys

Instances:

    hliftA2, liftA2_NP  :: SListI  xs  => (forall a. f a -> f' a -> f'' a) -> NP  f xs  -> NP  f' xs  -> NP  f'' xs
    hliftA2, liftA2_NS  :: SListI  xs  => (forall a. f a -> f' a -> f'' a) -> NP  f xs  -> NS  f' xs  -> NS  f'' xs
    hliftA2, liftA2_POP :: SListI2 xss => (forall a. f a -> f' a -> f'' a) -> POP f xss -> POP f' xss -> POP f'' xss
    hliftA2, liftA2_SOP :: SListI2 xss => (forall a. f a -> f' a -> f'' a) -> POP f xss -> SOP f' xss -> SOP f'' xss

hliftA3 :: forall {k} {l} h (xs :: l) f f' f'' f'''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs #

A generalized form of `liftA3`, which in turn is a generalized `zipWith3`.

Takes a lifted ternary function and uses it to combine three structures of equal shape into a single structure.

It either takes three product structures to a product structure, or two product structures and one sum structure to a sum structure.

Specification:

    hliftA3 f xs ys zs = hpure (fn_3 f) ` hap ` xs ` hap ` ys ` hap ` zs

Instances:

    hliftA3, liftA3_NP  :: SListI  xs  => (forall a. f a -> f' a -> f'' a -> f''' a) -> NP  f xs  -> NP  f' xs  -> NP  f'' xs  -> NP  f''' xs
    hliftA3, liftA3_NS  :: SListI  xs  => (forall a. f a -> f' a -> f'' a -> f''' a) -> NP  f xs  -> NP  f' xs  -> NS  f'' xs  -> NS  f''' xs
    hliftA3, liftA3_POP :: SListI2 xss => (forall a. f a -> f' a -> f'' a -> f''' a) -> POP f xss -> POP f' xss -> POP f'' xss -> POP f''' xs
    hliftA3, liftA3_SOP :: SListI2 xss => (forall a. f a -> f' a -> f'' a -> f''' a) -> POP f xss -> POP f' xss -> SOP f'' xss -> SOP f''' xs

hmap :: forall {k} {l} h (xs :: l) f f'. (SListIN (Prod h) xs, HAp h) => (forall (a :: k). f a -> f' a) -> h f xs -> h f' xs #

Another name for `hliftA`.

Since: 0.2

hzipWith :: forall {k} {l} h (xs :: l) f f' f''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs #

Another name for `hliftA2`.

Since: 0.2

hzipWith3 :: forall {k} {l} h (xs :: l) f f' f'' f'''. (SListIN (Prod h) xs, HAp h, HAp (Prod h)) => (forall (a :: k). f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs #

Another name for `hliftA3`.

Since: 0.2

hcliftA :: forall {k} {l} h c (xs :: l) proxy f f'. (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs #

Variant of `hliftA` that takes a constrained function.

Specification:

    hcliftA p f xs = hcpure p (fn f) ` hap ` xs

hcliftA2 :: forall {k} {l} h c (xs :: l) proxy f f' f''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs #

Variant of `hliftA2` that takes a constrained function.

Specification:

    hcliftA2 p f xs ys = hcpure p (fn_2 f) ` hap ` xs ` hap ` ys

hcliftA3 :: forall {k} {l} h c (xs :: l) proxy f f' f'' f'''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs #

Variant of `hliftA3` that takes a constrained function.

Specification:

    hcliftA3 p f xs ys zs = hcpure p (fn_3 f) ` hap ` xs ` hap ` ys ` hap ` zs

hcmap :: forall {k} {l} h c (xs :: l) proxy f f'. (AllN (Prod h) c xs, HAp h) => proxy c -> (forall (a :: k). c a => f a -> f' a) -> h f xs -> h f' xs #

Another name for `hcliftA`.

Since: 0.2

hczipWith :: forall {k} {l} h c (xs :: l) proxy f f' f''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs #

Another name for `hcliftA2`.

Since: 0.2

hczipWith3 :: forall {k} {l} h c (xs :: l) proxy f f' f'' f'''. (AllN (Prod h) c xs, HAp h, HAp (Prod h)) => proxy c -> (forall (a :: k). c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs #

Another name for `hcliftA3`.

Since: 0.2

# Collapsing homogeneous structures

type family CollapseTo (h :: (k -> Type) -> l -> Type) x #

Maps products to lists, and sums to identities.

#### Instances

Instances details

type CollapseTo (POP :: (k -> Type) -> [[k]] -> Type) a # |
Instance details Defined in Data.SOP.NP type CollapseTo (POP :: (k -> Type) -> [[k]] -> Type) a = [[a]]
type CollapseTo (SOP :: (k -> Type) -> [[k]] -> Type) a # |
Instance details Defined in Data.SOP.NS type CollapseTo (SOP :: (k -> Type) -> [[k]] -> Type) a = [a]
type CollapseTo (NP :: (k -> Type) -> [k] -> Type) a # |
Instance details Defined in Data.SOP.NP type CollapseTo (NP :: (k -> Type) -> [k] -> Type) a = [a]
type CollapseTo (NS :: (k -> Type) -> [k] -> Type) a # |
Instance details Defined in Data.SOP.NS type CollapseTo (NS :: (k -> Type) -> [k] -> Type) a = a

class HCollapse (h :: (k -> Type) -> l -> Type) where #

A class for collapsing a heterogeneous structure into a homogeneous one.

Methods

hcollapse :: forall (xs :: l) a. SListIN h xs => h (K a :: k -> Type) xs -> CollapseTo h a #

Collapse a heterogeneous structure with homogeneous elements into a homogeneous structure.

If a heterogeneous structure is instantiated to the constant functor `K`, then it is in fact homogeneous. This function maps such a value to a simpler Haskell datatype reflecting that. An ``NS` (`K` a)` contains a single `a`, and an ``NP` (`K` a)` contains a list of `a`s.

Instances:

    hcollapse, collapse_NP  :: NP  (K a) xs  ->  [a]
    hcollapse, collapse_NS  :: NS  (K a) xs  ->   a
    hcollapse, collapse_POP :: POP (K a) xss -> [[a]]
    hcollapse, collapse_SOP :: SOP (K a) xss ->  [a]

#### Instances

Instances details

HCollapse (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hcollapse :: forall (xs :: [[k]]) a. SListIN (POP :: (k -> Type) -> [[k]] -> Type) xs => POP (K a :: k -> Type) xs -> CollapseTo (POP :: (k -> Type) -> [[k]] -> Type) a #
HCollapse (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hcollapse :: forall (xs :: [[k]]) a. SListIN (SOP :: (k -> Type) -> [[k]] -> Type) xs => SOP (K a :: k -> Type) xs -> CollapseTo (SOP :: (k -> Type) -> [[k]] -> Type) a #
HCollapse (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hcollapse :: forall (xs :: [k]) a. SListIN (NP :: (k -> Type) -> [k] -> Type) xs => NP (K a :: k -> Type) xs -> CollapseTo (NP :: (k -> Type) -> [k] -> Type) a #
HCollapse (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hcollapse :: forall (xs :: [k]) a. SListIN (NS :: (k -> Type) -> [k] -> Type) xs => NS (K a :: k -> Type) xs -> CollapseTo (NS :: (k -> Type) -> [k] -> Type) a #

# Folding and sequencing

class HTraverse_ (h :: (k -> Type) -> l -> Type) where #

A generalization of `traverse_` or `foldMap`.

Since: 0.3.2.0

Methods

hctraverse_ :: forall c (xs :: l) g proxy f. (AllN h c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> h f xs -> g () #

Corresponds to `traverse_`.

Instances:

    hctraverse_, ctraverse__NP  :: (All  c xs , Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> NP  f xs  -> g ()
    hctraverse_, ctraverse__NS  :: (All2 c xs , Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> NS  f xs  -> g ()
    hctraverse_, ctraverse__POP :: (All  c xss, Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> POP f xss -> g ()
    hctraverse_, ctraverse__SOP :: (All2 c xss, Applicative g) => proxy c -> (forall a. c a => f a -> g ()) -> SOP f xss -> g ()

Since: 0.3.2.0

htraverse_ :: forall (xs :: l) g f. (SListIN h xs, Applicative g) => (forall (a :: k). f a -> g ()) -> h f xs -> g () #

Unconstrained version of `hctraverse_`.

Instances:

    traverse_, traverse__NP  :: (SListI  xs , Applicative g) => (forall a. f a -> g ()) -> NP  f xs  -> g ()
    traverse_, traverse__NS  :: (SListI  xs , Applicative g) => (forall a. f a -> g ()) -> NS  f xs  -> g ()
    traverse_, traverse__POP :: (SListI2 xss, Applicative g) => (forall a. f a -> g ()) -> POP f xss -> g ()
    traverse_, traverse__SOP :: (SListI2 xss, Applicative g) => (forall a. f a -> g ()) -> SOP f xss -> g ()

Since: 0.3.2.0

#### Instances

Instances details

HTraverse_ (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hctraverse_ :: forall c (xs :: [[k]]) g proxy f. (AllN (POP :: (k -> Type) -> [[k]] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> POP f xs -> g () # htraverse_ :: forall (xs :: [[k]]) g f. (SListIN (POP :: (k -> Type) -> [[k]] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g ()) -> POP f xs -> g () #
HTraverse_ (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hctraverse_ :: forall c (xs :: [[k]]) g proxy f. (AllN (SOP :: (k -> Type) -> [[k]] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> SOP f xs -> g () # htraverse_ :: forall (xs :: [[k]]) g f. (SListIN (SOP :: (k -> Type) -> [[k]] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g ()) -> SOP f xs -> g () #
HTraverse_ (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hctraverse_ :: forall c (xs :: [k]) g proxy f. (AllN (NP :: (k -> Type) -> [k] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> NP f xs -> g () # htraverse_ :: forall (xs :: [k]) g f. (SListIN (NP :: (k -> Type) -> [k] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g ()) -> NP f xs -> g () #
HTraverse_ (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hctraverse_ :: forall c (xs :: [k]) g proxy f. (AllN (NS :: (k -> Type) -> [k] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g ()) -> NS f xs -> g () # htraverse_ :: forall (xs :: [k]) g f. (SListIN (NS :: (k -> Type) -> [k] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g ()) -> NS f xs -> g () #

class HAp h => HSequence (h :: (k -> Type) -> l -> Type) where #

A generalization of `sequenceA`.

Methods

hsequence' :: forall (xs :: l) f (g :: k -> Type). (SListIN h xs, Applicative f) => h (f :.: g) xs -> f (h g xs) #

Corresponds to `sequenceA`.

Lifts an applicative functor out of a structure.

Instances:

    hsequence', sequence'_NP  :: (SListI  xs , Applicative f) => NP  (f :.: g) xs  -> f (NP  g xs )
    hsequence', sequence'_NS  :: (SListI  xs , Applicative f) => NS  (f :.: g) xs  -> f (NS  g xs )
    hsequence', sequence'_POP :: (SListI2 xss, Applicative f) => POP (f :.: g) xss -> f (POP g xss)
    hsequence', sequence'_SOP :: (SListI2 xss, Applicative f) => SOP (f :.: g) xss -> f (SOP g xss)

hctraverse' :: forall c (xs :: l) g proxy f f'. (AllN h c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> h f xs -> g (h f' xs) #

Corresponds to `traverse`.

Instances:

    hctraverse', ctraverse'_NP  :: (All  c xs , Applicative g) => proxy c -> (forall a. c a => f a -> g (f' a)) -> NP  f xs  -> g (NP  f' xs )
    hctraverse', ctraverse'_NS  :: (All2 c xs , Applicative g) => proxy c -> (forall a. c a => f a -> g (f' a)) -> NS  f xs  -> g (NS  f' xs )
    hctraverse', ctraverse'_POP :: (All  c xss, Applicative g) => proxy c -> (forall a. c a => f a -> g (f' a)) -> POP f xss -> g (POP f' xss)
    hctraverse', ctraverse'_SOP :: (All2 c xss, Applicative g) => proxy c -> (forall a. c a => f a -> g (f' a)) -> SOP f xss -> g (SOP f' xss)

Since: 0.3.2.0

htraverse' :: forall (xs :: l) g f f'. (SListIN h xs, Applicative g) => (forall (a :: k). f a -> g (f' a)) -> h f xs -> g (h f' xs) #

Unconstrained variant of `hctraverse'`.

Instances:

    htraverse', traverse'_NP  :: (SListI  xs , Applicative g) => (forall a. c a => f a -> g (f' a)) -> NP  f xs  -> g (NP  f' xs )
    htraverse', traverse'_NS  :: (SListI2 xs , Applicative g) => (forall a. c a => f a -> g (f' a)) -> NS  f xs  -> g (NS  f' xs )
    htraverse', traverse'_POP :: (SListI  xss, Applicative g) => (forall a. c a => f a -> g (f' a)) -> POP f xss -> g (POP f' xss)
    htraverse', traverse'_SOP :: (SListI2 xss, Applicative g) => (forall a. c a => f a -> g (f' a)) -> SOP f xss -> g (SOP f' xss)

Since: 0.3.2.0

#### Instances

Instances details

HSequence (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hsequence' :: forall (xs :: [[k]]) f (g :: k -> Type). (SListIN (POP :: (k -> Type) -> [[k]] -> Type) xs, Applicative f) => POP (f :.: g) xs -> f (POP g xs) # hctraverse' :: forall c (xs :: [[k]]) g proxy f f'. (AllN (POP :: (k -> Type) -> [[k]] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> POP f xs -> g (POP f' xs) # htraverse' :: forall (xs :: [[k]]) g f f'. (SListIN (POP :: (k -> Type) -> [[k]] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g (f' a)) -> POP f xs -> g (POP f' xs) #
HSequence (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hsequence' :: forall (xs :: [[k]]) f (g :: k -> Type). (SListIN (SOP :: (k -> Type) -> [[k]] -> Type) xs, Applicative f) => SOP (f :.: g) xs -> f (SOP g xs) # hctraverse' :: forall c (xs :: [[k]]) g proxy f f'. (AllN (SOP :: (k -> Type) -> [[k]] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> SOP f xs -> g (SOP f' xs) # htraverse' :: forall (xs :: [[k]]) g f f'. (SListIN (SOP :: (k -> Type) -> [[k]] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g (f' a)) -> SOP f xs -> g (SOP f' xs) #
HSequence (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NP Methods hsequence' :: forall (xs :: [k]) f (g :: k -> Type). (SListIN (NP :: (k -> Type) -> [k] -> Type) xs, Applicative f) => NP (f :.: g) xs -> f (NP g xs) # hctraverse' :: forall c (xs :: [k]) g proxy f f'. (AllN (NP :: (k -> Type) -> [k] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> NP f xs -> g (NP f' xs) # htraverse' :: forall (xs :: [k]) g f f'. (SListIN (NP :: (k -> Type) -> [k] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g (f' a)) -> NP f xs -> g (NP f' xs) #
HSequence (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hsequence' :: forall (xs :: [k]) f (g :: k -> Type). (SListIN (NS :: (k -> Type) -> [k] -> Type) xs, Applicative f) => NS (f :.: g) xs -> f (NS g xs) # hctraverse' :: forall c (xs :: [k]) g proxy f f'. (AllN (NS :: (k -> Type) -> [k] -> Type) c xs, Applicative g) => proxy c -> (forall (a :: k). c a => f a -> g (f' a)) -> NS f xs -> g (NS f' xs) # htraverse' :: forall (xs :: [k]) g f f'. (SListIN (NS :: (k -> Type) -> [k] -> Type) xs, Applicative g) => (forall (a :: k). f a -> g (f' a)) -> NS f xs -> g (NS f' xs) #

## Derived functions

hcfoldMap :: forall {k} {l} h c (xs :: l) m proxy f. (HTraverse_ h, AllN h c xs, Monoid m) => proxy c -> (forall (a :: k). c a => f a -> m) -> h f xs -> m #

Special case of `hctraverse_`.

Since: 0.3.2.0

hcfor_ :: forall {k} {l} h c (xs :: l) g proxy f. (HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> h f xs -> (forall (a :: k). c a => f a -> g ()) -> g () #

Flipped version of `hctraverse_`.

Since: 0.3.2.0

hsequence :: forall {l} h (xs :: l) f. (SListIN h xs, SListIN (Prod h) xs, HSequence h, Applicative f) => h f xs -> f (h I xs) #

Special case of `hsequence'` where `g = `I``.

hsequenceK :: forall {k} {l} h (xs :: l) f a. (SListIN h xs, SListIN (Prod h) xs, Applicative f, HSequence h) => h (K (f a) :: k -> Type) xs -> f (h (K a :: k -> Type) xs) #

Special case of `hsequence'` where `g = `K` a`.

hctraverse :: forall {l} h c (xs :: l) g proxy f. (HSequence h, AllN h c xs, Applicative g) => proxy c -> (forall a. c a => f a -> g a) -> h f xs -> g (h I xs) #

Special case of `hctraverse'` where `f' = `I``.

Since: 0.3.2.0

hcfor :: forall {l} h c (xs :: l) g proxy f. (HSequence h, AllN h c xs, Applicative g) => proxy c -> h f xs -> (forall a. c a => f a -> g a) -> g (h I xs) #

Flipped version of `hctraverse`.

Since: 0.3.2.0

# Indexing into sums

class HIndex (h :: (k -> Type) -> l -> Type) where #

A class for determining which choice in a sum-like structure a value represents.

Methods

hindex :: forall (f :: k -> Type) (xs :: l). h f xs -> Int #

If `h` is a sum-like structure representing a choice between `n` different options, and `x` is a value of type `h f xs`, then ``hindex` x` returns a number between `0` and `n - 1` representing the index of the choice made by `x`.

Instances:

    hindex, index_NS  :: NS  f xs -> Int
    hindex, index_SOP :: SOP f xs -> Int

Examples:

    >>> hindex (S (S (Z (I False))))
    2
    >>> hindex (Z (K ()))
    0
    >>> hindex (SOP (S (Z (I True :* I 'x' :* Nil))))
    1

Since: 0.2.4.0

#### Instances

Instances details

HIndex (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hindex :: forall (f :: k -> Type) (xs :: [[k]]). SOP f xs -> Int #
HIndex (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hindex :: forall (f :: k -> Type) (xs :: [k]). NS f xs -> Int #

# Applying all injections

type family UnProd (h :: (k -> Type) -> l -> Type) :: (k -> Type) -> l -> Type #

Maps a structure containing products to the corresponding sum structure.

Since: 0.2.4.0

#### Instances

Instances details

type UnProd (POP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS type UnProd (POP :: (k -> Type) -> [[k]] -> Type) = SOP :: (k -> Type) -> [[k]] -> Type
type UnProd (NP :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS type UnProd (NP :: (k -> Type) -> [k] -> Type) = NS :: (k -> Type) -> [k] -> Type

class UnProd (Prod h) ~ h => HApInjs (h :: (k -> Type) -> l -> Type) where #

A class for applying all injections corresponding to a sum-like structure to a table containing suitable arguments.

Methods

hapInjs :: forall (xs :: l) (f :: k -> Type). SListIN h xs => Prod h f xs -> [h f xs] #

For a given table (product-like structure), produce a list where each element corresponds to the application of an injection function into the corresponding sum-like structure.

Instances:

    hapInjs, apInjs_NP  :: SListI  xs  => NP  f xs -> [NS  f xs ]
    hapInjs, apInjs_SOP :: SListI2 xss => POP f xs -> [SOP f xss]

Examples:

    >>> hapInjs (I 'x' :* I True :* I 2 :* Nil) :: [NS I '[Char, Bool, Int]]
    [Z (I 'x'),S (Z (I True)),S (S (Z (I 2)))]

    >>> hapInjs (POP ((I 'x' :* Nil) :* (I True :* I 2 :* Nil) :* Nil)) :: [SOP I '[ '[Char], '[Bool, Int]]]
    [SOP (Z (I 'x' :* Nil)),SOP (S (Z (I True :* I 2 :* Nil)))]

Unfortunately the type-signatures are required in GHC-7.10 and older.

Since: 0.2.4.0

#### Instances

Instances details

HApInjs (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hapInjs :: forall (xs :: [[k]]) (f :: k -> Type). SListIN (SOP :: (k -> Type) -> [[k]] -> Type) xs => Prod (SOP :: (k -> Type) -> [[k]] -> Type) f xs -> [SOP f xs] #
HApInjs (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hapInjs :: forall (xs :: [k]) (f :: k -> Type). SListIN (NS :: (k -> Type) -> [k] -> Type) xs => Prod (NS :: (k -> Type) -> [k] -> Type) f xs -> [NS f xs] #

# Expanding sums to products

class HExpand (h :: (k -> Type) -> l -> Type) where #

A class for expanding sum structures into corresponding product structures, filling in the slots not targeted by the sum with default values.

Since: 0.2.5.0

Methods

hexpand :: forall (xs :: l) f. SListIN (Prod h) xs => (forall (x :: k). f x) -> h f xs -> Prod h f xs #

Expand a given sum structure into a corresponding product structure by placing the value contained in the sum into the corresponding position in the product, and using the given default value for all other positions.

Instances:

    hexpand, expand_NS  :: SListI xs   => (forall x . f x) -> NS  f xs  -> NP  f xs
    hexpand, expand_SOP :: SListI2 xss => (forall x . f x) -> SOP f xss -> POP f xss

Examples:

    >>> hexpand Nothing (S (Z (Just 3))) :: NP Maybe '[Char, Int, Bool]
    Nothing :* Just 3 :* Nothing :* Nil
    >>> hexpand [] (SOP (S (Z ([1,2] :* "xyz" :* Nil)))) :: POP [] '[ '[Bool], '[Int, Char] ]
    POP (([] :* Nil) :* ([1,2] :* "xyz" :* Nil) :* Nil)

Since: 0.2.5.0

hcexpand :: forall c (xs :: l) proxy f. AllN (Prod h) c xs => proxy c -> (forall (x :: k). c x => f x) -> h f xs -> Prod h f xs #

Variant of `hexpand` that allows passing a constrained default.

Instances:

    hcexpand, cexpand_NS  :: All  c xs  => proxy c -> (forall x . c x => f x) -> NS  f xs  -> NP  f xs
    hcexpand, cexpand_SOP :: All2 c xss => proxy c -> (forall x . c x => f x) -> SOP f xss -> POP f xss

Examples:

    >>> hcexpand (Proxy :: Proxy Bounded) (I minBound) (S (Z (I 20))) :: NP I '[Bool, Int, Ordering]
    I False :* I 20 :* I LT :* Nil
    >>> hcexpand (Proxy :: Proxy Num) (I 0) (SOP (S (Z (I 1 :* I 2 :* Nil)))) :: POP I '[ '[Double], '[Int, Int] ]
    POP ((I 0.0 :* Nil) :* (I 1 :* I 2 :* Nil) :* Nil)

Since: 0.2.5.0

#### Instances

Instances details

HExpand (SOP :: (k -> Type) -> [[k]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hexpand :: forall (xs :: [[k]]) f. SListIN (Prod (SOP :: (k -> Type) -> [[k]] -> Type)) xs => (forall (x :: k). f x) -> SOP f xs -> Prod (SOP :: (k -> Type) -> [[k]] -> Type) f xs # hcexpand :: forall c (xs :: [[k]]) proxy f. AllN (Prod (SOP :: (k -> Type) -> [[k]] -> Type)) c xs => proxy c -> (forall (x :: k). c x => f x) -> SOP f xs -> Prod (SOP :: (k -> Type) -> [[k]] -> Type) f xs #
HExpand (NS :: (k -> Type) -> [k] -> Type) # |
Instance details Defined in Data.SOP.NS Methods hexpand :: forall (xs :: [k]) f. SListIN (Prod (NS :: (k -> Type) -> [k] -> Type)) xs => (forall (x :: k). f x) -> NS f xs -> Prod (NS :: (k -> Type) -> [k] -> Type) f xs # hcexpand :: forall c (xs :: [k]) proxy f. AllN (Prod (NS :: (k -> Type) -> [k] -> Type)) c xs => proxy c -> (forall (x :: k). c x => f x) -> NS f xs -> Prod (NS :: (k -> Type) -> [k] -> Type) f xs #

# Transformation of index lists and coercions

class ((Same h1 :: (k2 -> Type) -> l2 -> Type) ~ h2, (Same h2 :: (k1 -> Type) -> l1 -> Type) ~ h1) => HTrans (h1 :: (k1 -> Type) -> l1 -> Type) (h2 :: (k2 -> Type) -> l2 -> Type) where #

A class for transforming structures into related structures with a different index list, as long as the index lists have the same shape and the elements and interpretation functions are suitably related.

Since: 0.3.1.0

Methods

htrans :: forall c (xs :: l1) (ys :: l2) proxy f g. AllZipN (Prod h1) c xs ys => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> h1 f xs -> h2 g ys #

Transform a structure into a related structure given a conversion function for the elements.

Since: 0.3.1.0

hcoerce :: forall (f :: k1 -> Type) (g :: k2 -> Type) (xs :: l1) (ys :: l2). AllZipN (Prod h1) (LiftedCoercible f g) xs ys => h1 f xs -> h2 g ys #

Safely coerce a structure into a representationally equal structure.

This is a special case of `htrans`, but can be implemented more efficiently; for example in terms of `unsafeCoerce`.

Examples:

    >>> hcoerce (I (Just LT) :* I (Just 'x') :* I (Just True) :* Nil) :: NP Maybe '[Ordering, Char, Bool]
    Just LT :* Just 'x' :* Just True :* Nil
    >>> hcoerce (SOP (Z (K True :* K False :* Nil))) :: SOP I '[ '[Bool, Bool], '[Bool] ]
    SOP (Z (I True :* I False :* Nil))

Since: 0.3.1.0

#### Instances

Instances details

HTrans (POP :: (k1 -> Type) -> [[k1]] -> Type) (POP :: (k2 -> Type) -> [[k2]] -> Type) # |
Instance details Defined in Data.SOP.NP Methods htrans :: forall c (xs :: [[k1]]) (ys :: [[k2]]) proxy f g. AllZipN (Prod (POP :: (k1 -> Type) -> [[k1]] -> Type)) c xs ys => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> POP f xs -> POP g ys # hcoerce :: forall (f :: k1 -> Type) (g :: k2 -> Type) (xs :: [[k1]]) (ys :: [[k2]]). AllZipN (Prod (POP :: (k1 -> Type) -> [[k1]] -> Type)) (LiftedCoercible f g) xs ys => POP f xs -> POP g ys #
HTrans (SOP :: (k1 -> Type) -> [[k1]] -> Type) (SOP :: (k2 -> Type) -> [[k2]] -> Type) # |
Instance details Defined in Data.SOP.NS Methods htrans :: forall c (xs :: [[k1]]) (ys :: [[k2]]) proxy f g. AllZipN (Prod (SOP :: (k1 -> Type) -> [[k1]] -> Type)) c xs ys => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> SOP f xs -> SOP g ys # hcoerce :: forall (f :: k1 -> Type) (g :: k2 -> Type) (xs :: [[k1]]) (ys :: [[k2]]). AllZipN (Prod (SOP :: (k1 -> Type) -> [[k1]] -> Type)) (LiftedCoercible f g) xs ys => SOP f xs -> SOP g ys #
HTrans (NP :: (k1 -> Type) -> [k1] -> Type) (NP :: (k2 -> Type) -> [k2] -> Type) # |
Instance details Defined in Data.SOP.NP Methods htrans :: forall c (xs :: [k1]) (ys :: [k2]) proxy f g. AllZipN (Prod (NP :: (k1 -> Type) -> [k1] -> Type)) c xs ys => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> NP f xs -> NP g ys # hcoerce :: forall (f :: k1 -> Type) (g :: k2 -> Type) (xs :: [k1]) (ys :: [k2]). AllZipN (Prod (NP :: (k1 -> Type) -> [k1] -> Type)) (LiftedCoercible f g) xs ys => NP f xs -> NP g ys #
HTrans (NS :: (k1 -> Type) -> [k1] -> Type) (NS :: (k2 -> Type) -> [k2] -> Type) # |
Instance details Defined in Data.SOP.NS Methods htrans :: forall c (xs :: [k1]) (ys :: [k2]) proxy f g. AllZipN (Prod (NS :: (k1 -> Type) -> [k1] -> Type)) c xs ys => proxy c -> (forall (x :: k1) (y :: k2). c x y => f x -> g y) -> NS f xs -> NS g ys # hcoerce :: forall (f :: k1 -> Type) (g :: k2 -> Type) (xs :: [k1]) (ys :: [k2]). AllZipN (Prod (NS :: (k1 -> Type) -> [k1] -> Type)) (LiftedCoercible f g) xs ys => NS f xs -> NS g ys #

hfromI :: forall {l1} {k2} {l2} h1 (f :: k2 -> Type) (xs :: l1) (ys :: l2) h2. (AllZipN (Prod h1) (LiftedCoercible I f) xs ys, HTrans h1 h2) => h1 I xs -> h2 f ys #

Specialization of `hcoerce`.

Since: 0.3.1.0

htoI :: forall {k1} {l1} {l2} h1 (f :: k1 -> Type) (xs :: l1) (ys :: l2) h2. (AllZipN (Prod h1) (LiftedCoercible f I) xs ys, HTrans h1 h2) => h1 f xs -> h2 I ys #

Specialization of `hcoerce`.

Since: 0.3.1.0