Data.NamedSOP.Map

Documentation

data NMap :: [Mapping s Type] -> Type where

A depedently-typed product, or map. The following are roughly equivalent:

type A = NMap '[ "a" ':-> Int, "b" ':-> Bool ]
data A = A { a :: Int, b :: Bool }

Constructors

NMapEmpty :: NMap '[]

NMapExt :: forall k v xs. v -> NMap xs -> NMap ((k :-> v) ': xs)

Instances

(Eq v, Eq (NMap xs)) => Eq (NMap ((k :-> v) ': xs))

Defined in Data.NamedSOP.Map

Methods

(==) :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Bool

(/=) :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Bool

Eq (NMap ([] :: [Mapping s Type]))

Defined in Data.NamedSOP.Map

Methods

(==) :: NMap [] -> NMap [] -> Bool

(/=) :: NMap [] -> NMap [] -> Bool

(Ord v, Ord (NMap xs)) => Ord (NMap ((k :-> v) ': xs))

Defined in Data.NamedSOP.Map

Methods

compare :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Ordering

(<) :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Bool

(<=) :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Bool

(>) :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Bool

(>=) :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> Bool

max :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs)

min :: NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs) -> NMap ((k :-> v) ': xs)

Ord (NMap ([] :: [Mapping s Type]))

Defined in Data.NamedSOP.Map

Methods

compare :: NMap [] -> NMap [] -> Ordering

(<) :: NMap [] -> NMap [] -> Bool

(<=) :: NMap [] -> NMap [] -> Bool

(>) :: NMap [] -> NMap [] -> Bool

(>=) :: NMap [] -> NMap [] -> Bool

max :: NMap [] -> NMap [] -> NMap []

min :: NMap [] -> NMap [] -> NMap []

ShowMap xs => Show (NMap xs)

Defined in Data.NamedSOP.Map

Methods

showsPrec :: Int -> NMap xs -> ShowS

show :: NMap xs -> String

showList :: [NMap xs] -> ShowS

unionMap :: forall s (xs :: [Mapping s *]) (ys :: [Mapping s *]). (SingI xs, SingI ys, SOrd s) => (NMap xs, NMap ys) -> NMap (Union xs ys)

Combine two NMaps in a way such that the original ordering of their fields doesn't matter; no matter how you combine smaller maps to create a large one, you are guaranteed to have a sorted NMap when you finish.

NMaps form a commutative monoid under unionMap, with NMapEmpty as the identity.

This function takes a tuple as an argument so that it is symmetric with ununionMap.

ununionMap :: forall s (xs :: [Mapping s *]) (ys :: [Mapping s *]). (SingI xs, SingI ys, SOrd s) => NMap (Union xs ys) -> (NMap xs, NMap ys)

Split a sorted NMap into two arbitrary (and potentially unsorted) submaps. Conveniently select the submaps to split into using -XTypeApplications. (Note the empty type argument for the key kind).

>>> m :: NMap '[ "a" ':-> Int, "b" ':-> Bool, "c" ':-> String ]
>>> m = NMapExt 1 (NMapExt True (NMapExt "hello" NMapEmpty))
>>> ununionMap @_ @'[ "b" ':-> Bool, "a" ':-> Int ] @'[ "c" ':-> String ] m
({ b :-> True, a :-> 1 },{ c :-> "hello" })

module Data.NamedSOP.Type