hset-1.1.0: Primitive heterogenous read-only set

Safe HaskellSafe-Inferred
LanguageHaskell2010

Data.HSet

Contents

Synopsis

Documentation

data HSet elems where Source

Heterogeneous set (list) of elements with unique types. Useful with MonadReader.

>>> let x = HSCons (10 :: Int) $ HSCons (20 :: Double) HSNil
>>> x
HSCons (10) (HSCons (20.0) (HSNil))

>>> hget x :: Int
10

>>> hget x :: Double
20.0

Note that hget takes specific element from list of uniquely typed elements depending on what type is required to be returned.

Constructors

HSNil :: HSet [] 
HSCons :: (False ~ Elem elem elems) => !elem -> !(HSet elems) -> HSet (elem : elems) 

Instances

(Eq e, Eq (HSet els)) => Eq (HSet ((:) * e els)) 
Eq (HSet ([] *)) 
(Ord e, Ord (HSet els)) => Ord (HSet ((:) * e els)) 
Ord (HSet ([] *)) 
(Show e, Show (HSet els)) => Show (HSet ((:) * e els)) 
Show (HSet ([] *)) 
Typeable ([*] -> *) HSet 

class (i ~ Index e els) => HGet els e i where Source

Typeclass for sets and elements.

Methods

hget :: HSet els -> e Source

Gets any data from HSet for you

Instances

HGet ((:) * e els) e Z 
((~) Nat i (Index * e els), (~) Nat (S i) (Index * e ((:) * e1 els)), HGet els e i) => HGet ((:) * e1 els) e (S i) 

type HGetable els e = HGet els e (Index e els) Source

Enables deriving of the fact that e is contained within els and it's safe to say that hget can be performed on this particular pair.

hask :: (MonadReader (HSet els) m, HGetable els e) => m e Source

class (eq ~ TEq els els2) => SubHSet els els2 eq where Source

Takes subset of some hset, including subset of same elements in different order

>>> let x = (HSCons "hello" $ HSCons 1234 $ HSCons 12.123 HSNil) :: HSet '[String, Int, Double]

>>> subHSet x :: HSet '[Double, Int]
HSCons (12.123) (HSCons (1234) (HSNil))

>>> subHSet x :: HSet '[String, Double]
HSCons ("hello") (HSCons (12.123) (HSNil))

>>> subHSet x :: HSet '[Int, String]
HSCons (1234) (HSCons ("hello") (HSNil))

Methods

subHSet :: HSet els -> HSet els2 Source

Instances

(~) Bool eq (TEq [*] els ([] *)) => SubHSet els ([] *) eq 
(HGetable els el, (~) Bool False (Elem * el els2), SubHSet els els2 subeq, (~) [*] els ((:) * el els2), (~) Bool True (TEq [*] els ((:) * el els2))) => SubHSet els ((:) * el els2) True 
(HGetable els el, (~) Bool False (Elem * el els2), SubHSet els els2 subeq, (~) Bool False (TEq [*] els ((:) * el els2))) => SubHSet els ((:) * el els2) False 

type SubHSetable els1 els2 eq = (SubHSet els1 els2 eq, eq ~ TEq els1 els2) Source

hdelete :: SubHSetable els (Delete a els) eq => proxy a -> HSet els -> HSet (Delete a els) Source

Removes element from HSet of specified type

>>> let x = (HSCons "sdf" $ HSCons 123 HSNil) :: HSet '[String, Int]

>>> hdelete (Proxy :: Proxy Int) x
HSCons ("sdf") (HSNil)

>>> hdelete (Proxy :: Proxy String) x
HSCons (123) (HSNil)

hnarrow :: SubHSetable els subels eq => proxy subels -> HSet els -> HSet subels Source

Like subHSet but with proxy for convenience

>>> let x = (HSCons "hello" $ HSCons 123 $ HSCons 345 HSNil) :: HSet '[String, Int, Integer]

>>> hnarrow (Proxy :: Proxy '[]) x
HSNil

>>> hnarrow (Proxy :: Proxy '[String]) x
HSCons ("hello") (HSNil)

>>> hnarrow (Proxy :: Proxy '[Int, Integer]) x
HSCons (123) (HSCons (345) (HSNil))

>>> hnarrow (Proxy :: Proxy '[Integer, Int]) x
HSCons (345) (HSCons (123) (HSNil))

Work with Labeled elements

hgetLabeled :: forall proxy label e els. HGetable els (Labeled label e) => proxy label -> HSet els -> e Source

>>> let y = HSCons (Labeled 10 :: Labeled "x" Int) $ HSCons (Labeled 20 :: Labeled "y" Int) HSNil
>>> y
HSCons (Labeled {unLabeled = 10}) (HSCons (Labeled {unLabeled = 20}) (HSNil))

>>> hgetLabeled (Proxy :: Proxy "x") y :: Int
10

>>> hgetLabeled (Proxy :: Proxy "y") y :: Int
20

haskLabeled :: forall proxy label e els m. (HGetable els (Labeled label e), MonadReader (HSet els) m, Applicative m) => proxy label -> m e Source

Reexports

module Data.HSet.Labeled