Safe Haskell | None |
---|---|
Language | Haskell2010 |
Data.SOP.Classes
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 productNS
:: (k ->Type
) -> ( [k] ->Type
) -- n-ary sumPOP
:: (k ->Type
) -> ([[k]] ->Type
) -- product of productsSOP
:: (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
or
Type
to datatypes of kind
Type
->
Type
(k ->
. This module
also derives a number of derived combinators.
Type
) -> (l ->
Type
)
The actual instances are defined in Data.SOP.NP and Data.SOP.NS .
Synopsis
- class HPure (h :: (k -> Type ) -> l -> Type ) where
-
newtype
(f
-.->
g) a =
Fn
{
- apFn :: f a -> g a
- fn :: (f a -> f' a) -> (f -.-> f') a
- fn_2 :: (f a -> f' a -> f'' a) -> (f -.-> (f' -.-> f'')) a
- fn_3 :: (f a -> f' a -> f'' a -> f''' a) -> (f -.-> (f' -.-> (f'' -.-> f'''))) a
- fn_4 :: (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
- hliftA :: ( SListIN ( Prod h) xs, HAp h) => ( forall a. f a -> f' a) -> h f xs -> h f' xs
- hliftA2 :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hliftA3 :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs
- hmap :: ( SListIN ( Prod h) xs, HAp h) => ( forall a. f a -> f' a) -> h f xs -> h f' xs
- hzipWith :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hzipWith3 :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs
- hcliftA :: ( AllN ( Prod h) c xs, HAp h) => proxy c -> ( forall a. c a => f a -> f' a) -> h f xs -> h f' xs
- hcliftA2 :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hcliftA3 :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. 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 :: ( AllN ( Prod h) c xs, HAp h) => proxy c -> ( forall a. c a => f a -> f' a) -> h f xs -> h f' xs
- hczipWith :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs
- hczipWith3 :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. 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 :: Type ) :: Type
-
class
HCollapse
(h :: (k ->
Type
) -> l ->
Type
)
where
- hcollapse :: SListIN h xs => h ( K a) xs -> CollapseTo h a
-
class
HTraverse_
(h :: (k ->
Type
) -> l ->
Type
)
where
- hctraverse_ :: ( AllN h c xs, Applicative g) => proxy c -> ( forall a. c a => f a -> g ()) -> h f xs -> g ()
- htraverse_ :: ( SListIN h xs, Applicative g) => ( forall a. f a -> g ()) -> h f xs -> g ()
-
class
HAp
h =>
HSequence
(h :: (k ->
Type
) -> l ->
Type
)
where
- hsequence' :: ( SListIN h xs, Applicative f) => h (f :.: g) xs -> f (h g xs)
- hctraverse' :: ( AllN h c xs, Applicative g) => proxy c -> ( forall a. c a => f a -> g (f' a)) -> h f xs -> g (h f' xs)
- htraverse' :: ( SListIN h xs, Applicative g) => ( forall a. f a -> g (f' a)) -> h f xs -> g (h f' xs)
- hcfoldMap :: ( HTraverse_ h, AllN h c xs, Monoid m) => proxy c -> ( forall a. c a => f a -> m) -> h f xs -> m
- hcfor_ :: ( HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> h f xs -> ( forall a. c a => f a -> g ()) -> g ()
- hsequence :: ( SListIN h xs, SListIN ( Prod h) xs, HSequence h) => Applicative f => h f xs -> f (h I xs)
- hsequenceK :: ( SListIN h xs, SListIN ( Prod h) xs, Applicative f, HSequence h) => h ( K (f a)) xs -> f (h ( K a) xs)
- hctraverse :: ( 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 :: ( 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
- type family UnProd (h :: (k -> Type ) -> l -> Type ) :: (k -> Type ) -> l -> Type
- class UnProd ( Prod h) ~ h => HApInjs (h :: (k -> Type ) -> l -> Type ) where
- class HExpand (h :: (k -> Type ) -> l -> Type ) where
- class ( Same h1 ~ h2, Same h2 ~ h1) => HTrans (h1 :: (k1 -> Type ) -> l1 -> Type ) (h2 :: (k2 -> Type ) -> l2 -> Type ) where
- hfromI :: ( AllZipN ( Prod h1) ( LiftedCoercible I f) xs ys, HTrans h1 h2) => h1 I xs -> h2 f ys
- htoI :: ( 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 Source #
Methods
hpure :: SListIN h xs => ( forall a. f a) -> h f xs Source #
Corresponds to
pure
directly.
Instances:
hpure
,pure_NP
::SListI
xs => (forall a. f a) ->NP
f xshpure
,pure_POP
::SListI2
xss => (forall a. f a) ->POP
f xss
hcpure :: AllN h c xs => proxy c -> ( forall a. c a => f a) -> h f xs Source #
A variant of
hpure
that allows passing in a constrained
argument.
Calling
where
hcpure
f s
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
states.
AllN
h c xs
Instances:
hcpure
,cpure_NP
:: (All
c xs ) => proxy c -> (forall a. c a => f a) ->NP
f xshcpure
,cpure_POP
:: (All2
c xss) => proxy c -> (forall a. c a => f a) ->POP
f xss
Generalized
<*>
fn :: (f a -> f' a) -> (f -.-> f') a Source #
Construct a lifted function.
Same as
Fn
. Only available for uniformity with the
higher-arity versions.
fn_2 :: (f a -> f' a -> f'' a) -> (f -.-> (f' -.-> f'')) a Source #
Construct a binary lifted function.
fn_3 :: (f a -> f' a -> f'' a -> f''' a) -> (f -.-> (f' -.-> (f'' -.-> f'''))) a Source #
Construct a ternary lifted function.
fn_4 :: (f a -> f' a -> f'' a -> f''' a -> f'''' a) -> (f -.-> (f' -.-> (f'' -.-> (f''' -.-> f'''')))) a Source #
Construct a quarternary lifted function.
type family Same (h :: (k1 -> Type ) -> l1 -> Type ) :: (k2 -> Type ) -> l2 -> Type Source #
Maps a structure to the same structure.
type family Prod (h :: (k -> Type ) -> l -> Type ) :: (k -> Type ) -> l -> Type Source #
Maps a structure containing sums to the corresponding product structure.
class ( Prod ( Prod h) ~ Prod h, HPure ( Prod h)) => HAp (h :: (k -> Type ) -> l -> Type ) where Source #
A generalization of
<*>
.
Methods
hap :: Prod h (f -.-> g) xs -> h f xs -> h g xs Source #
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 xshap
,ap_NS
::NP
(f -.-> g) xs ->NS
f xs ->NS
g xshap
,ap_POP
::POP
(f -.-> g) xss ->POP
f xss ->POP
g xsshap
,ap_SOP
::POP
(f -.-> g) xss ->SOP
f xss ->SOP
g xss
Derived functions
hliftA :: ( SListIN ( Prod h) xs, HAp h) => ( forall a. f a -> f' a) -> h f xs -> h f' xs Source #
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' xshliftA
,liftA_NS
::SListI
xs => (forall a. f a -> f' a) ->NS
f xs ->NS
f' xshliftA
,liftA_POP
::SListI2
xss => (forall a. f a -> f' a) ->POP
f xss ->POP
f' xsshliftA
,liftA_SOP
::SListI2
xss => (forall a. f a -> f' a) ->SOP
f xss ->SOP
f' xss
hliftA2 :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs Source #
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'' xshliftA2
,liftA2_NS
::SListI
xs => (forall a. f a -> f' a -> f'' a) ->NP
f xs ->NS
f' xs ->NS
f'' xshliftA2
,liftA2_POP
::SListI2
xss => (forall a. f a -> f' a -> f'' a) ->POP
f xss ->POP
f' xss ->POP
f'' xsshliftA2
,liftA2_SOP
::SListI2
xss => (forall a. f a -> f' a -> f'' a) ->POP
f xss ->SOP
f' xss ->SOP
f'' xss
hliftA3 :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs Source #
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''' xshliftA3
,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''' xshliftA3
,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''' xshliftA3
,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 :: ( SListIN ( Prod h) xs, HAp h) => ( forall a. f a -> f' a) -> h f xs -> h f' xs Source #
Another name for
hliftA
.
Since: 0.2
hzipWith :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs Source #
Another name for
hliftA2
.
Since: 0.2
hzipWith3 :: ( SListIN ( Prod h) xs, HAp h, HAp ( Prod h)) => ( forall a. f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs Source #
Another name for
hliftA3
.
Since: 0.2
hcliftA :: ( AllN ( Prod h) c xs, HAp h) => proxy c -> ( forall a. c a => f a -> f' a) -> h f xs -> h f' xs Source #
hcliftA2 :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs Source #
hcliftA3 :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs Source #
hcmap :: ( AllN ( Prod h) c xs, HAp h) => proxy c -> ( forall a. c a => f a -> f' a) -> h f xs -> h f' xs Source #
Another name for
hcliftA
.
Since: 0.2
hczipWith :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. c a => f a -> f' a -> f'' a) -> Prod h f xs -> h f' xs -> h f'' xs Source #
Another name for
hcliftA2
.
Since: 0.2
hczipWith3 :: ( AllN ( Prod h) c xs, HAp h, HAp ( Prod h)) => proxy c -> ( forall a. c a => f a -> f' a -> f'' a -> f''' a) -> Prod h f xs -> Prod h f' xs -> h f'' xs -> h f''' xs Source #
Another name for
hcliftA3
.
Since: 0.2
Collapsing homogeneous structures
type family CollapseTo (h :: (k -> Type ) -> l -> Type ) (x :: Type ) :: Type Source #
Maps products to lists, and sums to identities.
Instances
type CollapseTo ( NP :: (k -> Type ) -> [k] -> Type ) a Source # | |
Defined in Data.SOP.NP |
|
type CollapseTo ( POP :: (k -> Type ) -> [[k]] -> Type ) a Source # | |
Defined in Data.SOP.NP |
|
type CollapseTo ( NS :: (k -> Type ) -> [k] -> Type ) a Source # | |
Defined in Data.SOP.NS |
|
type CollapseTo ( SOP :: (k -> Type ) -> [[k]] -> Type ) a Source # | |
Defined in Data.SOP.NS |
class HCollapse (h :: (k -> Type ) -> l -> Type ) where Source #
A class for collapsing a heterogeneous structure into a homogeneous one.
Methods
hcollapse :: SListIN h xs => h ( K a) xs -> CollapseTo h a Source #
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
contains a single
NS
(
K
a)
a
, and an
contains
a list of
NP
(
K
a)
a
s.
Instances:
hcollapse
,collapse_NP
::NP
(K
a) xs -> [a]hcollapse
,collapse_NS
::NS
(K
a) xs -> ahcollapse
,collapse_POP
::POP
(K
a) xss -> [[a]]hcollapse
,collapse_SOP
::SOP
(K
a) xss -> [a]
Instances
HCollapse ( NP :: (k -> Type ) -> [k] -> Type ) Source # | |
Defined in Data.SOP.NP |
|
HCollapse ( POP :: (k -> Type ) -> [[k]] -> Type ) Source # | |
Defined in Data.SOP.NP |
|
HCollapse ( NS :: (k -> Type ) -> [k] -> Type ) Source # | |
Defined in Data.SOP.NS |
|
HCollapse ( SOP :: (k -> Type ) -> [[k]] -> Type ) Source # | |
Defined in Data.SOP.NS |
Folding and sequencing
class HTraverse_ (h :: (k -> Type ) -> l -> Type ) where Source #
Methods
hctraverse_ :: ( AllN h c xs, Applicative g) => proxy c -> ( forall a. c a => f a -> g ()) -> h f xs -> g () Source #
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_ :: ( SListIN h xs, Applicative g) => ( forall a. f a -> g ()) -> h f xs -> g () Source #
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
HTraverse_ ( NP :: (k -> Type ) -> [k] -> Type ) Source # | |
Defined in Data.SOP.NP Methods hctraverse_ :: forall c (xs :: l) g proxy f. ( AllN NP c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g ()) -> NP f xs -> g () Source # htraverse_ :: forall (xs :: l) g f. ( SListIN NP xs, Applicative g) => ( forall (a :: k0). f a -> g ()) -> NP f xs -> g () Source # |
|
HTraverse_ ( POP :: (k -> Type ) -> [[k]] -> Type ) Source # | |
Defined in Data.SOP.NP Methods hctraverse_ :: forall c (xs :: l) g proxy f. ( AllN POP c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g ()) -> POP f xs -> g () Source # htraverse_ :: forall (xs :: l) g f. ( SListIN POP xs, Applicative g) => ( forall (a :: k0). f a -> g ()) -> POP f xs -> g () Source # |
|
HTraverse_ ( NS :: (k -> Type ) -> [k] -> Type ) Source # | |
Defined in Data.SOP.NS Methods hctraverse_ :: forall c (xs :: l) g proxy f. ( AllN NS c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g ()) -> NS f xs -> g () Source # htraverse_ :: forall (xs :: l) g f. ( SListIN NS xs, Applicative g) => ( forall (a :: k0). f a -> g ()) -> NS f xs -> g () Source # |
|
HTraverse_ ( SOP :: (k -> Type ) -> [[k]] -> Type ) Source # | |
Defined in Data.SOP.NS Methods hctraverse_ :: forall c (xs :: l) g proxy f. ( AllN SOP c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g ()) -> SOP f xs -> g () Source # htraverse_ :: forall (xs :: l) g f. ( SListIN SOP xs, Applicative g) => ( forall (a :: k0). f a -> g ()) -> SOP f xs -> g () Source # |
class HAp h => HSequence (h :: (k -> Type ) -> l -> Type ) where Source #
A generalization of
sequenceA
.
Methods
hsequence' :: ( SListIN h xs, Applicative f) => h (f :.: g) xs -> f (h g xs) Source #
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' :: ( AllN h c xs, Applicative g) => proxy c -> ( forall a. c a => f a -> g (f' a)) -> h f xs -> g (h f' xs) Source #
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' :: ( SListIN h xs, Applicative g) => ( forall a. f a -> g (f' a)) -> h f xs -> g (h f' xs) Source #
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
HSequence ( NP :: (k -> Type ) -> [k] -> Type ) Source # | |
Defined in Data.SOP.NP Methods hsequence' :: forall (xs :: l) f (g :: k0 -> Type ). ( SListIN NP xs, Applicative f) => NP (f :.: g) xs -> f ( NP g xs) Source # hctraverse' :: forall c (xs :: l) g proxy f f'. ( AllN NP c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g (f' a)) -> NP f xs -> g ( NP f' xs) Source # htraverse' :: forall (xs :: l) g f f'. ( SListIN NP xs, Applicative g) => ( forall (a :: k0). f a -> g (f' a)) -> NP f xs -> g ( NP f' xs) Source # |
|
HSequence ( POP :: (k -> Type ) -> [[k]] -> Type ) Source # | |
Defined in Data.SOP.NP Methods hsequence' :: forall (xs :: l) f (g :: k0 -> Type ). ( SListIN POP xs, Applicative f) => POP (f :.: g) xs -> f ( POP g xs) Source # hctraverse' :: forall c (xs :: l) g proxy f f'. ( AllN POP c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g (f' a)) -> POP f xs -> g ( POP f' xs) Source # htraverse' :: forall (xs :: l) g f f'. ( SListIN POP xs, Applicative g) => ( forall (a :: k0). f a -> g (f' a)) -> POP f xs -> g ( POP f' xs) Source # |
|
HSequence ( NS :: (k -> Type ) -> [k] -> Type ) Source # | |
Defined in Data.SOP.NS Methods hsequence' :: forall (xs :: l) f (g :: k0 -> Type ). ( SListIN NS xs, Applicative f) => NS (f :.: g) xs -> f ( NS g xs) Source # hctraverse' :: forall c (xs :: l) g proxy f f'. ( AllN NS c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g (f' a)) -> NS f xs -> g ( NS f' xs) Source # htraverse' :: forall (xs :: l) g f f'. ( SListIN NS xs, Applicative g) => ( forall (a :: k0). f a -> g (f' a)) -> NS f xs -> g ( NS f' xs) Source # |
|
HSequence ( SOP :: (k -> Type ) -> [[k]] -> Type ) Source # | |
Defined in Data.SOP.NS Methods hsequence' :: forall (xs :: l) f (g :: k0 -> Type ). ( SListIN SOP xs, Applicative f) => SOP (f :.: g) xs -> f ( SOP g xs) Source # hctraverse' :: forall c (xs :: l) g proxy f f'. ( AllN SOP c xs, Applicative g) => proxy c -> ( forall (a :: k0). c a => f a -> g (f' a)) -> SOP f xs -> g ( SOP f' xs) Source # htraverse' :: forall (xs :: l) g f f'. ( SListIN SOP xs, Applicative g) => ( forall (a :: k0). f a -> g (f' a)) -> SOP f xs -> g ( SOP f' xs) Source # |
Derived functions
hcfoldMap :: ( HTraverse_ h, AllN h c xs, Monoid m) => proxy c -> ( forall a. c a => f a -> m) -> h f xs -> m Source #
Special case of
hctraverse_
.
Since: 0.3.2.0
hcfor_ :: ( HTraverse_ h, AllN h c xs, Applicative g) => proxy c -> h f xs -> ( forall a. c a => f a -> g ()) -> g () Source #
Flipped version of
hctraverse_
.
Since: 0.3.2.0
hsequence :: ( SListIN h xs, SListIN ( Prod h) xs, HSequence h) => Applicative f => h f xs -> f (h I xs) Source #
Special case of
hsequence'
where
g =
.
I
hsequenceK :: ( SListIN h xs, SListIN ( Prod h) xs, Applicative f, HSequence h) => h ( K (f a)) xs -> f (h ( K a) xs) Source #
Special case of
hsequence'
where
g =
.
K
a
hctraverse :: ( 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) Source #
Special case of
hctraverse'
where
f' =
.
I
Since: 0.3.2.0
hcfor :: ( 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) Source #
Flipped version of
hctraverse
.
Since: 0.3.2.0
Indexing into sums
class HIndex (h :: (k -> Type ) -> l -> Type ) where Source #
A class for determining which choice in a sum-like structure a value represents.
Methods
hindex :: h f xs -> Int Source #
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
returns a number between
hindex
x
0
and
n - 1
representing the index of the choice
made by
x
.
Instances:
hindex
,index_NS
::NS
f xs -> Inthindex
,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
Applying all injections
type family UnProd (h :: (k -> Type ) -> l -> Type ) :: (k -> Type ) -> l -> Type Source #
Maps a structure containing products to the corresponding sum structure.
Since: 0.2.4.0
class UnProd ( Prod h) ~ h => HApInjs (h :: (k -> Type ) -> l -> Type ) where Source #
A class for applying all injections corresponding to a sum-like structure to a table containing suitable arguments.
Methods
hapInjs :: SListIN h xs => Prod h f xs -> [h f xs] Source #
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
Expanding sums to products
class HExpand (h :: (k -> Type ) -> l -> Type ) where Source #
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 :: SListIN ( Prod h) xs => ( forall x. f x) -> h f xs -> Prod h f xs Source #
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 xshexpand
,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 :: AllN ( Prod h) c xs => proxy c -> ( forall x. c x => f x) -> h f xs -> Prod h f xs Source #
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 xshcexpand
,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
Transformation of index lists and coercions
class ( Same h1 ~ h2, Same h2 ~ h1) => HTrans (h1 :: (k1 -> Type ) -> l1 -> Type ) (h2 :: (k2 -> Type ) -> l2 -> Type ) where Source #
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 :: AllZipN ( Prod h1) c xs ys => proxy c -> ( forall x y. c x y => f x -> g y) -> h1 f xs -> h2 g ys Source #
Transform a structure into a related structure given a conversion function for the elements.
Since: 0.3.1.0
hcoerce :: AllZipN ( Prod h1) ( LiftedCoercible f g) xs ys => h1 f xs -> h2 g ys Source #
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
HTrans ( NP :: (k1 -> Type ) -> [k1] -> Type ) ( NP :: (k2 -> Type ) -> [k2] -> Type ) Source # | |
Defined in Data.SOP.NP Methods htrans :: forall c (xs :: l1) (ys :: l2) proxy f g. AllZipN ( Prod NP ) c xs ys => proxy c -> ( forall (x :: k10) (y :: k20). c x y => f x -> g y) -> NP f xs -> NP g ys Source # hcoerce :: forall (f :: k10 -> Type ) (g :: k20 -> Type ) (xs :: l1) (ys :: l2). AllZipN ( Prod NP ) ( LiftedCoercible f g) xs ys => NP f xs -> NP g ys Source # |
|
HTrans ( POP :: (k1 -> Type ) -> [[k1]] -> Type ) ( POP :: (k2 -> Type ) -> [[k2]] -> Type ) Source # | |
Defined in Data.SOP.NP Methods htrans :: forall c (xs :: l1) (ys :: l2) proxy f g. AllZipN ( Prod POP ) c xs ys => proxy c -> ( forall (x :: k10) (y :: k20). c x y => f x -> g y) -> POP f xs -> POP g ys Source # hcoerce :: forall (f :: k10 -> Type ) (g :: k20 -> Type ) (xs :: l1) (ys :: l2). AllZipN ( Prod POP ) ( LiftedCoercible f g) xs ys => POP f xs -> POP g ys Source # |
|
HTrans ( NS :: (k1 -> Type ) -> [k1] -> Type ) ( NS :: (k2 -> Type ) -> [k2] -> Type ) Source # | |
Defined in Data.SOP.NS Methods htrans :: forall c (xs :: l1) (ys :: l2) proxy f g. AllZipN ( Prod NS ) c xs ys => proxy c -> ( forall (x :: k10) (y :: k20). c x y => f x -> g y) -> NS f xs -> NS g ys Source # hcoerce :: forall (f :: k10 -> Type ) (g :: k20 -> Type ) (xs :: l1) (ys :: l2). AllZipN ( Prod NS ) ( LiftedCoercible f g) xs ys => NS f xs -> NS g ys Source # |
|
HTrans ( SOP :: (k1 -> Type ) -> [[k1]] -> Type ) ( SOP :: (k2 -> Type ) -> [[k2]] -> Type ) Source # | |
Defined in Data.SOP.NS Methods htrans :: forall c (xs :: l1) (ys :: l2) proxy f g. AllZipN ( Prod SOP ) c xs ys => proxy c -> ( forall (x :: k10) (y :: k20). c x y => f x -> g y) -> SOP f xs -> SOP g ys Source # hcoerce :: forall (f :: k10 -> Type ) (g :: k20 -> Type ) (xs :: l1) (ys :: l2). AllZipN ( Prod SOP ) ( LiftedCoercible f g) xs ys => SOP f xs -> SOP g ys Source # |