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)

Methods

fmap :: (a -> b) -> HashMapChildren c p a -> HashMapChildren c p b

(<$) :: a -> HashMapChildren c p b -> HashMapChildren c p a

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

Methods

fold :: Monoid m => HashMapChildren c p m -> m

foldMap :: Monoid m => (a -> m) -> HashMapChildren c p a -> m

foldr :: (a -> b -> b) -> b -> HashMapChildren c p a -> b

foldr' :: (a -> b -> b) -> b -> HashMapChildren c p a -> b

foldl :: (b -> a -> b) -> b -> HashMapChildren c p a -> b

foldl' :: (b -> a -> b) -> b -> HashMapChildren c p a -> b

foldr1 :: (a -> a -> a) -> HashMapChildren c p a -> a

foldl1 :: (a -> a -> a) -> HashMapChildren c p a -> a

toList :: HashMapChildren c p a -> [a]

null :: HashMapChildren c p a -> Bool

length :: HashMapChildren c p a -> Int

elem :: Eq a => a -> HashMapChildren c p a -> Bool

maximum :: Ord a => HashMapChildren c p a -> a

minimum :: Ord a => HashMapChildren c p a -> a

sum :: Num a => HashMapChildren c p a -> a

product :: Num a => HashMapChildren c p a -> a

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

Methods

traverse :: Applicative f => (a -> f b) -> HashMapChildren c p a -> f (HashMapChildren c p b)

sequenceA :: Applicative f => HashMapChildren c p (f a) -> f (HashMapChildren c p a)

mapM :: Monad m => (a -> m b) -> HashMapChildren c p a -> m (HashMapChildren c p b)

sequence :: Monad m => HashMapChildren c p (m a) -> m (HashMapChildren c p a)

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

Methods

(==) :: HashMapChildren c p a -> HashMapChildren c p a -> Bool

(/=) :: HashMapChildren c p a -> HashMapChildren c p a -> Bool

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

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashMapChildren c p a -> c (HashMapChildren c p a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HashMapChildren c p a)

toConstr :: HashMapChildren c p a -> Constr

dataTypeOf :: HashMapChildren c p a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HashMapChildren c p a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HashMapChildren c p a))

gmapT :: (forall b. Data b => b -> b) -> HashMapChildren c p a -> HashMapChildren c p a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashMapChildren c p a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashMapChildren c p a -> r

gmapQ :: (forall d. Data d => d -> u) -> HashMapChildren c p a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HashMapChildren c p a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashMapChildren c p a -> m (HashMapChildren c p a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMapChildren c p a -> m (HashMapChildren c p a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMapChildren c p a -> m (HashMapChildren c p a)

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

Methods

showsPrec :: Int -> HashMapChildren c p a -> ShowS

show :: HashMapChildren c p a -> String

showList :: [HashMapChildren c p a] -> ShowS

Generic (HashMapChildren c p a)

Associated Types

type Rep (HashMapChildren c p a) :: * -> *

Methods

from :: HashMapChildren c p a -> Rep (HashMapChildren c p a) x

to :: Rep (HashMapChildren c p a) x -> HashMapChildren c p a

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

Methods

mempty :: HashMapChildren c p a

mappend :: HashMapChildren c p a -> HashMapChildren c p a -> HashMapChildren c p a

mconcat :: [HashMapChildren c p a] -> HashMapChildren c p a

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

Methods

rnf :: HashMapChildren c p a -> ()

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

Methods

arbitrary :: Gen (HashMapChildren c p a)

shrink :: HashMapChildren c p a -> [HashMapChildren c p a]

type Rep (HashMapChildren c p a)

type Rep (HashMapChildren c p a) = D1 (MetaData "HashMapChildren" "Data.Trie.HashMap" "tries-0.0.4.1-IEbUlBVLW3O6hxW0ik7Url" False) (C1 (MetaCons "HashMapChildren" PrefixI True) ((:*:) (S1 (MetaSel (Just Symbol "hashMapNode") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Maybe a))) (S1 (MetaSel (Just Symbol "hashMapChildren") NoSourceUnpackedness SourceStrict DecidedStrict) (Rec0 (Maybe (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)

Methods

lookup :: NonEmpty p -> HashMapStep c p a -> Maybe a

insert :: NonEmpty p -> a -> HashMapStep c p a -> HashMapStep c p a

delete :: NonEmpty p -> HashMapStep c p a -> HashMapStep c p a

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

Methods

fmap :: (a -> b) -> HashMapStep c p a -> HashMapStep c p b

(<$) :: a -> HashMapStep c p b -> HashMapStep c p a

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

Methods

fold :: Monoid m => HashMapStep c p m -> m

foldMap :: Monoid m => (a -> m) -> HashMapStep c p a -> m

foldr :: (a -> b -> b) -> b -> HashMapStep c p a -> b

foldr' :: (a -> b -> b) -> b -> HashMapStep c p a -> b

foldl :: (b -> a -> b) -> b -> HashMapStep c p a -> b

foldl' :: (b -> a -> b) -> b -> HashMapStep c p a -> b

foldr1 :: (a -> a -> a) -> HashMapStep c p a -> a

foldl1 :: (a -> a -> a) -> HashMapStep c p a -> a

toList :: HashMapStep c p a -> [a]

null :: HashMapStep c p a -> Bool

length :: HashMapStep c p a -> Int

elem :: Eq a => a -> HashMapStep c p a -> Bool

maximum :: Ord a => HashMapStep c p a -> a

minimum :: Ord a => HashMapStep c p a -> a

sum :: Num a => HashMapStep c p a -> a

product :: Num a => HashMapStep c p a -> a

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

Methods

traverse :: Applicative f => (a -> f b) -> HashMapStep c p a -> f (HashMapStep c p b)

sequenceA :: Applicative f => HashMapStep c p (f a) -> f (HashMapStep c p a)

mapM :: Monad m => (a -> m b) -> HashMapStep c p a -> m (HashMapStep c p b)

sequence :: Monad m => HashMapStep c p (m a) -> m (HashMapStep c p a)

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

Methods

(==) :: HashMapStep c p a -> HashMapStep c p a -> Bool

(/=) :: HashMapStep c p a -> HashMapStep c p a -> Bool

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

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HashMapStep c p a -> c (HashMapStep c p a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (HashMapStep c p a)

toConstr :: HashMapStep c p a -> Constr

dataTypeOf :: HashMapStep c p a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (HashMapStep c p a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (HashMapStep c p a))

gmapT :: (forall b. Data b => b -> b) -> HashMapStep c p a -> HashMapStep c p a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HashMapStep c p a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HashMapStep c p a -> r

gmapQ :: (forall d. Data d => d -> u) -> HashMapStep c p a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HashMapStep c p a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HashMapStep c p a -> m (HashMapStep c p a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMapStep c p a -> m (HashMapStep c p a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HashMapStep c p a -> m (HashMapStep c p a)

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

Methods

showsPrec :: Int -> HashMapStep c p a -> ShowS

show :: HashMapStep c p a -> String

showList :: [HashMapStep c p a] -> ShowS

Generic (HashMapStep c p a)

Associated Types

type Rep (HashMapStep c p a) :: * -> *

Methods

from :: HashMapStep c p a -> Rep (HashMapStep c p a) x

to :: Rep (HashMapStep c p a) x -> HashMapStep c p a

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

Methods

mempty :: HashMapStep c p a

mappend :: HashMapStep c p a -> HashMapStep c p a -> HashMapStep c p a

mconcat :: [HashMapStep c p a] -> HashMapStep c p a

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

Methods

rnf :: HashMapStep c p a -> ()

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

Methods

arbitrary :: Gen (HashMapStep c p a)

shrink :: HashMapStep c p a -> [HashMapStep c p a]

type Rep (HashMapStep c p a)

type Rep (HashMapStep c p a) = D1 (MetaData "HashMapStep" "Data.Trie.HashMap" "tries-0.0.4.1-IEbUlBVLW3O6hxW0ik7Url" True) (C1 (MetaCons "HashMapStep" PrefixI True) (S1 (MetaSel (Just Symbol "unHashMapStep") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (HashMap p (HashMapChildren 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

Methods

lookup :: NonEmpty p -> HashMapTrie p a -> Maybe a

insert :: NonEmpty p -> a -> HashMapTrie p a -> HashMapTrie p a

delete :: NonEmpty p -> HashMapTrie p a -> HashMapTrie p a

Functor (HashMapTrie p)

Methods

fmap :: (a -> b) -> HashMapTrie p a -> HashMapTrie p b

(<$) :: a -> HashMapTrie p b -> HashMapTrie p a

Foldable (HashMapTrie p)

Methods

fold :: Monoid m => HashMapTrie p m -> m

foldMap :: Monoid m => (a -> m) -> HashMapTrie p a -> m

foldr :: (a -> b -> b) -> b -> HashMapTrie p a -> b

foldr' :: (a -> b -> b) -> b -> HashMapTrie p a -> b

foldl :: (b -> a -> b) -> b -> HashMapTrie p a -> b

foldl' :: (b -> a -> b) -> b -> HashMapTrie p a -> b

foldr1 :: (a -> a -> a) -> HashMapTrie p a -> a

foldl1 :: (a -> a -> a) -> HashMapTrie p a -> a

toList :: HashMapTrie p a -> [a]

null :: HashMapTrie p a -> Bool

length :: HashMapTrie p a -> Int

elem :: Eq a => a -> HashMapTrie p a -> Bool

maximum :: Ord a => HashMapTrie p a -> a

minimum :: Ord a => HashMapTrie p a -> a

sum :: Num a => HashMapTrie p a -> a

product :: Num a => HashMapTrie p a -> a

Traversable (HashMapTrie p)

Methods

traverse :: Applicative f => (a -> f b) -> HashMapTrie p a -> f (HashMapTrie p b)

sequenceA :: Applicative f => HashMapTrie p (f a) -> f (HashMapTrie p a)

mapM :: Monad m => (a -> m b) -> HashMapTrie p a -> m (HashMapTrie p b)

sequence :: Monad m => HashMapTrie p (m a) -> m (HashMapTrie p a)

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

Methods

lookup :: Key (HashMapTrie p) -> HashMapTrie p a -> Maybe a

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

Methods

(==) :: HashMapTrie p a -> HashMapTrie p a -> Bool

(/=) :: HashMapTrie p a -> HashMapTrie p a -> Bool

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

Methods

showsPrec :: Int -> HashMapTrie p a -> ShowS

show :: HashMapTrie p a -> String

showList :: [HashMapTrie p a] -> ShowS

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

Methods

mempty :: HashMapTrie p a

mappend :: HashMapTrie p a -> HashMapTrie p a -> HashMapTrie p a

mconcat :: [HashMapTrie p a] -> HashMapTrie p a

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

Methods

arbitrary :: Gen (HashMapTrie p a)

shrink :: HashMapTrie p a -> [HashMapTrie p a]

type Key (HashMapTrie p)

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.