Data.MonoTraversable.Keys

Type-classes mirroring type-classes from Key, but working with monomorphic containers.

The motivation is that some commonly used data types (i.e., ByteString and Text) do not allow for instances of type-classes like Keyed, Indexable, and FoldableWithKey, since they are monomorphic structures. This module allows both monomorphic and polymorphic data types to be instances of the same type-classes.

All of the laws for the polymorphic type-classes apply to their monomorphic cousins.

Note that all type-classes have been prefixed with Mono, and functions have been prefixed with o. The mnemonic is inherited from MonoTraversable.

Documentation

type family MonoKey key

Type family for getting the type of the key of a monomorphic container.

Instances

type MonoKey ByteString

Defined in Data.MonoTraversable.Keys

type MonoKey ByteString = Int

type MonoKey ByteString

Defined in Data.MonoTraversable.Keys

type MonoKey ByteString = Int

type MonoKey IntSet

Defined in Data.MonoTraversable.Keys

type MonoKey IntSet = Int

type MonoKey Text

Defined in Data.MonoTraversable.Keys

type MonoKey Text = Int

type MonoKey Text

Defined in Data.MonoTraversable.Keys

type MonoKey Text = Int

type MonoKey (ZipList a)

Defined in Data.MonoTraversable.Keys

type MonoKey (ZipList a) = Int

type MonoKey (Identity a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Identity a) = ()

type MonoKey (IntMap a)

Defined in Data.MonoTraversable.Keys

type MonoKey (IntMap a) = Int

type MonoKey (Seq a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Seq a) = Int

type MonoKey (ViewL a)

Defined in Data.MonoTraversable.Keys

type MonoKey (ViewL a) = ()

type MonoKey (ViewR a)

Defined in Data.MonoTraversable.Keys

type MonoKey (ViewR a) = ()

type MonoKey (Set e)

Defined in Data.MonoTraversable.Keys

type MonoKey (Set e) = Int

type MonoKey (Tree a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Tree a) = Seq Int

type MonoKey (IO a)

Defined in Data.MonoTraversable.Keys

type MonoKey (IO a) = ()

type MonoKey (HashSet e)

Defined in Data.MonoTraversable.Keys

type MonoKey (HashSet e) = Int

type MonoKey (Vector a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Vector a) = Int

type MonoKey (Vector a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Vector a) = Int

type MonoKey (Vector a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Vector a) = Int

type MonoKey (NonEmpty a)

Defined in Data.MonoTraversable.Keys

type MonoKey (NonEmpty a) = Int

type MonoKey (Maybe a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Maybe a) = ()

type MonoKey [a]

Defined in Data.MonoTraversable.Keys

type MonoKey [a] = Int

type MonoKey (WrappedMonad m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (WrappedMonad m a) = ()

type MonoKey (Either a b)

Defined in Data.MonoTraversable.Keys

type MonoKey (Either a b) = ()

type MonoKey (Arg a b)

Defined in Data.MonoTraversable.Keys

type MonoKey (Arg a b) = ()

type MonoKey (Map k v)

Defined in Data.MonoTraversable.Keys

type MonoKey (Map k v) = k

type MonoKey (ListT m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (ListT m a) = Int

type MonoKey (MaybeT m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (MaybeT m a) = ()

type MonoKey (HashMap k v)

Defined in Data.MonoTraversable.Keys

type MonoKey (HashMap k v) = k

type MonoKey (r -> a)

Defined in Data.MonoTraversable.Keys

type MonoKey (r -> a) = ()

type MonoKey (a, b)

Defined in Data.MonoTraversable.Keys

type MonoKey (a, b) = ()

type MonoKey (WrappedArrow a b c)

Defined in Data.MonoTraversable.Keys

type MonoKey (WrappedArrow a b c) = ()

type MonoKey (Const m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Const m a) = ()

type MonoKey (IdentityT m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (IdentityT m a) = ()

type MonoKey (ReaderT r m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (ReaderT r m a) = (r, Key m)

type MonoKey (StateT s m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (StateT s m a) = ()

type MonoKey (StateT s m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (StateT s m a) = ()

type MonoKey (WriterT w m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (WriterT w m a) = ()

type MonoKey (WriterT w m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (WriterT w m a) = ()

type MonoKey (Product f g a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Product f g a) = Either (Key f) (Key g)

type MonoKey (ContT r m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (ContT r m a) = ()

type MonoKey (Compose f g a)

Defined in Data.MonoTraversable.Keys

type MonoKey (Compose f g a) = (MonoKey (f a), MonoKey (g a))

type MonoKey (RWST r w s m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (RWST r w s m a) = ()

type MonoKey (RWST r w s m a)

Defined in Data.MonoTraversable.Keys

type MonoKey (RWST r w s m a) = ()

Keyed Monomorphic Structures

class MonoFunctor mono => MonoKeyed mono where

Monomorphic containers that can be mapped over.

Minimal complete definition

Nothing

Methods

omapWithKey :: (MonoKey mono -> Element mono -> Element mono) -> mono -> mono

Map over a monomorphic container

default omapWithKey :: (Keyed f, Element (f a) ~ a, MonoKey (f a) ~ Key f, f a ~ mono) => (MonoKey mono -> Element mono -> Element mono) -> mono -> mono

Instances

MonoKeyed ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey ByteString -> Element ByteString -> Element ByteString) -> ByteString -> ByteString

MonoKeyed ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey ByteString -> Element ByteString -> Element ByteString) -> ByteString -> ByteString

MonoKeyed Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey Text -> Element Text -> Element Text) -> Text -> Text

MonoKeyed Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey Text -> Element Text -> Element Text) -> Text -> Text

MonoKeyed (ZipList a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> ZipList a

MonoKeyed (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Identity a

MonoKeyed (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (IntMap a) -> Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> IntMap a

MonoKeyed (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Seq a

MonoKeyed (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (ViewL a) -> Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> ViewL a

MonoKeyed (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (ViewR a) -> Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> ViewR a

MonoKeyed (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Tree a) -> Element (Tree a) -> Element (Tree a)) -> Tree a -> Tree a

MonoKeyed (IO a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (IO a) -> Element (IO a) -> Element (IO a)) -> IO a -> IO a

MonoKeyed (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a

Storable a => MonoKeyed (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a

Unbox a => MonoKeyed (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a

MonoKeyed (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a

MonoKeyed (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe a

MonoKeyed [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey [a] -> Element [a] -> Element [a]) -> [a] -> [a]

Monad m => MonoKeyed (WrappedMonad m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (WrappedMonad m a) -> Element (WrappedMonad m a) -> Element (WrappedMonad m a)) -> WrappedMonad m a -> WrappedMonad m a

MonoKeyed (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Either a b

MonoKeyed (Arg a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Arg a b) -> Element (Arg a b) -> Element (Arg a b)) -> Arg a b -> Arg a b

MonoKeyed (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Map k v

Functor m => MonoKeyed (ListT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (ListT m a) -> Element (ListT m a) -> Element (ListT m a)) -> ListT m a -> ListT m a

Functor m => MonoKeyed (MaybeT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (MaybeT m a) -> Element (MaybeT m a) -> Element (MaybeT m a)) -> MaybeT m a -> MaybeT m a

MonoKeyed (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> HashMap k v

MonoKeyed (r -> a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (r -> a) -> Element (r -> a) -> Element (r -> a)) -> (r -> a) -> r -> a

MonoKeyed (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> (a, b)

Arrow a => MonoKeyed (WrappedArrow a b c)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (WrappedArrow a b c) -> Element (WrappedArrow a b c) -> Element (WrappedArrow a b c)) -> WrappedArrow a b c -> WrappedArrow a b c

MonoKeyed (Const m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Const m a) -> Element (Const m a) -> Element (Const m a)) -> Const m a -> Const m a

Functor m => MonoKeyed (IdentityT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (IdentityT m a) -> Element (IdentityT m a) -> Element (IdentityT m a)) -> IdentityT m a -> IdentityT m a

Keyed m => MonoKeyed (ReaderT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (ReaderT r m a) -> Element (ReaderT r m a) -> Element (ReaderT r m a)) -> ReaderT r m a -> ReaderT r m a

Functor m => MonoKeyed (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a

Functor m => MonoKeyed (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a

Functor m => MonoKeyed (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a

Functor m => MonoKeyed (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a

(Keyed f, Keyed g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoKeyed (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Product f g a) -> Element (Product f g a) -> Element (Product f g a)) -> Product f g a -> Product f g a

Functor m => MonoKeyed (ContT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (ContT r m a) -> Element (ContT r m a) -> Element (ContT r m a)) -> ContT r m a -> ContT r m a

(Keyed f, Keyed g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoKeyed (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (Compose f g a) -> Element (Compose f g a) -> Element (Compose f g a)) -> Compose f g a -> Compose f g a

Functor m => MonoKeyed (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a

Functor m => MonoKeyed (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

omapWithKey :: (MonoKey (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a

class MonoFoldable mono => MonoFoldableWithKey mono where

Monomorphic containers that can be folded over thier pairs of elements and corresponding keys.

Minimal complete definition

ofoldMapWithKey | ofoldlWithKey

Methods

otoKeyedList :: mono -> [(MonoKey mono, Element mono)]

ofoldMapWithKey :: Monoid m => (MonoKey mono -> Element mono -> m) -> mono -> m

ofoldrWithKey :: (MonoKey mono -> Element mono -> a -> a) -> a -> mono -> a

ofoldlWithKey :: (a -> MonoKey mono -> Element mono -> a) -> a -> mono -> a

Instances

MonoFoldableWithKey ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: ByteString -> [(MonoKey ByteString, Element ByteString)]

ofoldMapWithKey :: Monoid m => (MonoKey ByteString -> Element ByteString -> m) -> ByteString -> m

ofoldrWithKey :: (MonoKey ByteString -> Element ByteString -> a -> a) -> a -> ByteString -> a

ofoldlWithKey :: (a -> MonoKey ByteString -> Element ByteString -> a) -> a -> ByteString -> a

MonoFoldableWithKey ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: ByteString -> [(MonoKey ByteString, Element ByteString)]

ofoldMapWithKey :: Monoid m => (MonoKey ByteString -> Element ByteString -> m) -> ByteString -> m

ofoldrWithKey :: (MonoKey ByteString -> Element ByteString -> a -> a) -> a -> ByteString -> a

ofoldlWithKey :: (a -> MonoKey ByteString -> Element ByteString -> a) -> a -> ByteString -> a

MonoFoldableWithKey IntSet

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: IntSet -> [(MonoKey IntSet, Element IntSet)]

ofoldMapWithKey :: Monoid m => (MonoKey IntSet -> Element IntSet -> m) -> IntSet -> m

ofoldrWithKey :: (MonoKey IntSet -> Element IntSet -> a -> a) -> a -> IntSet -> a

ofoldlWithKey :: (a -> MonoKey IntSet -> Element IntSet -> a) -> a -> IntSet -> a

MonoFoldableWithKey Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Text -> [(MonoKey Text, Element Text)]

ofoldMapWithKey :: Monoid m => (MonoKey Text -> Element Text -> m) -> Text -> m

ofoldrWithKey :: (MonoKey Text -> Element Text -> a -> a) -> a -> Text -> a

ofoldlWithKey :: (a -> MonoKey Text -> Element Text -> a) -> a -> Text -> a

MonoFoldableWithKey Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Text -> [(MonoKey Text, Element Text)]

ofoldMapWithKey :: Monoid m => (MonoKey Text -> Element Text -> m) -> Text -> m

ofoldrWithKey :: (MonoKey Text -> Element Text -> a -> a) -> a -> Text -> a

ofoldlWithKey :: (a -> MonoKey Text -> Element Text -> a) -> a -> Text -> a

MonoFoldableWithKey (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Identity a -> [(MonoKey (Identity a), Element (Identity a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Identity a) -> Element (Identity a) -> m) -> Identity a -> m

ofoldrWithKey :: (MonoKey (Identity a) -> Element (Identity a) -> a0 -> a0) -> a0 -> Identity a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Identity a) -> Element (Identity a) -> a0) -> a0 -> Identity a -> a0

MonoFoldableWithKey (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: IntMap a -> [(MonoKey (IntMap a), Element (IntMap a))]

ofoldMapWithKey :: Monoid m => (MonoKey (IntMap a) -> Element (IntMap a) -> m) -> IntMap a -> m

ofoldrWithKey :: (MonoKey (IntMap a) -> Element (IntMap a) -> a0 -> a0) -> a0 -> IntMap a -> a0

ofoldlWithKey :: (a0 -> MonoKey (IntMap a) -> Element (IntMap a) -> a0) -> a0 -> IntMap a -> a0

MonoFoldableWithKey (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Seq a -> [(MonoKey (Seq a), Element (Seq a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Seq a) -> Element (Seq a) -> m) -> Seq a -> m

ofoldrWithKey :: (MonoKey (Seq a) -> Element (Seq a) -> a0 -> a0) -> a0 -> Seq a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Seq a) -> Element (Seq a) -> a0) -> a0 -> Seq a -> a0

MonoFoldableWithKey (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: ViewL a -> [(MonoKey (ViewL a), Element (ViewL a))]

ofoldMapWithKey :: Monoid m => (MonoKey (ViewL a) -> Element (ViewL a) -> m) -> ViewL a -> m

ofoldrWithKey :: (MonoKey (ViewL a) -> Element (ViewL a) -> a0 -> a0) -> a0 -> ViewL a -> a0

ofoldlWithKey :: (a0 -> MonoKey (ViewL a) -> Element (ViewL a) -> a0) -> a0 -> ViewL a -> a0

MonoFoldableWithKey (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: ViewR a -> [(MonoKey (ViewR a), Element (ViewR a))]

ofoldMapWithKey :: Monoid m => (MonoKey (ViewR a) -> Element (ViewR a) -> m) -> ViewR a -> m

ofoldrWithKey :: (MonoKey (ViewR a) -> Element (ViewR a) -> a0 -> a0) -> a0 -> ViewR a -> a0

ofoldlWithKey :: (a0 -> MonoKey (ViewR a) -> Element (ViewR a) -> a0) -> a0 -> ViewR a -> a0

Ord e => MonoFoldableWithKey (Set e)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Set e -> [(MonoKey (Set e), Element (Set e))]

ofoldMapWithKey :: Monoid m => (MonoKey (Set e) -> Element (Set e) -> m) -> Set e -> m

ofoldrWithKey :: (MonoKey (Set e) -> Element (Set e) -> a -> a) -> a -> Set e -> a

ofoldlWithKey :: (a -> MonoKey (Set e) -> Element (Set e) -> a) -> a -> Set e -> a

MonoFoldableWithKey (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Tree a -> [(MonoKey (Tree a), Element (Tree a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Tree a) -> Element (Tree a) -> m) -> Tree a -> m

ofoldrWithKey :: (MonoKey (Tree a) -> Element (Tree a) -> a0 -> a0) -> a0 -> Tree a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Tree a) -> Element (Tree a) -> a0) -> a0 -> Tree a -> a0

MonoFoldableWithKey (HashSet v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: HashSet v -> [(MonoKey (HashSet v), Element (HashSet v))]

ofoldMapWithKey :: Monoid m => (MonoKey (HashSet v) -> Element (HashSet v) -> m) -> HashSet v -> m

ofoldrWithKey :: (MonoKey (HashSet v) -> Element (HashSet v) -> a -> a) -> a -> HashSet v -> a

ofoldlWithKey :: (a -> MonoKey (HashSet v) -> Element (HashSet v) -> a) -> a -> HashSet v -> a

MonoFoldableWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Vector a -> [(MonoKey (Vector a), Element (Vector a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Vector a) -> Element (Vector a) -> m) -> Vector a -> m

ofoldrWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> a0 -> a0) -> a0 -> Vector a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Vector a) -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0

Storable a => MonoFoldableWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Vector a -> [(MonoKey (Vector a), Element (Vector a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Vector a) -> Element (Vector a) -> m) -> Vector a -> m

ofoldrWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> a0 -> a0) -> a0 -> Vector a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Vector a) -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0

Unbox a => MonoFoldableWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Vector a -> [(MonoKey (Vector a), Element (Vector a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Vector a) -> Element (Vector a) -> m) -> Vector a -> m

ofoldrWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> a0 -> a0) -> a0 -> Vector a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Vector a) -> Element (Vector a) -> a0) -> a0 -> Vector a -> a0

MonoFoldableWithKey (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: NonEmpty a -> [(MonoKey (NonEmpty a), Element (NonEmpty a))]

ofoldMapWithKey :: Monoid m => (MonoKey (NonEmpty a) -> Element (NonEmpty a) -> m) -> NonEmpty a -> m

ofoldrWithKey :: (MonoKey (NonEmpty a) -> Element (NonEmpty a) -> a0 -> a0) -> a0 -> NonEmpty a -> a0

ofoldlWithKey :: (a0 -> MonoKey (NonEmpty a) -> Element (NonEmpty a) -> a0) -> a0 -> NonEmpty a -> a0

MonoFoldableWithKey (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Maybe a -> [(MonoKey (Maybe a), Element (Maybe a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Maybe a) -> Element (Maybe a) -> m) -> Maybe a -> m

ofoldrWithKey :: (MonoKey (Maybe a) -> Element (Maybe a) -> a0 -> a0) -> a0 -> Maybe a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Maybe a) -> Element (Maybe a) -> a0) -> a0 -> Maybe a -> a0

MonoFoldableWithKey [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: [a] -> [(MonoKey [a], Element [a])]

ofoldMapWithKey :: Monoid m => (MonoKey [a] -> Element [a] -> m) -> [a] -> m

ofoldrWithKey :: (MonoKey [a] -> Element [a] -> a0 -> a0) -> a0 -> [a] -> a0

ofoldlWithKey :: (a0 -> MonoKey [a] -> Element [a] -> a0) -> a0 -> [a] -> a0

MonoFoldableWithKey (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Either a b -> [(MonoKey (Either a b), Element (Either a b))]

ofoldMapWithKey :: Monoid m => (MonoKey (Either a b) -> Element (Either a b) -> m) -> Either a b -> m

ofoldrWithKey :: (MonoKey (Either a b) -> Element (Either a b) -> a0 -> a0) -> a0 -> Either a b -> a0

ofoldlWithKey :: (a0 -> MonoKey (Either a b) -> Element (Either a b) -> a0) -> a0 -> Either a b -> a0

MonoFoldableWithKey (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Map k v -> [(MonoKey (Map k v), Element (Map k v))]

ofoldMapWithKey :: Monoid m => (MonoKey (Map k v) -> Element (Map k v) -> m) -> Map k v -> m

ofoldrWithKey :: (MonoKey (Map k v) -> Element (Map k v) -> a -> a) -> a -> Map k v -> a

ofoldlWithKey :: (a -> MonoKey (Map k v) -> Element (Map k v) -> a) -> a -> Map k v -> a

Foldable f => MonoFoldableWithKey (ListT f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: ListT f a -> [(MonoKey (ListT f a), Element (ListT f a))]

ofoldMapWithKey :: Monoid m => (MonoKey (ListT f a) -> Element (ListT f a) -> m) -> ListT f a -> m

ofoldrWithKey :: (MonoKey (ListT f a) -> Element (ListT f a) -> a0 -> a0) -> a0 -> ListT f a -> a0

ofoldlWithKey :: (a0 -> MonoKey (ListT f a) -> Element (ListT f a) -> a0) -> a0 -> ListT f a -> a0

Foldable f => MonoFoldableWithKey (MaybeT f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: MaybeT f a -> [(MonoKey (MaybeT f a), Element (MaybeT f a))]

ofoldMapWithKey :: Monoid m => (MonoKey (MaybeT f a) -> Element (MaybeT f a) -> m) -> MaybeT f a -> m

ofoldrWithKey :: (MonoKey (MaybeT f a) -> Element (MaybeT f a) -> a0 -> a0) -> a0 -> MaybeT f a -> a0

ofoldlWithKey :: (a0 -> MonoKey (MaybeT f a) -> Element (MaybeT f a) -> a0) -> a0 -> MaybeT f a -> a0

MonoFoldableWithKey (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: HashMap k v -> [(MonoKey (HashMap k v), Element (HashMap k v))]

ofoldMapWithKey :: Monoid m => (MonoKey (HashMap k v) -> Element (HashMap k v) -> m) -> HashMap k v -> m

ofoldrWithKey :: (MonoKey (HashMap k v) -> Element (HashMap k v) -> a -> a) -> a -> HashMap k v -> a

ofoldlWithKey :: (a -> MonoKey (HashMap k v) -> Element (HashMap k v) -> a) -> a -> HashMap k v -> a

MonoFoldableWithKey (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: (a, b) -> [(MonoKey (a, b), Element (a, b))]

ofoldMapWithKey :: Monoid m => (MonoKey (a, b) -> Element (a, b) -> m) -> (a, b) -> m

ofoldrWithKey :: (MonoKey (a, b) -> Element (a, b) -> a0 -> a0) -> a0 -> (a, b) -> a0

ofoldlWithKey :: (a0 -> MonoKey (a, b) -> Element (a, b) -> a0) -> a0 -> (a, b) -> a0

MonoFoldableWithKey (Const m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Const m a -> [(MonoKey (Const m a), Element (Const m a))]

ofoldMapWithKey :: Monoid m0 => (MonoKey (Const m a) -> Element (Const m a) -> m0) -> Const m a -> m0

ofoldrWithKey :: (MonoKey (Const m a) -> Element (Const m a) -> a0 -> a0) -> a0 -> Const m a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Const m a) -> Element (Const m a) -> a0) -> a0 -> Const m a -> a0

Foldable f => MonoFoldableWithKey (IdentityT f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: IdentityT f a -> [(MonoKey (IdentityT f a), Element (IdentityT f a))]

ofoldMapWithKey :: Monoid m => (MonoKey (IdentityT f a) -> Element (IdentityT f a) -> m) -> IdentityT f a -> m

ofoldrWithKey :: (MonoKey (IdentityT f a) -> Element (IdentityT f a) -> a0 -> a0) -> a0 -> IdentityT f a -> a0

ofoldlWithKey :: (a0 -> MonoKey (IdentityT f a) -> Element (IdentityT f a) -> a0) -> a0 -> IdentityT f a -> a0

Foldable f => MonoFoldableWithKey (WriterT w f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: WriterT w f a -> [(MonoKey (WriterT w f a), Element (WriterT w f a))]

ofoldMapWithKey :: Monoid m => (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> m) -> WriterT w f a -> m

ofoldrWithKey :: (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> a0 -> a0) -> a0 -> WriterT w f a -> a0

ofoldlWithKey :: (a0 -> MonoKey (WriterT w f a) -> Element (WriterT w f a) -> a0) -> a0 -> WriterT w f a -> a0

Foldable f => MonoFoldableWithKey (WriterT w f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: WriterT w f a -> [(MonoKey (WriterT w f a), Element (WriterT w f a))]

ofoldMapWithKey :: Monoid m => (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> m) -> WriterT w f a -> m

ofoldrWithKey :: (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> a0 -> a0) -> a0 -> WriterT w f a -> a0

ofoldlWithKey :: (a0 -> MonoKey (WriterT w f a) -> Element (WriterT w f a) -> a0) -> a0 -> WriterT w f a -> a0

(FoldableWithKey f, FoldableWithKey g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoFoldableWithKey (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Product f g a -> [(MonoKey (Product f g a), Element (Product f g a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Product f g a) -> Element (Product f g a) -> m) -> Product f g a -> m

ofoldrWithKey :: (MonoKey (Product f g a) -> Element (Product f g a) -> a0 -> a0) -> a0 -> Product f g a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Product f g a) -> Element (Product f g a) -> a0) -> a0 -> Product f g a -> a0

(FoldableWithKey f, FoldableWithKey g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoFoldableWithKey (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otoKeyedList :: Compose f g a -> [(MonoKey (Compose f g a), Element (Compose f g a))]

ofoldMapWithKey :: Monoid m => (MonoKey (Compose f g a) -> Element (Compose f g a) -> m) -> Compose f g a -> m

ofoldrWithKey :: (MonoKey (Compose f g a) -> Element (Compose f g a) -> a0 -> a0) -> a0 -> Compose f g a -> a0

ofoldlWithKey :: (a0 -> MonoKey (Compose f g a) -> Element (Compose f g a) -> a0) -> a0 -> Compose f g a -> a0

class (MonoKeyed mono, MonoFoldableWithKey mono, MonoTraversable mono) => MonoTraversableWithKey mono where

Monomorphic containers that can be traversed from left to right over thier pairs of elements and corresponding keys.

Minimal complete definition

otraverseWithKey

Methods

otraverseWithKey :: Applicative f => (MonoKey mono -> Element mono -> f (Element mono)) -> mono -> f mono

Map each key-element pair of a monomorphic container to an action, evaluate these actions from left to right, and collect the results. {-# INLINE otraverseWithKey #-}

default otraverseWithKey :: (Applicative f, TraversableWithKey t, Element (t a) ~ a, MonoKey (t a) ~ Key t, t a ~ mono) => (MonoKey mono -> Element mono -> f (Element mono)) -> mono -> f mono

omapWithKeyM :: Monad m => (MonoKey mono -> Element mono -> m (Element mono)) -> mono -> m mono

Like otraverse but with a Monad constraint.

Instances

MonoTraversableWithKey ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey ByteString -> Element ByteString -> f (Element ByteString)) -> ByteString -> f ByteString

omapWithKeyM :: Monad m => (MonoKey ByteString -> Element ByteString -> m (Element ByteString)) -> ByteString -> m ByteString

MonoTraversableWithKey ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey ByteString -> Element ByteString -> f (Element ByteString)) -> ByteString -> f ByteString

omapWithKeyM :: Monad m => (MonoKey ByteString -> Element ByteString -> m (Element ByteString)) -> ByteString -> m ByteString

MonoTraversableWithKey Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey Text -> Element Text -> f (Element Text)) -> Text -> f Text

omapWithKeyM :: Monad m => (MonoKey Text -> Element Text -> m (Element Text)) -> Text -> m Text

MonoTraversableWithKey Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey Text -> Element Text -> f (Element Text)) -> Text -> f Text

omapWithKeyM :: Monad m => (MonoKey Text -> Element Text -> m (Element Text)) -> Text -> m Text

MonoTraversableWithKey (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Identity a) -> Element (Identity a) -> f (Element (Identity a))) -> Identity a -> f (Identity a)

omapWithKeyM :: Monad m => (MonoKey (Identity a) -> Element (Identity a) -> m (Element (Identity a))) -> Identity a -> m (Identity a)

MonoTraversableWithKey (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (IntMap a) -> Element (IntMap a) -> f (Element (IntMap a))) -> IntMap a -> f (IntMap a)

omapWithKeyM :: Monad m => (MonoKey (IntMap a) -> Element (IntMap a) -> m (Element (IntMap a))) -> IntMap a -> m (IntMap a)

MonoTraversableWithKey (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Seq a) -> Element (Seq a) -> f (Element (Seq a))) -> Seq a -> f (Seq a)

omapWithKeyM :: Monad m => (MonoKey (Seq a) -> Element (Seq a) -> m (Element (Seq a))) -> Seq a -> m (Seq a)

MonoTraversableWithKey (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (ViewL a) -> Element (ViewL a) -> f (Element (ViewL a))) -> ViewL a -> f (ViewL a)

omapWithKeyM :: Monad m => (MonoKey (ViewL a) -> Element (ViewL a) -> m (Element (ViewL a))) -> ViewL a -> m (ViewL a)

MonoTraversableWithKey (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (ViewR a) -> Element (ViewR a) -> f (Element (ViewR a))) -> ViewR a -> f (ViewR a)

omapWithKeyM :: Monad m => (MonoKey (ViewR a) -> Element (ViewR a) -> m (Element (ViewR a))) -> ViewR a -> m (ViewR a)

MonoTraversableWithKey (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Tree a) -> Element (Tree a) -> f (Element (Tree a))) -> Tree a -> f (Tree a)

omapWithKeyM :: Monad m => (MonoKey (Tree a) -> Element (Tree a) -> m (Element (Tree a))) -> Tree a -> m (Tree a)

MonoTraversableWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Vector a) -> Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a)

omapWithKeyM :: Monad m => (MonoKey (Vector a) -> Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a)

Storable a => MonoTraversableWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Vector a) -> Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a)

omapWithKeyM :: Monad m => (MonoKey (Vector a) -> Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a)

Unbox a => MonoTraversableWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Vector a) -> Element (Vector a) -> f (Element (Vector a))) -> Vector a -> f (Vector a)

omapWithKeyM :: Monad m => (MonoKey (Vector a) -> Element (Vector a) -> m (Element (Vector a))) -> Vector a -> m (Vector a)

MonoTraversableWithKey (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (NonEmpty a) -> Element (NonEmpty a) -> f (Element (NonEmpty a))) -> NonEmpty a -> f (NonEmpty a)

omapWithKeyM :: Monad m => (MonoKey (NonEmpty a) -> Element (NonEmpty a) -> m (Element (NonEmpty a))) -> NonEmpty a -> m (NonEmpty a)

MonoTraversableWithKey (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Maybe a) -> Element (Maybe a) -> f (Element (Maybe a))) -> Maybe a -> f (Maybe a)

omapWithKeyM :: Monad m => (MonoKey (Maybe a) -> Element (Maybe a) -> m (Element (Maybe a))) -> Maybe a -> m (Maybe a)

MonoTraversableWithKey [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey [a] -> Element [a] -> f (Element [a])) -> [a] -> f [a]

omapWithKeyM :: Monad m => (MonoKey [a] -> Element [a] -> m (Element [a])) -> [a] -> m [a]

MonoTraversableWithKey (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Either a b) -> Element (Either a b) -> f (Element (Either a b))) -> Either a b -> f (Either a b)

omapWithKeyM :: Monad m => (MonoKey (Either a b) -> Element (Either a b) -> m (Element (Either a b))) -> Either a b -> m (Either a b)

MonoTraversableWithKey (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Map k v) -> Element (Map k v) -> f (Element (Map k v))) -> Map k v -> f (Map k v)

omapWithKeyM :: Monad m => (MonoKey (Map k v) -> Element (Map k v) -> m (Element (Map k v))) -> Map k v -> m (Map k v)

Traversable f => MonoTraversableWithKey (ListT f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (ListT f a) -> Element (ListT f a) -> f0 (Element (ListT f a))) -> ListT f a -> f0 (ListT f a)

omapWithKeyM :: Monad m => (MonoKey (ListT f a) -> Element (ListT f a) -> m (Element (ListT f a))) -> ListT f a -> m (ListT f a)

Traversable f => MonoTraversableWithKey (MaybeT f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (MaybeT f a) -> Element (MaybeT f a) -> f0 (Element (MaybeT f a))) -> MaybeT f a -> f0 (MaybeT f a)

omapWithKeyM :: Monad m => (MonoKey (MaybeT f a) -> Element (MaybeT f a) -> m (Element (MaybeT f a))) -> MaybeT f a -> m (MaybeT f a)

MonoTraversableWithKey (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (HashMap k v) -> Element (HashMap k v) -> f (Element (HashMap k v))) -> HashMap k v -> f (HashMap k v)

omapWithKeyM :: Monad m => (MonoKey (HashMap k v) -> Element (HashMap k v) -> m (Element (HashMap k v))) -> HashMap k v -> m (HashMap k v)

MonoTraversableWithKey (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (a, b) -> Element (a, b) -> f (Element (a, b))) -> (a, b) -> f (a, b)

omapWithKeyM :: Monad m => (MonoKey (a, b) -> Element (a, b) -> m (Element (a, b))) -> (a, b) -> m (a, b)

MonoTraversableWithKey (Const m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f => (MonoKey (Const m a) -> Element (Const m a) -> f (Element (Const m a))) -> Const m a -> f (Const m a)

omapWithKeyM :: Monad m0 => (MonoKey (Const m a) -> Element (Const m a) -> m0 (Element (Const m a))) -> Const m a -> m0 (Const m a)

Traversable f => MonoTraversableWithKey (IdentityT f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (IdentityT f a) -> Element (IdentityT f a) -> f0 (Element (IdentityT f a))) -> IdentityT f a -> f0 (IdentityT f a)

omapWithKeyM :: Monad m => (MonoKey (IdentityT f a) -> Element (IdentityT f a) -> m (Element (IdentityT f a))) -> IdentityT f a -> m (IdentityT f a)

Traversable f => MonoTraversableWithKey (WriterT w f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> f0 (Element (WriterT w f a))) -> WriterT w f a -> f0 (WriterT w f a)

omapWithKeyM :: Monad m => (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> m (Element (WriterT w f a))) -> WriterT w f a -> m (WriterT w f a)

Traversable f => MonoTraversableWithKey (WriterT w f a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> f0 (Element (WriterT w f a))) -> WriterT w f a -> f0 (WriterT w f a)

omapWithKeyM :: Monad m => (MonoKey (WriterT w f a) -> Element (WriterT w f a) -> m (Element (WriterT w f a))) -> WriterT w f a -> m (WriterT w f a)

(MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g, TraversableWithKey f, TraversableWithKey g) => MonoTraversableWithKey (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (Product f g a) -> Element (Product f g a) -> f0 (Element (Product f g a))) -> Product f g a -> f0 (Product f g a)

omapWithKeyM :: Monad m => (MonoKey (Product f g a) -> Element (Product f g a) -> m (Element (Product f g a))) -> Product f g a -> m (Product f g a)

(MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g, TraversableWithKey f, TraversableWithKey g) => MonoTraversableWithKey (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

otraverseWithKey :: Applicative f0 => (MonoKey (Compose f g a) -> Element (Compose f g a) -> f0 (Element (Compose f g a))) -> Compose f g a -> f0 (Compose f g a)

omapWithKeyM :: Monad m => (MonoKey (Compose f g a) -> Element (Compose f g a) -> m (Element (Compose f g a))) -> Compose f g a -> m (Compose f g a)

Adjustable Monomorphic Structures

class MonoFunctor mono => MonoAdjustable mono where

Monomorphic container that can adjust elements "in place."

Minimal complete definition

oadjust

Methods

oadjust :: (Element mono -> Element mono) -> MonoKey mono -> mono -> mono

default oadjust :: (Adjustable f, Element (f a) ~ a, MonoKey (f a) ~ Key f, f a ~ mono) => (Element mono -> Element mono) -> MonoKey mono -> mono -> mono

oreplace :: MonoKey mono -> Element mono -> mono -> mono

Instances

MonoAdjustable ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element ByteString -> Element ByteString) -> MonoKey ByteString -> ByteString -> ByteString

oreplace :: MonoKey ByteString -> Element ByteString -> ByteString -> ByteString

MonoAdjustable ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element ByteString -> Element ByteString) -> MonoKey ByteString -> ByteString -> ByteString

oreplace :: MonoKey ByteString -> Element ByteString -> ByteString -> ByteString

MonoAdjustable Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element Text -> Element Text) -> MonoKey Text -> Text -> Text

oreplace :: MonoKey Text -> Element Text -> Text -> Text

MonoAdjustable Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element Text -> Element Text) -> MonoKey Text -> Text -> Text

oreplace :: MonoKey Text -> Element Text -> Text -> Text

MonoAdjustable (ZipList a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (ZipList a) -> Element (ZipList a)) -> MonoKey (ZipList a) -> ZipList a -> ZipList a

oreplace :: MonoKey (ZipList a) -> Element (ZipList a) -> ZipList a -> ZipList a

MonoAdjustable (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Identity a) -> Element (Identity a)) -> MonoKey (Identity a) -> Identity a -> Identity a

oreplace :: MonoKey (Identity a) -> Element (Identity a) -> Identity a -> Identity a

MonoAdjustable (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (IntMap a) -> Element (IntMap a)) -> MonoKey (IntMap a) -> IntMap a -> IntMap a

oreplace :: MonoKey (IntMap a) -> Element (IntMap a) -> IntMap a -> IntMap a

MonoAdjustable (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Seq a) -> Element (Seq a)) -> MonoKey (Seq a) -> Seq a -> Seq a

oreplace :: MonoKey (Seq a) -> Element (Seq a) -> Seq a -> Seq a

MonoAdjustable (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (ViewL a) -> Element (ViewL a)) -> MonoKey (ViewL a) -> ViewL a -> ViewL a

oreplace :: MonoKey (ViewL a) -> Element (ViewL a) -> ViewL a -> ViewL a

MonoAdjustable (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (ViewR a) -> Element (ViewR a)) -> MonoKey (ViewR a) -> ViewR a -> ViewR a

oreplace :: MonoKey (ViewR a) -> Element (ViewR a) -> ViewR a -> ViewR a

MonoAdjustable (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Tree a) -> Element (Tree a)) -> MonoKey (Tree a) -> Tree a -> Tree a

oreplace :: MonoKey (Tree a) -> Element (Tree a) -> Tree a -> Tree a

MonoAdjustable (IO a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (IO a) -> Element (IO a)) -> MonoKey (IO a) -> IO a -> IO a

oreplace :: MonoKey (IO a) -> Element (IO a) -> IO a -> IO a

MonoAdjustable (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Vector a) -> Element (Vector a)) -> MonoKey (Vector a) -> Vector a -> Vector a

oreplace :: MonoKey (Vector a) -> Element (Vector a) -> Vector a -> Vector a

Storable a => MonoAdjustable (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Vector a) -> Element (Vector a)) -> MonoKey (Vector a) -> Vector a -> Vector a

oreplace :: MonoKey (Vector a) -> Element (Vector a) -> Vector a -> Vector a

Unbox a => MonoAdjustable (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Vector a) -> Element (Vector a)) -> MonoKey (Vector a) -> Vector a -> Vector a

oreplace :: MonoKey (Vector a) -> Element (Vector a) -> Vector a -> Vector a

MonoAdjustable (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (NonEmpty a) -> Element (NonEmpty a)) -> MonoKey (NonEmpty a) -> NonEmpty a -> NonEmpty a

oreplace :: MonoKey (NonEmpty a) -> Element (NonEmpty a) -> NonEmpty a -> NonEmpty a

MonoAdjustable (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Maybe a) -> Element (Maybe a)) -> MonoKey (Maybe a) -> Maybe a -> Maybe a

oreplace :: MonoKey (Maybe a) -> Element (Maybe a) -> Maybe a -> Maybe a

MonoAdjustable [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element [a] -> Element [a]) -> MonoKey [a] -> [a] -> [a]

oreplace :: MonoKey [a] -> Element [a] -> [a] -> [a]

Monad m => MonoAdjustable (WrappedMonad m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (WrappedMonad m a) -> Element (WrappedMonad m a)) -> MonoKey (WrappedMonad m a) -> WrappedMonad m a -> WrappedMonad m a

oreplace :: MonoKey (WrappedMonad m a) -> Element (WrappedMonad m a) -> WrappedMonad m a -> WrappedMonad m a

MonoAdjustable (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Either a b) -> Element (Either a b)) -> MonoKey (Either a b) -> Either a b -> Either a b

oreplace :: MonoKey (Either a b) -> Element (Either a b) -> Either a b -> Either a b

MonoAdjustable (Arg a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Arg a b) -> Element (Arg a b)) -> MonoKey (Arg a b) -> Arg a b -> Arg a b

oreplace :: MonoKey (Arg a b) -> Element (Arg a b) -> Arg a b -> Arg a b

Ord k => MonoAdjustable (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Map k v) -> Element (Map k v)) -> MonoKey (Map k v) -> Map k v -> Map k v

oreplace :: MonoKey (Map k v) -> Element (Map k v) -> Map k v -> Map k v

Functor m => MonoAdjustable (ListT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (ListT m a) -> Element (ListT m a)) -> MonoKey (ListT m a) -> ListT m a -> ListT m a

oreplace :: MonoKey (ListT m a) -> Element (ListT m a) -> ListT m a -> ListT m a

Functor m => MonoAdjustable (MaybeT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (MaybeT m a) -> Element (MaybeT m a)) -> MonoKey (MaybeT m a) -> MaybeT m a -> MaybeT m a

oreplace :: MonoKey (MaybeT m a) -> Element (MaybeT m a) -> MaybeT m a -> MaybeT m a

(Eq k, Hashable k) => MonoAdjustable (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (HashMap k v) -> Element (HashMap k v)) -> MonoKey (HashMap k v) -> HashMap k v -> HashMap k v

oreplace :: MonoKey (HashMap k v) -> Element (HashMap k v) -> HashMap k v -> HashMap k v

MonoAdjustable (r -> a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (r -> a) -> Element (r -> a)) -> MonoKey (r -> a) -> (r -> a) -> r -> a

oreplace :: MonoKey (r -> a) -> Element (r -> a) -> (r -> a) -> r -> a

MonoAdjustable (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (a, b) -> Element (a, b)) -> MonoKey (a, b) -> (a, b) -> (a, b)

oreplace :: MonoKey (a, b) -> Element (a, b) -> (a, b) -> (a, b)

Arrow a => MonoAdjustable (WrappedArrow a b c)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (WrappedArrow a b c) -> Element (WrappedArrow a b c)) -> MonoKey (WrappedArrow a b c) -> WrappedArrow a b c -> WrappedArrow a b c

oreplace :: MonoKey (WrappedArrow a b c) -> Element (WrappedArrow a b c) -> WrappedArrow a b c -> WrappedArrow a b c

MonoAdjustable (Const m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Const m a) -> Element (Const m a)) -> MonoKey (Const m a) -> Const m a -> Const m a

oreplace :: MonoKey (Const m a) -> Element (Const m a) -> Const m a -> Const m a

Functor m => MonoAdjustable (IdentityT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (IdentityT m a) -> Element (IdentityT m a)) -> MonoKey (IdentityT m a) -> IdentityT m a -> IdentityT m a

oreplace :: MonoKey (IdentityT m a) -> Element (IdentityT m a) -> IdentityT m a -> IdentityT m a

Functor m => MonoAdjustable (ReaderT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (ReaderT r m a) -> Element (ReaderT r m a)) -> MonoKey (ReaderT r m a) -> ReaderT r m a -> ReaderT r m a

oreplace :: MonoKey (ReaderT r m a) -> Element (ReaderT r m a) -> ReaderT r m a -> ReaderT r m a

Functor m => MonoAdjustable (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (StateT s m a) -> Element (StateT s m a)) -> MonoKey (StateT s m a) -> StateT s m a -> StateT s m a

oreplace :: MonoKey (StateT s m a) -> Element (StateT s m a) -> StateT s m a -> StateT s m a

Functor m => MonoAdjustable (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (StateT s m a) -> Element (StateT s m a)) -> MonoKey (StateT s m a) -> StateT s m a -> StateT s m a

oreplace :: MonoKey (StateT s m a) -> Element (StateT s m a) -> StateT s m a -> StateT s m a

Functor m => MonoAdjustable (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (WriterT w m a) -> Element (WriterT w m a)) -> MonoKey (WriterT w m a) -> WriterT w m a -> WriterT w m a

oreplace :: MonoKey (WriterT w m a) -> Element (WriterT w m a) -> WriterT w m a -> WriterT w m a

Functor m => MonoAdjustable (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (WriterT w m a) -> Element (WriterT w m a)) -> MonoKey (WriterT w m a) -> WriterT w m a -> WriterT w m a

oreplace :: MonoKey (WriterT w m a) -> Element (WriterT w m a) -> WriterT w m a -> WriterT w m a

(Adjustable f, Adjustable g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoAdjustable (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (Product f g a) -> Element (Product f g a)) -> MonoKey (Product f g a) -> Product f g a -> Product f g a

oreplace :: MonoKey (Product f g a) -> Element (Product f g a) -> Product f g a -> Product f g a

Functor m => MonoAdjustable (ContT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (ContT r m a) -> Element (ContT r m a)) -> MonoKey (ContT r m a) -> ContT r m a -> ContT r m a

oreplace :: MonoKey (ContT r m a) -> Element (ContT r m a) -> ContT r m a -> ContT r m a

Functor m => MonoAdjustable (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (RWST r w s m a) -> Element (RWST r w s m a)) -> MonoKey (RWST r w s m a) -> RWST r w s m a -> RWST r w s m a

oreplace :: MonoKey (RWST r w s m a) -> Element (RWST r w s m a) -> RWST r w s m a -> RWST r w s m a

Functor m => MonoAdjustable (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oadjust :: (Element (RWST r w s m a) -> Element (RWST r w s m a)) -> MonoKey (RWST r w s m a) -> RWST r w s m a -> RWST r w s m a

oreplace :: MonoKey (RWST r w s m a) -> Element (RWST r w s m a) -> RWST r w s m a -> RWST r w s m a

Zippable Monomorphic Structures

class MonoFunctor mono => MonoZip mono where

Monomorphic container that can be zipped together, merging thier elements.

Laws:

ozipWith const u u === ozipWith (flip const) u u === u
ozipWith (flip f) x y === ozipWith f y x
ozipWith (a b -> f (g a) (h b)) x y === ozipWith f (omap g x) (omap h y)

Methods

ozipWith :: (Element mono -> Element mono -> Element mono) -> mono -> mono -> mono

Instances

MonoZip ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> ByteString -> ByteString

MonoZip ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> ByteString -> ByteString

MonoZip Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element Text -> Element Text -> Element Text) -> Text -> Text -> Text

MonoZip Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element Text -> Element Text -> Element Text) -> Text -> Text -> Text

MonoZip (ZipList a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> ZipList a -> ZipList a

MonoZip (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Identity a -> Identity a

MonoZip (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (IntMap a) -> Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> IntMap a -> IntMap a

MonoZip (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Seq a -> Seq a

MonoZip (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (ViewL a) -> Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> ViewL a -> ViewL a

MonoZip (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (ViewR a) -> Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> ViewR a -> ViewR a

MonoZip (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Tree a) -> Element (Tree a) -> Element (Tree a)) -> Tree a -> Tree a -> Tree a

MonoZip (IO a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (IO a) -> Element (IO a) -> Element (IO a)) -> IO a -> IO a -> IO a

MonoZip (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a -> Vector a

Storable a => MonoZip (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a -> Vector a

Unbox a => MonoZip (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a -> Vector a

MonoZip (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a -> NonEmpty a

MonoZip (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe a -> Maybe a

MonoZip [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element [a] -> Element [a] -> Element [a]) -> [a] -> [a] -> [a]

Monad m => MonoZip (WrappedMonad m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (WrappedMonad m a) -> Element (WrappedMonad m a) -> Element (WrappedMonad m a)) -> WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

MonoZip (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Either a b -> Either a b

MonoZip (Arg a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Arg a b) -> Element (Arg a b) -> Element (Arg a b)) -> Arg a b -> Arg a b -> Arg a b

Ord k => MonoZip (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Map k v -> Map k v

Applicative m => MonoZip (ListT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (ListT m a) -> Element (ListT m a) -> Element (ListT m a)) -> ListT m a -> ListT m a -> ListT m a

Applicative m => MonoZip (MaybeT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (MaybeT m a) -> Element (MaybeT m a) -> Element (MaybeT m a)) -> MaybeT m a -> MaybeT m a -> MaybeT m a

(Eq k, Hashable k) => MonoZip (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> HashMap k v -> HashMap k v

MonoZip (r -> a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (r -> a) -> Element (r -> a) -> Element (r -> a)) -> (r -> a) -> (r -> a) -> r -> a

MonoZip (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> (a, b) -> (a, b)

Arrow a => MonoZip (WrappedArrow a b c)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (WrappedArrow a b c) -> Element (WrappedArrow a b c) -> Element (WrappedArrow a b c)) -> WrappedArrow a b c -> WrappedArrow a b c -> WrappedArrow a b c

MonoZip (Const m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Const m a) -> Element (Const m a) -> Element (Const m a)) -> Const m a -> Const m a -> Const m a

Applicative m => MonoZip (IdentityT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (IdentityT m a) -> Element (IdentityT m a) -> Element (IdentityT m a)) -> IdentityT m a -> IdentityT m a -> IdentityT m a

Applicative m => MonoZip (ReaderT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (ReaderT r m a) -> Element (ReaderT r m a) -> Element (ReaderT r m a)) -> ReaderT r m a -> ReaderT r m a -> ReaderT r m a

Applicative m => MonoZip (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a -> StateT s m a

Applicative m => MonoZip (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a -> StateT s m a

(Applicative m, Monoid w) => MonoZip (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a -> WriterT w m a

(Applicative m, Monoid w) => MonoZip (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a -> WriterT w m a

(Zip f, Zip g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoZip (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Product f g a) -> Element (Product f g a) -> Element (Product f g a)) -> Product f g a -> Product f g a -> Product f g a

Functor m => MonoZip (ContT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (ContT r m a) -> Element (ContT r m a) -> Element (ContT r m a)) -> ContT r m a -> ContT r m a -> ContT r m a

(Zip f, Zip g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoZip (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (Compose f g a) -> Element (Compose f g a) -> Element (Compose f g a)) -> Compose f g a -> Compose f g a -> Compose f g a

(Applicative m, Semigroup w) => MonoZip (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a -> RWST r w s m a

(Applicative m, Semigroup w) => MonoZip (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWith :: (Element (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a -> RWST r w s m a

class (MonoKeyed mono, MonoZip mono) => MonoZipWithKey mono where

Monomorphic container that can be zipped together, merging thier pairs of elements and corresponding keys.

Methods

ozipWithKey :: (MonoKey mono -> Element mono -> Element mono -> Element mono) -> mono -> mono -> mono

Instances

MonoZipWithKey ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey ByteString -> Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> ByteString -> ByteString

MonoZipWithKey ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey ByteString -> Element ByteString -> Element ByteString -> Element ByteString) -> ByteString -> ByteString -> ByteString

MonoZipWithKey Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey Text -> Element Text -> Element Text -> Element Text) -> Text -> Text -> Text

MonoZipWithKey Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey Text -> Element Text -> Element Text -> Element Text) -> Text -> Text -> Text

MonoZipWithKey (ZipList a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (ZipList a) -> Element (ZipList a) -> Element (ZipList a) -> Element (ZipList a)) -> ZipList a -> ZipList a -> ZipList a

MonoZipWithKey (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Identity a) -> Element (Identity a) -> Element (Identity a) -> Element (Identity a)) -> Identity a -> Identity a -> Identity a

MonoZipWithKey (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (IntMap a) -> Element (IntMap a) -> Element (IntMap a) -> Element (IntMap a)) -> IntMap a -> IntMap a -> IntMap a

MonoZipWithKey (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Seq a) -> Element (Seq a) -> Element (Seq a) -> Element (Seq a)) -> Seq a -> Seq a -> Seq a

MonoZipWithKey (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (ViewL a) -> Element (ViewL a) -> Element (ViewL a) -> Element (ViewL a)) -> ViewL a -> ViewL a -> ViewL a

MonoZipWithKey (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (ViewR a) -> Element (ViewR a) -> Element (ViewR a) -> Element (ViewR a)) -> ViewR a -> ViewR a -> ViewR a

MonoZipWithKey (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Tree a) -> Element (Tree a) -> Element (Tree a) -> Element (Tree a)) -> Tree a -> Tree a -> Tree a

MonoZipWithKey (IO a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (IO a) -> Element (IO a) -> Element (IO a) -> Element (IO a)) -> IO a -> IO a -> IO a

MonoZipWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a -> Vector a

Storable a => MonoZipWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a -> Vector a

Unbox a => MonoZipWithKey (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Vector a) -> Element (Vector a) -> Element (Vector a) -> Element (Vector a)) -> Vector a -> Vector a -> Vector a

MonoZipWithKey (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a) -> Element (NonEmpty a)) -> NonEmpty a -> NonEmpty a -> NonEmpty a

MonoZipWithKey (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Maybe a) -> Element (Maybe a) -> Element (Maybe a) -> Element (Maybe a)) -> Maybe a -> Maybe a -> Maybe a

MonoZipWithKey [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey [a] -> Element [a] -> Element [a] -> Element [a]) -> [a] -> [a] -> [a]

Monad m => MonoZipWithKey (WrappedMonad m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (WrappedMonad m a) -> Element (WrappedMonad m a) -> Element (WrappedMonad m a) -> Element (WrappedMonad m a)) -> WrappedMonad m a -> WrappedMonad m a -> WrappedMonad m a

MonoZipWithKey (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Either a b) -> Element (Either a b) -> Element (Either a b) -> Element (Either a b)) -> Either a b -> Either a b -> Either a b

MonoZipWithKey (Arg a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Arg a b) -> Element (Arg a b) -> Element (Arg a b) -> Element (Arg a b)) -> Arg a b -> Arg a b -> Arg a b

Ord k => MonoZipWithKey (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Map k v) -> Element (Map k v) -> Element (Map k v) -> Element (Map k v)) -> Map k v -> Map k v -> Map k v

Applicative m => MonoZipWithKey (ListT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (ListT m a) -> Element (ListT m a) -> Element (ListT m a) -> Element (ListT m a)) -> ListT m a -> ListT m a -> ListT m a

Monad m => MonoZipWithKey (MaybeT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (MaybeT m a) -> Element (MaybeT m a) -> Element (MaybeT m a) -> Element (MaybeT m a)) -> MaybeT m a -> MaybeT m a -> MaybeT m a

(Eq k, Hashable k) => MonoZipWithKey (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v) -> Element (HashMap k v)) -> HashMap k v -> HashMap k v -> HashMap k v

MonoZipWithKey (r -> a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (r -> a) -> Element (r -> a) -> Element (r -> a) -> Element (r -> a)) -> (r -> a) -> (r -> a) -> r -> a

MonoZipWithKey (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (a, b) -> Element (a, b) -> Element (a, b) -> Element (a, b)) -> (a, b) -> (a, b) -> (a, b)

Arrow a => MonoZipWithKey (WrappedArrow a b c)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (WrappedArrow a b c) -> Element (WrappedArrow a b c) -> Element (WrappedArrow a b c) -> Element (WrappedArrow a b c)) -> WrappedArrow a b c -> WrappedArrow a b c -> WrappedArrow a b c

MonoZipWithKey (Const m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Const m a) -> Element (Const m a) -> Element (Const m a) -> Element (Const m a)) -> Const m a -> Const m a -> Const m a

Applicative m => MonoZipWithKey (IdentityT m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (IdentityT m a) -> Element (IdentityT m a) -> Element (IdentityT m a) -> Element (IdentityT m a)) -> IdentityT m a -> IdentityT m a -> IdentityT m a

(Applicative m, ZipWithKey m) => MonoZipWithKey (ReaderT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (ReaderT r m a) -> Element (ReaderT r m a) -> Element (ReaderT r m a) -> Element (ReaderT r m a)) -> ReaderT r m a -> ReaderT r m a -> ReaderT r m a

Applicative m => MonoZipWithKey (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a -> StateT s m a

Applicative m => MonoZipWithKey (StateT s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a) -> Element (StateT s m a)) -> StateT s m a -> StateT s m a -> StateT s m a

(Applicative m, Monoid w) => MonoZipWithKey (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a -> WriterT w m a

(Applicative m, Monoid w) => MonoZipWithKey (WriterT w m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a) -> Element (WriterT w m a)) -> WriterT w m a -> WriterT w m a -> WriterT w m a

(ZipWithKey f, ZipWithKey g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoZipWithKey (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Product f g a) -> Element (Product f g a) -> Element (Product f g a) -> Element (Product f g a)) -> Product f g a -> Product f g a -> Product f g a

Functor m => MonoZipWithKey (ContT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (ContT r m a) -> Element (ContT r m a) -> Element (ContT r m a) -> Element (ContT r m a)) -> ContT r m a -> ContT r m a -> ContT r m a

(ZipWithKey f, ZipWithKey g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoZipWithKey (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (Compose f g a) -> Element (Compose f g a) -> Element (Compose f g a) -> Element (Compose f g a)) -> Compose f g a -> Compose f g a -> Compose f g a

(Applicative m, Semigroup w) => MonoZipWithKey (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a -> RWST r w s m a

(Applicative m, Semigroup w) => MonoZipWithKey (RWST r w s m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

ozipWithKey :: (MonoKey (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a) -> Element (RWST r w s m a)) -> RWST r w s m a -> RWST r w s m a -> RWST r w s m a

Monomorphic Indexing / Querries

class MonoLookup mono => MonoIndexable mono where

Monomorphic container that can be indexed by a key for an element.

Minimal complete definition

oindex

Methods

oindex :: mono -> MonoKey mono -> Element mono

default oindex :: (Indexable f, Element (f a) ~ a, MonoKey (f a) ~ Key f, f a ~ mono) => mono -> MonoKey mono -> Element mono

Instances

MonoIndexable ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: ByteString -> MonoKey ByteString -> Element ByteString

MonoIndexable ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: ByteString -> MonoKey ByteString -> Element ByteString

MonoIndexable IntSet

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: IntSet -> MonoKey IntSet -> Element IntSet

MonoIndexable Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Text -> MonoKey Text -> Element Text

MonoIndexable Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Text -> MonoKey Text -> Element Text

MonoIndexable (ZipList a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: ZipList a -> MonoKey (ZipList a) -> Element (ZipList a)

MonoIndexable (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Identity a -> MonoKey (Identity a) -> Element (Identity a)

MonoIndexable (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: IntMap a -> MonoKey (IntMap a) -> Element (IntMap a)

MonoIndexable (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Seq a -> MonoKey (Seq a) -> Element (Seq a)

MonoIndexable (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: ViewL a -> MonoKey (ViewL a) -> Element (ViewL a)

MonoIndexable (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: ViewR a -> MonoKey (ViewR a) -> Element (ViewR a)

Ord a => MonoIndexable (Set a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Set a -> MonoKey (Set a) -> Element (Set a)

MonoIndexable (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Tree a -> MonoKey (Tree a) -> Element (Tree a)

MonoIndexable (HashSet v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: HashSet v -> MonoKey (HashSet v) -> Element (HashSet v)

MonoIndexable (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Vector a -> MonoKey (Vector a) -> Element (Vector a)

Storable a => MonoIndexable (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Vector a -> MonoKey (Vector a) -> Element (Vector a)

Unbox a => MonoIndexable (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Vector a -> MonoKey (Vector a) -> Element (Vector a)

MonoIndexable (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: NonEmpty a -> MonoKey (NonEmpty a) -> Element (NonEmpty a)

MonoIndexable (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Maybe a -> MonoKey (Maybe a) -> Element (Maybe a)

MonoIndexable [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: [a] -> MonoKey [a] -> Element [a]

MonoIndexable (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Either a b -> MonoKey (Either a b) -> Element (Either a b)

MonoIndexable (Arg a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Arg a b -> MonoKey (Arg a b) -> Element (Arg a b)

Ord k => MonoIndexable (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Map k v -> MonoKey (Map k v) -> Element (Map k v)

(Eq k, Hashable k) => MonoIndexable (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: HashMap k v -> MonoKey (HashMap k v) -> Element (HashMap k v)

MonoIndexable (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: (a, b) -> MonoKey (a, b) -> Element (a, b)

Indexable m => MonoIndexable (ReaderT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: ReaderT r m a -> MonoKey (ReaderT r m a) -> Element (ReaderT r m a)

(Indexable f, Indexable g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoIndexable (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Product f g a -> MonoKey (Product f g a) -> Element (Product f g a)

(Indexable f, Indexable g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoIndexable (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

oindex :: Compose f g a -> MonoKey (Compose f g a) -> Element (Compose f g a)

class MonoLookup mono where

Monomorphic container that can be querried by a key for an element.

Minimal complete definition

olookup

Methods

olookup :: MonoKey mono -> mono -> Maybe (Element mono)

default olookup :: (Lookup f, Element (f a) ~ a, MonoKey (f a) ~ Key f, f a ~ mono) => MonoKey mono -> mono -> Maybe (Element mono)

Instances

MonoLookup ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey ByteString -> ByteString -> Maybe (Element ByteString)

MonoLookup ByteString

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey ByteString -> ByteString -> Maybe (Element ByteString)

MonoLookup IntSet

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey IntSet -> IntSet -> Maybe (Element IntSet)

MonoLookup Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey Text -> Text -> Maybe (Element Text)

MonoLookup Text

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey Text -> Text -> Maybe (Element Text)

MonoLookup (ZipList a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (ZipList a) -> ZipList a -> Maybe (Element (ZipList a))

MonoLookup (Identity a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Identity a) -> Identity a -> Maybe (Element (Identity a))

MonoLookup (IntMap a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (IntMap a) -> IntMap a -> Maybe (Element (IntMap a))

MonoLookup (Seq a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Seq a) -> Seq a -> Maybe (Element (Seq a))

MonoLookup (ViewL a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (ViewL a) -> ViewL a -> Maybe (Element (ViewL a))

MonoLookup (ViewR a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (ViewR a) -> ViewR a -> Maybe (Element (ViewR a))

Ord a => MonoLookup (Set a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Set a) -> Set a -> Maybe (Element (Set a))

MonoLookup (Tree a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Tree a) -> Tree a -> Maybe (Element (Tree a))

MonoLookup (HashSet v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (HashSet v) -> HashSet v -> Maybe (Element (HashSet v))

MonoLookup (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Vector a) -> Vector a -> Maybe (Element (Vector a))

Storable a => MonoLookup (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Vector a) -> Vector a -> Maybe (Element (Vector a))

Unbox a => MonoLookup (Vector a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Vector a) -> Vector a -> Maybe (Element (Vector a))

MonoLookup (NonEmpty a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (NonEmpty a) -> NonEmpty a -> Maybe (Element (NonEmpty a))

MonoLookup (Maybe a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Maybe a) -> Maybe a -> Maybe (Element (Maybe a))

MonoLookup [a]

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey [a] -> [a] -> Maybe (Element [a])

MonoLookup (Either a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Either a b) -> Either a b -> Maybe (Element (Either a b))

MonoLookup (Arg a b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Arg a b) -> Arg a b -> Maybe (Element (Arg a b))

Ord k => MonoLookup (Map k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Map k v) -> Map k v -> Maybe (Element (Map k v))

(Eq k, Hashable k) => MonoLookup (HashMap k v)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (HashMap k v) -> HashMap k v -> Maybe (Element (HashMap k v))

MonoLookup (a, b)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (a, b) -> (a, b) -> Maybe (Element (a, b))

Lookup m => MonoLookup (ReaderT r m a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (ReaderT r m a) -> ReaderT r m a -> Maybe (Element (ReaderT r m a))

(Lookup f, Lookup g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoLookup (Product f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Product f g a) -> Product f g a -> Maybe (Element (Product f g a))

(Lookup f, Lookup g, MonoKey (f a) ~ Key f, MonoKey (g a) ~ Key g) => MonoLookup (Compose f g a)

Since: 0.1.0

Defined in Data.MonoTraversable.Keys

Methods

olookup :: MonoKey (Compose f g a) -> Compose f g a -> Maybe (Element (Compose f g a))

Monomorphic unwrapping with key

ofoldlWithKeyUnwrap :: MonoFoldableWithKey mono => (x -> Element mono -> x) -> x -> (x -> b) -> mono -> b

A strict left fold, together with an unwrap function.

This is convenient when the accumulator value is not the same as the final expected type. It is provided mainly for integration with the foldl package, to be used in conjunction with purely.

Since: 0.1.0

ofoldWithKeyMUnwrap :: (Monad m, MonoFoldableWithKey mono) => (x -> Element mono -> m x) -> m x -> (x -> m b) -> mono -> m b

A monadic strict left fold, together with an unwrap function.

Similar to foldlUnwrap, but allows monadic actions. To be used with impurely from foldl.

Since: 0.1.0