Data.RBR

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

The Red-Black tree. It will be used, as a kind, to index the Record and Variant types.

Instances

(Eq k, Eq v) => Eq (Map k v)

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)

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

A map without entries. See also unit and impossible.

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

Require a constraint for every key-value pair in a tree. This is a generalization of All from Data.SOP.

cpara_Map constructs a Record by means of a constraint for producing the nodes of the tree. The constraint is passed as a Proxy.

Minimal complete definition

cpara_Map

Instances

KeysValuesAll (c :: k -> v -> Constraint) (E :: Map k v)

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)

Defined in Data.RBR.Internal

Methods

cpara_Map :: proxy c -> r E -> (forall (left0 :: Map k v) (k :: k) (v :: v) (right0 :: Map k v) (color0 :: Color). (c k v, KeysValuesAll c left0, KeysValuesAll c right0) => r left0 -> r right0 -> r (N color0 left0 k v right0)) -> r (N color left k2 v2 right)

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

Two-place constraint saying that the symbol can be demoted to String. Nothing is required from the value type.

Defined using the "class synonym" trick.

Instances

KnownSymbol k => KnownKey k (v :: z)

Defined in Data.RBR.Internal

demoteKeys :: forall t. KeysValuesAll KnownKey t => Record (K String) t

Create a Record containing the names of each field.

The names are represented by a constant functor K carrying an annotation of type String. This means that there aren't actually any values of the type that corresponds to each field, only the String annotations.

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

Two-place constraint saying that the symbol can be demoted to String, and that a term-level representation can be obtained for the value type.

Defined using the "class synonym" trick.

Instances

(KnownSymbol k, Typeable v) => KnownKeyTypeableValue k v

Defined in Data.RBR.Internal

demoteEntries :: forall t. KeysValuesAll KnownKeyTypeableValue t => Record (K (String, TypeRep)) t

Create a record containing the names of each field along with a term-level representation of each type.

See also collapse_Record for getting the entries as a list.

Records and Variants

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

An extensible product-like type with named fields.

The values in the Record come wrapped in a type constructor f, which por pure records will be the identity functor I.

Instances

(Productlike ([] :: [Type]) t result, Show (NP f result)) => Show (Record f t)

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

A Record without components is a boring, uninformative type whose single value can be conjured out of thin air.

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

Create a Record, knowing that both keys and values satisfy a 2-place constraint. The constraint is passed as a Proxy.

The naming scheme follows that of cpure_NP.

collapse_Record :: forall t result a. Productlike '[] t result => Record (K a) t -> [a]

Collapse a Record composed of K annotations.

The naming scheme follows that of collapse_NP.

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

Show a Record in a friendlier way than the default Show instance. The function argument will usually be show, but it can be used to unwrap the value of each field before showing it.

prettyShowRecordI :: forall t flat. (KeysValuesAll KnownKey t, Productlike '[] t flat, All Show flat, SListI flat) => Record I t -> String

Like prettyShowRecord but specialized to pure records.

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

An extensible sum-like type with named branches.

The values in the Variant come wrapped in a type constructor f, which por pure variants will be the identity functor I.

Instances

(Sumlike ([] :: [Type]) t result, Show (NS f result)) => Show (Variant f t)

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 -> b

A Variant without branches doesn't have any values. From an impossible thing, anything can come out.

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

Show a Variant in a friendlier way than the default Show instance. The function argument will usually be show, but it can be used to unwrap the value of the branch before showing it.

prettyShowVariantI :: forall t flat. (KeysValuesAll KnownKey t, Productlike '[] t flat, Sumlike '[] t flat, All Show flat, SListI flat) => Variant I t -> String

Like prettyShowVariant but specialized to pure variants.

Inserting and widening

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

Class that determines if the pair of a Symbol key and a Type can be inserted into a type-level tree.

The associated type family Insert produces the resulting tree.

At the term level, this manifests in insert, which adds a new field to a record, and in widen, which lets you use a Variant in a bigger context than the one in which is was defined. insert tends to be more useful in practice.

If the tree already has the key but with a different type, the insertion fails to compile.

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)

Instances

(InsertableHelper1 k v t, CanMakeBlack (Insert1 k v t)) => Insertable k v t

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 :: forall k v t f. Insertable k v t => f v -> Record f t -> Record f (Insert k v t)

Alias for insert.

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

Like insert but specialized to pure Records.

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

Like addField but specialized to pure Records.

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

Insert a list of type level key / value pairs into a type-level tree.

Equations

InsertAll '[] t = t

InsertAll ('(name, fieldType) ': es) t = Insert name fieldType (InsertAll es t)

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

Build a type-level tree out of a list of type level key / value pairs.

Deleting and winnowing

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

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)

Instances

(Delable k v t, CanMakeBlack (Del k v t)) => Deletable k v t

Class that determines if the pair of a Symbol key and a Type can be deleted from a type-level tree.

The associated type family Delete produces the resulting tree.

At the term level, this manifests in delete, which removes a field from a record, and in winnow, which checks if a Variant is of a given branch and returns the value in the branch if there's a match, or a reduced Variant if there isn't.

winnow tends to be more useful in practice.

If the tree already has the key but with a different type, the deletion fails to compile.

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 :: forall k v t. Deletable k v t => Variant I t -> Either (Variant I (Delete k v t)) v

Like winnow but specialized to pure Variants.

Projecting and injecting

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

Class that determines if a given Symbol key is present in a type-level tree.

The Value type family gives the Type corresponding to the key.

field takes a field name (given through TypeApplications) and a Record, and returns a pair of a setter for the field and the original value of the field.

branch takes a branch name (given through TypeApplications) and returns a pair of a match function and a constructor.

Associated Types

type Value k t :: 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)

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 ...

Auxiliary type family to avoid repetition and help improve compilation times.

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 ...

Auxiliary type family to avoid repetition and help improve compilation times.

Equations

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

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

Get the value of a field for a Record.

projectI :: forall k t. Key k t => Record I t -> Value k t

Like project but specialized to pure Records.

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

Alias for project.

getFieldI :: forall k t. Key k t => Record I t -> Value k t

Like getField but specialized to pure Records.

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

Set the value of a field for a Record.

setFieldI :: forall k t. Key k t => Value k t -> Record I t -> Record I t

Like setField but specialized to pure Records.

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

Modify the value of a field for a Record.

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

Like modifyField but specialized to pure Records.

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

Put a value into the branch of a Variant.

injectI :: forall k t. Key k t => Value k t -> Variant I t

Like inject but specialized to pure Variants.

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

Check if a Variant value is the given branch.

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

Like match but specialized to pure Variantss.

Eliminating variants

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

Process a Variant using a eliminator Record that carries handlers for each possible branch of the Variant.

newtype Case f a b

Represents a handler for a branch of a Variant.

Constructors

Case (f b -> a)

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

A form of addField for creating eliminators for Variants.

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

A pure version of addCase.

Subsets of fields and branches

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

Instances

(Key k t, Value k t ~ v) => PresentIn t k v

Defined in Data.RBR.Internal

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

Constraint for trees that represent subsets of fields of Record-like types.

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

Like field, but targets multiple fields at the same time

projectSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f whole -> Record f subset

Like project, but extracts multiple fields at the same time.

Can also be used to convert between structurally dissimilar trees that nevertheless have the same entries.

getFieldSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f whole -> Record f subset

Alias for projectSubset.

setFieldSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f subset -> Record f whole -> Record f whole

Like setField, but sets multiple fields at the same time.

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

Like modifyField, but modifies multiple fields at the same time.

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

Constraint for trees that represent subsets of branches of Variant-like types.

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

Like branch, but targets multiple branches at the same time.

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

Like inject, but injects one of several possible branches.

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

Like match, but matches more than one branch.

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

Like eliminate, but allows the eliminator Record to have more fields than there are branches in the Variant.

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 :: Type) where

Minimal complete definition

Nothing

Associated Types

type RecordCode r :: Map Symbol Type

Methods

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

toRecord :: (Generic r, ToRecordHelper E (Rep r), RecordCode r ~ RecordCode' E (Rep r)) => r -> Record I (RecordCode r)

class ToRecord r => FromRecord (r :: Type) where

Minimal complete definition

Nothing

Methods

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

fromRecord :: (Generic r, FromRecordHelper (RecordCode r) (Rep r)) => Record I (RecordCode r) -> r

type family VariantCode (s :: Type) :: Map Symbol Type where ...

Equations

VariantCode s = VariantCode' E (Rep s)

class ToVariant (s :: Type) where

Minimal complete definition

Nothing

Methods

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

toVariant :: (Generic s, ToVariantHelper (VariantCode s) (Rep s)) => s -> Variant I (VariantCode s)

class FromVariant (s :: Type) where

Minimal complete definition

Nothing

Methods

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

fromVariant :: (Generic s, FromVariantHelper (VariantCode s) (Rep s)) => 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

Class from converting Records to and from the n-ary product type NP from Data.SOP.

prefixNP flattens a Record and adds it to the initial part of the product.

breakNP reconstructs a Record from the initial part of the product and returns the unconsumed part.

The functions toNP and fromNP are usually easier to use.

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

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

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 :: forall t result f. Productlike '[] t result => NP f result -> Record f t

Convert a n-ary product into a compatible Record.

toNP :: forall t result f. Productlike '[] t result => Record f t -> NP f result

Convert a Record into a n-ary product.

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

Class from converting Variants to and from the n-ary sum type NS from Data.SOP.

prefixNS flattens a Variant and adds it to the initial part of the sum.

breakNS reconstructs a Variant from the initial part of the sum and returns the unconsumed part.

The functions toNS and fromNS are usually easier to use.

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 (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

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 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

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 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)

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)))

Sumlike start (N color (E :: Map Symbol Type) k v (E :: Map Symbol Type)) (v ': start)

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))

fromNS :: forall t result f. Sumlike '[] t result => NS f result -> Variant f t

Convert a n-ary sum into a compatible Variant.

toNS :: forall t result f. Sumlike '[] t result => Variant f t -> NS f result

Convert a Variant into a n-ary sum.

Data.SOP re-exports

newtype I a

The identity type functor.

Like Identity, but with a shorter name.

Constructors

I a

Instances

Monad I

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

Defined in Data.SOP.BasicFunctors

Methods

fmap :: (a -> b) -> I a -> I b

(<$) :: a -> I b -> I a

Applicative I

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

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

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

Defined in Data.SOP.BasicFunctors

Methods

liftEq :: (a -> b -> Bool) -> I a -> I b -> Bool

Ord1 I

Since: sop-core-0.2.4.0

Defined in Data.SOP.BasicFunctors

Methods

liftCompare :: (a -> b -> Ordering) -> I a -> I b -> Ordering

Read1 I

Since: sop-core-0.2.4.0

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

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

Defined in Data.SOP.BasicFunctors

Methods

liftRnf :: (a -> ()) -> I a -> ()

Eq a => Eq (I a)

Defined in Data.SOP.BasicFunctors

Methods

(==) :: I a -> I a -> Bool

(/=) :: I a -> I a -> Bool

Ord a => Ord (I a)

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)

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)

Defined in Data.SOP.BasicFunctors

Methods

showsPrec :: Int -> I a -> ShowS

show :: I a -> String

showList :: [I a] -> ShowS

Generic (I a)

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

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

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

Defined in Data.SOP.BasicFunctors

Methods

rnf :: I a -> ()

type Rep (I a)

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

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

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

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

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

Defined in Data.SOP.BasicFunctors

Methods

liftRnf2 :: (a -> ()) -> (b -> ()) -> K a b -> ()

Functor (K a :: Type -> Type)

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)

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)

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)

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

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

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

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

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

Defined in Data.SOP.BasicFunctors

Methods

liftRnf :: (a0 -> ()) -> K a a0 -> ()

Eq a => Eq (K a b)

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)

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)

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)

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)

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

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

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

Defined in Data.SOP.BasicFunctors

Methods

rnf :: K a b -> ()

type Rep (K a b)

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)

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)

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)

Defined in Data.SOP.NP

Methods

hap :: Prod NP (f -.-> g) xs -> NP f xs -> NP g xs

HCollapse (NP :: (k -> Type) -> [k] -> Type)

Defined in Data.SOP.NP

Methods

hcollapse :: SListIN NP xs => NP (K a) xs -> CollapseTo NP a

HTraverse_ (NP :: (k -> Type) -> [k] -> Type)

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)

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)

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)

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)

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

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

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

Defined in Data.SOP.NP

Methods

rnf :: NP f xs -> ()

type Same (NP :: (k1 -> Type) -> [k1] -> Type)

Defined in Data.SOP.NP

type Same (NP :: (k1 -> Type) -> [k1] -> Type) = (NP :: (k2 -> Type) -> [k2] -> Type)

type Prod (NP :: (k -> Type) -> [k] -> Type)

Defined in Data.SOP.NP

type Prod (NP :: (k -> Type) -> [k] -> Type) = (NP :: (k -> Type) -> [k] -> Type)

type UnProd (NP :: (k -> Type) -> [k] -> Type)

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

Defined in Data.SOP.NP

type CollapseTo (NP :: (k -> Type) -> [k] -> Type) a = [a]

type SListIN (NP :: (k -> Type) -> [k] -> Type)

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)

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)

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)

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)

Defined in Data.SOP.NS

Methods

hap :: Prod NS (f -.-> g) xs -> NS f xs -> NS g xs

HCollapse (NS :: (k -> Type) -> [k] -> Type)

Defined in Data.SOP.NS

Methods

hcollapse :: SListIN NS xs => NS (K a) xs -> CollapseTo NS a

HTraverse_ (NS :: (k -> Type) -> [k] -> Type)

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)

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)

Defined in Data.SOP.NS

Methods

hindex :: NS f xs -> Int

HApInjs (NS :: (k -> Type) -> [k] -> Type)

Defined in Data.SOP.NS

Methods

hapInjs :: SListIN NS xs => Prod NS f xs -> [NS f xs]

HExpand (NS :: (k -> Type) -> [k] -> Type)

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)

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)

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)

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

Defined in Data.SOP.NS

Methods

rnf :: NS f xs -> ()

type Same (NS :: (k1 -> Type) -> [k1] -> Type)

Defined in Data.SOP.NS

type Same (NS :: (k1 -> Type) -> [k1] -> Type) = (NS :: (k2 -> Type) -> [k2] -> Type)

type Prod (NS :: (k -> Type) -> [k] -> Type)

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

Defined in Data.SOP.NS

type CollapseTo (NS :: (k -> Type) -> [k] -> Type) a = a

type SListIN (NS :: (k -> Type) -> [k] -> Type)

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)

Defined in Data.SOP.NS

type AllN (NS :: (k -> Type) -> [k] -> Type) (c :: k -> Constraint) = All c