Data.Trie.HashMap

One Step

data HashMapChildren c p a

Constructors

HashMapChildren

Fields

hashMapNode :: Maybe a

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

Instances

Functor (c p) => Functor (HashMapChildren c p)

Foldable (c p) => Foldable (HashMapChildren c p)

Traversable (c p) => Traversable (HashMapChildren c p)

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

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

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

Generic (HashMapChildren c p a)

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

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

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

type Rep (HashMapChildren c p a)

newtype HashMapStep c p a

Constructors

HashMapStep

Fields

unHashMapStep :: HashMap p (HashMapChildren c p a)

Instances

(Hashable p, Eq p, Trie NonEmpty p c) => Trie NonEmpty p (HashMapStep c)

Functor (c p) => Functor (HashMapStep c p)

Foldable (c p) => Foldable (HashMapStep c p)

Traversable (c p) => Traversable (HashMapStep c p)

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

(Eq p, Data p, Data a, Data (c p a), Typeable (* -> * -> *) c, Hashable p) => Data (HashMapStep c p a)

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

Generic (HashMapStep c p a)

(Hashable p, Eq p, Monoid (c p a)) => Monoid (HashMapStep c p a)

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

(Arbitrary a, Arbitrary p, Arbitrary (c p a), Hashable p, Eq p) => Arbitrary (HashMapStep c p a)

type Rep (HashMapStep c p a)

insert :: (Hashable p, Eq p, Trie NonEmpty p c, Monoid (c p a)) => NonEmpty p -> a -> HashMapStep c p a -> HashMapStep c p a

empty :: HashMapStep c p a

singleton :: Hashable p => p -> a -> HashMapStep c p a

Fixpoint of Steps

newtype HashMapTrie p a

Constructors

HashMapTrie

Fields

unHashMapTrie :: HashMapStep HashMapTrie p a

Instances

(Hashable p, Eq p) => Trie NonEmpty p HashMapTrie

Functor (HashMapTrie p)

Foldable (HashMapTrie p)

Traversable (HashMapTrie p)

(Hashable p, Eq p) => Lookup (HashMapTrie p)

(Eq p, Eq a) => Eq (HashMapTrie p a)

(Show p, Show a) => Show (HashMapTrie p a)

(Eq p, Hashable p) => Monoid (HashMapTrie p a)

(Eq p, Hashable p, Arbitrary p, Arbitrary a) => Arbitrary (HashMapTrie p a)

type Key (HashMapTrie p) = NonEmpty p

Conversion

keys :: (Hashable p, Eq p) => HashMapTrie p a -> [NonEmpty p]

elems :: HashMapTrie p a -> [a]

Query

subtrie :: (Hashable p, Eq p) => NonEmpty p -> HashMapTrie p a -> Maybe (HashMapTrie p a)

match :: (Hashable p, Eq p) => NonEmpty p -> HashMapTrie p a -> Maybe (NonEmpty p, a, [p])

matches :: (Hashable p, Eq p) => NonEmpty p -> HashMapTrie p a -> [(NonEmpty p, a, [p])]

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.