Safe Haskell	None
Language	Haskell2010

Data.RBR.Internal

Description

See here for the original term-level code by Stefan Kahrs. It is also copied at the end of this file. Some parts of the type-level code include the correspondign term-level parts in their comments.

Synopsis

data Color
- = R
- | B
data Map symbol q
- = E
- | N Color (Map symbol q) symbol q (Map symbol q)
type Empty = E
type family KeysValuesAllF (c :: symbol -> q -> Constraint) (t :: Map symbol q) :: Constraint where ...
class KeysValuesAllF c t => KeysValuesAll (c :: symbol -> q -> Constraint) (t :: Map symbol q) where
- cpara_Map :: proxy c -> r E -> (forall left k v right color. (c k v, KeysValuesAll c left, KeysValuesAll c right) => r left -> r right -> r (N color left k v right)) -> r t
class Maplike (t :: Map Symbol Type) where
- pure_Record :: (forall v. f v) -> Record f t
- sequence_Record :: Applicative f => Record f t -> f (Record I t)
- sequence'_Record :: Applicative f => Record (f :.: g) t -> f (Record g t)
- liftA_Record :: (forall a. f a -> g a) -> Record f t -> Record g t
- liftA2_Record :: (forall a. f a -> g a -> h a) -> Record f t -> Record g t -> Record h t
- liftA_Variant :: (forall a. f a -> g a) -> Variant f t -> Variant g t
- liftA2_Variant :: (forall a. f a -> g a -> h a) -> Record f t -> Variant g t -> Variant h t
- injections'_Variant :: Record (Case f (Variant f t)) t
- injections_Record :: Record (Case f (Endo (Record f t))) t
- collapse'_Record :: Monoid a => Record (K a) t -> a
- collapse_Variant :: Variant (K a) t -> a
injections_Variant :: Maplike t => Record (VariantInjection f t) t
newtype VariantInjection (f :: q -> Type) (t :: Map Symbol q) (v :: q) = VariantInjection {
- runVariantInjection :: f v -> Variant f t
}
cpure_Record :: forall c t f. KeysValuesAll c t => Proxy c -> (forall k v. c k v => f v) -> Record f t
cpure'_Record :: forall c t f. KeysValuesAll (KeyValueConstraints KnownSymbol c) t => Proxy c -> (forall v. c v => String -> f v) -> Record f t
demoteKeys :: forall t. KeysValuesAll KnownKey t => Record (K String) t
class KnownSymbol k => KnownKey (k :: Symbol) (v :: q)
demoteEntries :: forall t. KeysValuesAll KnownKeyTypeableValue t => Record (K (String, TypeRep)) t
class (KnownSymbol k, Typeable v) => KnownKeyTypeableValue (k :: Symbol) (v :: q)
class (kc k, vc v) => KeyValueConstraints (kc :: Symbol -> Constraint) (vc :: q -> Constraint) (k :: Symbol) (v :: q)
class vc v => ValueConstraint (vc :: q -> Constraint) (k :: Symbol) (v :: q)
data Record (f :: q -> Type) (t :: Map Symbol q) where
- Empty :: Record f E
- Node :: Record f left -> f v -> Record f right -> Record f (N color left k v right)
collapse_Record :: forall t result a. Productlike '[] t result => Record (K a) t -> [a]
prettyShow_Record :: forall t f. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => (forall x. Show x => f x -> String) -> Record f t -> String
prettyShow_RecordI :: forall t. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => Record I t -> String
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
prettyShowRecordI :: forall t flat. (KeysValuesAll KnownKey t, Productlike '[] t flat, All Show flat, SListI flat) => Record I t -> String
unit :: Record f Empty
data Variant (f :: q -> Type) (t :: Map Symbol q) where
- Here :: f v -> Variant f (N color left k v right)
- LookRight :: Variant f t -> Variant f (N color' left' k' v' t)
- LookLeft :: Variant f t -> Variant f (N color' t k' v' right')
impossible :: Variant f Empty -> b
prettyShow_Variant :: forall t flat f. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => (forall x. Show x => f x -> String) -> Variant f t -> String
prettyShow_VariantI :: forall t flat. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => Variant I t -> String
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
prettyShowVariantI :: forall t flat. (KeysValuesAll KnownKey t, Productlike '[] t flat, Sumlike '[] t flat, All Show flat, SListI flat) => Variant I t -> String
type family InsertAll (es :: [(Symbol, q)]) (t :: Map Symbol q) :: Map Symbol q where ...
type FromList (es :: [(Symbol, q)]) = InsertAll es Empty
insert :: forall k v t f. Insertable k v t => f v -> Record f t -> Record f (Insert k v t)
widen :: forall k v t f. Insertable k v t => 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)
insertI :: forall k v t. Insertable k v t => v -> Record I t -> Record I (Insert k v t)
addFieldI :: forall k v t. Insertable k v t => v -> Record I t -> Record I (Insert k v t)
class Insertable (k :: Symbol) (v :: q) (t :: Map Symbol q) where
- type Insert k v t :: Map Symbol q
- _insert :: f v -> Record f t -> Record f (Insert k v t)
- _widen :: Variant f t -> Variant f (Insert k v t)
class CanMakeBlack (t :: Map Symbol k) where
- type MakeBlack t :: Map Symbol k
- makeBlackR :: Record f t -> Record f (MakeBlack t)
- makeBlackV :: Variant f t -> Variant f (MakeBlack t)
class InsertableHelper1 (k :: Symbol) (v :: q) (t :: Map Symbol q) where
- type Insert1 k v t :: Map Symbol q
- insert1 :: f v -> Record f t -> Record f (Insert1 k v t)
- widen1 :: Variant f t -> Variant f (Insert1 k v t)
class InsertableHelper2 (ordering :: Ordering) (k :: Symbol) (v :: q) (color :: Color) (left :: Map Symbol q) (k' :: Symbol) (v' :: q) (right :: Map Symbol q) where
- type Insert2 ordering k v color left k' v' right :: Map Symbol q
- insert2 :: f v -> Record f (N color left k' v' right) -> Record f (Insert2 ordering k v color left k' v' right)
- widen2 :: Variant f (N color left k' v' right) -> Variant f (Insert2 ordering k v color left k' v' right)
data BalanceAction
- = BalanceSpecial
- | BalanceLL
- | BalanceLR
- | BalanceRL
- | BalanceRR
- | DoNotBalance
type family ShouldBalance (left :: Map k' v') (right :: Map k' v') :: BalanceAction where ...
class Balanceable (left :: Map Symbol q) (k :: Symbol) (v :: q) (right :: Map Symbol q) where
- type Balance left k v right :: Map Symbol q
- balanceR :: Record f (N color left k v right) -> Record f (Balance left k v right)
- balanceV :: Variant f (N color left k v right) -> Variant f (Balance left k v right)
class BalanceableHelper (action :: BalanceAction) (left :: Map Symbol q) (k :: Symbol) (v :: q) (right :: Map Symbol q) where
- type Balance' action left k v right :: Map Symbol q
- balanceR' :: Record f (N color left k v right) -> Record f (Balance' action left k v right)
- balanceV' :: Variant f (N color left k v right) -> Variant f (Balance' action left k v right)
type family Field (f :: q -> Type) (t :: Map Symbol q) (v :: q) where ...
type family Branch (f :: q -> Type) (t :: Map Symbol q) (v :: q) where ...
class Key (k :: Symbol) (t :: Map Symbol q) where
- type Value k t :: q
- _field :: Field f t (Value k t)
- _branch :: Branch f t (Value k t)
field :: forall k t f. Key k t => Field f t (Value k t)
branch :: forall k t f. Key k t => Branch f t (Value k t)
class KeyHelper (ordering :: Ordering) (k :: Symbol) (left :: Map Symbol q) (v :: q) (right :: Map Symbol q) where
- type Value' ordering k left v right :: q
- field' :: Field f (N colorx left kx v right) (Value' ordering k left v right)
- branch' :: Branch f (N colorx left kx v right) (Value' ordering k left v right)
project :: forall k t f. Key k t => Record f t -> f (Value k t)
getField :: forall k t f. Key k t => Record f t -> f (Value k t)
setField :: forall k t f. Key k t => f (Value k t) -> Record f t -> Record f t
modifyField :: forall k t f. Key k t => (f (Value k t) -> f (Value k t)) -> Record f t -> Record f t
inject :: forall k t f. Key k t => f (Value k t) -> Variant f t
match :: forall k t f. Key k t => Variant f t -> Maybe (f (Value k t))
projectI :: forall k t. Key k t => Record I t -> Value k t
getFieldI :: forall k t. Key k t => Record I t -> Value k t
setFieldI :: forall k t. Key k t => Value k t -> Record I t -> Record I t
modifyFieldI :: forall k t. Key k t => (Value k t -> Value k t) -> Record I t -> Record I t
injectI :: forall k t. Key k t => Value k t -> Variant I t
matchI :: forall k t. Key k t => Variant I t -> Maybe (Value k t)
eliminate :: (Productlike '[] t result, Sumlike '[] t result, SListI result) => Record (Case f r) t -> Variant f t -> r
eliminate_Variant :: Maplike t => Record (Case f r) t -> Variant f t -> r
newtype Case f a b = Case {
- runCase :: 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)
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)
newtype SetField f a b = SetField {
- getSetField :: f b -> a -> a
}
class (Key k t, Value k t ~ v) => PresentIn (t :: Map Symbol q) (k :: Symbol) (v :: q)
type ProductlikeSubset (subset :: Map Symbol q) (whole :: Map Symbol q) (flat :: [q]) = (KeysValuesAll (PresentIn whole) subset, Productlike '[] subset flat, SListI flat)
fieldSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f whole -> (Record f subset -> Record f whole, Record f subset)
projectSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f whole -> Record f subset
getFieldSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f whole -> Record f subset
setFieldSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => Record f subset -> Record f whole -> Record f whole
modifyFieldSubset :: forall subset whole flat f. ProductlikeSubset subset whole flat => (Record f subset -> Record f subset) -> Record f whole -> Record f whole
type SumlikeSubset (subset :: Map Symbol q) (whole :: Map Symbol q) (subflat :: [q]) (wholeflat :: [q]) = (KeysValuesAll (PresentIn whole) subset, Productlike '[] whole wholeflat, Sumlike '[] whole wholeflat, SListI wholeflat, Productlike '[] subset subflat, Sumlike '[] subset subflat, SListI subflat)
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)
injectSubset :: forall subset whole subflat wholeflat f. SumlikeSubset subset whole subflat wholeflat => Variant f subset -> Variant f whole
matchSubset :: forall subset whole subflat wholeflat f. SumlikeSubset subset whole subflat wholeflat => Variant f whole -> Maybe (Variant f subset)
eliminateSubset :: forall subset whole subflat wholeflat f r. SumlikeSubset subset whole subflat wholeflat => Record (Case f r) whole -> Variant f subset -> r
class Productlike (start :: [k]) (t :: Map Symbol k) (result :: [k]) | 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)
prefixNP :: forall start t result f. Productlike start t result => Record f t -> NP f start -> NP f result
breakNP :: forall start t result f. Productlike start t result => NP f result -> (Record f t, NP f start)
toNP :: forall t result f. Productlike '[] t result => Record f t -> NP f result
fromNP :: forall t result f. Productlike '[] t result => NP f result -> Record f t
class Sumlike (start :: [k]) (t :: Map Symbol k) (result :: [k]) | 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)
prefixNS :: forall start t result f. Sumlike start t result => Either (NS f start) (Variant f t) -> NS f result
breakNS :: forall start t result f. Sumlike start t result => NS f result -> Either (NS f start) (Variant f t)
toNS :: forall t result f. Sumlike '[] t result => Variant f t -> NS f result
fromNS :: forall t result f. Sumlike '[] t result => NS f result -> Variant f t
class ToRecord (r :: Type) where
- type RecordCode r :: Map Symbol Type
- toRecord :: r -> Record I (RecordCode r)
class ToRecordHelper (start :: Map Symbol Type) (g :: Type -> Type) where
- type RecordCode' start g :: Map Symbol Type
- toRecord' :: Record I start -> g x -> Record I (RecordCode' start g)
class ToRecord r => FromRecord (r :: Type) where
- fromRecord :: Record I (RecordCode r) -> r
type IsRecordType (r :: Type) (t :: Map Symbol Type) = (Generic r, ToRecord r, RecordCode r ~ t, FromRecord r)
class FromRecordHelper (t :: Map Symbol Type) (g :: Type -> Type) where
- fromRecord' :: Record I t -> g x
type family VariantCode (s :: Type) :: Map Symbol Type where ...
type family VariantCode' (acc :: Map Symbol Type) (g :: Type -> Type) :: Map Symbol Type where ...
class FromVariant (s :: Type) where
- fromVariant :: Variant I (VariantCode s) -> s
type IsVariantType (v :: Type) (t :: Map Symbol Type) = (Generic v, ToVariant v, VariantCode v ~ t, FromVariant v)
class FromVariantHelper (t :: Map Symbol Type) (g :: Type -> Type) where
- fromVariant' :: Variant I t -> Maybe (g x)
class ToVariant (s :: Type) where
- toVariant :: s -> Variant I (VariantCode s)
class ToVariantHelper (t :: Map Symbol Type) (g :: Type -> Type) where
- toVariant' :: g x -> Variant I t
type family DiscriminateBalL (l :: Map k v) (r :: Map k v) :: Bool where ...
class BalanceableL (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where
- type BalL l k v r :: Map Symbol q
- balLR :: Record f (N color l k v r) -> Record f (BalL l k v r)
- balLV :: Variant f (N color l k v r) -> Variant f (BalL l k v r)
class BalanceableHelperL (b :: Bool) (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where
- type BalL' b l k v r :: Map Symbol q
- balLR' :: Record f (N color l k v r) -> Record f (BalL' b l k v r)
- balLV' :: Variant f (N color l k v r) -> Variant f (BalL' b l k v r)
type family DiscriminateBalR (l :: Map k v) (r :: Map k v) :: Bool where ...
class BalanceableR (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where
- type BalR l k v r :: Map Symbol q
- balRR :: Record f (N color l k v r) -> Record f (BalR l k v r)
- balRV :: Variant f (N color l k v r) -> Variant f (BalR l k v r)
class BalanceableHelperR (b :: Bool) (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where
- type BalR' b l k v r :: Map Symbol q
- balRR' :: Record f (N color l k v r) -> Record f (BalR' b l k v r)
- balRV' :: Variant f (N color l k v r) -> Variant f (BalR' b l k v r)
class Fuseable (l :: Map Symbol q) (r :: Map Symbol q) where
- type Fuse l r :: Map Symbol q
- fuseRecord :: Record f l -> Record f r -> Record f (Fuse l r)
- fuseVariant :: Either (Variant f l) (Variant f r) -> Variant f (Fuse l r)
class FuseableHelper1 (fused :: Map Symbol q) (l :: Map Symbol q) (r :: Map Symbol q) where
- type Fuse1 fused l r :: Map Symbol q
- fuseRecord1 :: Record f l -> Record f r -> Record f (Fuse l r)
- fuseVariant1 :: Either (Variant f l) (Variant f r) -> Variant f (Fuse l r)
class FuseableHelper2 (fused :: Map Symbol q) (l :: Map Symbol q) (r :: Map Symbol q) where
- type Fuse2 fused l r :: Map Symbol q
- fuseRecord2 :: Record f l -> Record f r -> Record f (Fuse l r)
- fuseVariant2 :: Either (Variant f l) (Variant f r) -> Variant f (Fuse l r)
class Delable (k :: Symbol) (v :: q) (t :: Map Symbol q) where
- type Del k v t :: Map Symbol q
- del :: Record f t -> Record f (Del k v t)
- win :: Variant f t -> Either (Variant f (Del k v t)) (f v)
class DelableL (k :: Symbol) (v :: q) (l :: Map Symbol q) (kx :: Symbol) (vx :: q) (r :: Map Symbol q) where
- type DelL k v l kx vx r :: Map Symbol q
- delL :: Record f (N color l kx vx r) -> Record f (DelL k v l kx vx r)
- winL :: Variant f (N color l kx vx r) -> Either (Variant f (DelL k v l kx vx r)) (f v)
class DelableR (k :: Symbol) (v :: q) (l :: Map Symbol q) (kx :: Symbol) (vx :: q) (r :: Map Symbol q) where
- type DelR k v l kx vx r :: Map Symbol q
- delR :: Record f (N color l kx vx r) -> Record f (DelR k v l kx vx r)
- winR :: Variant f (N color l kx vx r) -> Either (Variant f (DelR k v l kx vx r)) (f v)
class DelableHelper (ordering :: Ordering) (k :: Symbol) (v :: q) (l :: Map Symbol q) (kx :: Symbol) (vx :: q) (r :: Map Symbol q) where
- type Del' ordering k v l kx vx r :: Map Symbol q
- del' :: Record f (N color l kx vx r) -> Record f (Del' ordering k v l kx vx r)
- win' :: Variant f (N color l kx vx r) -> Either (Variant f (Del' ordering k v l kx vx r)) (f v)
class Deletable (k :: Symbol) (v :: q) (t :: Map Symbol q) where
- type Delete k v t :: Map Symbol q
- _delete :: Record f t -> Record f (Delete k v t)
- _winnow :: Variant f t -> Either (Variant f (Delete k v t)) (f v)
delete :: forall k v t f. Deletable k v t => Record f t -> Record f (Delete k v t)
winnow :: forall k v t f. Deletable k v t => 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

Documentation

>>> :set -XDataKinds -XTypeApplications -XPartialTypeSignatures -XFlexibleContexts -XTypeFamilies -XDeriveGeneric
>>> :set -Wno-partial-type-signatures
>>> import Data.RBR
>>> import Data.SOP
>>> import GHC.Generics

data Color Source #

The color of a node.

Constructors

R
B

Instances

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

data Map symbol q Source #

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

Constructors

E
N Color (Map symbol q) symbol q (Map symbol q)

Instances

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

type Empty = E Source #

A map without entries. See also unit and impossible.

type family KeysValuesAllF (c :: symbol -> q -> Constraint) (t :: Map symbol q) :: Constraint where ... Source #

Equations

KeysValuesAllF _ E = ()
KeysValuesAllF c (N color left k v right) = (c k v, KeysValuesAll c left, KeysValuesAll c right)

class KeysValuesAllF c t => KeysValuesAll (c :: symbol -> q -> Constraint) (t :: Map symbol q) where Source #

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

Methods

cpara_Map :: proxy c -> r E -> (forall left k v right color. (c k v, KeysValuesAll c left, KeysValuesAll c right) => r left -> r right -> r (N color left k v right)) -> r t Source #

Instances

KeysValuesAll (c :: symbol -> q -> Constraint) (E :: Map symbol q) Source #
Instance details Defined in Data.RBR.Internal Methods cpara_Map :: proxy c -> r E -> (forall (left :: Map symbol0 q0) (k :: symbol0) (v :: q0) (right :: Map symbol0 q0) (color :: Color). (c k v, KeysValuesAll c left, KeysValuesAll c right) => r left -> r right -> r (N color left k v right)) -> r E Source #
(c k v, KeysValuesAll c left, KeysValuesAll c right) => KeysValuesAll (c :: symbol -> q -> Constraint) (N color left k v right :: Map symbol q) Source #
Instance details Defined in Data.RBR.Internal Methods cpara_Map :: proxy c -> r E -> (forall (left0 :: Map symbol0 q0) (k0 :: symbol0) (v0 :: q0) (right0 :: Map symbol0 q0) (color0 :: Color). (c k0 v0, KeysValuesAll c left0, KeysValuesAll c right0) => r left0 -> r right0 -> r (N color0 left0 k0 v0 right0)) -> r (N color left k v right) Source #

class Maplike (t :: Map Symbol Type) where Source #

This typeclass provides generalizations of Applicative-like functions which work over Records and Variants.

Methods

pure_Record :: (forall v. f v) -> Record f t Source #

See cpure_Record and cpure'_Record for more useful versions of this function.

The naming scheme follows that of pure_NP.

sequence_Record :: Applicative f => Record f t -> f (Record I t) Source #

Pulls out an Applicative that wraps each field, resulting in an Applicative containing a pure Record.

The naming scheme follows that of sequence_NP.

sequence'_Record :: Applicative f => Record (f :.: g) t -> f (Record g t) Source #

Like sequence_Record, but only pulls out the outer Applicative from an Applicative composition that wraps each field. See :.:.

This can be useful for staged computations, where each stage is represented by an Applicative layer.

The naming scheme follows that of sequence'_NP.

liftA_Record :: (forall a. f a -> g a) -> Record f t -> Record g t Source #

Apply a transformation to the type constructor which wraps the fields of a Record.

The naming scheme follows that of liftA_NP.

liftA2_Record :: (forall a. f a -> g a -> h a) -> Record f t -> Record g t -> Record h t Source #

The naming scheme follows that of liftA2_NP.

liftA_Variant :: (forall a. f a -> g a) -> Variant f t -> Variant g t Source #

Apply a transformation to the active branch of a Variant.

The naming scheme follows that of liftA_NS.

liftA2_Variant :: (forall a. f a -> g a -> h a) -> Record f t -> Variant g t -> Variant h t Source #

Given a Record of transformation, apply the one which matches the active branch of Variant.

The naming scheme follows that of liftA2_NS.

injections'_Variant :: Record (Case f (Variant f t)) t Source #

Constructs a Record made of functions which take a value of the field's type and inject it in the Variant branch which corresponds to the field.

Compare to injections from generics-sop.

injections_Record :: Record (Case f (Endo (Record f t))) t Source #

Constructs a Record made of functions which take a value of the field's type and return a record updater function that sets the field.

collapse'_Record :: Monoid a => Record (K a) t -> a Source #

Collapse a Record composed of K monoidal annotations.

>>> collapse'_Record (unit :: Record (K [Bool]) Empty)
[]

>>> collapse'_Record (insert @"bar" (K [False]) unit)
[False]

The naming scheme follows that of collapse_NP.

collapse_Variant :: Variant (K a) t -> a Source #

Instances

Maplike (E :: Map Symbol Type) Source #
Instance details Defined in Data.RBR.Internal Methods pure_Record :: (forall v. f v) -> Record f E Source # sequence_Record :: Applicative f => Record f E -> f (Record I E) Source # sequence'_Record :: Applicative f => Record (f :.: g) E -> f (Record g E) Source # liftA_Record :: (forall a. f a -> g a) -> Record f E -> Record g E Source # liftA2_Record :: (forall a. f a -> g a -> h a) -> Record f E -> Record g E -> Record h E Source # liftA_Variant :: (forall a. f a -> g a) -> Variant f E -> Variant g E Source # liftA2_Variant :: (forall a. f a -> g a -> h a) -> Record f E -> Variant g E -> Variant h E Source # injections'_Variant :: Record (Case f (Variant f E)) E Source # injections_Record :: Record (Case f (Endo (Record f E))) E Source # collapse'_Record :: Monoid a => Record (K a) E -> a Source # collapse_Variant :: Variant (K a) E -> a Source #
(Maplike left, Maplike right) => Maplike (N color left k v right) Source #
Instance details Defined in Data.RBR.Internal Methods pure_Record :: (forall v0. f v0) -> Record f (N color left k v right) Source # sequence_Record :: Applicative f => Record f (N color left k v right) -> f (Record I (N color left k v right)) Source # sequence'_Record :: Applicative f => Record (f :.: g) (N color left k v right) -> f (Record g (N color left k v right)) Source # liftA_Record :: (forall a. f a -> g a) -> Record f (N color left k v right) -> Record g (N color left k v right) Source # liftA2_Record :: (forall a. f a -> g a -> h a) -> Record f (N color left k v right) -> Record g (N color left k v right) -> Record h (N color left k v right) Source # liftA_Variant :: (forall a. f a -> g a) -> Variant f (N color left k v right) -> Variant g (N color left k v right) Source # liftA2_Variant :: (forall a. f a -> g a -> h a) -> Record f (N color left k v right) -> Variant g (N color left k v right) -> Variant h (N color left k v right) Source # injections'_Variant :: Record (Case f (Variant f (N color left k v right))) (N color left k v right) Source # injections_Record :: Record (Case f (Endo (Record f (N color left k v right)))) (N color left k v right) Source # collapse'_Record :: Monoid a => Record (K a) (N color left k v right) -> a Source # collapse_Variant :: Variant (K a) (N color left k v right) -> a Source #

injections_Variant :: Maplike t => Record (VariantInjection f t) t Source #

Deprecated: Use injections'_Variant instead

newtype VariantInjection (f :: q -> Type) (t :: Map Symbol q) (v :: q) Source #

Deprecated: Use Case instead

Constructors

VariantInjection	Deprecated: Use Case instead
Fields runVariantInjection :: f v -> Variant f t

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

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.

cpure'_Record :: forall c t f. KeysValuesAll (KeyValueConstraints KnownSymbol c) t => Proxy c -> (forall v. c v => String -> f v) -> Record f t Source #

Create a Record, knowing that the keys can be demoted to strings and that the values satisfy some constraint. The constraint is passed as a Proxy.

The function that constructs each field receives the name of the field as an argument.

The naming scheme follows that of cpure_NP.

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

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.

>>> putStrLn $ prettyShow_Record show $ demoteKeys @(FromList [ '("foo",Char), '("bar",Bool) ])
{bar = K "bar", foo = K "foo"}

For computations involving field names, sometimes cpure'_Record is a better option.

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

Two-place constraint saying that a Symbol key can be demoted to String. Nothing is required from the corresponding value.

Defined using the "class synonym" trick.

Instances

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

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

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

>>> putStrLn $ prettyShow_Record show $ demoteEntries @(FromList [ '("foo",Char), '("bar",Bool) ])
{bar = K ("bar",Bool), foo = K ("foo",Char)}

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

Two-place constraint saying that a Symbol key can be demoted to String, and that the corresponding value Type has a term-level representation.

Defined using the "class synonym" trick.

Instances

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

class (kc k, vc v) => KeyValueConstraints (kc :: Symbol -> Constraint) (vc :: q -> Constraint) (k :: Symbol) (v :: q) Source #

Lifts two one-place constraints (one for keys, one for values) to a two-place constraint. Useful with function like cpure_Record.

Defined using the "class synonym" trick.

Instances

(kc k, vc v) => KeyValueConstraints kc (vc :: q -> Constraint) k (v :: q) Source #
Instance details Defined in Data.RBR.Internal

class vc v => ValueConstraint (vc :: q -> Constraint) (k :: Symbol) (v :: q) Source #

Lifts a one-place constraint for values to a two-place constraint. Useful with function like cpure_Record.

Defined using the "class synonym" trick.

Instances

vc v => ValueConstraint (vc :: q -> Constraint) k (v :: q) Source #
Instance details Defined in Data.RBR.Internal

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

An extensible product-like type with named fields.

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

See also insert, delete and project.

Constructors

Empty :: Record f E
Node :: Record f left -> f v -> Record f right -> Record f (N color left k v right)

Instances

(Productlike ([] :: [q]) t result, Show (NP f result)) => Show (Record f t) Source #
Instance details Defined in Data.RBR.Internal Methods showsPrec :: Int -> Record f t -> ShowS # show :: Record f t -> String # showList :: [Record f t] -> ShowS #
FromRecord (Record I t) Source #
Instance details Defined in Data.RBR.Internal Methods fromRecord :: Record I (RecordCode (Record I t)) -> Record I t Source #
ToRecord (Record I t) Source #
Instance details Defined in Data.RBR.Internal Associated Types type RecordCode (Record I t) :: Map Symbol Type Source # Methods toRecord :: Record I t -> Record I (RecordCode (Record I t)) Source #
type RecordCode (Record I t) Source #
Instance details Defined in Data.RBR.Internal type RecordCode (Record I t) = t

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

Deprecated: Use collapse'_Record

prettyShow_Record :: forall t f. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => (forall x. Show x => f x -> String) -> Record f t -> String Source #

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.

prettyShow_RecordI :: forall t. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => Record I t -> String Source #

Like prettyShow_Record but specialized to pure records.

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

Deprecated: Use prettyShow_Record

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

Deprecated: Use prettyShow_RecordI

unit :: Record f Empty Source #

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

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

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.

See also widen, winnow and inject.

Constructors

Here :: f v -> Variant f (N color left k v right)
LookRight :: Variant f t -> Variant f (N color' left' k' v' t)
LookLeft :: Variant f t -> Variant f (N color' t k' v' right')

Instances

(Sumlike ([] :: [q]) t result, Show (NS f result)) => Show (Variant f t) Source #
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 Empty -> b Source #

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

prettyShow_Variant :: forall t flat f. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => (forall x. Show x => f x -> String) -> Variant f t -> String Source #

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.

prettyShow_VariantI :: forall t flat. (Maplike t, KeysValuesAll (KeyValueConstraints KnownSymbol Show) t) => Variant I t -> String Source #

Like prettyShow_Variant but specialized to pure variants.

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

Deprecated: Use prettyShow_Variant

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

Deprecated: Use prettyShow_VariantI

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

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

Equations

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

type FromList (es :: [(Symbol, q)]) = InsertAll es Empty Source #

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

insert :: forall k v t f. Insertable k v t => f v -> Record f t -> Record f (Insert k v t) Source #

Adds a new field to a Record.

>>> project @"foo" (insert @"foo" (I 'a') unit)
I 'a'

>>> project @"foo" (insert @"foo" @Char Nothing unit)
Nothing

widen :: forall k v t f. Insertable k v t => Variant f t -> Variant f (Insert k v t) Source #

Lets you use a Variant in a bigger context than the one in which is was defined.

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

Alias for insert.

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

Like insert but specialized to pure Records.

>>> projectI @"foo" (insertI @"foo" 'a' unit)
'a'

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

Like addField but specialized to pure Records.

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

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

The associated type family Insert produces the resulting map.

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 map already has the key but with a different type, the insertion fails to compile.

Associated Types

type Insert k v t :: Map Symbol q Source #

Methods

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

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

Instances

(InsertableHelper1 k v t, Insert1 k v t ~ inserted, CanMakeBlack inserted) => Insertable k (v :: q) (t :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert k v t :: Map Symbol q Source # Methods _insert :: f v -> Record f t -> Record f (Insert k v t) Source # _widen :: Variant f t -> Variant f (Insert k v t) Source #

class CanMakeBlack (t :: Map Symbol k) where Source #

Associated Types

type MakeBlack t :: Map Symbol k Source #

Methods

makeBlackR :: Record f t -> Record f (MakeBlack t) Source #

makeBlackV :: Variant f t -> Variant f (MakeBlack t) Source #

Instances

CanMakeBlack (E :: Map Symbol k) Source #
Instance details Defined in Data.RBR.Internal Associated Types type MakeBlack E :: Map Symbol k Source # Methods makeBlackR :: Record f E -> Record f (MakeBlack E) Source # makeBlackV :: Variant f E -> Variant f (MakeBlack E) Source #
CanMakeBlack (N color left k2 v right :: Map Symbol k1) Source #
Instance details Defined in Data.RBR.Internal Associated Types type MakeBlack (N color left k2 v right) :: Map Symbol k Source # Methods makeBlackR :: Record f (N color left k2 v right) -> Record f (MakeBlack (N color left k2 v right)) Source # makeBlackV :: Variant f (N color left k2 v right) -> Variant f (MakeBlack (N color left k2 v right)) Source #

class InsertableHelper1 (k :: Symbol) (v :: q) (t :: Map Symbol q) where Source #

Associated Types

type Insert1 k v t :: Map Symbol q Source #

Methods

insert1 :: f v -> Record f t -> Record f (Insert1 k v t) Source #

widen1 :: Variant f t -> Variant f (Insert1 k v t) Source #

Instances

InsertableHelper1 k (v :: q) (E :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert1 k v E :: Map Symbol q Source # Methods insert1 :: f v -> Record f E -> Record f (Insert1 k v E) Source # widen1 :: Variant f E -> Variant f (Insert1 k v E) Source #
(CmpSymbol k k' ~ ordering, InsertableHelper2 ordering k v color left k' v' right) => InsertableHelper1 k (v :: q) (N color left k' v' right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert1 k v (N color left k' v' right) :: Map Symbol q Source # Methods insert1 :: f v -> Record f (N color left k' v' right) -> Record f (Insert1 k v (N color left k' v' right)) Source # widen1 :: Variant f (N color left k' v' right) -> Variant f (Insert1 k v (N color left k' v' right)) Source #

class InsertableHelper2 (ordering :: Ordering) (k :: Symbol) (v :: q) (color :: Color) (left :: Map Symbol q) (k' :: Symbol) (v' :: q) (right :: Map Symbol q) where Source #

Associated Types

type Insert2 ordering k v color left k' v' right :: Map Symbol q Source #

Methods

insert2 :: f v -> Record f (N color left k' v' right) -> Record f (Insert2 ordering k v color left k' v' right) Source #

widen2 :: Variant f (N color left k' v' right) -> Variant f (Insert2 ordering k v color left k' v' right) Source #

Instances

InsertableHelper2 EQ k (v :: q) color (left :: Map Symbol q) k (v :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert2 EQ k v color left k v right :: Map Symbol q Source # Methods insert2 :: f v -> Record f (N color left k v right) -> Record f (Insert2 EQ k v color left k v right) Source # widen2 :: Variant f (N color left k v right) -> Variant f (Insert2 EQ k v color left k v right) Source #
(InsertableHelper1 k v right, Insert1 k v right ~ inserted, Balanceable left k' v' inserted) => InsertableHelper2 GT k (v :: q) R (left :: Map Symbol q) k' (v' :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert2 GT k v R left k' v' right :: Map Symbol q Source # Methods insert2 :: f v -> Record f (N R left k' v' right) -> Record f (Insert2 GT k v R left k' v' right) Source # widen2 :: Variant f (N R left k' v' right) -> Variant f (Insert2 GT k v R left k' v' right) Source #
(InsertableHelper1 k v right, Insert1 k v right ~ inserted, Balanceable left k' v' inserted) => InsertableHelper2 GT k (v :: q) B (left :: Map Symbol q) k' (v' :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert2 GT k v B left k' v' right :: Map Symbol q Source # Methods insert2 :: f v -> Record f (N B left k' v' right) -> Record f (Insert2 GT k v B left k' v' right) Source # widen2 :: Variant f (N B left k' v' right) -> Variant f (Insert2 GT k v B left k' v' right) Source #
(InsertableHelper1 k v left, Insert1 k v left ~ inserted, Balanceable inserted k' v' right) => InsertableHelper2 LT k (v :: q) R (left :: Map Symbol q) k' (v' :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert2 LT k v R left k' v' right :: Map Symbol q Source # Methods insert2 :: f v -> Record f (N R left k' v' right) -> Record f (Insert2 LT k v R left k' v' right) Source # widen2 :: Variant f (N R left k' v' right) -> Variant f (Insert2 LT k v R left k' v' right) Source #
(InsertableHelper1 k v left, Insert1 k v left ~ inserted, Balanceable inserted k' v' right) => InsertableHelper2 LT k (v :: q) B (left :: Map Symbol q) k' (v' :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Insert2 LT k v B left k' v' right :: Map Symbol q Source # Methods insert2 :: f v -> Record f (N B left k' v' right) -> Record f (Insert2 LT k v B left k' v' right) Source # widen2 :: Variant f (N B left k' v' right) -> Variant f (Insert2 LT k v B left k' v' right) Source #

data BalanceAction Source #

Constructors

BalanceSpecial
BalanceLL
BalanceLR
BalanceRL
BalanceRR
DoNotBalance

Instances

Show BalanceAction Source #
Instance details Defined in Data.RBR.Internal Methods showsPrec :: Int -> BalanceAction -> ShowS # show :: BalanceAction -> String # showList :: [BalanceAction] -> ShowS #

type family ShouldBalance (left :: Map k' v') (right :: Map k' v') :: BalanceAction where ... Source #

Equations

ShouldBalance (N R _ _ _ _) (N R _ _ _ _) = BalanceSpecial
ShouldBalance (N R (N R _ _ _ _) _ _ _) _ = BalanceLL
ShouldBalance (N R _ _ _ (N R _ _ _ _)) _ = BalanceLR
ShouldBalance _ (N R (N R _ _ _ _) _ _ _) = BalanceRL
ShouldBalance _ (N R _ _ _ (N R _ _ _ _)) = BalanceRR
ShouldBalance _ _ = DoNotBalance

class Balanceable (left :: Map Symbol q) (k :: Symbol) (v :: q) (right :: Map Symbol q) where Source #

Associated Types

type Balance left k v right :: Map Symbol q Source #

Methods

balanceR :: Record f (N color left k v right) -> Record f (Balance left k v right) Source #

balanceV :: Variant f (N color left k v right) -> Variant f (Balance left k v right) Source #

Instances

(ShouldBalance left right ~ action, BalanceableHelper action left k v right) => Balanceable (left :: Map Symbol q) k (v :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance left k v right :: Map Symbol q Source # Methods balanceR :: Record f (N color left k v right) -> Record f (Balance left k v right) Source # balanceV :: Variant f (N color left k v right) -> Variant f (Balance left k v right) Source #

class BalanceableHelper (action :: BalanceAction) (left :: Map Symbol q) (k :: Symbol) (v :: q) (right :: Map Symbol q) where Source #

Associated Types

type Balance' action left k v right :: Map Symbol q Source #

Methods

balanceR' :: Record f (N color left k v right) -> Record f (Balance' action left k v right) Source #

balanceV' :: Variant f (N color left k v right) -> Variant f (Balance' action left k v right) Source #

Instances

BalanceableHelper DoNotBalance (a :: Map Symbol q) k (v :: q) (b :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance' DoNotBalance a k v b :: Map Symbol q Source # Methods balanceR' :: Record f (N color a k v b) -> Record f (Balance' DoNotBalance a k v b) Source # balanceV' :: Variant f (N color a k v b) -> Variant f (Balance' DoNotBalance a k v b) Source #
BalanceableHelper BalanceRR (a :: Map Symbol q) k1 (v1 :: q) (N R b k2 v2 (N R c k3 v3 d) :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance' BalanceRR a k1 v1 (N R b k2 v2 (N R c k3 v3 d)) :: Map Symbol q Source # Methods balanceR' :: Record f (N color a k1 v1 (N R b k2 v2 (N R c k3 v3 d))) -> Record f (Balance' BalanceRR a k1 v1 (N R b k2 v2 (N R c k3 v3 d))) Source # balanceV' :: Variant f (N color a k1 v1 (N R b k2 v2 (N R c k3 v3 d))) -> Variant f (Balance' BalanceRR a k1 v1 (N R b k2 v2 (N R c k3 v3 d))) Source #
BalanceableHelper BalanceRL (a :: Map Symbol q) k1 (v1 :: q) (N R (N R b k2 v2 c) k3 v3 d :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance' BalanceRL a k1 v1 (N R (N R b k2 v2 c) k3 v3 d) :: Map Symbol q Source # Methods balanceR' :: Record f (N color a k1 v1 (N R (N R b k2 v2 c) k3 v3 d)) -> Record f (Balance' BalanceRL a k1 v1 (N R (N R b k2 v2 c) k3 v3 d)) Source # balanceV' :: Variant f (N color a k1 v1 (N R (N R b k2 v2 c) k3 v3 d)) -> Variant f (Balance' BalanceRL a k1 v1 (N R (N R b k2 v2 c) k3 v3 d)) Source #
BalanceableHelper BalanceLR (N R a k1 v1 (N R b k2 v2 c) :: Map Symbol q) k3 (v3 :: q) (d :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance' BalanceLR (N R a k1 v1 (N R b k2 v2 c)) k3 v3 d :: Map Symbol q Source # Methods balanceR' :: Record f (N color (N R a k1 v1 (N R b k2 v2 c)) k3 v3 d) -> Record f (Balance' BalanceLR (N R a k1 v1 (N R b k2 v2 c)) k3 v3 d) Source # balanceV' :: Variant f (N color (N R a k1 v1 (N R b k2 v2 c)) k3 v3 d) -> Variant f (Balance' BalanceLR (N R a k1 v1 (N R b k2 v2 c)) k3 v3 d) Source #
BalanceableHelper BalanceLL (N R (N R a k1 v1 b) k2 v2 c :: Map Symbol q) k3 (v3 :: q) (d :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance' BalanceLL (N R (N R a k1 v1 b) k2 v2 c) k3 v3 d :: Map Symbol q Source # Methods balanceR' :: Record f (N color (N R (N R a k1 v1 b) k2 v2 c) k3 v3 d) -> Record f (Balance' BalanceLL (N R (N R a k1 v1 b) k2 v2 c) k3 v3 d) Source # balanceV' :: Variant f (N color (N R (N R a k1 v1 b) k2 v2 c) k3 v3 d) -> Variant f (Balance' BalanceLL (N R (N R a k1 v1 b) k2 v2 c) k3 v3 d) Source #
BalanceableHelper BalanceSpecial (N R left1 k1 v1 right1 :: Map Symbol q) kx (vx :: q) (N R left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Balance' BalanceSpecial (N R left1 k1 v1 right1) kx vx (N R left2 k2 v2 right2) :: Map Symbol q Source # Methods balanceR' :: Record f (N color (N R left1 k1 v1 right1) kx vx (N R left2 k2 v2 right2)) -> Record f (Balance' BalanceSpecial (N R left1 k1 v1 right1) kx vx (N R left2 k2 v2 right2)) Source # balanceV' :: Variant f (N color (N R left1 k1 v1 right1) kx vx (N R left2 k2 v2 right2)) -> Variant f (Balance' BalanceSpecial (N R left1 k1 v1 right1) kx vx (N R left2 k2 v2 right2)) Source #

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

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 :: q -> Type) (t :: Map Symbol q) (v :: q) where ... Source #

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)

class Key (k :: Symbol) (t :: Map Symbol q) where Source #

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

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

Associated Types

type Value k t :: q Source #

Methods

_field :: Field f t (Value k t) Source #

_branch :: Branch f t (Value k t) Source #

Instances

(CmpSymbol k' k ~ ordering, KeyHelper ordering k left v' right) => Key k (N color left k' v' right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Value k (N color left k' v' right) :: q Source # Methods _field :: Field f (N color left k' v' right) (Value k (N color left k' v' right)) Source # _branch :: Branch f (N color left k' v' right) (Value k (N color left k' v' right)) Source #

field :: forall k t f. Key k t => Field f t (Value k t) Source #

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 :: forall k t f. Key k t => Branch f t (Value k t) Source #

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

class KeyHelper (ordering :: Ordering) (k :: Symbol) (left :: Map Symbol q) (v :: q) (right :: Map Symbol q) where Source #

Associated Types

type Value' ordering k left v right :: q Source #

Methods

field' :: Field f (N colorx left kx v right) (Value' ordering k left v right) Source #

branch' :: Branch f (N colorx left kx v right) (Value' ordering k left v right) Source #

Instances

KeyHelper EQ k (left :: Map Symbol q) (v :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Value' EQ k left v right :: q Source # Methods field' :: Field f (N colorx left kx v right) (Value' EQ k left v right) Source # branch' :: Branch f (N colorx left kx v right) (Value' EQ k left v right) Source #
(CmpSymbol k2 k ~ ordering, KeyHelper ordering k left2 v2 right2) => KeyHelper LT k (left :: Map Symbol q) (v :: q) (N color2 left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Value' LT k left v (N color2 left2 k2 v2 right2) :: q Source # Methods field' :: Field f (N colorx left kx v (N color2 left2 k2 v2 right2)) (Value' LT k left v (N color2 left2 k2 v2 right2)) Source # branch' :: Branch f (N colorx left kx v (N color2 left2 k2 v2 right2)) (Value' LT k left v (N color2 left2 k2 v2 right2)) Source #
(CmpSymbol k2 k ~ ordering, KeyHelper ordering k left2 v2 right2) => KeyHelper GT k (N color2 left2 k2 v2 right2 :: Map Symbol q) (v' :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Value' GT k (N color2 left2 k2 v2 right2) v' right :: q Source # Methods field' :: Field f (N colorx (N color2 left2 k2 v2 right2) kx v' right) (Value' GT k (N color2 left2 k2 v2 right2) v' right) Source # branch' :: Branch f (N colorx (N color2 left2 k2 v2 right2) kx v' right) (Value' GT k (N color2 left2 k2 v2 right2) v' right) Source #

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

Get the value of a field for a Record.

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

Alias for project.

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

Set the value of a field for a Record.

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

Modify the value of a field for a Record.

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

Put a value into the branch of a Variant.

>>> match @"foo" (inject @"foo" (I 'a') :: Variant I (Insert "foo" Char Empty))
Just (I 'a')

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

Check if a Variant value is the given branch.

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

Like project but specialized to pure Records.

>>> projectI @"foo" (insertI @"foo" 'a' (insertI @"bar" False unit))
'a'

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

Like getField but specialized to pure Records.

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

Like setField but specialized to pure Records.

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

Like modifyField but specialized to pure Records.

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

Like inject but specialized to pure Variants.

>>> matchI @"foo" (injectI @"foo" 'a' :: Variant I (Insert "foo" Char Empty))
Just 'a'

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

Like match but specialized to pure Variantss.

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

Deprecated: Use eliminate_Variant instead.

eliminate_Variant :: Maplike t => Record (Case f r) t -> Variant f t -> r Source #

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

>>> eliminate_Variant (addCaseI @"foo" @Int succ (addCaseI @"bar" pred unit)) (injectI @"bar" 33)
32

newtype Case f a b Source #

Represents a handler for a branch of a Variant.

Constructors

Case
Fields runCase :: f b -> a

Instances

Functor f => Contravariant (Case f a) Source #
Instance details Defined in Data.RBR.Internal Methods contramap :: (a0 -> b) -> Case f a b -> Case f a a0 # (>$) :: b -> Case f a b -> Case f a a0 #

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

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

A pure version of addCase.

newtype SetField f a b Source #

Constructors

SetField
Fields getSetField :: f b -> a -> a

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

For a given Map, produces a two-place constraint confirming the presence of a entry.

Defined using the "class synonym" trick.

Instances

(Key k t, Value k t ~ v) => PresentIn (t :: Map Symbol q) k (v :: q) Source #
Instance details Defined in Data.RBR.Internal

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

Deprecated: This constraint is obsolete

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

Deprecated: Use Data.RBR.Subset.fieldSubset

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

Deprecated: Use Data.RBR.Subset.projectSubset

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

Deprecated: Use Data.RBR.Subset.getFieldSubset

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

Deprecated: Use Data.RBR.Subset.setFieldSubset

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

Deprecated: Use Data.RBR.Subset.modifyFieldSubset

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

Deprecated: This constraint is obsolete

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

Deprecated: Use Data.RBR.Subset.branchSubset

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

Deprecated: Use Data.RBR.Subset.injectSubset

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

Deprecated: Use Data.RBR.Subset.matchSubset

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

Deprecated: Use Data.RBR.Subset.eliminateSubset

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

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

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

Instances

Productlike (start :: [k]) (E :: Map Symbol k) (start :: [k]) Source #
Instance details Defined in Data.RBR.Internal Methods _prefixNP :: Record f E -> NP f start -> NP f start Source # _breakNP :: NP f start -> (Record f E, NP f start) Source #
(Productlike start right middle, Productlike (v ': middle) left result) => Productlike (start :: [q]) (N color left k v right :: Map Symbol q) (result :: [q]) Source #
Instance details Defined in Data.RBR.Internal Methods _prefixNP :: Record f (N color left k v right) -> NP f start -> NP f result Source # _breakNP :: NP f result -> (Record f (N color left k v right), NP f start) Source #

prefixNP :: forall start t result f. Productlike start t result => Record f t -> NP f start -> NP f result Source #

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

breakNP :: forall start t result f. Productlike start t result => NP f result -> (Record f t, NP f start) Source #

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

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

Convert a Record into a n-ary product. The order of the elements in the product is not the order of insertion in the record.

>>> toNP (insertI @"foo" 'a' (insertI @"bar" True unit))
I True :* I 'a' :* Nil

fromNP :: forall t result f. Productlike '[] t result => NP f result -> Record f t Source #

Convert a n-ary product into a compatible Record. Usually follows an invocation of toNP.

>>> :{
    prettyShow_RecordI $ 
    fromNP @(Insert "foo" _ (Insert "bar" _ Empty)) $
    toNP $ 
    insertI @"foo" 'a' $
    insertI @"bar" True $
    unit
:}
"{bar = True, foo = 'a'}"

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

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

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

Instances

Sumlike (v ': start) (N colorL leftL kL vL rightL) result => Sumlike (start :: [q]) (N color (N colorL leftL kL vL rightL) k v (E :: Map Symbol q) :: Map Symbol q) (result :: [q]) Source #
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 Source # _breakNS :: NS f result -> Either (NS f start) (Variant f (N color (N colorL leftL kL vL rightL) k v E)) Source #
(Sumlike start (N colorR leftR kR vR rightR) middle, Sumlike (v ': middle) (N colorL leftL kL vL rightL) result) => Sumlike (start :: [q]) (N color (N colorL leftL kL vL rightL) k v (N colorR leftR kR vR rightR) :: Map Symbol q) (result :: [q]) Source #
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 Source # _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))) Source #
Sumlike start (N colorR leftR kR vR rightR) middle => Sumlike (start :: [a]) (N color (E :: Map Symbol a) k v (N colorR leftR kR vR rightR) :: Map Symbol a) (v ': middle :: [a]) Source #
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) Source # _breakNS :: NS f (v ': middle) -> Either (NS f start) (Variant f (N color E k v (N colorR leftR kR vR rightR))) Source #
Sumlike (start :: [a]) (N color (E :: Map Symbol a) k v (E :: Map Symbol a) :: Map Symbol a) (v ': start :: [a]) Source #
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) Source # _breakNS :: NS f (v ': start) -> Either (NS f start) (Variant f (N color E k v E)) Source #

prefixNS :: forall start t result f. Sumlike start t result => Either (NS f start) (Variant f t) -> NS f result Source #

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

breakNS :: forall start t result f. Sumlike start t result => NS f result -> Either (NS f start) (Variant f t) Source #

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

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

Convert a Variant into a n-ary sum.

>>> toNS (injectI @"foo" 'a' :: Variant I (Insert "foo" Char (Insert "bar" Bool Empty)))
S (Z (I 'a'))

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

Convert a n-ary sum into a compatible Variant.

>>> :{
    prettyShow_VariantI $ 
    fromNS @(FromList [ '("foo",_), '("bar",_) ]) $ 
    toNS $ 
    (injectI @"foo" 'a' :: Variant I (FromList [ '("foo",Char), '("bar",Bool) ]))
:}
"foo ('a')"

class ToRecord (r :: Type) where Source #

Minimal complete definition

Nothing

Associated Types

type RecordCode r :: Map Symbol Type Source #

Methods

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

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

Instances

ToRecord (Record I t) Source #
Instance details Defined in Data.RBR.Internal Associated Types type RecordCode (Record I t) :: Map Symbol Type Source # Methods toRecord :: Record I t -> Record I (RecordCode (Record I t)) Source #

class ToRecordHelper (start :: Map Symbol Type) (g :: Type -> Type) where Source #

Associated Types

type RecordCode' start g :: Map Symbol Type Source #

Methods

toRecord' :: Record I start -> g x -> Record I (RecordCode' start g) Source #

Instances

(ToRecordHelper start t2, RecordCode' start t2 ~ middle, ToRecordHelper middle t1) => ToRecordHelper start (t1 :*: t2) Source #
Instance details Defined in Data.RBR.Internal Associated Types type RecordCode' start (t1 :: t2) :: Map Symbol Type Source # Methods toRecord' :: Record I start -> (t1 :: t2) x -> Record I (RecordCode' start (t1 :*: t2)) Source #
Insertable k v start => ToRecordHelper start (S1 (MetaSel (Just k) unpackedness strictness laziness) (Rec0 v)) Source #
Instance details Defined in Data.RBR.Internal Associated Types type RecordCode' start (S1 (MetaSel (Just k) unpackedness strictness laziness) (Rec0 v)) :: Map Symbol Type Source # Methods toRecord' :: Record I start -> S1 (MetaSel (Just k) unpackedness strictness laziness) (Rec0 v) x -> Record I (RecordCode' start (S1 (MetaSel (Just k) unpackedness strictness laziness) (Rec0 v))) Source #
ToRecordHelper (E :: Map Symbol Type) fields => ToRecordHelper (E :: Map Symbol Type) (D1 meta (C1 metacons fields)) Source #
Instance details Defined in Data.RBR.Internal Associated Types type RecordCode' E (D1 meta (C1 metacons fields)) :: Map Symbol Type Source # Methods toRecord' :: Record I E -> D1 meta (C1 metacons fields) x -> Record I (RecordCode' E (D1 meta (C1 metacons fields))) Source #

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

Minimal complete definition

Nothing

Methods

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

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

Instances

FromRecord (Record I t) Source #
Instance details Defined in Data.RBR.Internal Methods fromRecord :: Record I (RecordCode (Record I t)) -> Record I t Source #

type IsRecordType (r :: Type) (t :: Map Symbol Type) = (Generic r, ToRecord r, RecordCode r ~ t, FromRecord r) Source #

The naming scheme follows that of IsProductType.

class FromRecordHelper (t :: Map Symbol Type) (g :: Type -> Type) where Source #

Methods

fromRecord' :: Record I t -> g x Source #

Instances

(FromRecordHelper t t1, FromRecordHelper t t2) => FromRecordHelper t (t1 :*: t2) Source #
Instance details Defined in Data.RBR.Internal Methods fromRecord' :: Record I t -> (t1 :*: t2) x Source #
(Key k t, Value k t ~ v) => FromRecordHelper t (S1 (MetaSel (Just k) unpackedness strictness laziness) (Rec0 v)) Source #
Instance details Defined in Data.RBR.Internal Methods fromRecord' :: Record I t -> S1 (MetaSel (Just k) unpackedness strictness laziness) (Rec0 v) x Source #
FromRecordHelper t fields => FromRecordHelper t (D1 meta (C1 metacons fields)) Source #
Instance details Defined in Data.RBR.Internal Methods fromRecord' :: Record I t -> D1 meta (C1 metacons fields) x Source #

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

Equations

VariantCode s = VariantCode' E (Rep s)

type family VariantCode' (acc :: Map Symbol Type) (g :: Type -> Type) :: Map Symbol Type where ... Source #

Equations

VariantCode' acc (D1 meta fields) = VariantCode' acc fields
VariantCode' acc (t1 :+: t2) = VariantCode' (VariantCode' acc t2) t1
VariantCode' acc (C1 (MetaCons k _ _) (S1 (MetaSel Nothing unpackedness strictness laziness) (Rec0 v))) = Insert k v acc
VariantCode' acc (C1 (MetaCons k _ _) U1) = Insert k () acc

class FromVariant (s :: Type) where Source #

Minimal complete definition

Nothing

Methods

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

fromVariant :: (Generic s, FromVariantHelper (VariantCode s) (Rep s)) => Variant I (VariantCode s) -> s Source #

type IsVariantType (v :: Type) (t :: Map Symbol Type) = (Generic v, ToVariant v, VariantCode v ~ t, FromVariant v) Source #

The naming scheme follows that of IsProductType.

class FromVariantHelper (t :: Map Symbol Type) (g :: Type -> Type) where Source #

Methods

fromVariant' :: Variant I t -> Maybe (g x) Source #

Instances

(FromVariantHelper t t1, FromVariantHelper t t2) => FromVariantHelper t (t1 :+: t2) Source #
Instance details Defined in Data.RBR.Internal Methods fromVariant' :: Variant I t -> Maybe ((t1 :+: t2) x) Source #
(Key k t, Value k t ~ ()) => FromVariantHelper t (C1 (MetaCons k x y) (U1 :: Type -> Type)) Source #
Instance details Defined in Data.RBR.Internal Methods fromVariant' :: Variant I t -> Maybe (C1 (MetaCons k x y) U1 x0) Source #
(Key k t, Value k t ~ v) => FromVariantHelper t (C1 (MetaCons k x y) (S1 (MetaSel (Nothing :: Maybe Symbol) unpackedness strictness laziness) (Rec0 v))) Source #
Instance details Defined in Data.RBR.Internal Methods fromVariant' :: Variant I t -> Maybe (C1 (MetaCons k x y) (S1 (MetaSel Nothing unpackedness strictness laziness) (Rec0 v)) x0) Source #
FromVariantHelper t fields => FromVariantHelper t (D1 meta fields) Source #
Instance details Defined in Data.RBR.Internal Methods fromVariant' :: Variant I t -> Maybe (D1 meta fields x) Source #

class ToVariant (s :: Type) where Source #

Minimal complete definition

Nothing

Methods

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

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

class ToVariantHelper (t :: Map Symbol Type) (g :: Type -> Type) where Source #

Methods

toVariant' :: g x -> Variant I t Source #

Instances

(ToVariantHelper t t1, ToVariantHelper t t2) => ToVariantHelper t (t1 :+: t2) Source #
Instance details Defined in Data.RBR.Internal Methods toVariant' :: (t1 :+: t2) x -> Variant I t Source #
(Key k t, Value k t ~ ()) => ToVariantHelper t (C1 (MetaCons k x y) (U1 :: Type -> Type)) Source #
Instance details Defined in Data.RBR.Internal Methods toVariant' :: C1 (MetaCons k x y) U1 x0 -> Variant I t Source #
(Key k t, Value k t ~ v) => ToVariantHelper t (C1 (MetaCons k x y) (S1 (MetaSel (Nothing :: Maybe Symbol) unpackedness strictness laziness) (Rec0 v))) Source #
Instance details Defined in Data.RBR.Internal Methods toVariant' :: C1 (MetaCons k x y) (S1 (MetaSel Nothing unpackedness strictness laziness) (Rec0 v)) x0 -> Variant I t Source #
ToVariantHelper t fields => ToVariantHelper t (D1 meta fields) Source #
Instance details Defined in Data.RBR.Internal Methods toVariant' :: D1 meta fields x -> Variant I t Source #

type family DiscriminateBalL (l :: Map k v) (r :: Map k v) :: Bool where ... Source #

Equations

DiscriminateBalL (N R _ _ _ _) _ = False
DiscriminateBalL _ _ = True

class BalanceableL (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where Source #

Associated Types

type BalL l k v r :: Map Symbol q Source #

Methods

balLR :: Record f (N color l k v r) -> Record f (BalL l k v r) Source #

balLV :: Variant f (N color l k v r) -> Variant f (BalL l k v r) Source #

Instances

(DiscriminateBalL l r ~ b, BalanceableHelperL b l k v r) => BalanceableL (l :: Map Symbol q) k (v :: q) (r :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalL l k v r :: Map Symbol q Source # Methods balLR :: Record f (N color l k v r) -> Record f (BalL l k v r) Source # balLV :: Variant f (N color l k v r) -> Variant f (BalL l k v r) Source #

class BalanceableHelperL (b :: Bool) (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where Source #

Associated Types

type BalL' b l k v r :: Map Symbol q Source #

Methods

balLR' :: Record f (N color l k v r) -> Record f (BalL' b l k v r) Source #

balLV' :: Variant f (N color l k v r) -> Variant f (BalL' b l k v r) Source #

Instances

(N R l k kv r ~ g, BalanceableHelper (ShouldBalance t3 g) t3 z zv g) => BalanceableHelperL True (t1 :: Map Symbol q) y (yv :: q) (N R (N B t2 u uv t3) z zv (N B l k kv r) :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalL' True t1 y yv (N R (N B t2 u uv t3) z zv (N B l k kv r)) :: Map Symbol q Source # Methods balLR' :: Record f (N color t1 y yv (N R (N B t2 u uv t3) z zv (N B l k kv r))) -> Record f (BalL' True t1 y yv (N R (N B t2 u uv t3) z zv (N B l k kv r))) Source # balLV' :: Variant f (N color t1 y yv (N R (N B t2 u uv t3) z zv (N B l k kv r))) -> Variant f (BalL' True t1 y yv (N R (N B t2 u uv t3) z zv (N B l k kv r))) Source #
(N R t2 z zv t3 ~ g, BalanceableHelper (ShouldBalance t1 g) t1 y yv g) => BalanceableHelperL True (t1 :: Map Symbol q) y (yv :: q) (N B t2 z zv t3 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalL' True t1 y yv (N B t2 z zv t3) :: Map Symbol q Source # Methods balLR' :: Record f (N color t1 y yv (N B t2 z zv t3)) -> Record f (BalL' True t1 y yv (N B t2 z zv t3)) Source # balLV' :: Variant f (N color t1 y yv (N B t2 z zv t3)) -> Variant f (BalL' True t1 y yv (N B t2 z zv t3)) Source #
BalanceableHelperL False (N R left1 k1 v1 right1 :: Map Symbol q) k2 (v2 :: q) (right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalL' False (N R left1 k1 v1 right1) k2 v2 right2 :: Map Symbol q Source # Methods balLR' :: Record f (N color (N R left1 k1 v1 right1) k2 v2 right2) -> Record f (BalL' False (N R left1 k1 v1 right1) k2 v2 right2) Source # balLV' :: Variant f (N color (N R left1 k1 v1 right1) k2 v2 right2) -> Variant f (BalL' False (N R left1 k1 v1 right1) k2 v2 right2) Source #

type family DiscriminateBalR (l :: Map k v) (r :: Map k v) :: Bool where ... Source #

Equations

DiscriminateBalR _ (N R _ _ _ _) = False
DiscriminateBalR _ _ = True

class BalanceableR (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where Source #

Associated Types

type BalR l k v r :: Map Symbol q Source #

Methods

balRR :: Record f (N color l k v r) -> Record f (BalR l k v r) Source #

balRV :: Variant f (N color l k v r) -> Variant f (BalR l k v r) Source #

Instances

(DiscriminateBalR l r ~ b, BalanceableHelperR b l k v r) => BalanceableR (l :: Map Symbol q) k (v :: q) (r :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalR l k v r :: Map Symbol q Source # Methods balRR :: Record f (N color l k v r) -> Record f (BalR l k v r) Source # balRV :: Variant f (N color l k v r) -> Variant f (BalR l k v r) Source #

class BalanceableHelperR (b :: Bool) (l :: Map Symbol q) (k :: Symbol) (v :: q) (r :: Map Symbol q) where Source #

Associated Types

type BalR' b l k v r :: Map Symbol q Source #

Methods

balRR' :: Record f (N color l k v r) -> Record f (BalR' b l k v r) Source #

balRV' :: Variant f (N color l k v r) -> Variant f (BalR' b l k v r) Source #

Instances

BalanceableHelperR False (right2 :: Map Symbol q) k2 (v2 :: q) (N R left1 k1 v1 right1 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalR' False right2 k2 v2 (N R left1 k1 v1 right1) :: Map Symbol q Source # Methods balRR' :: Record f (N color right2 k2 v2 (N R left1 k1 v1 right1)) -> Record f (BalR' False right2 k2 v2 (N R left1 k1 v1 right1)) Source # balRV' :: Variant f (N color right2 k2 v2 (N R left1 k1 v1 right1)) -> Variant f (BalR' False right2 k2 v2 (N R left1 k1 v1 right1)) Source #
(N R t2 u uv t3 ~ g, ShouldBalance g l ~ shouldbalance, BalanceableHelper shouldbalance g z zv l) => BalanceableHelperR True (N R (N B t2 u uv t3) z zv (N B l k kv r) :: Map Symbol q) y (yv :: q) (t1 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalR' True (N R (N B t2 u uv t3) z zv (N B l k kv r)) y yv t1 :: Map Symbol q Source # Methods balRR' :: Record f (N color (N R (N B t2 u uv t3) z zv (N B l k kv r)) y yv t1) -> Record f (BalR' True (N R (N B t2 u uv t3) z zv (N B l k kv r)) y yv t1) Source # balRV' :: Variant f (N color (N R (N B t2 u uv t3) z zv (N B l k kv r)) y yv t1) -> Variant f (BalR' True (N R (N B t2 u uv t3) z zv (N B l k kv r)) y yv t1) Source #
(N R t2 z zv t3 ~ g, ShouldBalance g t1 ~ shouldbalance, BalanceableHelper shouldbalance g y yv t1) => BalanceableHelperR True (N B t2 z zv t3 :: Map Symbol q) y (yv :: q) (t1 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type BalR' True (N B t2 z zv t3) y yv t1 :: Map Symbol q Source # Methods balRR' :: Record f (N color (N B t2 z zv t3) y yv t1) -> Record f (BalR' True (N B t2 z zv t3) y yv t1) Source # balRV' :: Variant f (N color (N B t2 z zv t3) y yv t1) -> Variant f (BalR' True (N B t2 z zv t3) y yv t1) Source #

class Fuseable (l :: Map Symbol q) (r :: Map Symbol q) where Source #

Associated Types

type Fuse l r :: Map Symbol q Source #

Methods

fuseRecord :: Record f l -> Record f r -> Record f (Fuse l r) Source #

fuseVariant :: Either (Variant f l) (Variant f r) -> Variant f (Fuse l r) Source #

Instances

Fuseable (E :: Map Symbol q) (E :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse E E :: Map Symbol q Source # Methods fuseRecord :: Record f E -> Record f E -> Record f (Fuse E E) Source # fuseVariant :: Either (Variant f E) (Variant f E) -> Variant f (Fuse E E) Source #
Fuseable (E :: Map Symbol q) (N color left k v right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse E (N color left k v right) :: Map Symbol q Source # Methods fuseRecord :: Record f E -> Record f (N color left k v right) -> Record f (Fuse E (N color left k v right)) Source # fuseVariant :: Either (Variant f E) (Variant f (N color left k v right)) -> Variant f (Fuse E (N color left k v right)) Source #
Fuseable (N color left k v right :: Map Symbol q) (E :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse (N color left k v right) E :: Map Symbol q Source # Methods fuseRecord :: Record f (N color left k v right) -> Record f E -> Record f (Fuse (N color left k v right) E) Source # fuseVariant :: Either (Variant f (N color left k v right)) (Variant f E) -> Variant f (Fuse (N color left k v right) E) Source #
Fuseable right1 (N B left2 k2 v2 right2) => Fuseable (N R left1 k1 v1 right1 :: Map Symbol q) (N B left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse (N R left1 k1 v1 right1) (N B left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord :: Record f (N R left1 k1 v1 right1) -> Record f (N B left2 k2 v2 right2) -> Record f (Fuse (N R left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source # fuseVariant :: Either (Variant f (N R left1 k1 v1 right1)) (Variant f (N B left2 k2 v2 right2)) -> Variant f (Fuse (N R left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source #
Fuseable (N B left1 k1 v1 right1) left2 => Fuseable (N B left1 k1 v1 right1 :: Map Symbol q) (N R left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse (N B left1 k1 v1 right1) (N R left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord :: Record f (N B left1 k1 v1 right1) -> Record f (N R left2 k2 v2 right2) -> Record f (Fuse (N B left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source # fuseVariant :: Either (Variant f (N B left1 k1 v1 right1)) (Variant f (N R left2 k2 v2 right2)) -> Variant f (Fuse (N B left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source #
(Fuseable right1 left2, Fuse right1 left2 ~ fused, FuseableHelper1 fused (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) => Fuseable (N R left1 k1 v1 right1 :: Map Symbol q) (N R left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord :: Record f (N R left1 k1 v1 right1) -> Record f (N R left2 k2 v2 right2) -> Record f (Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source # fuseVariant :: Either (Variant f (N R left1 k1 v1 right1)) (Variant f (N R left2 k2 v2 right2)) -> Variant f (Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source #
(Fuseable right1 left2, Fuse right1 left2 ~ fused, FuseableHelper2 fused (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) => Fuseable (N B left1 k1 v1 right1 :: Map Symbol q) (N B left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord :: Record f (N B left1 k1 v1 right1) -> Record f (N B left2 k2 v2 right2) -> Record f (Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source # fuseVariant :: Either (Variant f (N B left1 k1 v1 right1)) (Variant f (N B left2 k2 v2 right2)) -> Variant f (Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source #

class FuseableHelper1 (fused :: Map Symbol q) (l :: Map Symbol q) (r :: Map Symbol q) where Source #

Associated Types

type Fuse1 fused l r :: Map Symbol q Source #

Methods

fuseRecord1 :: Record f l -> Record f r -> Record f (Fuse l r) Source #

fuseVariant1 :: Either (Variant f l) (Variant f r) -> Variant f (Fuse l r) Source #

Instances

FuseableHelper1 (E :: Map Symbol q) (N R left1 k1 v1 (E :: Map Symbol q) :: Map Symbol q) (N R (E :: Map Symbol q) k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse1 E (N R left1 k1 v1 E) (N R E k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord1 :: Record f (N R left1 k1 v1 E) -> Record f (N R E k2 v2 right2) -> Record f (Fuse (N R left1 k1 v1 E) (N R E k2 v2 right2)) Source # fuseVariant1 :: Either (Variant f (N R left1 k1 v1 E)) (Variant f (N R E k2 v2 right2)) -> Variant f (Fuse (N R left1 k1 v1 E) (N R E k2 v2 right2)) Source #
(Fuseable right1 left2, Fuse right1 left2 ~ N B s1 z zv s2) => FuseableHelper1 (N B s1 z zv s2 :: Map Symbol q) (N R left1 k1 v1 right1 :: Map Symbol q) (N R left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse1 (N B s1 z zv s2) (N R left1 k1 v1 right1) (N R left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord1 :: Record f (N R left1 k1 v1 right1) -> Record f (N R left2 k2 v2 right2) -> Record f (Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source # fuseVariant1 :: Either (Variant f (N R left1 k1 v1 right1)) (Variant f (N R left2 k2 v2 right2)) -> Variant f (Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source #
(Fuseable right1 left2, Fuse right1 left2 ~ N R s1 z zv s2) => FuseableHelper1 (N R s1 z zv s2 :: Map Symbol q) (N R left1 k1 v1 right1 :: Map Symbol q) (N R left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse1 (N R s1 z zv s2) (N R left1 k1 v1 right1) (N R left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord1 :: Record f (N R left1 k1 v1 right1) -> Record f (N R left2 k2 v2 right2) -> Record f (Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source # fuseVariant1 :: Either (Variant f (N R left1 k1 v1 right1)) (Variant f (N R left2 k2 v2 right2)) -> Variant f (Fuse (N R left1 k1 v1 right1) (N R left2 k2 v2 right2)) Source #

class FuseableHelper2 (fused :: Map Symbol q) (l :: Map Symbol q) (r :: Map Symbol q) where Source #

Associated Types

type Fuse2 fused l r :: Map Symbol q Source #

Methods

fuseRecord2 :: Record f l -> Record f r -> Record f (Fuse l r) Source #

fuseVariant2 :: Either (Variant f l) (Variant f r) -> Variant f (Fuse l r) Source #

Instances

BalanceableL left1 k1 v1 (N B (E :: Map Symbol q) k2 v2 right2) => FuseableHelper2 (E :: Map Symbol q) (N B left1 k1 v1 (E :: Map Symbol q) :: Map Symbol q) (N B (E :: Map Symbol q) k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse2 E (N B left1 k1 v1 E) (N B E k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord2 :: Record f (N B left1 k1 v1 E) -> Record f (N B E k2 v2 right2) -> Record f (Fuse (N B left1 k1 v1 E) (N B E k2 v2 right2)) Source # fuseVariant2 :: Either (Variant f (N B left1 k1 v1 E)) (Variant f (N B E k2 v2 right2)) -> Variant f (Fuse (N B left1 k1 v1 E) (N B E k2 v2 right2)) Source #
(Fuseable right1 left2, Fuse right1 left2 ~ N B s1 z zv s2, BalanceableL left1 k1 v1 (N B (N B s1 z zv s2) k2 v2 right2)) => FuseableHelper2 (N B s1 z zv s2 :: Map Symbol q) (N B left1 k1 v1 right1 :: Map Symbol q) (N B left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse2 (N B s1 z zv s2) (N B left1 k1 v1 right1) (N B left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord2 :: Record f (N B left1 k1 v1 right1) -> Record f (N B left2 k2 v2 right2) -> Record f (Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source # fuseVariant2 :: Either (Variant f (N B left1 k1 v1 right1)) (Variant f (N B left2 k2 v2 right2)) -> Variant f (Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source #
(Fuseable right1 left2, Fuse right1 left2 ~ N R s1 z zv s2) => FuseableHelper2 (N R s1 z zv s2 :: Map Symbol q) (N B left1 k1 v1 right1 :: Map Symbol q) (N B left2 k2 v2 right2 :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Fuse2 (N R s1 z zv s2) (N B left1 k1 v1 right1) (N B left2 k2 v2 right2) :: Map Symbol q Source # Methods fuseRecord2 :: Record f (N B left1 k1 v1 right1) -> Record f (N B left2 k2 v2 right2) -> Record f (Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source # fuseVariant2 :: Either (Variant f (N B left1 k1 v1 right1)) (Variant f (N B left2 k2 v2 right2)) -> Variant f (Fuse (N B left1 k1 v1 right1) (N B left2 k2 v2 right2)) Source #

class Delable (k :: Symbol) (v :: q) (t :: Map Symbol q) where Source #

Associated Types

type Del k v t :: Map Symbol q Source #

Methods

del :: Record f t -> Record f (Del k v t) Source #

win :: Variant f t -> Either (Variant f (Del k v t)) (f v) Source #

Instances

Delable k (v :: q) (E :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Del k v E :: Map Symbol q Source # Methods del :: Record f E -> Record f (Del k v E) Source # win :: Variant f E -> Either (Variant f (Del k v E)) (f v) Source #
(CmpSymbol kx k ~ ordering, DelableHelper ordering k v left kx vx right) => Delable k (v :: q) (N color left kx vx right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Del k v (N color left kx vx right) :: Map Symbol q Source # Methods del :: Record f (N color left kx vx right) -> Record f (Del k v (N color left kx vx right)) Source # win :: Variant f (N color left kx vx right) -> Either (Variant f (Del k v (N color left kx vx right))) (f v) Source #

class DelableL (k :: Symbol) (v :: q) (l :: Map Symbol q) (kx :: Symbol) (vx :: q) (r :: Map Symbol q) where Source #

Associated Types

type DelL k v l kx vx r :: Map Symbol q Source #

Methods

delL :: Record f (N color l kx vx r) -> Record f (DelL k v l kx vx r) Source #

winL :: Variant f (N color l kx vx r) -> Either (Variant f (DelL k v l kx vx r)) (f v) Source #

Instances

DelableL k (v :: q) (E :: Map Symbol q) kx (vx :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type DelL k v E kx vx right :: Map Symbol q Source # Methods delL :: Record f (N color E kx vx right) -> Record f (DelL k v E kx vx right) Source # winL :: Variant f (N color E kx vx right) -> Either (Variant f (DelL k v E kx vx right)) (f v) Source #
Delable k v (N R leftz kz vz rightz) => DelableL k (v :: q) (N R leftz kz vz rightz :: Map Symbol q) kx (vx :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type DelL k v (N R leftz kz vz rightz) kx vx right :: Map Symbol q Source # Methods delL :: Record f (N color (N R leftz kz vz rightz) kx vx right) -> Record f (DelL k v (N R leftz kz vz rightz) kx vx right) Source # winL :: Variant f (N color (N R leftz kz vz rightz) kx vx right) -> Either (Variant f (DelL k v (N R leftz kz vz rightz) kx vx right)) (f v) Source #
(N B leftz kz vz rightz ~ g, Delable k v g, Del k v g ~ deleted, BalanceableL deleted kx vx right) => DelableL k (v :: q) (N B leftz kz vz rightz :: Map Symbol q) kx (vx :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type DelL k v (N B leftz kz vz rightz) kx vx right :: Map Symbol q Source # Methods delL :: Record f (N color (N B leftz kz vz rightz) kx vx right) -> Record f (DelL k v (N B leftz kz vz rightz) kx vx right) Source # winL :: Variant f (N color (N B leftz kz vz rightz) kx vx right) -> Either (Variant f (DelL k v (N B leftz kz vz rightz) kx vx right)) (f v) Source #

class DelableR (k :: Symbol) (v :: q) (l :: Map Symbol q) (kx :: Symbol) (vx :: q) (r :: Map Symbol q) where Source #

Associated Types

type DelR k v l kx vx r :: Map Symbol q Source #

Methods

delR :: Record f (N color l kx vx r) -> Record f (DelR k v l kx vx r) Source #

winR :: Variant f (N color l kx vx r) -> Either (Variant f (DelR k v l kx vx r)) (f v) Source #

Instances

DelableR k (v :: q) (left :: Map Symbol q) kx (vx :: q) (E :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type DelR k v left kx vx E :: Map Symbol q Source # Methods delR :: Record f (N color left kx vx E) -> Record f (DelR k v left kx vx E) Source # winR :: Variant f (N color left kx vx E) -> Either (Variant f (DelR k v left kx vx E)) (f v) Source #
Delable k v (N R leftz kz vz rightz) => DelableR k (v :: q) (left :: Map Symbol q) kx (vx :: q) (N R leftz kz vz rightz :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type DelR k v left kx vx (N R leftz kz vz rightz) :: Map Symbol q Source # Methods delR :: Record f (N color left kx vx (N R leftz kz vz rightz)) -> Record f (DelR k v left kx vx (N R leftz kz vz rightz)) Source # winR :: Variant f (N color left kx vx (N R leftz kz vz rightz)) -> Either (Variant f (DelR k v left kx vx (N R leftz kz vz rightz))) (f v) Source #
(N B leftz kz vz rightz ~ g, Delable k v g, Del k v g ~ deleted, BalanceableR left kx vx deleted) => DelableR k (v :: q) (left :: Map Symbol q) kx (vx :: q) (N B leftz kz vz rightz :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type DelR k v left kx vx (N B leftz kz vz rightz) :: Map Symbol q Source # Methods delR :: Record f (N color left kx vx (N B leftz kz vz rightz)) -> Record f (DelR k v left kx vx (N B leftz kz vz rightz)) Source # winR :: Variant f (N color left kx vx (N B leftz kz vz rightz)) -> Either (Variant f (DelR k v left kx vx (N B leftz kz vz rightz))) (f v) Source #

class DelableHelper (ordering :: Ordering) (k :: Symbol) (v :: q) (l :: Map Symbol q) (kx :: Symbol) (vx :: q) (r :: Map Symbol q) where Source #

Associated Types

type Del' ordering k v l kx vx r :: Map Symbol q Source #

Methods

del' :: Record f (N color l kx vx r) -> Record f (Del' ordering k v l kx vx r) Source #

win' :: Variant f (N color l kx vx r) -> Either (Variant f (Del' ordering k v l kx vx r)) (f v) Source #

Instances

DelableR k v left kx vx right => DelableHelper LT k (v :: q) (left :: Map Symbol q) kx (vx :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Del' LT k v left kx vx right :: Map Symbol q Source # Methods del' :: Record f (N color left kx vx right) -> Record f (Del' LT k v left kx vx right) Source # win' :: Variant f (N color left kx vx right) -> Either (Variant f (Del' LT k v left kx vx right)) (f v) Source #
Fuseable left right => DelableHelper EQ k (v :: q) (left :: Map Symbol q) k (v :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Del' EQ k v left k v right :: Map Symbol q Source # Methods del' :: Record f (N color left k v right) -> Record f (Del' EQ k v left k v right) Source # win' :: Variant f (N color left k v right) -> Either (Variant f (Del' EQ k v left k v right)) (f v) Source #
DelableL k v left kx vx right => DelableHelper GT k (v :: q) (left :: Map Symbol q) kx (vx :: q) (right :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Del' GT k v left kx vx right :: Map Symbol q Source # Methods del' :: Record f (N color left kx vx right) -> Record f (Del' GT k v left kx vx right) Source # win' :: Variant f (N color left kx vx right) -> Either (Variant f (Del' GT k v left kx vx right)) (f v) Source #

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

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

The associated type family Delete produces the resulting map.

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 map already has the key but with a different type, the deletion fails to compile.

Associated Types

type Delete k v t :: Map Symbol q Source #

Methods

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

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

Instances

(Delable k v t, Del k v t ~ deleted, CanMakeBlack deleted) => Deletable k (v :: q) (t :: Map Symbol q) Source #
Instance details Defined in Data.RBR.Internal Associated Types type Delete k v t :: Map Symbol q Source # Methods _delete :: Record f t -> Record f (Delete k v t) Source # _winnow :: Variant f t -> Either (Variant f (Delete k v t)) (f v) Source #

delete :: forall k v t f. Deletable k v t => Record f t -> Record f (Delete k v t) Source #

Removes a field from a Record.

winnow :: forall k v t f. Deletable k v t => Variant f t -> Either (Variant f (Delete k v t)) (f v) Source #

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.

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

Like winnow but specialized to pure Variants.

>>> winnow @"bar" @Bool (injectI @"bar" False :: Variant I (FromList [ '("foo",Char), '("bar",Bool) ]))
Right (I False)

>>> prettyShow_VariantI `first` winnow @"foo" @Char (injectI @"bar" False :: Variant I (FromList [ '("foo",Char), '("bar",Bool) ]))
Left "bar (False)"