Data.GenericTrie.Internal

Unstable implementation details

Documentation

class TrieKey k where

Types that may be used as the key of a Trie.

For data declarations, the instance can be automatically derived from a Generic instance.

Minimal complete definition

Nothing

Associated Types

type TrieRep k :: Type -> Type

Type of the representation of tries for this key.

type TrieRep k = TrieRepDefault k

Methods

trieEmpty :: Trie k a

Construct an empty trie

default trieEmpty :: TrieRep k ~ TrieRepDefault k => Trie k a

trieNull :: Trie k a -> Bool

Test for an empty trie

default trieNull :: TrieRep k ~ TrieRepDefault k => Trie k a -> Bool

trieLookup :: k -> Trie k a -> Maybe a

Lookup element from trie

default trieLookup :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> Trie k a -> Maybe a

trieInsert :: k -> a -> Trie k a -> Trie k a

Insert element into trie

default trieInsert :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> a -> Trie k a -> Trie k a

trieDelete :: k -> Trie k a -> Trie k a

Delete element from trie

default trieDelete :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> Trie k a -> Trie k a

trieAlter :: k -> (Maybe a -> Maybe a) -> Trie k a -> Trie k a

Insert, modify, or remove an element in a trie

default trieAlter :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> (Maybe a -> Maybe a) -> Trie k a -> Trie k a

trieSingleton :: k -> a -> Trie k a

Construct a trie holding a single value

default trieSingleton :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> a -> Trie k a

trieMap :: (a -> b) -> Trie k a -> Trie k b

Apply a function to all values stored in a trie

default trieMap :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k) => (a -> b) -> Trie k a -> Trie k b

trieTraverse :: Applicative f => (a -> f b) -> Trie k a -> f (Trie k b)

Traverse the values stored in a trie

default trieTraverse :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k, Applicative f) => (a -> f b) -> Trie k a -> f (Trie k b)

trieMapMaybeWithKey :: (k -> a -> Maybe b) -> Trie k a -> Trie k b

Apply a function to the values of a Trie and keep the elements of the trie that result in a Just value.

default trieMapMaybeWithKey :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => (k -> a -> Maybe b) -> Trie k a -> Trie k b

trieFoldWithKey :: (k -> a -> r -> r) -> r -> Trie k a -> r

Fold a trie with a function of both key and value.

default trieFoldWithKey :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k, Generic k) => (k -> a -> r -> r) -> r -> Trie k a -> r

trieTraverseWithKey :: Applicative f => (k -> a -> f b) -> Trie k a -> f (Trie k b)

Traverse a trie with a function of both key and value.

default trieTraverseWithKey :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k, Generic k, Applicative f) => (k -> a -> f b) -> Trie k a -> f (Trie k b)

trieTraverseMaybeWithKey :: Applicative f => (k -> a -> f (Maybe b)) -> Trie k a -> f (Trie k b)

Traverse a trie with a function of both key and value, and keep the elements of the trie that result in a Just value.

default trieTraverseMaybeWithKey :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k, Generic k, Applicative f) => (k -> a -> f (Maybe b)) -> Trie k a -> f (Trie k b)

trieMergeWithKey :: (k -> a -> b -> Maybe c) -> (Trie k a -> Trie k c) -> (Trie k b -> Trie k c) -> Trie k a -> Trie k b -> Trie k c

default trieMergeWithKey :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k, Generic k) => (k -> a -> b -> Maybe c) -> (Trie k a -> Trie k c) -> (Trie k b -> Trie k c) -> Trie k a -> Trie k b -> Trie k c

Instances

TrieKey Void

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Void :: Type -> Type

Methods

trieEmpty :: Trie Void a

trieNull :: Trie Void a -> Bool

trieLookup :: Void -> Trie Void a -> Maybe a

trieInsert :: Void -> a -> Trie Void a -> Trie Void a

trieDelete :: Void -> Trie Void a -> Trie Void a

trieAlter :: Void -> (Maybe a -> Maybe a) -> Trie Void a -> Trie Void a

trieSingleton :: Void -> a -> Trie Void a

trieMap :: (a -> b) -> Trie Void a -> Trie Void b

trieTraverse :: Applicative f => (a -> f b) -> Trie Void a -> f (Trie Void b)

trieMapMaybeWithKey :: (Void -> a -> Maybe b) -> Trie Void a -> Trie Void b

trieFoldWithKey :: (Void -> a -> r -> r) -> r -> Trie Void a -> r

trieTraverseWithKey :: Applicative f => (Void -> a -> f b) -> Trie Void a -> f (Trie Void b)

trieTraverseMaybeWithKey :: Applicative f => (Void -> a -> f (Maybe b)) -> Trie Void a -> f (Trie Void b)

trieMergeWithKey :: (Void -> a -> b -> Maybe c) -> (Trie Void a -> Trie Void c) -> (Trie Void b -> Trie Void c) -> Trie Void a -> Trie Void b -> Trie Void c

TrieKey Ordering

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Ordering :: Type -> Type

Methods

trieEmpty :: Trie Ordering a

trieNull :: Trie Ordering a -> Bool

trieLookup :: Ordering -> Trie Ordering a -> Maybe a

trieInsert :: Ordering -> a -> Trie Ordering a -> Trie Ordering a

trieDelete :: Ordering -> Trie Ordering a -> Trie Ordering a

trieAlter :: Ordering -> (Maybe a -> Maybe a) -> Trie Ordering a -> Trie Ordering a

trieSingleton :: Ordering -> a -> Trie Ordering a

trieMap :: (a -> b) -> Trie Ordering a -> Trie Ordering b

trieTraverse :: Applicative f => (a -> f b) -> Trie Ordering a -> f (Trie Ordering b)

trieMapMaybeWithKey :: (Ordering -> a -> Maybe b) -> Trie Ordering a -> Trie Ordering b

trieFoldWithKey :: (Ordering -> a -> r -> r) -> r -> Trie Ordering a -> r

trieTraverseWithKey :: Applicative f => (Ordering -> a -> f b) -> Trie Ordering a -> f (Trie Ordering b)

trieTraverseMaybeWithKey :: Applicative f => (Ordering -> a -> f (Maybe b)) -> Trie Ordering a -> f (Trie Ordering b)

trieMergeWithKey :: (Ordering -> a -> b -> Maybe c) -> (Trie Ordering a -> Trie Ordering c) -> (Trie Ordering b -> Trie Ordering c) -> Trie Ordering a -> Trie Ordering b -> Trie Ordering c

TrieKey Integer

Integer tries are implemented with Map.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Integer :: Type -> Type

Methods

trieEmpty :: Trie Integer a

trieNull :: Trie Integer a -> Bool

trieLookup :: Integer -> Trie Integer a -> Maybe a

trieInsert :: Integer -> a -> Trie Integer a -> Trie Integer a

trieDelete :: Integer -> Trie Integer a -> Trie Integer a

trieAlter :: Integer -> (Maybe a -> Maybe a) -> Trie Integer a -> Trie Integer a

trieSingleton :: Integer -> a -> Trie Integer a

trieMap :: (a -> b) -> Trie Integer a -> Trie Integer b

trieTraverse :: Applicative f => (a -> f b) -> Trie Integer a -> f (Trie Integer b)

trieMapMaybeWithKey :: (Integer -> a -> Maybe b) -> Trie Integer a -> Trie Integer b

trieFoldWithKey :: (Integer -> a -> r -> r) -> r -> Trie Integer a -> r

trieTraverseWithKey :: Applicative f => (Integer -> a -> f b) -> Trie Integer a -> f (Trie Integer b)

trieTraverseMaybeWithKey :: Applicative f => (Integer -> a -> f (Maybe b)) -> Trie Integer a -> f (Trie Integer b)

trieMergeWithKey :: (Integer -> a -> b -> Maybe c) -> (Trie Integer a -> Trie Integer c) -> (Trie Integer b -> Trie Integer c) -> Trie Integer a -> Trie Integer b -> Trie Integer c

TrieKey Natural

Natural tries are implemented with Map.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Natural :: Type -> Type

Methods

trieEmpty :: Trie Natural a

trieNull :: Trie Natural a -> Bool

trieLookup :: Natural -> Trie Natural a -> Maybe a

trieInsert :: Natural -> a -> Trie Natural a -> Trie Natural a

trieDelete :: Natural -> Trie Natural a -> Trie Natural a

trieAlter :: Natural -> (Maybe a -> Maybe a) -> Trie Natural a -> Trie Natural a

trieSingleton :: Natural -> a -> Trie Natural a

trieMap :: (a -> b) -> Trie Natural a -> Trie Natural b

trieTraverse :: Applicative f => (a -> f b) -> Trie Natural a -> f (Trie Natural b)

trieMapMaybeWithKey :: (Natural -> a -> Maybe b) -> Trie Natural a -> Trie Natural b

trieFoldWithKey :: (Natural -> a -> r -> r) -> r -> Trie Natural a -> r

trieTraverseWithKey :: Applicative f => (Natural -> a -> f b) -> Trie Natural a -> f (Trie Natural b)

trieTraverseMaybeWithKey :: Applicative f => (Natural -> a -> f (Maybe b)) -> Trie Natural a -> f (Trie Natural b)

trieMergeWithKey :: (Natural -> a -> b -> Maybe c) -> (Trie Natural a -> Trie Natural c) -> (Trie Natural b -> Trie Natural c) -> Trie Natural a -> Trie Natural b -> Trie Natural c

TrieKey ()

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep () :: Type -> Type

Methods

trieEmpty :: Trie () a

trieNull :: Trie () a -> Bool

trieLookup :: () -> Trie () a -> Maybe a

trieInsert :: () -> a -> Trie () a -> Trie () a

trieDelete :: () -> Trie () a -> Trie () a

trieAlter :: () -> (Maybe a -> Maybe a) -> Trie () a -> Trie () a

trieSingleton :: () -> a -> Trie () a

trieMap :: (a -> b) -> Trie () a -> Trie () b

trieTraverse :: Applicative f => (a -> f b) -> Trie () a -> f (Trie () b)

trieMapMaybeWithKey :: (() -> a -> Maybe b) -> Trie () a -> Trie () b

trieFoldWithKey :: (() -> a -> r -> r) -> r -> Trie () a -> r

trieTraverseWithKey :: Applicative f => (() -> a -> f b) -> Trie () a -> f (Trie () b)

trieTraverseMaybeWithKey :: Applicative f => (() -> a -> f (Maybe b)) -> Trie () a -> f (Trie () b)

trieMergeWithKey :: (() -> a -> b -> Maybe c) -> (Trie () a -> Trie () c) -> (Trie () b -> Trie () c) -> Trie () a -> Trie () b -> Trie () c

TrieKey Bool

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Bool :: Type -> Type

Methods

trieEmpty :: Trie Bool a

trieNull :: Trie Bool a -> Bool

trieLookup :: Bool -> Trie Bool a -> Maybe a

trieInsert :: Bool -> a -> Trie Bool a -> Trie Bool a

trieDelete :: Bool -> Trie Bool a -> Trie Bool a

trieAlter :: Bool -> (Maybe a -> Maybe a) -> Trie Bool a -> Trie Bool a

trieSingleton :: Bool -> a -> Trie Bool a

trieMap :: (a -> b) -> Trie Bool a -> Trie Bool b

trieTraverse :: Applicative f => (a -> f b) -> Trie Bool a -> f (Trie Bool b)

trieMapMaybeWithKey :: (Bool -> a -> Maybe b) -> Trie Bool a -> Trie Bool b

trieFoldWithKey :: (Bool -> a -> r -> r) -> r -> Trie Bool a -> r

trieTraverseWithKey :: Applicative f => (Bool -> a -> f b) -> Trie Bool a -> f (Trie Bool b)

trieTraverseMaybeWithKey :: Applicative f => (Bool -> a -> f (Maybe b)) -> Trie Bool a -> f (Trie Bool b)

trieMergeWithKey :: (Bool -> a -> b -> Maybe c) -> (Trie Bool a -> Trie Bool c) -> (Trie Bool b -> Trie Bool c) -> Trie Bool a -> Trie Bool b -> Trie Bool c

TrieKey Char

Char tries are implemented with IntMap.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Char :: Type -> Type

Methods

trieEmpty :: Trie Char a

trieNull :: Trie Char a -> Bool

trieLookup :: Char -> Trie Char a -> Maybe a

trieInsert :: Char -> a -> Trie Char a -> Trie Char a

trieDelete :: Char -> Trie Char a -> Trie Char a

trieAlter :: Char -> (Maybe a -> Maybe a) -> Trie Char a -> Trie Char a

trieSingleton :: Char -> a -> Trie Char a

trieMap :: (a -> b) -> Trie Char a -> Trie Char b

trieTraverse :: Applicative f => (a -> f b) -> Trie Char a -> f (Trie Char b)

trieMapMaybeWithKey :: (Char -> a -> Maybe b) -> Trie Char a -> Trie Char b

trieFoldWithKey :: (Char -> a -> r -> r) -> r -> Trie Char a -> r

trieTraverseWithKey :: Applicative f => (Char -> a -> f b) -> Trie Char a -> f (Trie Char b)

trieTraverseMaybeWithKey :: Applicative f => (Char -> a -> f (Maybe b)) -> Trie Char a -> f (Trie Char b)

trieMergeWithKey :: (Char -> a -> b -> Maybe c) -> (Trie Char a -> Trie Char c) -> (Trie Char b -> Trie Char c) -> Trie Char a -> Trie Char b -> Trie Char c

TrieKey Int

Int tries are implemented with IntMap.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Int :: Type -> Type

Methods

trieEmpty :: Trie Int a

trieNull :: Trie Int a -> Bool

trieLookup :: Int -> Trie Int a -> Maybe a

trieInsert :: Int -> a -> Trie Int a -> Trie Int a

trieDelete :: Int -> Trie Int a -> Trie Int a

trieAlter :: Int -> (Maybe a -> Maybe a) -> Trie Int a -> Trie Int a

trieSingleton :: Int -> a -> Trie Int a

trieMap :: (a -> b) -> Trie Int a -> Trie Int b

trieTraverse :: Applicative f => (a -> f b) -> Trie Int a -> f (Trie Int b)

trieMapMaybeWithKey :: (Int -> a -> Maybe b) -> Trie Int a -> Trie Int b

trieFoldWithKey :: (Int -> a -> r -> r) -> r -> Trie Int a -> r

trieTraverseWithKey :: Applicative f => (Int -> a -> f b) -> Trie Int a -> f (Trie Int b)

trieTraverseMaybeWithKey :: Applicative f => (Int -> a -> f (Maybe b)) -> Trie Int a -> f (Trie Int b)

trieMergeWithKey :: (Int -> a -> b -> Maybe c) -> (Trie Int a -> Trie Int c) -> (Trie Int b -> Trie Int c) -> Trie Int a -> Trie Int b -> Trie Int c

TrieKey Word

Word tries are implemented with IntMap.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep Word :: Type -> Type

Methods

trieEmpty :: Trie Word a

trieNull :: Trie Word a -> Bool

trieLookup :: Word -> Trie Word a -> Maybe a

trieInsert :: Word -> a -> Trie Word a -> Trie Word a

trieDelete :: Word -> Trie Word a -> Trie Word a

trieAlter :: Word -> (Maybe a -> Maybe a) -> Trie Word a -> Trie Word a

trieSingleton :: Word -> a -> Trie Word a

trieMap :: (a -> b) -> Trie Word a -> Trie Word b

trieTraverse :: Applicative f => (a -> f b) -> Trie Word a -> f (Trie Word b)

trieMapMaybeWithKey :: (Word -> a -> Maybe b) -> Trie Word a -> Trie Word b

trieFoldWithKey :: (Word -> a -> r -> r) -> r -> Trie Word a -> r

trieTraverseWithKey :: Applicative f => (Word -> a -> f b) -> Trie Word a -> f (Trie Word b)

trieTraverseMaybeWithKey :: Applicative f => (Word -> a -> f (Maybe b)) -> Trie Word a -> f (Trie Word b)

trieMergeWithKey :: (Word -> a -> b -> Maybe c) -> (Trie Word a -> Trie Word c) -> (Trie Word b -> Trie Word c) -> Trie Word a -> Trie Word b -> Trie Word c

Ord k => TrieKey (OrdKey k)

OrdKey tries are implemented with Map, this is intended for cases where it is better for some reason to force the use of a Map than to use the generically derived structure.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (OrdKey k) :: Type -> Type

Methods

trieEmpty :: Trie (OrdKey k) a

trieNull :: Trie (OrdKey k) a -> Bool

trieLookup :: OrdKey k -> Trie (OrdKey k) a -> Maybe a

trieInsert :: OrdKey k -> a -> Trie (OrdKey k) a -> Trie (OrdKey k) a

trieDelete :: OrdKey k -> Trie (OrdKey k) a -> Trie (OrdKey k) a

trieAlter :: OrdKey k -> (Maybe a -> Maybe a) -> Trie (OrdKey k) a -> Trie (OrdKey k) a

trieSingleton :: OrdKey k -> a -> Trie (OrdKey k) a

trieMap :: (a -> b) -> Trie (OrdKey k) a -> Trie (OrdKey k) b

trieTraverse :: Applicative f => (a -> f b) -> Trie (OrdKey k) a -> f (Trie (OrdKey k) b)

trieMapMaybeWithKey :: (OrdKey k -> a -> Maybe b) -> Trie (OrdKey k) a -> Trie (OrdKey k) b

trieFoldWithKey :: (OrdKey k -> a -> r -> r) -> r -> Trie (OrdKey k) a -> r

trieTraverseWithKey :: Applicative f => (OrdKey k -> a -> f b) -> Trie (OrdKey k) a -> f (Trie (OrdKey k) b)

trieTraverseMaybeWithKey :: Applicative f => (OrdKey k -> a -> f (Maybe b)) -> Trie (OrdKey k) a -> f (Trie (OrdKey k) b)

trieMergeWithKey :: (OrdKey k -> a -> b -> Maybe c) -> (Trie (OrdKey k) a -> Trie (OrdKey k) c) -> (Trie (OrdKey k) b -> Trie (OrdKey k) c) -> Trie (OrdKey k) a -> Trie (OrdKey k) b -> Trie (OrdKey k) c

TrieKey k => TrieKey (Maybe k)

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (Maybe k) :: Type -> Type

Methods

trieEmpty :: Trie (Maybe k) a

trieNull :: Trie (Maybe k) a -> Bool

trieLookup :: Maybe k -> Trie (Maybe k) a -> Maybe a

trieInsert :: Maybe k -> a -> Trie (Maybe k) a -> Trie (Maybe k) a

trieDelete :: Maybe k -> Trie (Maybe k) a -> Trie (Maybe k) a

trieAlter :: Maybe k -> (Maybe a -> Maybe a) -> Trie (Maybe k) a -> Trie (Maybe k) a

trieSingleton :: Maybe k -> a -> Trie (Maybe k) a

trieMap :: (a -> b) -> Trie (Maybe k) a -> Trie (Maybe k) b

trieTraverse :: Applicative f => (a -> f b) -> Trie (Maybe k) a -> f (Trie (Maybe k) b)

trieMapMaybeWithKey :: (Maybe k -> a -> Maybe b) -> Trie (Maybe k) a -> Trie (Maybe k) b

trieFoldWithKey :: (Maybe k -> a -> r -> r) -> r -> Trie (Maybe k) a -> r

trieTraverseWithKey :: Applicative f => (Maybe k -> a -> f b) -> Trie (Maybe k) a -> f (Trie (Maybe k) b)

trieTraverseMaybeWithKey :: Applicative f => (Maybe k -> a -> f (Maybe b)) -> Trie (Maybe k) a -> f (Trie (Maybe k) b)

trieMergeWithKey :: (Maybe k -> a -> b -> Maybe c) -> (Trie (Maybe k) a -> Trie (Maybe k) c) -> (Trie (Maybe k) b -> Trie (Maybe k) c) -> Trie (Maybe k) a -> Trie (Maybe k) b -> Trie (Maybe k) c

TrieKey k => TrieKey [k]

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep [k] :: Type -> Type

Methods

trieEmpty :: Trie [k] a

trieNull :: Trie [k] a -> Bool

trieLookup :: [k] -> Trie [k] a -> Maybe a

trieInsert :: [k] -> a -> Trie [k] a -> Trie [k] a

trieDelete :: [k] -> Trie [k] a -> Trie [k] a

trieAlter :: [k] -> (Maybe a -> Maybe a) -> Trie [k] a -> Trie [k] a

trieSingleton :: [k] -> a -> Trie [k] a

trieMap :: (a -> b) -> Trie [k] a -> Trie [k] b

trieTraverse :: Applicative f => (a -> f b) -> Trie [k] a -> f (Trie [k] b)

trieMapMaybeWithKey :: ([k] -> a -> Maybe b) -> Trie [k] a -> Trie [k] b

trieFoldWithKey :: ([k] -> a -> r -> r) -> r -> Trie [k] a -> r

trieTraverseWithKey :: Applicative f => ([k] -> a -> f b) -> Trie [k] a -> f (Trie [k] b)

trieTraverseMaybeWithKey :: Applicative f => ([k] -> a -> f (Maybe b)) -> Trie [k] a -> f (Trie [k] b)

trieMergeWithKey :: ([k] -> a -> b -> Maybe c) -> (Trie [k] a -> Trie [k] c) -> (Trie [k] b -> Trie [k] c) -> Trie [k] a -> Trie [k] b -> Trie [k] c

(TrieKey a, TrieKey b) => TrieKey (Either a b)

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (Either a b) :: Type -> Type

Methods

trieEmpty :: Trie (Either a b) a0

trieNull :: Trie (Either a b) a0 -> Bool

trieLookup :: Either a b -> Trie (Either a b) a0 -> Maybe a0

trieInsert :: Either a b -> a0 -> Trie (Either a b) a0 -> Trie (Either a b) a0

trieDelete :: Either a b -> Trie (Either a b) a0 -> Trie (Either a b) a0

trieAlter :: Either a b -> (Maybe a0 -> Maybe a0) -> Trie (Either a b) a0 -> Trie (Either a b) a0

trieSingleton :: Either a b -> a0 -> Trie (Either a b) a0

trieMap :: (a0 -> b0) -> Trie (Either a b) a0 -> Trie (Either a b) b0

trieTraverse :: Applicative f => (a0 -> f b0) -> Trie (Either a b) a0 -> f (Trie (Either a b) b0)

trieMapMaybeWithKey :: (Either a b -> a0 -> Maybe b0) -> Trie (Either a b) a0 -> Trie (Either a b) b0

trieFoldWithKey :: (Either a b -> a0 -> r -> r) -> r -> Trie (Either a b) a0 -> r

trieTraverseWithKey :: Applicative f => (Either a b -> a0 -> f b0) -> Trie (Either a b) a0 -> f (Trie (Either a b) b0)

trieTraverseMaybeWithKey :: Applicative f => (Either a b -> a0 -> f (Maybe b0)) -> Trie (Either a b) a0 -> f (Trie (Either a b) b0)

trieMergeWithKey :: (Either a b -> a0 -> b0 -> Maybe c) -> (Trie (Either a b) a0 -> Trie (Either a b) c) -> (Trie (Either a b) b0 -> Trie (Either a b) c) -> Trie (Either a b) a0 -> Trie (Either a b) b0 -> Trie (Either a b) c

(TrieKey a, TrieKey b) => TrieKey (a, b)

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (a, b) :: Type -> Type

Methods

trieEmpty :: Trie (a, b) a0

trieNull :: Trie (a, b) a0 -> Bool

trieLookup :: (a, b) -> Trie (a, b) a0 -> Maybe a0

trieInsert :: (a, b) -> a0 -> Trie (a, b) a0 -> Trie (a, b) a0

trieDelete :: (a, b) -> Trie (a, b) a0 -> Trie (a, b) a0

trieAlter :: (a, b) -> (Maybe a0 -> Maybe a0) -> Trie (a, b) a0 -> Trie (a, b) a0

trieSingleton :: (a, b) -> a0 -> Trie (a, b) a0

trieMap :: (a0 -> b0) -> Trie (a, b) a0 -> Trie (a, b) b0

trieTraverse :: Applicative f => (a0 -> f b0) -> Trie (a, b) a0 -> f (Trie (a, b) b0)

trieMapMaybeWithKey :: ((a, b) -> a0 -> Maybe b0) -> Trie (a, b) a0 -> Trie (a, b) b0

trieFoldWithKey :: ((a, b) -> a0 -> r -> r) -> r -> Trie (a, b) a0 -> r

trieTraverseWithKey :: Applicative f => ((a, b) -> a0 -> f b0) -> Trie (a, b) a0 -> f (Trie (a, b) b0)

trieTraverseMaybeWithKey :: Applicative f => ((a, b) -> a0 -> f (Maybe b0)) -> Trie (a, b) a0 -> f (Trie (a, b) b0)

trieMergeWithKey :: ((a, b) -> a0 -> b0 -> Maybe c) -> (Trie (a, b) a0 -> Trie (a, b) c) -> (Trie (a, b) b0 -> Trie (a, b) c) -> Trie (a, b) a0 -> Trie (a, b) b0 -> Trie (a, b) c

(TrieKey a, TrieKey b, TrieKey c) => TrieKey (a, b, c)

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (a, b, c) :: Type -> Type

Methods

trieEmpty :: Trie (a, b, c) a0

trieNull :: Trie (a, b, c) a0 -> Bool

trieLookup :: (a, b, c) -> Trie (a, b, c) a0 -> Maybe a0

trieInsert :: (a, b, c) -> a0 -> Trie (a, b, c) a0 -> Trie (a, b, c) a0

trieDelete :: (a, b, c) -> Trie (a, b, c) a0 -> Trie (a, b, c) a0

trieAlter :: (a, b, c) -> (Maybe a0 -> Maybe a0) -> Trie (a, b, c) a0 -> Trie (a, b, c) a0

trieSingleton :: (a, b, c) -> a0 -> Trie (a, b, c) a0

trieMap :: (a0 -> b0) -> Trie (a, b, c) a0 -> Trie (a, b, c) b0

trieTraverse :: Applicative f => (a0 -> f b0) -> Trie (a, b, c) a0 -> f (Trie (a, b, c) b0)

trieMapMaybeWithKey :: ((a, b, c) -> a0 -> Maybe b0) -> Trie (a, b, c) a0 -> Trie (a, b, c) b0

trieFoldWithKey :: ((a, b, c) -> a0 -> r -> r) -> r -> Trie (a, b, c) a0 -> r

trieTraverseWithKey :: Applicative f => ((a, b, c) -> a0 -> f b0) -> Trie (a, b, c) a0 -> f (Trie (a, b, c) b0)

trieTraverseMaybeWithKey :: Applicative f => ((a, b, c) -> a0 -> f (Maybe b0)) -> Trie (a, b, c) a0 -> f (Trie (a, b, c) b0)

trieMergeWithKey :: ((a, b, c) -> a0 -> b0 -> Maybe c0) -> (Trie (a, b, c) a0 -> Trie (a, b, c) c0) -> (Trie (a, b, c) b0 -> Trie (a, b, c) c0) -> Trie (a, b, c) a0 -> Trie (a, b, c) b0 -> Trie (a, b, c) c0

(TrieKey a, TrieKey b, TrieKey c, TrieKey d) => TrieKey (a, b, c, d)

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (a, b, c, d) :: Type -> Type

Methods

trieEmpty :: Trie (a, b, c, d) a0

trieNull :: Trie (a, b, c, d) a0 -> Bool

trieLookup :: (a, b, c, d) -> Trie (a, b, c, d) a0 -> Maybe a0

trieInsert :: (a, b, c, d) -> a0 -> Trie (a, b, c, d) a0 -> Trie (a, b, c, d) a0

trieDelete :: (a, b, c, d) -> Trie (a, b, c, d) a0 -> Trie (a, b, c, d) a0

trieAlter :: (a, b, c, d) -> (Maybe a0 -> Maybe a0) -> Trie (a, b, c, d) a0 -> Trie (a, b, c, d) a0

trieSingleton :: (a, b, c, d) -> a0 -> Trie (a, b, c, d) a0

trieMap :: (a0 -> b0) -> Trie (a, b, c, d) a0 -> Trie (a, b, c, d) b0

trieTraverse :: Applicative f => (a0 -> f b0) -> Trie (a, b, c, d) a0 -> f (Trie (a, b, c, d) b0)

trieMapMaybeWithKey :: ((a, b, c, d) -> a0 -> Maybe b0) -> Trie (a, b, c, d) a0 -> Trie (a, b, c, d) b0

trieFoldWithKey :: ((a, b, c, d) -> a0 -> r -> r) -> r -> Trie (a, b, c, d) a0 -> r

trieTraverseWithKey :: Applicative f => ((a, b, c, d) -> a0 -> f b0) -> Trie (a, b, c, d) a0 -> f (Trie (a, b, c, d) b0)

trieTraverseMaybeWithKey :: Applicative f => ((a, b, c, d) -> a0 -> f (Maybe b0)) -> Trie (a, b, c, d) a0 -> f (Trie (a, b, c, d) b0)

trieMergeWithKey :: ((a, b, c, d) -> a0 -> b0 -> Maybe c0) -> (Trie (a, b, c, d) a0 -> Trie (a, b, c, d) c0) -> (Trie (a, b, c, d) b0 -> Trie (a, b, c, d) c0) -> Trie (a, b, c, d) a0 -> Trie (a, b, c, d) b0 -> Trie (a, b, c, d) c0

(TrieKey a, TrieKey b, TrieKey c, TrieKey d, TrieKey e) => TrieKey (a, b, c, d, e)

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (a, b, c, d, e) :: Type -> Type

Methods

trieEmpty :: Trie (a, b, c, d, e) a0

trieNull :: Trie (a, b, c, d, e) a0 -> Bool

trieLookup :: (a, b, c, d, e) -> Trie (a, b, c, d, e) a0 -> Maybe a0

trieInsert :: (a, b, c, d, e) -> a0 -> Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) a0

trieDelete :: (a, b, c, d, e) -> Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) a0

trieAlter :: (a, b, c, d, e) -> (Maybe a0 -> Maybe a0) -> Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) a0

trieSingleton :: (a, b, c, d, e) -> a0 -> Trie (a, b, c, d, e) a0

trieMap :: (a0 -> b0) -> Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) b0

trieTraverse :: Applicative f => (a0 -> f b0) -> Trie (a, b, c, d, e) a0 -> f (Trie (a, b, c, d, e) b0)

trieMapMaybeWithKey :: ((a, b, c, d, e) -> a0 -> Maybe b0) -> Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) b0

trieFoldWithKey :: ((a, b, c, d, e) -> a0 -> r -> r) -> r -> Trie (a, b, c, d, e) a0 -> r

trieTraverseWithKey :: Applicative f => ((a, b, c, d, e) -> a0 -> f b0) -> Trie (a, b, c, d, e) a0 -> f (Trie (a, b, c, d, e) b0)

trieTraverseMaybeWithKey :: Applicative f => ((a, b, c, d, e) -> a0 -> f (Maybe b0)) -> Trie (a, b, c, d, e) a0 -> f (Trie (a, b, c, d, e) b0)

trieMergeWithKey :: ((a, b, c, d, e) -> a0 -> b0 -> Maybe c0) -> (Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) c0) -> (Trie (a, b, c, d, e) b0 -> Trie (a, b, c, d, e) c0) -> Trie (a, b, c, d, e) a0 -> Trie (a, b, c, d, e) b0 -> Trie (a, b, c, d, e) c0

class TrieKey k => ShowTrieKey k where

Minimal complete definition

Nothing

Methods

trieShowsPrec :: Show a => Int -> Trie k a -> ShowS

Show a representation of the internal structure of a trie

default trieShowsPrec :: (Show a, GTrieKeyShow (Rep k), TrieRep k ~ TrieRepDefault k) => Int -> Trie k a -> ShowS

Instances

ShowTrieKey Void

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Void a -> ShowS

ShowTrieKey Ordering

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Ordering a -> ShowS

ShowTrieKey Integer

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Integer a -> ShowS

ShowTrieKey Natural

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Natural a -> ShowS

ShowTrieKey ()

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie () a -> ShowS

ShowTrieKey Bool

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Bool a -> ShowS

ShowTrieKey Char

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Char a -> ShowS

ShowTrieKey Int

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Int a -> ShowS

ShowTrieKey Word

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie Word a -> ShowS

(Show k, Ord k) => ShowTrieKey (OrdKey k)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie (OrdKey k) a -> ShowS

ShowTrieKey k => ShowTrieKey (Maybe k)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie (Maybe k) a -> ShowS

ShowTrieKey k => ShowTrieKey [k]

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie [k] a -> ShowS

(ShowTrieKey a, ShowTrieKey b) => ShowTrieKey (Either a b)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a0 => Int -> Trie (Either a b) a0 -> ShowS

(ShowTrieKey a, ShowTrieKey b) => ShowTrieKey (a, b)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a0 => Int -> Trie (a, b) a0 -> ShowS

(ShowTrieKey a, ShowTrieKey b, ShowTrieKey c) => ShowTrieKey (a, b, c)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a0 => Int -> Trie (a, b, c) a0 -> ShowS

(ShowTrieKey a, ShowTrieKey b, ShowTrieKey c, ShowTrieKey d) => ShowTrieKey (a, b, c, d)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a0 => Int -> Trie (a, b, c, d) a0 -> ShowS

(ShowTrieKey a, ShowTrieKey b, ShowTrieKey c, ShowTrieKey d, ShowTrieKey e) => ShowTrieKey (a, b, c, d, e)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a0 => Int -> Trie (a, b, c, d, e) a0 -> ShowS

newtype Trie k a

A map from keys of type k, to values of type a.

Constructors

MkTrie (TrieRep k a)

Instances

TrieKey k => Foldable (Trie k)

Defined in Data.GenericTrie.Internal

Methods

fold :: Monoid m => Trie k m -> m

foldMap :: Monoid m => (a -> m) -> Trie k a -> m

foldMap' :: Monoid m => (a -> m) -> Trie k a -> m

foldr :: (a -> b -> b) -> b -> Trie k a -> b

foldr' :: (a -> b -> b) -> b -> Trie k a -> b

foldl :: (b -> a -> b) -> b -> Trie k a -> b

foldl' :: (b -> a -> b) -> b -> Trie k a -> b

foldr1 :: (a -> a -> a) -> Trie k a -> a

foldl1 :: (a -> a -> a) -> Trie k a -> a

toList :: Trie k a -> [a]

null :: Trie k a -> Bool

length :: Trie k a -> Int

elem :: Eq a => a -> Trie k a -> Bool

maximum :: Ord a => Trie k a -> a

minimum :: Ord a => Trie k a -> a

sum :: Num a => Trie k a -> a

product :: Num a => Trie k a -> a

TrieKey k => Traversable (Trie k)

Defined in Data.GenericTrie.Internal

Methods

traverse :: Applicative f => (a -> f b) -> Trie k a -> f (Trie k b)

sequenceA :: Applicative f => Trie k (f a) -> f (Trie k a)

mapM :: Monad m => (a -> m b) -> Trie k a -> m (Trie k b)

sequence :: Monad m => Trie k (m a) -> m (Trie k a)

TrieKey k => Functor (Trie k)

Defined in Data.GenericTrie.Internal

Methods

fmap :: (a -> b) -> Trie k a -> Trie k b

(<$) :: a -> Trie k b -> Trie k a

(TrieKey k, Show k, Show a) => Show (Trie k a)

Defined in Data.GenericTrie.Internal

Methods

showsPrec :: Int -> Trie k a -> ShowS

show :: Trie k a -> String

showList :: [Trie k a] -> ShowS

newtype OrdKey k

Tries indexed by OrdKey will be represented as an ordinary Map and the keys will be compared based on the Ord instance for k.

Constructors

OrdKey

Fields

• getOrdKey :: k

Instances

Read k => Read (OrdKey k)

Defined in Data.GenericTrie.Internal

Methods

readsPrec :: Int -> ReadS (OrdKey k)

readList :: ReadS [OrdKey k]

readPrec :: ReadPrec (OrdKey k)

readListPrec :: ReadPrec [OrdKey k]

Show k => Show (OrdKey k)

Defined in Data.GenericTrie.Internal

Methods

showsPrec :: Int -> OrdKey k -> ShowS

show :: OrdKey k -> String

showList :: [OrdKey k] -> ShowS

(Show k, Ord k) => ShowTrieKey (OrdKey k)

Defined in Data.GenericTrie.Internal

Methods

trieShowsPrec :: Show a => Int -> Trie (OrdKey k) a -> ShowS

Ord k => TrieKey (OrdKey k)

OrdKey tries are implemented with Map, this is intended for cases where it is better for some reason to force the use of a Map than to use the generically derived structure.

Defined in Data.GenericTrie.Internal

Associated Types

type TrieRep (OrdKey k) :: Type -> Type

Methods

trieEmpty :: Trie (OrdKey k) a

trieNull :: Trie (OrdKey k) a -> Bool

trieLookup :: OrdKey k -> Trie (OrdKey k) a -> Maybe a

trieInsert :: OrdKey k -> a -> Trie (OrdKey k) a -> Trie (OrdKey k) a

trieDelete :: OrdKey k -> Trie (OrdKey k) a -> Trie (OrdKey k) a

trieAlter :: OrdKey k -> (Maybe a -> Maybe a) -> Trie (OrdKey k) a -> Trie (OrdKey k) a

trieSingleton :: OrdKey k -> a -> Trie (OrdKey k) a

trieMap :: (a -> b) -> Trie (OrdKey k) a -> Trie (OrdKey k) b

trieTraverse :: Applicative f => (a -> f b) -> Trie (OrdKey k) a -> f (Trie (OrdKey k) b)

trieMapMaybeWithKey :: (OrdKey k -> a -> Maybe b) -> Trie (OrdKey k) a -> Trie (OrdKey k) b

trieFoldWithKey :: (OrdKey k -> a -> r -> r) -> r -> Trie (OrdKey k) a -> r

trieTraverseWithKey :: Applicative f => (OrdKey k -> a -> f b) -> Trie (OrdKey k) a -> f (Trie (OrdKey k) b)

trieTraverseMaybeWithKey :: Applicative f => (OrdKey k -> a -> f (Maybe b)) -> Trie (OrdKey k) a -> f (Trie (OrdKey k) b)

trieMergeWithKey :: (OrdKey k -> a -> b -> Maybe c) -> (Trie (OrdKey k) a -> Trie (OrdKey k) c) -> (Trie (OrdKey k) b -> Trie (OrdKey k) c) -> Trie (OrdKey k) a -> Trie (OrdKey k) b -> Trie (OrdKey k) c

Eq k => Eq (OrdKey k)

Defined in Data.GenericTrie.Internal

Methods

(==) :: OrdKey k -> OrdKey k -> Bool

(/=) :: OrdKey k -> OrdKey k -> Bool

Ord k => Ord (OrdKey k)

Defined in Data.GenericTrie.Internal

Methods

compare :: OrdKey k -> OrdKey k -> Ordering

(<) :: OrdKey k -> OrdKey k -> Bool

(<=) :: OrdKey k -> OrdKey k -> Bool

(>) :: OrdKey k -> OrdKey k -> Bool

(>=) :: OrdKey k -> OrdKey k -> Bool

max :: OrdKey k -> OrdKey k -> OrdKey k

min :: OrdKey k -> OrdKey k -> OrdKey k

type TrieRep (OrdKey k)

Defined in Data.GenericTrie.Internal

type TrieRep (OrdKey k) = Map k

toList :: TrieKey k => Trie k a -> [(k, a)]

Transform a trie to an association list.

Generic derivation implementation

genericTrieNull :: TrieRep k ~ TrieRepDefault k => Trie k a -> Bool

Generic implementation of trieNull. This is the default implementation.

genericTrieMap :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k) => (a -> b) -> Trie k a -> Trie k b

Generic implementation of trieMap. This is the default implementation.

genericTrieTraverse :: (GTrieKey (Rep k), TrieRep k ~ TrieRepDefault k, Applicative f) => (a -> f b) -> Trie k a -> f (Trie k b)

Generic implementation of trieTraverse. This is the default implementation.

genericTrieShowsPrec :: (Show a, GTrieKeyShow (Rep k), TrieRep k ~ TrieRepDefault k) => Int -> Trie k a -> ShowS

Generic implementation of trieShowsPrec. This is the default implementation.

genericInsert :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> a -> Trie k a -> Trie k a

Generic implementation of insert. This is the default implementation.

genericLookup :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> Trie k a -> Maybe a

Generic implementation of lookup. This is the default implementation.

genericDelete :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> Trie k a -> Trie k a

Generic implementation of delete. This is the default implementation.

genericAlter :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> (Maybe a -> Maybe a) -> Trie k a -> Trie k a

Generic implementation of alter. This is the default implementation.

genericMapMaybeWithKey :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => (k -> a -> Maybe b) -> Trie k a -> Trie k b

Generic implementation of mapMaybe. This is the default implementation.

genericSingleton :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => k -> a -> Trie k a

Generic implementation of singleton. This is the default implementation.

genericEmpty :: TrieRep k ~ TrieRepDefault k => Trie k a

Generic implementation of empty. This is the default implementation.

genericFoldWithKey :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k) => (k -> a -> r -> r) -> r -> Trie k a -> r

Generic implementation of foldWithKey. This is the default implementation.

genericTraverseWithKey :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k, Applicative f) => (k -> a -> f b) -> Trie k a -> f (Trie k b)

Generic implementation of traverseWithKey. This is the default implementation.

genericTraverseMaybeWithKey :: (GTrieKey (Rep k), Generic k, TrieRep k ~ TrieRepDefault k, Applicative f) => (k -> a -> f (Maybe b)) -> Trie k a -> f (Trie k b)

Generic implementation of traverseMaybeWithKey. This is the default implementation.

data TrieRepDefault k a

The default implementation of a TrieRep is GTrie wrapped in a Maybe. This wrapping is due to the GTrie being a non-empty trie allowing all the of the "emptiness" to be represented at the top level for any given generically implemented key.

class GTrieKey f where

TrieKey operations on Generic representations used to provide the default implementations of tries.

Methods

gtrieLookup :: f p -> GTrie f a -> Maybe a

gtrieInsert :: f p -> a -> GTrie f a -> GTrie f a

gtrieSingleton :: f p -> a -> GTrie f a

gtrieDelete :: f p -> GTrie f a -> Maybe (GTrie f a)

gtrieAlter :: f p -> (Maybe a -> Maybe a) -> GTrie f a -> Maybe (GTrie f a)

gtrieMap :: (a -> b) -> GTrie f a -> GTrie f b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie f a -> m (GTrie f b)

gmapMaybeWithKey :: (f p -> a -> Maybe b) -> GTrie f a -> Maybe (GTrie f b)

gfoldWithKey :: (f p -> a -> r -> r) -> r -> GTrie f a -> r

gtraverseWithKey :: Applicative m => (f p -> a -> m b) -> GTrie f a -> m (GTrie f b)

gtraverseMaybeWithKey :: Applicative m => (f p -> a -> m (Maybe b)) -> GTrie f a -> m (Maybe (GTrie f b))

gmergeWithKey :: (f p -> a -> b -> Maybe c) -> (GTrie f a -> Maybe (GTrie f c)) -> (GTrie f b -> Maybe (GTrie f c)) -> GTrie f a -> GTrie f b -> Maybe (GTrie f c)

Instances

GTrieKey (U1 :: Type -> Type)

Tries of constructors without fields are represented by a single value.

Defined in Data.GenericTrie.Internal

Methods

gtrieLookup :: U1 p -> GTrie U1 a -> Maybe a

gtrieInsert :: U1 p -> a -> GTrie U1 a -> GTrie U1 a

gtrieSingleton :: U1 p -> a -> GTrie U1 a

gtrieDelete :: U1 p -> GTrie U1 a -> Maybe (GTrie U1 a)

gtrieAlter :: U1 p -> (Maybe a -> Maybe a) -> GTrie U1 a -> Maybe (GTrie U1 a)

gtrieMap :: (a -> b) -> GTrie U1 a -> GTrie U1 b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie U1 a -> m (GTrie U1 b)

gmapMaybeWithKey :: (U1 p -> a -> Maybe b) -> GTrie U1 a -> Maybe (GTrie U1 b)

gfoldWithKey :: (U1 p -> a -> r -> r) -> r -> GTrie U1 a -> r

gtraverseWithKey :: Applicative m => (U1 p -> a -> m b) -> GTrie U1 a -> m (GTrie U1 b)

gtraverseMaybeWithKey :: Applicative m => (U1 p -> a -> m (Maybe b)) -> GTrie U1 a -> m (Maybe (GTrie U1 b))

gmergeWithKey :: (U1 p -> a -> b -> Maybe c) -> (GTrie U1 a -> Maybe (GTrie U1 c)) -> (GTrie U1 b -> Maybe (GTrie U1 c)) -> GTrie U1 a -> GTrie U1 b -> Maybe (GTrie U1 c)

GTrieKey (V1 :: Type -> Type)

Tries of types without constructors are represented by an empty type.

Defined in Data.GenericTrie.Internal

Methods

gtrieLookup :: V1 p -> GTrie V1 a -> Maybe a

gtrieInsert :: V1 p -> a -> GTrie V1 a -> GTrie V1 a

gtrieSingleton :: V1 p -> a -> GTrie V1 a

gtrieDelete :: V1 p -> GTrie V1 a -> Maybe (GTrie V1 a)

gtrieAlter :: V1 p -> (Maybe a -> Maybe a) -> GTrie V1 a -> Maybe (GTrie V1 a)

gtrieMap :: (a -> b) -> GTrie V1 a -> GTrie V1 b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie V1 a -> m (GTrie V1 b)

gmapMaybeWithKey :: (V1 p -> a -> Maybe b) -> GTrie V1 a -> Maybe (GTrie V1 b)

gfoldWithKey :: (V1 p -> a -> r -> r) -> r -> GTrie V1 a -> r

gtraverseWithKey :: Applicative m => (V1 p -> a -> m b) -> GTrie V1 a -> m (GTrie V1 b)

gtraverseMaybeWithKey :: Applicative m => (V1 p -> a -> m (Maybe b)) -> GTrie V1 a -> m (Maybe (GTrie V1 b))

gmergeWithKey :: (V1 p -> a -> b -> Maybe c) -> (GTrie V1 a -> Maybe (GTrie V1 c)) -> (GTrie V1 b -> Maybe (GTrie V1 c)) -> GTrie V1 a -> GTrie V1 b -> Maybe (GTrie V1 c)

(GTrieKey f, GTrieKey g) => GTrieKey (f :*: g)

Generic products are represented by tries of tries.

Defined in Data.GenericTrie.Internal

Methods

gtrieLookup :: (f :*: g) p -> GTrie (f :*: g) a -> Maybe a

gtrieInsert :: (f :*: g) p -> a -> GTrie (f :*: g) a -> GTrie (f :*: g) a

gtrieSingleton :: (f :*: g) p -> a -> GTrie (f :*: g) a

gtrieDelete :: (f :*: g) p -> GTrie (f :*: g) a -> Maybe (GTrie (f :*: g) a)

gtrieAlter :: (f :*: g) p -> (Maybe a -> Maybe a) -> GTrie (f :*: g) a -> Maybe (GTrie (f :*: g) a)

gtrieMap :: (a -> b) -> GTrie (f :*: g) a -> GTrie (f :*: g) b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie (f :*: g) a -> m (GTrie (f :*: g) b)

gmapMaybeWithKey :: ((f :*: g) p -> a -> Maybe b) -> GTrie (f :*: g) a -> Maybe (GTrie (f :*: g) b)

gfoldWithKey :: ((f :*: g) p -> a -> r -> r) -> r -> GTrie (f :*: g) a -> r

gtraverseWithKey :: Applicative m => ((f :*: g) p -> a -> m b) -> GTrie (f :*: g) a -> m (GTrie (f :*: g) b)

gtraverseMaybeWithKey :: Applicative m => ((f :*: g) p -> a -> m (Maybe b)) -> GTrie (f :*: g) a -> m (Maybe (GTrie (f :*: g) b))

gmergeWithKey :: ((f :*: g) p -> a -> b -> Maybe c) -> (GTrie (f :*: g) a -> Maybe (GTrie (f :*: g) c)) -> (GTrie (f :*: g) b -> Maybe (GTrie (f :*: g) c)) -> GTrie (f :*: g) a -> GTrie (f :*: g) b -> Maybe (GTrie (f :*: g) c)

(GTrieKey f, GTrieKey g) => GTrieKey (f :+: g)

Generic sums are represented by up to a pair of sub-tries.

Defined in Data.GenericTrie.Internal

Methods

gtrieLookup :: (f :+: g) p -> GTrie (f :+: g) a -> Maybe a

gtrieInsert :: (f :+: g) p -> a -> GTrie (f :+: g) a -> GTrie (f :+: g) a

gtrieSingleton :: (f :+: g) p -> a -> GTrie (f :+: g) a

gtrieDelete :: (f :+: g) p -> GTrie (f :+: g) a -> Maybe (GTrie (f :+: g) a)

gtrieAlter :: (f :+: g) p -> (Maybe a -> Maybe a) -> GTrie (f :+: g) a -> Maybe (GTrie (f :+: g) a)

gtrieMap :: (a -> b) -> GTrie (f :+: g) a -> GTrie (f :+: g) b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie (f :+: g) a -> m (GTrie (f :+: g) b)

gmapMaybeWithKey :: ((f :+: g) p -> a -> Maybe b) -> GTrie (f :+: g) a -> Maybe (GTrie (f :+: g) b)

gfoldWithKey :: ((f :+: g) p -> a -> r -> r) -> r -> GTrie (f :+: g) a -> r

gtraverseWithKey :: Applicative m => ((f :+: g) p -> a -> m b) -> GTrie (f :+: g) a -> m (GTrie (f :+: g) b)

gtraverseMaybeWithKey :: Applicative m => ((f :+: g) p -> a -> m (Maybe b)) -> GTrie (f :+: g) a -> m (Maybe (GTrie (f :+: g) b))

gmergeWithKey :: ((f :+: g) p -> a -> b -> Maybe c) -> (GTrie (f :+: g) a -> Maybe (GTrie (f :+: g) c)) -> (GTrie (f :+: g) b -> Maybe (GTrie (f :+: g) c)) -> GTrie (f :+: g) a -> GTrie (f :+: g) b -> Maybe (GTrie (f :+: g) c)

TrieKey k => GTrieKey (K1 i k :: Type -> Type)

Generic fields are represented by tries of the field type.

Defined in Data.GenericTrie.Internal

Methods

gtrieLookup :: K1 i k p -> GTrie (K1 i k) a -> Maybe a

gtrieInsert :: K1 i k p -> a -> GTrie (K1 i k) a -> GTrie (K1 i k) a

gtrieSingleton :: K1 i k p -> a -> GTrie (K1 i k) a

gtrieDelete :: K1 i k p -> GTrie (K1 i k) a -> Maybe (GTrie (K1 i k) a)

gtrieAlter :: K1 i k p -> (Maybe a -> Maybe a) -> GTrie (K1 i k) a -> Maybe (GTrie (K1 i k) a)

gtrieMap :: (a -> b) -> GTrie (K1 i k) a -> GTrie (K1 i k) b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie (K1 i k) a -> m (GTrie (K1 i k) b)

gmapMaybeWithKey :: (K1 i k p -> a -> Maybe b) -> GTrie (K1 i k) a -> Maybe (GTrie (K1 i k) b)

gfoldWithKey :: (K1 i k p -> a -> r -> r) -> r -> GTrie (K1 i k) a -> r

gtraverseWithKey :: Applicative m => (K1 i k p -> a -> m b) -> GTrie (K1 i k) a -> m (GTrie (K1 i k) b)

gtraverseMaybeWithKey :: Applicative m => (K1 i k p -> a -> m (Maybe b)) -> GTrie (K1 i k) a -> m (Maybe (GTrie (K1 i k) b))

gmergeWithKey :: (K1 i k p -> a -> b -> Maybe c) -> (GTrie (K1 i k) a -> Maybe (GTrie (K1 i k) c)) -> (GTrie (K1 i k) b -> Maybe (GTrie (K1 i k) c)) -> GTrie (K1 i k) a -> GTrie (K1 i k) b -> Maybe (GTrie (K1 i k) c)

GTrieKey f => GTrieKey (M1 i c f)

Generic metadata is skipped in trie representation and operations.

Defined in Data.GenericTrie.Internal

Methods

gtrieLookup :: M1 i c f p -> GTrie (M1 i c f) a -> Maybe a

gtrieInsert :: M1 i c f p -> a -> GTrie (M1 i c f) a -> GTrie (M1 i c f) a

gtrieSingleton :: M1 i c f p -> a -> GTrie (M1 i c f) a

gtrieDelete :: M1 i c f p -> GTrie (M1 i c f) a -> Maybe (GTrie (M1 i c f) a)

gtrieAlter :: M1 i c f p -> (Maybe a -> Maybe a) -> GTrie (M1 i c f) a -> Maybe (GTrie (M1 i c f) a)

gtrieMap :: (a -> b) -> GTrie (M1 i c f) a -> GTrie (M1 i c f) b

gtrieTraverse :: Applicative m => (a -> m b) -> GTrie (M1 i c f) a -> m (GTrie (M1 i c f) b)

gmapMaybeWithKey :: (M1 i c f p -> a -> Maybe b) -> GTrie (M1 i c f) a -> Maybe (GTrie (M1 i c f) b)

gfoldWithKey :: (M1 i c f p -> a -> r -> r) -> r -> GTrie (M1 i c f) a -> r

gtraverseWithKey :: Applicative m => (M1 i c f p -> a -> m b) -> GTrie (M1 i c f) a -> m (GTrie (M1 i c f) b)

gtraverseMaybeWithKey :: Applicative m => (M1 i c f p -> a -> m (Maybe b)) -> GTrie (M1 i c f) a -> m (Maybe (GTrie (M1 i c f) b))

gmergeWithKey :: (M1 i c f p -> a -> b -> Maybe c0) -> (GTrie (M1 i c f) a -> Maybe (GTrie (M1 i c f) c0)) -> (GTrie (M1 i c f) b -> Maybe (GTrie (M1 i c f) c0)) -> GTrie (M1 i c f) a -> GTrie (M1 i c f) b -> Maybe (GTrie (M1 i c f) c0)

data family GTrie f a

Mapping of generic representation of keys to trie structures.

Instances

GTrieKey f => Functor (GTrie f)

Defined in Data.GenericTrie.Internal

Methods

fmap :: (a -> b) -> GTrie f a -> GTrie f b

(<$) :: a -> GTrie f b -> GTrie f a

(Show a, GTrieKeyShow f) => Show (GTrie f a)

Defined in Data.GenericTrie.Internal

Methods

showsPrec :: Int -> GTrie f a -> ShowS

show :: GTrie f a -> String

showList :: [GTrie f a] -> ShowS

newtype GTrie (U1 :: Type -> Type) a

Defined in Data.GenericTrie.Internal

newtype GTrie (U1 :: Type -> Type) a = UTrie a

data GTrie (V1 :: Type -> Type) a

Defined in Data.GenericTrie.Internal

data GTrie (V1 :: Type -> Type) a

newtype GTrie (f :*: g) a

Defined in Data.GenericTrie.Internal

newtype GTrie (f :*: g) a = PTrie (GTrie f (GTrie g a))

data GTrie (f :+: g) a

Defined in Data.GenericTrie.Internal

data GTrie (f :+: g) a

• = STrieL !(GTrie f a)
• | STrieR !(GTrie g a)
• | STrieB !(GTrie f a) !(GTrie g a)

newtype GTrie (K1 i k :: Type -> Type) a

Defined in Data.GenericTrie.Internal

newtype GTrie (K1 i k :: Type -> Type) a = KTrie (Trie k a)

newtype GTrie (M1 i c f) a

Defined in Data.GenericTrie.Internal

newtype GTrie (M1 i c f) a = MTrie (GTrie f a)