Copyright	(c) gspia 2020-
License	BSD
Maintainer	gspia
Safe Haskell	Safe
Language	Haskell2010

Fcf.Data.MapC

Description

Fcf.Data.MapC

MapC provides an interface to mapping keys to values, which is similar to that given by the containers-package. Note that the this module still misses some of the methods that can be found in containers. If you need some, please do open up an issue or better, make a PR.

Many of the examples are from containers-package.

We call this MapC because name Map is reserved to the map-function in Fcf-package. The internal representation is type-level list. We hope that one day the internal representation is based on balanced trees similar to the one used in the containers.

Synopsis

data MapC k v = MapC [(k, v)]
data Empty :: Exp (MapC k v)
data Singleton :: k -> v -> Exp (MapC k v)
data FromList :: [(k, v)] -> Exp (MapC k v)
data Insert :: k -> v -> MapC k v -> Exp (MapC k v)
data InsertWith :: (v -> v -> Exp v) -> k -> v -> MapC k v -> Exp (MapC k v)
data InsWithHelp :: (v -> v -> Exp v) -> k -> v -> (k, v) -> Exp (k, v)
data Delete :: k -> MapC k v -> Exp (MapC k v)
data Adjust :: (v -> Exp v) -> k -> MapC k v -> Exp (MapC k v)
data AdjustHelp :: (v -> Exp v) -> k -> [(k, v)] -> Exp [(k, v)]
data Lookup :: k -> MapC k v -> Exp (Maybe v)
data Member :: k -> MapC k v -> Exp Bool
data NotMember :: k -> MapC k v -> Exp Bool
data Null :: MapC k v -> Exp Bool
data Size :: MapC k v -> Exp Nat
data Union :: MapC k v -> MapC k v -> Exp (MapC k v)
data UComb :: (k, v) -> [(k, v)] -> Exp [(k, v)]
data Difference :: MapC k v -> MapC k v -> Exp (MapC k v)
data DiffNotMem :: MapC k v -> k -> v -> Exp Bool
data Intersection :: MapC k v -> MapC k v -> Exp (MapC k v)
data InterMem :: MapC k v -> k -> v -> Exp Bool
data Disjoint :: MapC k v -> MapC k v -> Exp Bool
data Map :: (v -> Exp w) -> MapC k v -> Exp (MapC k w)
data MapWithKey :: (k -> v -> Exp w) -> MapC k v -> Exp (MapC k w)
data MWKhelp :: [(k, v)] -> Exp [(k, (k, v))]
data Foldr :: (v -> w -> Exp w) -> w -> MapC k v -> Exp w
data Elems :: MapC k v -> Exp [v]
data Keys :: MapC k v -> Exp [k]
data Assocs :: MapC k v -> Exp [(k, v)]
data ToList :: MapC k v -> Exp [(k, v)]
data Filter :: (v -> Exp Bool) -> MapC k v -> Exp (MapC k v)
data FilterWithKey :: (k -> v -> Exp Bool) -> MapC k v -> Exp (MapC k v)
data Partition :: (v -> Exp Bool) -> MapC k v -> Exp (MapC k v, MapC k v)
data PartitionHlp :: ([(k, v)], [(k, v)]) -> Exp (MapC k v, MapC k v)

Documentation

>>> import Fcf ( type (>=), Pure1, Pure2 )
>>> import           Fcf.Data.Nat

data MapC k v Source #

A type corresponding to Map in the containers. We call this MapC because name Map is reserved to the map-function in Fcf-package.

The representation is based on type-level lists. Please, do not use that fact but rather use the exposed API. (We hope to change the internal data type to balanced tree similar to the one used in containers. See TODO.md.)

Constructors

MapC [(k, v)]

Instances

type Eval (Empty :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Empty :: MapC k v -> Type) = MapC ([] :: [(k, v)])
type Eval (PartitionHlp ((,) xs ys) :: (MapC k v, MapC k v) -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (PartitionHlp ((,) xs ys) :: (MapC k v, MapC k v) -> Type) = (,) (MapC xs) (MapC ys)
type Eval (FromList lst :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (FromList lst :: MapC k v -> Type) = MapC lst
type Eval (Partition f (MapC lst) :: (MapC k v, MapC k v) -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Partition f (MapC lst) :: (MapC k v, MapC k v) -> Type) = Eval (PartitionHlp (Eval (Partition (f <=< (Snd :: (k, v) -> v -> Type)) lst)))
type Eval (Singleton k2 v2 :: MapC k1 v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Singleton k2 v2 :: MapC k1 v1 -> Type) = MapC ((,) k2 v2 ': ([] :: [(k1, v1)]))
type Eval (Delete k2 (MapC lst) :: MapC k1 v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Delete k2 (MapC lst) :: MapC k1 v -> Type) = MapC (Eval (Filter (Not <=< ((TyEq k2 :: k1 -> Bool -> Type) <=< (Fst :: (k1, v) -> k1 -> Type))) lst))
type Eval (Union (MapC lst1) (MapC lst2) :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Union (MapC lst1) (MapC lst2) :: MapC k v -> Type) = MapC (Eval (Foldr (UComb :: (k, v) -> [(k, v)] -> [(k, v)] -> Type) lst1 lst2))
type Eval (Filter f (MapC lst) :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Filter f (MapC lst) :: MapC k v -> Type) = MapC (Eval (Filter (f <=< (Snd :: (k, v) -> v -> Type)) lst))
type Eval (FilterWithKey f (MapC lst) :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (FilterWithKey f (MapC lst) :: MapC k v -> Type) = MapC (Eval (Filter (Uncurry f) lst))
type Eval (Intersection mp1 mp2 :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Intersection mp1 mp2 :: MapC k v -> Type) = Eval (FilterWithKey (InterMem mp2) mp1)
type Eval (Difference mp1 mp2 :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Difference mp1 mp2 :: MapC k v -> Type) = Eval (FilterWithKey (DiffNotMem mp2) mp1)
type Eval (Insert k2 v2 (MapC lst) :: MapC k1 v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Insert k2 v2 (MapC lst) :: MapC k1 v1 -> Type) = If (Eval (Elem k2 =<< Map (Fst :: (k1, v1) -> k1 -> Type) lst)) (MapC lst) (MapC ((,) k2 v2 ': lst))
type Eval (Adjust f k2 (MapC lst) :: MapC k1 v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Adjust f k2 (MapC lst) :: MapC k1 v -> Type) = MapC (Eval (AdjustHelp f k2 lst))
type Eval (MapWithKey f mp :: MapC k v2 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (MapWithKey f mp :: MapC k v2 -> Type) = MapC (Eval ((Map (Second (Uncurry f) :: (k, (k, v1)) -> (k, v2) -> Type) :: [(k, (k, v1))] -> [(k, v2)] -> Type) =<< ((MWKhelp :: [(k, v1)] -> [(k, (k, v1))] -> Type) =<< Assocs mp)))
type Eval (Map f mp :: MapC k v2 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Map f mp :: MapC k v2 -> Type) = MapC (Eval ((Map (Second f :: (k, v1) -> (k, v2) -> Type) :: [(k, v1)] -> [(k, v2)] -> Type) =<< Assocs mp))
type Eval (InsertWith f k2 v2 (MapC lst) :: MapC k1 v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (InsertWith f k2 v2 (MapC lst) :: MapC k1 v1 -> Type) = If (Eval (Elem k2 =<< Map (Fst :: (k1, v1) -> k1 -> Type) lst)) (MapC (Eval (Map (InsWithHelp f k2 v2) lst))) (MapC (Eval (lst ++ ((,) k2 v2 ': ([] :: [(k1, v1)])))))

data Empty :: Exp (MapC k v) Source #

Empty

Example

>>> :kind! (Eval Empty :: MapC Nat TL.Symbol)
(Eval Empty :: MapC Nat TL.Symbol) :: MapC Nat TL.Symbol
= 'MapC '[]

>>> :kind! (Eval Empty :: MapC Int String)
(Eval Empty :: MapC Int String) :: MapC Int [Char]
= 'MapC '[]

See also the other examples in this module.

Instances

type Eval (Empty :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Empty :: MapC k v -> Type) = MapC ([] :: [(k, v)])

data Singleton :: k -> v -> Exp (MapC k v) Source #

Singleton

Example

>>> :kind! Eval (Singleton 1 "haa")
Eval (Singleton 1 "haa") :: MapC Nat TL.Symbol
= 'MapC '[ '(1, "haa")]

Instances

type Eval (Singleton k2 v2 :: MapC k1 v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Singleton k2 v2 :: MapC k1 v1 -> Type) = MapC ((,) k2 v2 ': ([] :: [(k1, v1)]))

data FromList :: [(k, v)] -> Exp (MapC k v) Source #

Use FromList to construct a MapC from type-level list.

Example

>>> :kind! Eval (FromList '[ '(1,"haa"), '(2,"hoo")])
Eval (FromList '[ '(1,"haa"), '(2,"hoo")]) :: MapC Nat TL.Symbol
= 'MapC '[ '(1, "haa"), '(2, "hoo")]

Instances

type Eval (FromList lst :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (FromList lst :: MapC k v -> Type) = MapC lst

data Insert :: k -> v -> MapC k v -> Exp (MapC k v) Source #

Insert

Example

>>> :kind! Eval (Insert 3 "hih" =<< FromList '[ '(1,"haa"), '(2,"hoo")])
Eval (Insert 3 "hih" =<< FromList '[ '(1,"haa"), '(2,"hoo")]) :: MapC 
                                                                   Nat TL.Symbol
= 'MapC '[ '(3, "hih"), '(1, "haa"), '(2, "hoo")]

Instances

type Eval (Insert k2 v2 (MapC lst) :: MapC k1 v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Insert k2 v2 (MapC lst) :: MapC k1 v1 -> Type) = If (Eval (Elem k2 =<< Map (Fst :: (k1, v1) -> k1 -> Type) lst)) (MapC lst) (MapC ((,) k2 v2 ': lst))

data InsertWith :: (v -> v -> Exp v) -> k -> v -> MapC k v -> Exp (MapC k v) Source #

InsertWith if old there, map if no old, add

Example

>>> :kind! Eval (InsertWith (Pure2 TL.AppendSymbol) 5 "xxx" (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (InsertWith (Pure2 TL.AppendSymbol) 5 "xxx" (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: MapC 
                                                                                                Nat 
                                                                                                TL.Symbol
= 'MapC '[ '(5, "xxxa"), '(3, "b")]

>>> :kind! Eval (InsertWith (Pure2 TL.AppendSymbol) 7 "xxx" (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (InsertWith (Pure2 TL.AppendSymbol) 7 "xxx" (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: MapC 
                                                                                                Nat 
                                                                                                TL.Symbol
= 'MapC '[ '(5, "a"), '(3, "b"), '(7, "xxx")]

>>> :kind! Eval (InsertWith (Pure2 TL.AppendSymbol) 5 "xxx" =<< Empty)
Eval (InsertWith (Pure2 TL.AppendSymbol) 5 "xxx" =<< Empty) :: MapC 
                                                                 Nat TL.Symbol
= 'MapC '[ '(5, "xxx")]

Instances

type Eval (InsertWith f k2 v2 (MapC lst) :: MapC k1 v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (InsertWith f k2 v2 (MapC lst) :: MapC k1 v1 -> Type) = If (Eval (Elem k2 =<< Map (Fst :: (k1, v1) -> k1 -> Type) lst)) (MapC (Eval (Map (InsWithHelp f k2 v2) lst))) (MapC (Eval (lst ++ ((,) k2 v2 ': ([] :: [(k1, v1)])))))

data InsWithHelp :: (v -> v -> Exp v) -> k -> v -> (k, v) -> Exp (k, v) Source #

Instances

type Eval (InsWithHelp f k3 vNew ((,) k4 vOld) :: (k1, k2) -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (InsWithHelp f k3 vNew ((,) k4 vOld) :: (k1, k2) -> Type) = If (Eval (TyEq k3 k4)) ((,) k3 (Eval (f vNew vOld))) ((,) k4 vOld)

data Delete :: k -> MapC k v -> Exp (MapC k v) Source #

Delete

Example

>>> :kind! Eval (Delete 5 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Delete 5 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: MapC 
                                                              Nat TL.Symbol
= 'MapC '[ '(3, "b")]

>>> :kind! Eval (Delete 7 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Delete 7 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: MapC 
                                                              Nat TL.Symbol
= 'MapC '[ '(5, "a"), '(3, "b")]

>>> :kind! Eval (Delete 7 (Eval Empty))
Eval (Delete 7 (Eval Empty)) :: MapC Nat v
= 'MapC '[]

Instances

type Eval (Delete k2 (MapC lst) :: MapC k1 v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Delete k2 (MapC lst) :: MapC k1 v -> Type) = MapC (Eval (Filter (Not <=< ((TyEq k2 :: k1 -> Bool -> Type) <=< (Fst :: (k1, v) -> k1 -> Type))) lst))

data Adjust :: (v -> Exp v) -> k -> MapC k v -> Exp (MapC k v) Source #

Adjust

Example

>>> :kind! Eval (Adjust (Pure1 (TL.AppendSymbol "new ")) 5 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Adjust (Pure1 (TL.AppendSymbol "new ")) 5 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: MapC 
                                                                                               Nat 
                                                                                               TL.Symbol
= 'MapC '[ '(5, "new a"), '(3, "b")]

>>> :kind! Eval (Adjust (Pure1 (TL.AppendSymbol "new ")) 7 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Adjust (Pure1 (TL.AppendSymbol "new ")) 7 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: MapC 
                                                                                               Nat 
                                                                                               TL.Symbol
= 'MapC '[ '(5, "a"), '(3, "b")]

>>> :kind! Eval (Adjust (Pure1 (TL.AppendSymbol "new "))  7 (Eval Empty))
Eval (Adjust (Pure1 (TL.AppendSymbol "new "))  7 (Eval Empty)) :: MapC 
                                                                    Nat TL.Symbol
= 'MapC '[]

Instances

type Eval (Adjust f k2 (MapC lst) :: MapC k1 v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Adjust f k2 (MapC lst) :: MapC k1 v -> Type) = MapC (Eval (AdjustHelp f k2 lst))

data AdjustHelp :: (v -> Exp v) -> k -> [(k, v)] -> Exp [(k, v)] Source #

Instances

type Eval (AdjustHelp f k2 ((,) k3 v2 ': rst) :: [(k1, v1)] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (AdjustHelp f k2 ((,) k3 v2 ': rst) :: [(k1, v1)] -> Type) = If (Eval (TyEq k2 k3)) ((,) k2 (f @@ v2) ': Eval (AdjustHelp f k2 rst)) ((,) k3 v2 ': Eval (AdjustHelp f k2 rst))
type Eval (AdjustHelp _f _k ([] :: [(k, v)]) :: [(k, v)] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (AdjustHelp _f _k ([] :: [(k, v)]) :: [(k, v)] -> Type) = ([] :: [(k, v)])

data Lookup :: k -> MapC k v -> Exp (Maybe v) Source #

Lookup

Example

>>> :kind! Eval (Lookup 5 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Lookup 5 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: Maybe 
                                                              TL.Symbol
= 'Just "a"

>>> :kind! Eval (Lookup 7 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Lookup 7 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: Maybe 
                                                              TL.Symbol
= 'Nothing

Instances

type Eval (Lookup k2 (MapC ((,) k3 v2 ': rst)) :: Maybe v1 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Lookup k2 (MapC ((,) k3 v2 ': rst)) :: Maybe v1 -> Type) = Eval (If (Eval (TyEq k2 k3)) (Pure (Just v2)) (Lookup k2 (MapC rst)))
type Eval (Lookup k2 (MapC ([] :: [(k1, v)])) :: Maybe v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Lookup k2 (MapC ([] :: [(k1, v)])) :: Maybe v -> Type) = (Nothing :: Maybe v)

data Member :: k -> MapC k v -> Exp Bool Source #

Member

Example

>>> :kind! Eval (Member 5 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Member 5 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: Bool
= 'True
>>> :kind! Eval (Member 7 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (Member 7 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: Bool
= 'False

Instances

type Eval (Member k2 mp :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Member k2 mp :: Bool -> Type) = Eval (Elem k2 =<< Keys mp)

data NotMember :: k -> MapC k v -> Exp Bool Source #

NotMember

Example

>>> :kind! Eval (NotMember 5 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (NotMember 5 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: Bool
= 'False
>>> :kind! Eval (NotMember 7 (Eval (FromList '[ '(5,"a"), '(3,"b")])))
Eval (NotMember 7 (Eval (FromList '[ '(5,"a"), '(3,"b")]))) :: Bool
= 'True

Instances

type Eval (NotMember k2 mp :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (NotMember k2 mp :: Bool -> Type) = Eval (Not =<< (Elem k2 =<< Keys mp))

data Null :: MapC k v -> Exp Bool Source #

Null

Example

>>> :kind! Eval (Null =<< FromList '[ '(5,"a"), '(3,"b")])
Eval (Null =<< FromList '[ '(5,"a"), '(3,"b")]) :: Bool
= 'False
>>> :kind! Eval (Null =<< Empty)
Eval (Null =<< Empty) :: Bool
= 'True

Instances

type Eval (Null (MapC (_1 ': _2)) :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Null (MapC (_1 ': _2)) :: Bool -> Type) = False
type Eval (Null (MapC ([] :: [(k, v)])) :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Null (MapC ([] :: [(k, v)])) :: Bool -> Type) = True

data Size :: MapC k v -> Exp Nat Source #

Size

Example

>>> :kind! Eval (Size =<< FromList '[ '(5,"a"), '(3,"b")])
Eval (Size =<< FromList '[ '(5,"a"), '(3,"b")]) :: Nat
= 2

Instances

type Eval (Size (MapC lst) :: Nat -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Size (MapC lst) :: Nat -> Type) = Eval (Length lst)

data Union :: MapC k v -> MapC k v -> Exp (MapC k v) Source #

Union

Example

>>> :kind! Eval (Union (Eval (FromList '[ '(5,"a"), '(3,"b")])) (Eval (FromList '[ '(5,"A"), '(7,"c")])) )
Eval (Union (Eval (FromList '[ '(5,"a"), '(3,"b")])) (Eval (FromList '[ '(5,"A"), '(7,"c")])) ) :: MapC 
                                                                                                     Nat 
                                                                                                     TL.Symbol
= 'MapC '[ '(7, "c"), '(5, "a"), '(3, "b")]

Instances

type Eval (Union (MapC lst1) (MapC lst2) :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Union (MapC lst1) (MapC lst2) :: MapC k v -> Type) = MapC (Eval (Foldr (UComb :: (k, v) -> [(k, v)] -> [(k, v)] -> Type) lst1 lst2))

data UComb :: (k, v) -> [(k, v)] -> Exp [(k, v)] Source #

Instances

type Eval (UComb ((,) k3 v) lst :: [(k1, k2)] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (UComb ((,) k3 v) lst :: [(k1, k2)] -> Type) = If (Eval (Elem k3 =<< Map (Fst :: (k1, k2) -> k1 -> Type) lst)) lst ((,) k3 v ': lst)

data Difference :: MapC k v -> MapC k v -> Exp (MapC k v) Source #

Difference

Example

>>> :kind! Eval (Difference (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(5,"B"), '(7,"C")])))
Eval (Difference (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(5,"B"), '(7,"C")]))) :: MapC 
                                                                                                         Nat 
                                                                                                         TL.Symbol
= 'MapC '[ '(3, "a")]

Instances

type Eval (Difference mp1 mp2 :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Difference mp1 mp2 :: MapC k v -> Type) = Eval (FilterWithKey (DiffNotMem mp2) mp1)

data DiffNotMem :: MapC k v -> k -> v -> Exp Bool Source #

Instances

type Eval (DiffNotMem mp k2 _ :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (DiffNotMem mp k2 _ :: Bool -> Type) = Eval (Not =<< (Elem k2 =<< Keys mp))

data Intersection :: MapC k v -> MapC k v -> Exp (MapC k v) Source #

Intersection

Example

>>> :kind! Eval (Intersection (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(5,"B"), '(7,"C")])))
Eval (Intersection (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(5,"B"), '(7,"C")]))) :: MapC 
                                                                                                           Nat 
                                                                                                           TL.Symbol
= 'MapC '[ '(5, "b")]

Instances

type Eval (Intersection mp1 mp2 :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Intersection mp1 mp2 :: MapC k v -> Type) = Eval (FilterWithKey (InterMem mp2) mp1)

data InterMem :: MapC k v -> k -> v -> Exp Bool Source #

Instances

type Eval (InterMem mp k2 _ :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (InterMem mp k2 _ :: Bool -> Type) = Eval (Elem k2 =<< Keys mp)

data Disjoint :: MapC k v -> MapC k v -> Exp Bool Source #

Disjoint

Example

>>> :kind! Eval (Disjoint (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(5,"B"), '(7,"C")])))
Eval (Disjoint (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(5,"B"), '(7,"C")]))) :: Bool
= 'False

>>> :kind! Eval (Disjoint (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(2,"B"), '(7,"C")])))
Eval (Disjoint (Eval (FromList '[ '(3,"a"), '(5,"b")])) (Eval (FromList '[ '(2,"B"), '(7,"C")]))) :: Bool
= 'True
>>> :kind! Eval (Disjoint (Eval Empty) (Eval Empty))
Eval (Disjoint (Eval Empty) (Eval Empty)) :: Bool
= 'True

Instances

type Eval (Disjoint mp1 mp2 :: Bool -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Disjoint mp1 mp2 :: Bool -> Type) = Eval ((Null :: MapC k v -> Bool -> Type) =<< Intersection mp1 mp2)

data Map :: (v -> Exp w) -> MapC k v -> Exp (MapC k w) Source #

Instances

type Eval (Map f mp :: MapC k v2 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Map f mp :: MapC k v2 -> Type) = MapC (Eval ((Map (Second f :: (k, v1) -> (k, v2) -> Type) :: [(k, v1)] -> [(k, v2)] -> Type) =<< Assocs mp))

data MapWithKey :: (k -> v -> Exp w) -> MapC k v -> Exp (MapC k w) Source #

Instances

type Eval (MapWithKey f mp :: MapC k v2 -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (MapWithKey f mp :: MapC k v2 -> Type) = MapC (Eval ((Map (Second (Uncurry f) :: (k, (k, v1)) -> (k, v2) -> Type) :: [(k, (k, v1))] -> [(k, v2)] -> Type) =<< ((MWKhelp :: [(k, v1)] -> [(k, (k, v1))] -> Type) =<< Assocs mp)))

data MWKhelp :: [(k, v)] -> Exp [(k, (k, v))] Source #

Instances

type Eval (MWKhelp ((,) k2 v2 ': rst) :: [(k1, (k1, v1))] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (MWKhelp ((,) k2 v2 ': rst) :: [(k1, (k1, v1))] -> Type) = (,) k2 ((,) k2 v2) ': Eval (MWKhelp rst)
type Eval (MWKhelp ([] :: [(k, v)]) :: [(k, (k, v))] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (MWKhelp ([] :: [(k, v)]) :: [(k, (k, v))] -> Type) = ([] :: [(k, (k, v))])

data Foldr :: (v -> w -> Exp w) -> w -> MapC k v -> Exp w Source #

Foldr

Fold the values in the map using the given right-associative binary operator, such that 'foldr f z == foldr f z . elems'.

Note: the order of values in MapC is not well defined at the moment.

Example

>>> :kind! Eval (Fcf.Data.MapC.Foldr (Pure2 (TL.+)) 0  =<< (FromList '[ '(1,1), '(2,2)]))
Eval (Fcf.Data.MapC.Foldr (Pure2 (TL.+)) 0  =<< (FromList '[ '(1,1), '(2,2)])) :: Nat
= 3

Instances

type Eval (Foldr f w mp :: a -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Foldr f w mp :: a -> Type) = Eval (Foldr f w =<< Elems mp)

data Elems :: MapC k v -> Exp [v] Source #

Elems

Example

>>> :kind! Eval (Elems =<< FromList '[ '(5,"a"), '(3,"b")])
Eval (Elems =<< FromList '[ '(5,"a"), '(3,"b")]) :: [TL.Symbol]
= '["a", "b"]
>>> :kind! Eval (Elems =<< Empty)
Eval (Elems =<< Empty) :: [v]
= '[]

Instances

type Eval (Elems (MapC lst) :: [b] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Elems (MapC lst) :: [b] -> Type) = Eval (Map (Snd :: (a, b) -> b -> Type) lst)

data Keys :: MapC k v -> Exp [k] Source #

Keys

Example

>>> :kind! Eval (Keys =<< FromList '[ '(5,"a"), '(3,"b")])
Eval (Keys =<< FromList '[ '(5,"a"), '(3,"b")]) :: [Nat]
= '[5, 3]
>>> :kind! Eval (Keys =<< Empty)
Eval (Keys =<< Empty) :: [k]
= '[]

Instances

type Eval (Keys (MapC lst) :: [b1] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Keys (MapC lst) :: [b1] -> Type) = Eval (Map (Fst :: (b1, b2) -> b1 -> Type) lst)

data Assocs :: MapC k v -> Exp [(k, v)] Source #

Assocs

Example

>>> :kind! Eval (Assocs =<< FromList '[ '(5,"a"), '(3,"b")])
Eval (Assocs =<< FromList '[ '(5,"a"), '(3,"b")]) :: [(Nat, 
                                                       TL.Symbol)]
= '[ '(5, "a"), '(3, "b")]
>>> :kind! Eval (Assocs =<< Empty)
Eval (Assocs =<< Empty) :: [(k, v)]
= '[]

Instances

type Eval (Assocs (MapC lst) :: [(k, v)] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Assocs (MapC lst) :: [(k, v)] -> Type) = lst

data ToList :: MapC k v -> Exp [(k, v)] Source #

ToList

Example

>>> :kind! Eval (ToList =<< FromList '[ '(5,"a"), '(3,"b")])
Eval (ToList =<< FromList '[ '(5,"a"), '(3,"b")]) :: [(Nat, 
                                                       TL.Symbol)]
= '[ '(5, "a"), '(3, "b")]
>>> :kind! Eval (ToList =<< Empty)
Eval (ToList =<< Empty) :: [(k, v)]
= '[]

Instances

type Eval (ToList (MapC lst) :: [(k, v)] -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (ToList (MapC lst) :: [(k, v)] -> Type) = lst

data Filter :: (v -> Exp Bool) -> MapC k v -> Exp (MapC k v) Source #

Filter

Example

>>> :kind! Eval (Filter ((>=) 35) =<< FromList '[ '(5,50), '(3,30)])
Eval (Filter ((>=) 35) =<< FromList '[ '(5,50), '(3,30)]) :: MapC 
                                                               Nat Nat
= 'MapC '[ '(3, 30)]

Instances

type Eval (Filter f (MapC lst) :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Filter f (MapC lst) :: MapC k v -> Type) = MapC (Eval (Filter (f <=< (Snd :: (k, v) -> v -> Type)) lst))

data FilterWithKey :: (k -> v -> Exp Bool) -> MapC k v -> Exp (MapC k v) Source #

FilterWithKey

Example

>>> :kind! Eval (FilterWithKey (>=) (Eval (FromList '[ '(3,5), '(6,4)])))
Eval (FilterWithKey (>=) (Eval (FromList '[ '(3,5), '(6,4)]))) :: MapC 
                                                                    Nat Nat
= 'MapC '[ '(6, 4)]

Instances

type Eval (FilterWithKey f (MapC lst) :: MapC k v -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (FilterWithKey f (MapC lst) :: MapC k v -> Type) = MapC (Eval (Filter (Uncurry f) lst))

data Partition :: (v -> Exp Bool) -> MapC k v -> Exp (MapC k v, MapC k v) Source #

Partition

Example

>>> :kind! Eval (Partition ((>=) 35) =<< FromList '[ '(5,50), '(3,30)])
Eval (Partition ((>=) 35) =<< FromList '[ '(5,50), '(3,30)]) :: (MapC 
                                                                   Nat Nat, 
                                                                 MapC Nat Nat)
= '( 'MapC '[ '(3, 30)], 'MapC '[ '(5, 50)])

Instances

type Eval (Partition f (MapC lst) :: (MapC k v, MapC k v) -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (Partition f (MapC lst) :: (MapC k v, MapC k v) -> Type) = Eval (PartitionHlp (Eval (Partition (f <=< (Snd :: (k, v) -> v -> Type)) lst)))

data PartitionHlp :: ([(k, v)], [(k, v)]) -> Exp (MapC k v, MapC k v) Source #

Instances

type Eval (PartitionHlp ((,) xs ys) :: (MapC k v, MapC k v) -> Type) Source #
Instance details Defined in Fcf.Data.MapC type Eval (PartitionHlp ((,) xs ys) :: (MapC k v, MapC k v) -> Type) = (,) (MapC xs) (MapC ys)