Safe Haskell	None
Language	Haskell2010

Data.RBR

Contents

Type-level Red-Black tree
Records and Variants
Interfacing with normal records
Interfacing with Data.SOP
Data.SOP re-exports

Synopsis

data Map k v
type EmptyMap = (E :: Map k v)
class KeysValuesAllF c t => KeysValuesAll (c :: k -> v -> Constraint) (t :: Map k v)
class KnownSymbol k => KnownKey (k :: Symbol) (v :: z)
demoteKeys :: KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t => Record (K String :: Type -> Type) t
class (KnownSymbol k, Typeable v) => KnownKeyTypeableValue (k :: Symbol) v
demoteEntries :: KeysValuesAll KnownKeyTypeableValue t => Record (K (String, TypeRep) :: Type -> Type) t
data Record (f :: Type -> Type) (t :: Map Symbol Type)
unit :: Record f (E :: Map Symbol Type)
cpure_Record :: KeysValuesAll c t => Proxy c -> (forall (k :: Symbol) v. c k v => f v) -> Record f t
collapse_Record :: Productlike ([] :: [Type]) t result => Record (K a :: Type -> Type) t -> [a]
prettyShowRecord :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, All Show flat, SListI flat) => (forall x. Show x => f x -> String) -> Record f t -> String
prettyShowRecordI :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, All Show flat, SListI flat) => Record I t -> String
data Variant (f :: Type -> Type) (t :: Map Symbol Type)
impossible :: Variant f (E :: Map Symbol Type) -> b
prettyShowVariant :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, Sumlike ([] :: [Type]) t flat, All Show flat, SListI flat) => (forall x. Show x => f x -> String) -> Variant f t -> String
prettyShowVariantI :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, Sumlike ([] :: [Type]) t flat, All Show flat, SListI flat) => Variant I t -> String
class Insertable (k :: Symbol) v (t :: Map Symbol Type) where
- type Insert (k :: Symbol) v (t :: Map Symbol Type) :: Map Symbol Type
- insert :: f v -> Record f t -> Record f (Insert k v t)
- widen :: Variant f t -> Variant f (Insert k v t)
addField :: Insertable k v t => f v -> Record f t -> Record f (Insert k v t)
insertI :: Insertable k v t => v -> Record I t -> Record I (Insert k v t)
addFieldI :: Insertable k v t => v -> Record I t -> Record I (Insert k v t)
type family InsertAll (es :: [(Symbol, Type)]) (t :: Map Symbol Type) :: Map Symbol Type where ...
type FromList (es :: [(Symbol, Type)]) = InsertAll es (E :: Map Symbol Type)
class Deletable (k :: Symbol) v (t :: Map Symbol Type) where
- type Delete (k :: Symbol) v (t :: Map Symbol Type) :: Map Symbol Type
- delete :: Record f t -> Record f (Delete k v t)
- winnow :: Variant f t -> Either (Variant f (Delete k v t)) (f v)
winnowI :: Deletable k v t => Variant I t -> Either (Variant I (Delete k v t)) v
class Key (k :: Symbol) (t :: Map Symbol Type) where
- type Value (k :: Symbol) (t :: Map Symbol Type) :: Type
- field :: Field f t (Value k t)
- branch :: Branch f t (Value k t)
type family Field (f :: Type -> Type) (t :: Map Symbol Type) v :: Type where ...
type family Branch (f :: Type -> Type) (t :: Map Symbol Type) v :: Type where ...
project :: Key k t => Record f t -> f (Value k t)
projectI :: Key k t => Record I t -> Value k t
getField :: Key k t => Record f t -> f (Value k t)
getFieldI :: Key k t => Record I t -> Value k t
setField :: Key k t => f (Value k t) -> Record f t -> Record f t
setFieldI :: Key k t => Value k t -> Record I t -> Record I t
modifyField :: Key k t => (f (Value k t) -> f (Value k t)) -> Record f t -> Record f t
modifyFieldI :: Key k t => (Value k t -> Value k t) -> Record I t -> Record I t
inject :: Key k t => f (Value k t) -> Variant f t
injectI :: Key k t => Value k t -> Variant I t
match :: Key k t => Variant f t -> Maybe (f (Value k t))
matchI :: Key k t => Variant I t -> Maybe (Value k t)
eliminate :: (Productlike ([] :: [Type]) t result, Sumlike ([] :: [Type]) t result, SListI result) => Record (Case f r) t -> Variant f t -> r
newtype Case (f :: k -> Type) a (b :: k) :: forall k. (k -> Type) -> Type -> k -> Type = Case (f b -> a)
addCase :: Insertable k v t => (f v -> a) -> Record (Case f a) t -> Record (Case f a) (Insert k v t)
addCaseI :: Insertable k v t => (v -> a) -> Record (Case I a) t -> Record (Case I a) (Insert k v t)
class (Key k t, Value k t ~ v) => PresentIn (t :: Map Symbol Type) (k :: Symbol) v
type ProductlikeSubset (subset :: Map Symbol Type) (whole :: Map Symbol Type) (flat :: [Type]) = (KeysValuesAll (PresentIn whole) subset, Productlike ([] :: [Type]) subset flat, SListI flat)
fieldSubset :: ProductlikeSubset subset whole flat => Record f whole -> (Record f subset -> Record f whole, Record f subset)
projectSubset :: ProductlikeSubset subset whole flat => Record f whole -> Record f subset
getFieldSubset :: ProductlikeSubset subset whole flat => Record f whole -> Record f subset
setFieldSubset :: ProductlikeSubset subset whole flat => Record f subset -> Record f whole -> Record f whole
modifyFieldSubset :: ProductlikeSubset subset whole flat => (Record f subset -> Record f subset) -> Record f whole -> Record f whole
type SumlikeSubset (subset :: Map Symbol Type) (whole :: Map Symbol Type) (subflat :: [Type]) (wholeflat :: [Type]) = (KeysValuesAll (PresentIn whole) subset, Productlike ([] :: [Type]) whole wholeflat, Sumlike ([] :: [Type]) whole wholeflat, SListI wholeflat, Productlike ([] :: [Type]) subset subflat, Sumlike ([] :: [Type]) subset subflat, SListI subflat)
branchSubset :: SumlikeSubset subset whole subflat wholeflat => (Variant f whole -> Maybe (Variant f subset), Variant f subset -> Variant f whole)
injectSubset :: SumlikeSubset subset whole subflat wholeflat => Variant f subset -> Variant f whole
matchSubset :: SumlikeSubset subset whole subflat wholeflat => Variant f whole -> Maybe (Variant f subset)
eliminateSubset :: SumlikeSubset subset whole subflat wholeflat => Record (Case f r) whole -> Variant f subset -> r
class ToRecord r where
- type RecordCode r :: Map Symbol Type
- toRecord :: r -> Record I (RecordCode r)
class ToRecord r => FromRecord r where
- fromRecord :: Record I (RecordCode r) -> r
type family VariantCode s :: Map Symbol Type where ...
class ToVariant s where
- toVariant :: s -> Variant I (VariantCode s)
class FromVariant s where
- fromVariant :: Variant I (VariantCode s) -> s
class Productlike (start :: [Type]) (t :: Map Symbol Type) (result :: [Type]) | start t -> result, result t -> start where
- prefixNP :: Record f t -> NP f start -> NP f result
- breakNP :: NP f result -> (Record f t, NP f start)
fromNP :: Productlike ([] :: [Type]) t result => NP f result -> Record f t
toNP :: Productlike ([] :: [Type]) t result => Record f t -> NP f result
class Sumlike (start :: [Type]) (t :: Map Symbol Type) (result :: [Type]) | start t -> result, result t -> start where
- prefixNS :: Either (NS f start) (Variant f t) -> NS f result
- breakNS :: NS f result -> Either (NS f start) (Variant f t)
fromNS :: Sumlike ([] :: [Type]) t result => NS f result -> Variant f t
toNS :: Sumlike ([] :: [Type]) t result => Variant f t -> NS f result
newtype I a = I a
newtype K a (b :: k) :: forall k. Type -> k -> Type = K a
data NP (a :: k -> Type) (b :: [k]) :: forall k. (k -> Type) -> [k] -> Type where
- Nil :: forall k (a :: k -> Type) (b :: [k]). NP a ([] :: [k])
- (:*) :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). a x -> NP a xs -> NP a (x ': xs)
data NS (a :: k -> Type) (b :: [k]) :: forall k. (k -> Type) -> [k] -> Type where
- Z :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). a x -> NS a (x ': xs)
- S :: forall k (a :: k -> Type) (b :: [k]) (xs :: [k]) (x :: k). NS a xs -> NS a (x ': xs)

Type-level Red-Black tree

A Red-Black tree that is used at the type level, with DataKinds. The tree keeps track of what keys are present and to what types they correspond.

data Map k v #

Instances

(Eq k, Eq v) => Eq (Map k v)
Instance details Defined in Data.RBR.Internal Methods (==) :: Map k v -> Map k v -> Bool # (/=) :: Map k v -> Map k v -> Bool #
(Show k, Show v) => Show (Map k v)
Instance details Defined in Data.RBR.Internal Methods showsPrec :: Int -> Map k v -> ShowS # show :: Map k v -> String # showList :: [Map k v] -> ShowS #

type EmptyMap = (E :: Map k v) #

class KeysValuesAllF c t => KeysValuesAll (c :: k -> v -> Constraint) (t :: Map k v) #

Minimal complete definition

cpara_Map

Instances

KeysValuesAll (c :: k -> v -> Constraint) (E :: Map k v)
Instance details Defined in Data.RBR.Internal Methods cpara_Map :: proxy c -> r E -> (forall (left :: Map k0 v0) (k1 :: k0) (v1 :: v0) (right :: Map k0 v0) (color :: Color). (c k1 v1, KeysValuesAll c left, KeysValuesAll c right) => r left -> r right -> r (N color left k1 v1 right)) -> r E
(c k2 v2, KeysValuesAll c left, KeysValuesAll c right) => KeysValuesAll (c :: k1 -> v1 -> Constraint) (N color left k2 v2 right :: Map k1 v1)
Instance details Defined in Data.RBR.Internal Methods cpara_Map :: proxy c -> r E -> (forall (left0 :: Map k v) (k10 :: k) (v10 :: v) (right0 :: Map k v) (color0 :: Color). (c k10 v10, KeysValuesAll c left0, KeysValuesAll c right0) => r left0 -> r right0 -> r (N color0 left0 k10 v10 right0)) -> r (N color left k2 v2 right)

class KnownSymbol k => KnownKey (k :: Symbol) (v :: z) #

Instances

KnownSymbol k => KnownKey k (v :: z)
Instance details Defined in Data.RBR.Internal

demoteKeys :: KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t => Record (K String :: Type -> Type) t #

class (KnownSymbol k, Typeable v) => KnownKeyTypeableValue (k :: Symbol) v #

Instances

(KnownSymbol k, Typeable v) => KnownKeyTypeableValue k v
Instance details Defined in Data.RBR.Internal

demoteEntries :: KeysValuesAll KnownKeyTypeableValue t => Record (K (String, TypeRep) :: Type -> Type) t #

Records and Variants

data Record (f :: Type -> Type) (t :: Map Symbol Type) #

Instances

(Productlike ([] :: [Type]) t result, Show (NP f result)) => Show (Record f t)
Instance details Defined in Data.RBR.Internal Methods showsPrec :: Int -> Record f t -> ShowS # show :: Record f t -> String # showList :: [Record f t] -> ShowS #

unit :: Record f (E :: Map Symbol Type) #

cpure_Record :: KeysValuesAll c t => Proxy c -> (forall (k :: Symbol) v. c k v => f v) -> Record f t #

collapse_Record :: Productlike ([] :: [Type]) t result => Record (K a :: Type -> Type) t -> [a] #

prettyShowRecord :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, All Show flat, SListI flat) => (forall x. Show x => f x -> String) -> Record f t -> String #

prettyShowRecordI :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, All Show flat, SListI flat) => Record I t -> String #

data Variant (f :: Type -> Type) (t :: Map Symbol Type) #

Instances

(Sumlike ([] :: [Type]) t result, Show (NS f result)) => Show (Variant f t)
Instance details Defined in Data.RBR.Internal Methods showsPrec :: Int -> Variant f t -> ShowS # show :: Variant f t -> String # showList :: [Variant f t] -> ShowS #

impossible :: Variant f (E :: Map Symbol Type) -> b #

prettyShowVariant :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, Sumlike ([] :: [Type]) t flat, All Show flat, SListI flat) => (forall x. Show x => f x -> String) -> Variant f t -> String #

prettyShowVariantI :: (KeysValuesAll (KnownKey :: Symbol -> Type -> Constraint) t, Productlike ([] :: [Type]) t flat, Sumlike ([] :: [Type]) t flat, All Show flat, SListI flat) => Variant I t -> String #

Inserting and widening

class Insertable (k :: Symbol) v (t :: Map Symbol Type) where #

Associated Types

type Insert (k :: Symbol) v (t :: Map Symbol Type) :: Map Symbol Type #

Methods

insert :: f v -> Record f t -> Record f (Insert k v t) #

widen :: Variant f t -> Variant f (Insert k v t) #

Instances

(InsertableHelper1 k v t, CanMakeBlack (Insert1 k v t)) => Insertable k v t
Instance details Defined in Data.RBR.Internal Associated Types type Insert k v t :: Map Symbol Type # Methods insert :: f v -> Record f t -> Record f (Insert k v t) # widen :: Variant f t -> Variant f (Insert k v t) #

addField :: Insertable k v t => f v -> Record f t -> Record f (Insert k v t) #

insertI :: Insertable k v t => v -> Record I t -> Record I (Insert k v t) #

addFieldI :: Insertable k v t => v -> Record I t -> Record I (Insert k v t) #

type family InsertAll (es :: [(Symbol, Type)]) (t :: Map Symbol Type) :: Map Symbol Type where ... #

Equations

InsertAll ([] :: [(Symbol, Type)]) t = t
InsertAll ((,) name fieldType ': es) t = Insert name fieldType (InsertAll es t)

type FromList (es :: [(Symbol, Type)]) = InsertAll es (E :: Map Symbol Type) #

Deleting and winnowing

class Deletable (k :: Symbol) v (t :: Map Symbol Type) where #

Associated Types

type Delete (k :: Symbol) v (t :: Map Symbol Type) :: Map Symbol Type #

Methods

delete :: Record f t -> Record f (Delete k v t) #

winnow :: Variant f t -> Either (Variant f (Delete k v t)) (f v) #

Instances

(Delable k v t, CanMakeBlack (Del k v t)) => Deletable k v t
Instance details Defined in Data.RBR.Internal Associated Types type Delete k v t :: Map Symbol Type # Methods delete :: Record f t -> Record f (Delete k v t) # winnow :: Variant f t -> Either (Variant f (Delete k v t)) (f v) #

winnowI :: Deletable k v t => Variant I t -> Either (Variant I (Delete k v t)) v #

Projecting and injecting

class Key (k :: Symbol) (t :: Map Symbol Type) where #

Associated Types

type Value (k :: Symbol) (t :: Map Symbol Type) :: Type #

Methods

field :: Field f t (Value k t) #

branch :: Branch f t (Value k t) #

Instances

(CmpSymbol k' k ~ ordering, KeyHelper ordering k left v' right) => Key k (N color left k' v' right)
Instance details Defined in Data.RBR.Internal Associated Types type Value k (N color left k' v' right) :: Type # Methods field :: Field f (N color left k' v' right) (Value k (N color left k' v' right)) # branch :: Branch f (N color left k' v' right) (Value k (N color left k' v' right)) #

type family Field (f :: Type -> Type) (t :: Map Symbol Type) v :: Type where ... #

Equations

Field f t v = Record f t -> (f v -> Record f t, f v)

type family Branch (f :: Type -> Type) (t :: Map Symbol Type) v :: Type where ... #

Equations

Branch f t v = (Variant f t -> Maybe (f v), f v -> Variant f t)

project :: Key k t => Record f t -> f (Value k t) #

projectI :: Key k t => Record I t -> Value k t #

getField :: Key k t => Record f t -> f (Value k t) #

getFieldI :: Key k t => Record I t -> Value k t #

setField :: Key k t => f (Value k t) -> Record f t -> Record f t #

setFieldI :: Key k t => Value k t -> Record I t -> Record I t #

modifyField :: Key k t => (f (Value k t) -> f (Value k t)) -> Record f t -> Record f t #

modifyFieldI :: Key k t => (Value k t -> Value k t) -> Record I t -> Record I t #

inject :: Key k t => f (Value k t) -> Variant f t #

injectI :: Key k t => Value k t -> Variant I t #

match :: Key k t => Variant f t -> Maybe (f (Value k t)) #

matchI :: Key k t => Variant I t -> Maybe (Value k t) #

Eliminating variants

eliminate :: (Productlike ([] :: [Type]) t result, Sumlike ([] :: [Type]) t result, SListI result) => Record (Case f r) t -> Variant f t -> r #

newtype Case (f :: k -> Type) a (b :: k) :: forall k. (k -> Type) -> Type -> k -> Type #

Constructors

Case (f b -> a)

addCase :: Insertable k v t => (f v -> a) -> Record (Case f a) t -> Record (Case f a) (Insert k v t) #

addCaseI :: Insertable k v t => (v -> a) -> Record (Case I a) t -> Record (Case I a) (Insert k v t) #

Subsets of fields and branches

class (Key k t, Value k t ~ v) => PresentIn (t :: Map Symbol Type) (k :: Symbol) v #

Instances

(Key k t, Value k t ~ v) => PresentIn t k v
Instance details Defined in Data.RBR.Internal

type ProductlikeSubset (subset :: Map Symbol Type) (whole :: Map Symbol Type) (flat :: [Type]) = (KeysValuesAll (PresentIn whole) subset, Productlike ([] :: [Type]) subset flat, SListI flat) #

fieldSubset :: ProductlikeSubset subset whole flat => Record f whole -> (Record f subset -> Record f whole, Record f subset) #

projectSubset :: ProductlikeSubset subset whole flat => Record f whole -> Record f subset #

getFieldSubset :: ProductlikeSubset subset whole flat => Record f whole -> Record f subset #

setFieldSubset :: ProductlikeSubset subset whole flat => Record f subset -> Record f whole -> Record f whole #

modifyFieldSubset :: ProductlikeSubset subset whole flat => (Record f subset -> Record f subset) -> Record f whole -> Record f whole #

type SumlikeSubset (subset :: Map Symbol Type) (whole :: Map Symbol Type) (subflat :: [Type]) (wholeflat :: [Type]) = (KeysValuesAll (PresentIn whole) subset, Productlike ([] :: [Type]) whole wholeflat, Sumlike ([] :: [Type]) whole wholeflat, SListI wholeflat, Productlike ([] :: [Type]) subset subflat, Sumlike ([] :: [Type]) subset subflat, SListI subflat) #

branchSubset :: SumlikeSubset subset whole subflat wholeflat => (Variant f whole -> Maybe (Variant f subset), Variant f subset -> Variant f whole) #

injectSubset :: SumlikeSubset subset whole subflat wholeflat => Variant f subset -> Variant f whole #

matchSubset :: SumlikeSubset subset whole subflat wholeflat => Variant f whole -> Maybe (Variant f subset) #

eliminateSubset :: SumlikeSubset subset whole subflat wholeflat => Record (Case f r) whole -> Variant f subset -> r #

Interfacing with normal records

Typeclasses for converting to and from normal Haskell records and sum types.

They have default implementations based in GHC.Generics:

>>> data Person = Person { name :: String, age :: Int } deriving (Generic, Show)
>>> instance ToRecord Person
>>> instance FromRecord Person

>>> data Summy = Lefty Int | Righty Bool deriving (Generic,Show)
>>> instance ToVariant Summy
>>> instance FromVariant Summy

Only single-constructor records with named fields can have ToRecord and FromRecord instances.

Only sum types with exactly one anonymous argument on each branch can have ToVariant and FromVariant instances.

class ToRecord r where #

Minimal complete definition

Nothing

Associated Types

type RecordCode r :: Map Symbol Type #

Methods

toRecord :: r -> Record I (RecordCode r) #

class ToRecord r => FromRecord r where #

Minimal complete definition

Nothing

Methods

fromRecord :: Record I (RecordCode r) -> r #

type family VariantCode s :: Map Symbol Type where ... #

Equations

VariantCode s = VariantCode' (E :: Map Symbol Type) (Rep s)

class ToVariant s where #

Minimal complete definition

Nothing

Methods

toVariant :: s -> Variant I (VariantCode s) #

class FromVariant s where #

Minimal complete definition

Nothing

Methods

fromVariant :: Variant I (VariantCode s) -> s #

Interfacing with Data.SOP

class Productlike (start :: [Type]) (t :: Map Symbol Type) (result :: [Type]) | start t -> result, result t -> start where #

Methods

prefixNP :: Record f t -> NP f start -> NP f result #

breakNP :: NP f result -> (Record f t, NP f start) #

Instances

Productlike start (E :: Map Symbol Type) start
Instance details Defined in Data.RBR.Internal Methods prefixNP :: Record f E -> NP f start -> NP f start # breakNP :: NP f start -> (Record f E, NP f start) #
(Productlike start right middle, Productlike (v ': middle) left result) => Productlike start (N color left k v right) result
Instance details Defined in Data.RBR.Internal Methods prefixNP :: Record f (N color left k v right) -> NP f start -> NP f result # breakNP :: NP f result -> (Record f (N color left k v right), NP f start) #

fromNP :: Productlike ([] :: [Type]) t result => NP f result -> Record f t #

toNP :: Productlike ([] :: [Type]) t result => Record f t -> NP f result #

class Sumlike (start :: [Type]) (t :: Map Symbol Type) (result :: [Type]) | start t -> result, result t -> start where #

Methods

prefixNS :: Either (NS f start) (Variant f t) -> NS f result #

breakNS :: NS f result -> Either (NS f start) (Variant f t) #

Instances

(Sumlike start (N colorR leftR kR vR rightR) middle, Sumlike (v ': middle) (N colorL leftL kL vL rightL) result) => Sumlike start (N color (N colorL leftL kL vL rightL) k v (N colorR leftR kR vR rightR)) result
Instance details Defined in Data.RBR.Internal Methods prefixNS :: Either (NS f start) (Variant f (N color (N colorL leftL kL vL rightL) k v (N colorR leftR kR vR rightR))) -> NS f result # breakNS :: NS f result -> Either (NS f start) (Variant f (N color (N colorL leftL kL vL rightL) k v (N colorR leftR kR vR rightR))) #
Sumlike (v ': start) (N colorL leftL kL vL rightL) result => Sumlike start (N color (N colorL leftL kL vL rightL) k v (E :: Map Symbol Type)) result
Instance details Defined in Data.RBR.Internal Methods prefixNS :: Either (NS f start) (Variant f (N color (N colorL leftL kL vL rightL) k v E)) -> NS f result # breakNS :: NS f result -> Either (NS f start) (Variant f (N color (N colorL leftL kL vL rightL) k v E)) #
Sumlike start (N color (E :: Map Symbol Type) k v (E :: Map Symbol Type)) (v ': start)
Instance details Defined in Data.RBR.Internal Methods prefixNS :: Either (NS f start) (Variant f (N color E k v E)) -> NS f (v ': start) # breakNS :: NS f (v ': start) -> Either (NS f start) (Variant f (N color E k v E)) #
Sumlike start (N colorR leftR kR vR rightR) middle => Sumlike start (N color (E :: Map Symbol Type) k v (N colorR leftR kR vR rightR)) (v ': middle)
Instance details Defined in Data.RBR.Internal Methods prefixNS :: Either (NS f start) (Variant f (N color E k v (N colorR leftR kR vR rightR))) -> NS f (v ': middle) # breakNS :: NS f (v ': middle) -> Either (NS f start) (Variant f (N color E k v (N colorR leftR kR vR rightR))) #

fromNS :: Sumlike ([] :: [Type]) t result => NS f result -> Variant f t #

toNS :: Sumlike ([] :: [Type]) t result => Variant f t -> NS f result #

Data.SOP re-exports

newtype I a #

The identity type functor.

Like Identity, but with a shorter name.

Constructors

I a

Instances

Monad I
Instance details Defined in Data.SOP.BasicFunctors Methods (>>=) :: I a -> (a -> I b) -> I b # (>>) :: I a -> I b -> I b # return :: a -> I a # fail :: String -> I a #
Functor I
Instance details Defined in Data.SOP.BasicFunctors Methods fmap :: (a -> b) -> I a -> I b # (<$) :: a -> I b -> I a #
Applicative I
Instance details Defined in Data.SOP.BasicFunctors Methods pure :: a -> I a # (<>) :: I (a -> b) -> I a -> I b # liftA2 :: (a -> b -> c) -> I a -> I b -> I c # (>) :: I a -> I b -> I b # (<*) :: I a -> I b -> I a #
Foldable I
Instance details Defined in Data.SOP.BasicFunctors Methods fold :: Monoid m => I m -> m # foldMap :: Monoid m => (a -> m) -> I a -> m # foldr :: (a -> b -> b) -> b -> I a -> b # foldr' :: (a -> b -> b) -> b -> I a -> b # foldl :: (b -> a -> b) -> b -> I a -> b # foldl' :: (b -> a -> b) -> b -> I a -> b # foldr1 :: (a -> a -> a) -> I a -> a # foldl1 :: (a -> a -> a) -> I a -> a # toList :: I a -> [a] # null :: I a -> Bool # length :: I a -> Int # elem :: Eq a => a -> I a -> Bool # maximum :: Ord a => I a -> a # minimum :: Ord a => I a -> a # sum :: Num a => I a -> a # product :: Num a => I a -> a #
Traversable I
Instance details Defined in Data.SOP.BasicFunctors Methods traverse :: Applicative f => (a -> f b) -> I a -> f (I b) # sequenceA :: Applicative f => I (f a) -> f (I a) # mapM :: Monad m => (a -> m b) -> I a -> m (I b) # sequence :: Monad m => I (m a) -> m (I a) #
Eq1 I	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftEq :: (a -> b -> Bool) -> I a -> I b -> Bool #
Ord1 I	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftCompare :: (a -> b -> Ordering) -> I a -> I b -> Ordering #
Read1 I	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (I a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [I a] # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (I a) # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [I a] #
Show1 I	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> I a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [I a] -> ShowS #
NFData1 I	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftRnf :: (a -> ()) -> I a -> () #
Eq a => Eq (I a)
Instance details Defined in Data.SOP.BasicFunctors Methods (==) :: I a -> I a -> Bool # (/=) :: I a -> I a -> Bool #
Ord a => Ord (I a)
Instance details Defined in Data.SOP.BasicFunctors Methods compare :: I a -> I a -> Ordering # (<) :: I a -> I a -> Bool # (<=) :: I a -> I a -> Bool # (>) :: I a -> I a -> Bool # (>=) :: I a -> I a -> Bool # max :: I a -> I a -> I a # min :: I a -> I a -> I a #
Read a => Read (I a)
Instance details Defined in Data.SOP.BasicFunctors Methods readsPrec :: Int -> ReadS (I a) # readList :: ReadS [I a] # readPrec :: ReadPrec (I a) # readListPrec :: ReadPrec [I a] #
Show a => Show (I a)
Instance details Defined in Data.SOP.BasicFunctors Methods showsPrec :: Int -> I a -> ShowS # show :: I a -> String # showList :: [I a] -> ShowS #
Generic (I a)
Instance details Defined in Data.SOP.BasicFunctors Associated Types type Rep (I a) :: Type -> Type # Methods from :: I a -> Rep (I a) x # to :: Rep (I a) x -> I a #
Semigroup a => Semigroup (I a)	Since: sop-core-0.4.0.0
Instance details Defined in Data.SOP.BasicFunctors Methods (<>) :: I a -> I a -> I a # sconcat :: NonEmpty (I a) -> I a # stimes :: Integral b => b -> I a -> I a #
Monoid a => Monoid (I a)	Since: sop-core-0.4.0.0
Instance details Defined in Data.SOP.BasicFunctors Methods mempty :: I a # mappend :: I a -> I a -> I a # mconcat :: [I a] -> I a #
NFData a => NFData (I a)	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.BasicFunctors Methods rnf :: I a -> () #
type Rep (I a)
Instance details Defined in Data.SOP.BasicFunctors type Rep (I a) = D1 (MetaData "I" "Data.SOP.BasicFunctors" "sop-core-0.4.0.0-F1xCWaFkXPd3dWDWBPXHJg" True) (C1 (MetaCons "I" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

newtype K a (b :: k) :: forall k. Type -> k -> Type #

The constant type functor.

Like Constant, but kind-polymorphic in its second argument and with a shorter name.

Constructors

K a

Instances

Eq2 (K :: Type -> Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftEq2 :: (a -> b -> Bool) -> (c -> d -> Bool) -> K a c -> K b d -> Bool #
Ord2 (K :: Type -> Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftCompare2 :: (a -> b -> Ordering) -> (c -> d -> Ordering) -> K a c -> K b d -> Ordering #
Read2 (K :: Type -> Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftReadsPrec2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (K a b) # liftReadList2 :: (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [K a b] # liftReadPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec (K a b) # liftReadListPrec2 :: ReadPrec a -> ReadPrec [a] -> ReadPrec b -> ReadPrec [b] -> ReadPrec [K a b] #
Show2 (K :: Type -> Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftShowsPrec2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> K a b -> ShowS # liftShowList2 :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [K a b] -> ShowS #
NFData2 (K :: Type -> Type -> Type)	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftRnf2 :: (a -> ()) -> (b -> ()) -> K a b -> () #
Functor (K a :: Type -> Type)
Instance details Defined in Data.SOP.BasicFunctors Methods fmap :: (a0 -> b) -> K a a0 -> K a b # (<$) :: a0 -> K a b -> K a a0 #
Monoid a => Applicative (K a :: Type -> Type)
Instance details Defined in Data.SOP.BasicFunctors Methods pure :: a0 -> K a a0 # (<>) :: K a (a0 -> b) -> K a a0 -> K a b # liftA2 :: (a0 -> b -> c) -> K a a0 -> K a b -> K a c # (>) :: K a a0 -> K a b -> K a b # (<*) :: K a a0 -> K a b -> K a a0 #
Foldable (K a :: Type -> Type)
Instance details Defined in Data.SOP.BasicFunctors Methods fold :: Monoid m => K a m -> m # foldMap :: Monoid m => (a0 -> m) -> K a a0 -> m # foldr :: (a0 -> b -> b) -> b -> K a a0 -> b # foldr' :: (a0 -> b -> b) -> b -> K a a0 -> b # foldl :: (b -> a0 -> b) -> b -> K a a0 -> b # foldl' :: (b -> a0 -> b) -> b -> K a a0 -> b # foldr1 :: (a0 -> a0 -> a0) -> K a a0 -> a0 # foldl1 :: (a0 -> a0 -> a0) -> K a a0 -> a0 # toList :: K a a0 -> [a0] # null :: K a a0 -> Bool # length :: K a a0 -> Int # elem :: Eq a0 => a0 -> K a a0 -> Bool # maximum :: Ord a0 => K a a0 -> a0 # minimum :: Ord a0 => K a a0 -> a0 # sum :: Num a0 => K a a0 -> a0 # product :: Num a0 => K a a0 -> a0 #
Traversable (K a :: Type -> Type)
Instance details Defined in Data.SOP.BasicFunctors Methods traverse :: Applicative f => (a0 -> f b) -> K a a0 -> f (K a b) # sequenceA :: Applicative f => K a (f a0) -> f (K a a0) # mapM :: Monad m => (a0 -> m b) -> K a a0 -> m (K a b) # sequence :: Monad m => K a (m a0) -> m (K a a0) #
Eq a => Eq1 (K a :: Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftEq :: (a0 -> b -> Bool) -> K a a0 -> K a b -> Bool #
Ord a => Ord1 (K a :: Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftCompare :: (a0 -> b -> Ordering) -> K a a0 -> K a b -> Ordering #
Read a => Read1 (K a :: Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftReadsPrec :: (Int -> ReadS a0) -> ReadS [a0] -> Int -> ReadS (K a a0) # liftReadList :: (Int -> ReadS a0) -> ReadS [a0] -> ReadS [K a a0] # liftReadPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec (K a a0) # liftReadListPrec :: ReadPrec a0 -> ReadPrec [a0] -> ReadPrec [K a a0] #
Show a => Show1 (K a :: Type -> Type)	Since: sop-core-0.2.4.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftShowsPrec :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> Int -> K a a0 -> ShowS # liftShowList :: (Int -> a0 -> ShowS) -> ([a0] -> ShowS) -> [K a a0] -> ShowS #
NFData a => NFData1 (K a :: Type -> Type)	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.BasicFunctors Methods liftRnf :: (a0 -> ()) -> K a a0 -> () #
Eq a => Eq (K a b)
Instance details Defined in Data.SOP.BasicFunctors Methods (==) :: K a b -> K a b -> Bool # (/=) :: K a b -> K a b -> Bool #
Ord a => Ord (K a b)
Instance details Defined in Data.SOP.BasicFunctors Methods compare :: K a b -> K a b -> Ordering # (<) :: K a b -> K a b -> Bool # (<=) :: K a b -> K a b -> Bool # (>) :: K a b -> K a b -> Bool # (>=) :: K a b -> K a b -> Bool # max :: K a b -> K a b -> K a b # min :: K a b -> K a b -> K a b #
Read a => Read (K a b)
Instance details Defined in Data.SOP.BasicFunctors Methods readsPrec :: Int -> ReadS (K a b) # readList :: ReadS [K a b] # readPrec :: ReadPrec (K a b) # readListPrec :: ReadPrec [K a b] #
Show a => Show (K a b)
Instance details Defined in Data.SOP.BasicFunctors Methods showsPrec :: Int -> K a b -> ShowS # show :: K a b -> String # showList :: [K a b] -> ShowS #
Generic (K a b)
Instance details Defined in Data.SOP.BasicFunctors Associated Types type Rep (K a b) :: Type -> Type # Methods from :: K a b -> Rep (K a b) x # to :: Rep (K a b) x -> K a b #
Semigroup a => Semigroup (K a b)	Since: sop-core-0.4.0.0
Instance details Defined in Data.SOP.BasicFunctors Methods (<>) :: K a b -> K a b -> K a b # sconcat :: NonEmpty (K a b) -> K a b # stimes :: Integral b0 => b0 -> K a b -> K a b #
Monoid a => Monoid (K a b)	Since: sop-core-0.4.0.0
Instance details Defined in Data.SOP.BasicFunctors Methods mempty :: K a b # mappend :: K a b -> K a b -> K a b # mconcat :: [K a b] -> K a b #
NFData a => NFData (K a b)	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.BasicFunctors Methods rnf :: K a b -> () #
type Rep (K a b)
Instance details Defined in Data.SOP.BasicFunctors type Rep (K a b) = D1 (MetaData "K" "Data.SOP.BasicFunctors" "sop-core-0.4.0.0-F1xCWaFkXPd3dWDWBPXHJg" True) (C1 (MetaCons "K" PrefixI False) (S1 (MetaSel (Nothing :: Maybe Symbol) NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 a)))

data NP (a :: k -> Type) (b :: [k]) :: forall k. (k -> Type) -> [k] -> Type where #

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 ]

Constructors

Nil :: forall k (a :: k -> Type) (b :: [k]). NP a ([] :: [k])
(:*) :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). a x -> NP a xs -> NP a (x ': xs) infixr 5

Instances

HTrans (NP :: (k1 -> Type) -> [k1] -> Type) (NP :: (k2 -> Type) -> [k2] -> Type)
Instance details Defined in Data.SOP.NP Methods htrans :: 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 # hcoerce :: (AllZipN (Prod NP) (LiftedCoercible f g) xs ys, HTrans NP NP) => NP f xs -> NP g ys #
HPure (NP :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NP Methods hpure :: SListIN NP xs => (forall (a :: k0). f a) -> NP f xs # hcpure :: AllN NP c xs => proxy c -> (forall (a :: k0). c a => f a) -> NP f xs #
HAp (NP :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NP Methods hap :: Prod NP (f -.-> g) xs -> NP f xs -> NP g xs #
HCollapse (NP :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NP Methods hcollapse :: SListIN NP xs => NP (K a) xs -> CollapseTo NP a #
HTraverse_ (NP :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NP Methods hctraverse_ :: (AllN NP c xs, Applicative g) => proxy c -> (forall (a :: k0). c a => f a -> g ()) -> NP f xs -> g () # htraverse_ :: (SListIN NP xs, Applicative g) => (forall (a :: k0). f a -> g ()) -> NP f xs -> g () #
HSequence (NP :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NP Methods hsequence' :: (SListIN NP xs, Applicative f) => NP (f :.: g) xs -> f (NP g xs) # hctraverse' :: (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) # htraverse' :: (SListIN NP xs, Applicative g) => (forall (a :: k0). f a -> g (f' a)) -> NP f xs -> g (NP f' xs) #
All (Compose Eq f) xs => Eq (NP f xs)
Instance details Defined in Data.SOP.NP Methods (==) :: NP f xs -> NP f xs -> Bool # (/=) :: NP f xs -> NP f xs -> Bool #
(All (Compose Eq f) xs, All (Compose Ord f) xs) => Ord (NP f xs)
Instance details Defined in Data.SOP.NP Methods compare :: NP f xs -> NP f xs -> Ordering # (<) :: NP f xs -> NP f xs -> Bool # (<=) :: NP f xs -> NP f xs -> Bool # (>) :: NP f xs -> NP f xs -> Bool # (>=) :: NP f xs -> NP f xs -> Bool # max :: NP f xs -> NP f xs -> NP f xs # min :: NP f xs -> NP f xs -> NP f xs #
All (Compose Show f) xs => Show (NP f xs)
Instance details Defined in Data.SOP.NP Methods showsPrec :: Int -> NP f xs -> ShowS # show :: NP f xs -> String # showList :: [NP f xs] -> ShowS #
All (Compose Semigroup f) xs => Semigroup (NP f xs)	Since: sop-core-0.4.0.0
Instance details Defined in Data.SOP.NP Methods (<>) :: NP f xs -> NP f xs -> NP f xs # sconcat :: NonEmpty (NP f xs) -> NP f xs # stimes :: Integral b => b -> NP f xs -> NP f xs #
(All (Compose Monoid f) xs, All (Compose Semigroup f) xs) => Monoid (NP f xs)	Since: sop-core-0.4.0.0
Instance details Defined in Data.SOP.NP Methods mempty :: NP f xs # mappend :: NP f xs -> NP f xs -> NP f xs # mconcat :: [NP f xs] -> NP f xs #
All (Compose NFData f) xs => NFData (NP f xs)	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.NP Methods rnf :: NP f xs -> () #
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 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 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)
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 SListIN (NP :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NP type SListIN (NP :: (k -> Type) -> [k] -> Type) = (SListI :: [k] -> Constraint)
type AllN (NP :: (k -> Type) -> [k] -> Type) (c :: k -> Constraint)
Instance details Defined in Data.SOP.NP type AllN (NP :: (k -> Type) -> [k] -> Type) (c :: k -> Constraint) = All c
type AllZipN (NP :: (k -> Type) -> [k] -> Type) (c :: a -> b -> Constraint)
Instance details Defined in Data.SOP.NP type AllZipN (NP :: (k -> Type) -> [k] -> Type) (c :: a -> b -> Constraint) = AllZip c

data NS (a :: k -> Type) (b :: [k]) :: forall k. (k -> Type) -> [k] -> Type where #

An n-ary sum.

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

The constructor names are chosen to resemble Peano-style natural numbers, i.e., Z is for "zero", and S is for "successor". Chaining S and Z chooses the corresponding component of the sum.

Examples:

Z         :: f x -> NS f (x ': xs)
S . Z     :: f y -> NS f (x ': y ': xs)
S . S . Z :: f z -> NS f (x ': y ': z ': xs)
...

Note that empty sums (indexed by an empty list) have no non-bottom elements.

Two common instantiations of f are the identity functor I and the constant functor K. For I, the sum becomes a direct generalization of the Either type to arbitrarily many choices. For K a, the result is a homogeneous choice type, where the contents of the type-level list are ignored, but its length specifies the number of options.

In the context of the SOP approach to generic programming, an n-ary sum describes the top-level structure of a datatype, which is a choice between all of its constructors.

Examples:

Z (I 'x')      :: NS I       '[ Char, Bool ]
S (Z (I True)) :: NS I       '[ Char, Bool ]
S (Z (K 1))    :: NS (K Int) '[ Char, Bool ]

Constructors

Z :: forall k (a :: k -> Type) (b :: [k]) (x :: k) (xs :: [k]). a x -> NS a (x ': xs)
S :: forall k (a :: k -> Type) (b :: [k]) (xs :: [k]) (x :: k). NS a xs -> NS a (x ': xs)

Instances

HTrans (NS :: (k1 -> Type) -> [k1] -> Type) (NS :: (k2 -> Type) -> [k2] -> Type)
Instance details Defined in Data.SOP.NS Methods htrans :: 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 # hcoerce :: (AllZipN (Prod NS) (LiftedCoercible f g) xs ys, HTrans NS NS) => NS f xs -> NS g ys #
HAp (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hap :: Prod NS (f -.-> g) xs -> NS f xs -> NS g xs #
HCollapse (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hcollapse :: SListIN NS xs => NS (K a) xs -> CollapseTo NS a #
HTraverse_ (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hctraverse_ :: (AllN NS c xs, Applicative g) => proxy c -> (forall (a :: k0). c a => f a -> g ()) -> NS f xs -> g () # htraverse_ :: (SListIN NS xs, Applicative g) => (forall (a :: k0). f a -> g ()) -> NS f xs -> g () #
HSequence (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hsequence' :: (SListIN NS xs, Applicative f) => NS (f :.: g) xs -> f (NS g xs) # hctraverse' :: (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) # htraverse' :: (SListIN NS xs, Applicative g) => (forall (a :: k0). f a -> g (f' a)) -> NS f xs -> g (NS f' xs) #
HIndex (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hindex :: NS f xs -> Int #
HApInjs (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hapInjs :: SListIN NS xs => Prod NS f xs -> [NS f xs] #
HExpand (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS Methods hexpand :: SListIN (Prod NS) xs => (forall (x :: k0). f x) -> NS f xs -> Prod NS f xs # hcexpand :: AllN (Prod NS) c xs => proxy c -> (forall (x :: k0). c x => f x) -> NS f xs -> Prod NS f xs #
All (Compose Eq f) xs => Eq (NS f xs)
Instance details Defined in Data.SOP.NS Methods (==) :: NS f xs -> NS f xs -> Bool # (/=) :: NS f xs -> NS f xs -> Bool #
(All (Compose Eq f) xs, All (Compose Ord f) xs) => Ord (NS f xs)
Instance details Defined in Data.SOP.NS Methods compare :: NS f xs -> NS f xs -> Ordering # (<) :: NS f xs -> NS f xs -> Bool # (<=) :: NS f xs -> NS f xs -> Bool # (>) :: NS f xs -> NS f xs -> Bool # (>=) :: NS f xs -> NS f xs -> Bool # max :: NS f xs -> NS f xs -> NS f xs # min :: NS f xs -> NS f xs -> NS f xs #
All (Compose Show f) xs => Show (NS f xs)
Instance details Defined in Data.SOP.NS Methods showsPrec :: Int -> NS f xs -> ShowS # show :: NS f xs -> String # showList :: [NS f xs] -> ShowS #
All (Compose NFData f) xs => NFData (NS f xs)	Since: sop-core-0.2.5.0
Instance details Defined in Data.SOP.NS Methods rnf :: NS f xs -> () #
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 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)
type CollapseTo (NS :: (k -> Type) -> [k] -> Type) a
Instance details Defined in Data.SOP.NS type CollapseTo (NS :: (k -> Type) -> [k] -> Type) a = a
type SListIN (NS :: (k -> Type) -> [k] -> Type)
Instance details Defined in Data.SOP.NS type SListIN (NS :: (k -> Type) -> [k] -> Type) = (SListI :: [k] -> Constraint)
type AllN (NS :: (k -> Type) -> [k] -> Type) (c :: k -> Constraint)
Instance details Defined in Data.SOP.NS type AllN (NS :: (k -> Type) -> [k] -> Type) (c :: k -> Constraint) = All c