Data.Trie.Map

One Step

data MapChildren c p a

Constructors

MapChildren

Fields

mapNode :: Maybe a

mapChildren :: !(Maybe (c p a))

Instances

Functor (c p) => Functor (MapChildren c p)

Foldable (c p) => Foldable (MapChildren c p)

Traversable (c p) => Traversable (MapChildren c p)

(Eq a, Eq (c p a)) => Eq (MapChildren c p a)

(Data a, Data (c p a), Typeable (* -> * -> *) c, Typeable * p) => Data (MapChildren c p a)

(Ord a, Ord (c p a)) => Ord (MapChildren c p a)

(Show a, Show (c p a)) => Show (MapChildren c p a)

Generic (MapChildren c p a)

Monoid (c p a) => Monoid (MapChildren c p a)

(NFData (c p a), NFData p, NFData a) => NFData (MapChildren c p a)

(Arbitrary a, Arbitrary p, Arbitrary (c p a)) => Arbitrary (MapChildren c p a)

type Rep (MapChildren c p a)

newtype MapStep c p a

Constructors

MapStep

Fields

unMapStep :: Map p (MapChildren c p a)

Instances

(Ord p, Trie NonEmpty p c) => Trie NonEmpty p (MapStep c)

No insertion instance - requires children nodes to be a monoid. Use Data.Trie.Map.insert instead.

Functor (c p) => Functor (MapStep c p)

Foldable (c p) => Foldable (MapStep c p)

Traversable (c p) => Traversable (MapStep c p)

(Eq p, Eq a, Eq (c p a)) => Eq (MapStep c p a)

(Data p, Data a, Data (c p a), Ord p, Typeable (* -> * -> *) c) => Data (MapStep c p a)

(Ord p, Ord a, Ord (c p a)) => Ord (MapStep c p a)

(Show p, Show a, Show (c p a)) => Show (MapStep c p a)

Generic (MapStep c p a)

(Ord s, Monoid (c s a)) => Monoid (MapStep c s a)

(NFData (c p a), NFData p, NFData a) => NFData (MapStep c p a)

(Arbitrary a, Arbitrary p, Arbitrary (c p a), Ord p) => Arbitrary (MapStep c p a)

type Rep (MapStep c p a)

insert :: (Ord p, Trie NonEmpty p c, Monoid (c p a)) => NonEmpty p -> a -> MapStep c p a -> MapStep c p a

empty :: MapStep c s a

singleton :: s -> a -> MapStep c s a

Fixpoint of Steps

newtype MapTrie s a

Constructors

MapTrie

Fields

unMapTrie :: MapStep MapTrie s a

Instances

Ord s => Trie NonEmpty s MapTrie

Functor (MapTrie s)

Foldable (MapTrie s)

Traversable (MapTrie s)

Ord s => Lookup (MapTrie s)

(Eq s, Eq a) => Eq (MapTrie s a)

(Ord s, Ord a) => Ord (MapTrie s a)

(Show s, Show a) => Show (MapTrie s a)

Ord s => Monoid (MapTrie s a)

(Ord s, Arbitrary s, Arbitrary a) => Arbitrary (MapTrie s a)

type Key (MapTrie s) = NonEmpty s

Conversion

keys :: Ord s => MapTrie s a -> [NonEmpty s]

elems :: MapTrie s a -> [a]

Query

subtrie :: Ord s => NonEmpty s -> MapTrie s a -> Maybe (MapTrie s a)

match :: Ord s => NonEmpty s -> MapTrie s a -> Maybe (NonEmpty s, a, [s])

matches :: Ord s => NonEmpty s -> MapTrie s a -> [(NonEmpty s, a, [s])]

Returns a list of all the nodes along the path to the furthest point in the query, in order of the path walked from the root to the furthest point.