Control.Class.Impl.Map

If you just want to perform operations on maps, not write your own instances, Control.Class.Map is probably what you should be importing.

This package provides a number of type-classes that encapulate the idea of a key/value mapping. This includes your standard maps, but also arrays and potentially hashtables. This library only currently provide instances for types in package that are distributed with GHC.

Part of the motivation of this library is also consistency.

Pop quiz: Consider the insert, but don't check the documentation. If the key already exists in the map, which of the following occurs?

1. The map is unchanged.
2. The value at that key is updated.
3. error is called.
4. The result is undefined.

Personally, I had to check the documentation. The answer is actually option "2".

Imagine the potential minefield when changing collection types.

The classes in this library give explicit names for each of these behaviours, and if the implementers of those instances follow those specifications, users should be able to switch between different container types without changing their code nor their code's behaviour.

The naming convention and argument order is somewhat arbitary.

I've tried to follow existing convention but the existing convention is a bit mixed up.

For example insert for maps is actually called upsert in this library because that's what it actually does.

In anycase, I'll attempt to define the broad naming convention here, but there are further details in each class.

There's a number of prefixes to function which affect expected behaviour.

1. The unprefixed functions should call error if something is unexpected, e.g. a key already exists on insert or a key is not in collection on delete. They must not just return the structure unchanged, that is the role of maybe prefixed functions.
2. The "unsafe" prefixed functions may optionally just behave in an undefined fashion in the above case where one would instead error. For example, unsafe functions may do array lookups without bounds checking, potentially resulting in demons if they access memory they shouldn't.
3. The "maybe" prefixed functions shall not call error if the operation can not be completed but instead return the structure unchanged.
4. The "safe" prefixed functions actually have a Maybe return type which indicate whether the key is not found/already exists on insert.

Functions suffixed with Lookup actually have a different return type and generally allow one to access the contents of the structure before the change, the exact form depending on the function in particular. The reason for the Lookup suffix is that to implement these naively one can do a lookup before performing the operation. However, for example with deleteLookup on a map, it would be more efficient to just lookup the element to delete, grab it and delete it at the same time, so there is a point in overriding the default implementation.

Finally, you may notice some of the class functions that ordinarily accept a Functor, are renamed ending with a ..F_, and now have the Functor wrapped in a Coyoneda. This is because having Functors in class function defintions does not work with generalised newtype deriving.

The versions of the functions without the following underscores, i.e. ..F are what users should be using. When defining your own instances for these functions, it's probably best just apply 'toCoyonedaTransform'/'toCoyonedaTransformF' to their ordinary definitions. The non underscore style defintions run 'fromCoyonedaTransform'/'fromCoyonedaTransformF' on the class functions. Ideally rewrite rules included in these modules should reduce this pair of functions to id resulting in no runtime difference.

Regarding trailing F on the latter 'toCoyonedaTransform'/'toCoyonedaTransformF' function, use that when defining such Coyondea class functions which have return types wrapped in Maybe, namely the ones prefixed with safe....

To Do: Monadic versions of these functions, to be used on mutable structures for example.

Also To Do: Range lookups (and perhaps even range deletes?). In theory, for say maps, range lookups are not only possible but also faster than accessing the keys individually. But they've impossible for say hashmaps.

Pull requests welcome on github.

Documentation

type family Key t

Instances

type Key ShortByteString

type Key ShortByteString = Int

type Key ByteString

type Key ByteString = Int64

type Key ByteString

type Key ByteString = Int

type Key IntSet

type Key IntSet = Int

type Key (IntMap v)

type Key (IntMap v) = Int

type Key (Seq a)

type Key (Seq a) = Int

type Key (Set a)

type Key (Set a) = a

type Key (Lazy t)

type Key (Lazy t) = Key t

type Key (Lazy t)

type Key (Lazy t) = Key t

type Key (Strict t)

type Key (Strict t) = Key t

type Key (Array i e)

type Key (Array i e) = i

type Key (Map k _)

type Key (Map k _) = k

type family Value t

Instances

type Value ShortByteString

type Value ShortByteString = Word8

type Value ByteString

type Value ByteString = Word8

type Value ByteString

type Value ByteString = Word8

type Value IntSet

type Value IntSet = ()

type Value (IntMap v)

type Value (IntMap v) = v

type Value (Seq a)

type Value (Seq a) = a

type Value (Set a)

type Value (Set a) = ()

type Value (Lazy t)

type Value (Lazy t) = Value t

type Value (Lazy t)

type Value (Lazy t) = Value t

type Value (Strict t)

type Value (Strict t) = Value t

type Value (Array i e)

type Value (Array i e) = e

type Value (Map _ v)

type Value (Map _ v) = v

class LookupMap t where

LookupMap is a class that simply represents data types indexable by a key that you can read from. Whilst obviously not enforced by the class, it's intended that this only be implemented for types with "fast" lookups, say O(log n) at most.

Hence, LookupMap is not implemented for list for example.

Not that Set is an instance of this type, where the keys are just the set values and the unit type '()' is the "value" type.

You could in theory implement LookupMap (and indeed associated classes like UpdateMap and AlterMap) for structures with multiple keys, by making the key type a sum type or a list or something.

Minimal complete definition

lookup | (unsafeIndex | index), member

Methods

lookup :: Key t -> t -> Maybe (Value t)

lookup k x returns Just v if k is a key, Nothing otherwise

index :: Key t -> t -> Value t

Like lookup but throws an error for values that don't exist

unsafeIndex :: Key t -> t -> Value t

Like index but may be undefined for keys that don't exist

member :: Key t -> t -> Bool

notMember :: Key t -> t -> Bool

Instances

LookupMap ShortByteString

Methods

lookup :: Key ShortByteString -> ShortByteString -> Maybe (Value ShortByteString)

index :: Key ShortByteString -> ShortByteString -> Value ShortByteString

unsafeIndex :: Key ShortByteString -> ShortByteString -> Value ShortByteString

member :: Key ShortByteString -> ShortByteString -> Bool

notMember :: Key ShortByteString -> ShortByteString -> Bool

LookupMap ByteString

Methods

lookup :: Key ByteString -> ByteString -> Maybe (Value ByteString)

index :: Key ByteString -> ByteString -> Value ByteString

unsafeIndex :: Key ByteString -> ByteString -> Value ByteString

member :: Key ByteString -> ByteString -> Bool

notMember :: Key ByteString -> ByteString -> Bool

LookupMap ByteString

Methods

lookup :: Key ByteString -> ByteString -> Maybe (Value ByteString)

index :: Key ByteString -> ByteString -> Value ByteString

unsafeIndex :: Key ByteString -> ByteString -> Value ByteString

member :: Key ByteString -> ByteString -> Bool

notMember :: Key ByteString -> ByteString -> Bool

LookupMap IntSet

Methods

lookup :: Key IntSet -> IntSet -> Maybe (Value IntSet)

index :: Key IntSet -> IntSet -> Value IntSet

unsafeIndex :: Key IntSet -> IntSet -> Value IntSet

member :: Key IntSet -> IntSet -> Bool

notMember :: Key IntSet -> IntSet -> Bool

LookupMap (IntMap v)

Methods

lookup :: Key (IntMap v) -> IntMap v -> Maybe (Value (IntMap v))

index :: Key (IntMap v) -> IntMap v -> Value (IntMap v)

unsafeIndex :: Key (IntMap v) -> IntMap v -> Value (IntMap v)

member :: Key (IntMap v) -> IntMap v -> Bool

notMember :: Key (IntMap v) -> IntMap v -> Bool

LookupMap (Seq a)

Methods

lookup :: Key (Seq a) -> Seq a -> Maybe (Value (Seq a))

index :: Key (Seq a) -> Seq a -> Value (Seq a)

unsafeIndex :: Key (Seq a) -> Seq a -> Value (Seq a)

member :: Key (Seq a) -> Seq a -> Bool

notMember :: Key (Seq a) -> Seq a -> Bool

Ord a => LookupMap (Set a)

Methods

lookup :: Key (Set a) -> Set a -> Maybe (Value (Set a))

index :: Key (Set a) -> Set a -> Value (Set a)

unsafeIndex :: Key (Set a) -> Set a -> Value (Set a)

member :: Key (Set a) -> Set a -> Bool

notMember :: Key (Set a) -> Set a -> Bool

(IsLazyMap t, LookupMap t) => LookupMap (Lazy t)

Methods

lookup :: Key (Lazy t) -> Lazy t -> Maybe (Value (Lazy t))

index :: Key (Lazy t) -> Lazy t -> Value (Lazy t)

unsafeIndex :: Key (Lazy t) -> Lazy t -> Value (Lazy t)

member :: Key (Lazy t) -> Lazy t -> Bool

notMember :: Key (Lazy t) -> Lazy t -> Bool

LookupMap (Lazy (IntMap v))

Methods

lookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Value (Lazy (IntMap v)))

index :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Value (Lazy (IntMap v))

unsafeIndex :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Value (Lazy (IntMap v))

member :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Bool

notMember :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Bool

Ord k => LookupMap (Lazy (Map k v))

Methods

lookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Value (Lazy (Map k v)))

index :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Value (Lazy (Map k v))

unsafeIndex :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Value (Lazy (Map k v))

member :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Bool

notMember :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Bool

(IsStrictMap t, LookupMap t) => LookupMap (Strict t)

Methods

lookup :: Key (Strict t) -> Strict t -> Maybe (Value (Strict t))

index :: Key (Strict t) -> Strict t -> Value (Strict t)

unsafeIndex :: Key (Strict t) -> Strict t -> Value (Strict t)

member :: Key (Strict t) -> Strict t -> Bool

notMember :: Key (Strict t) -> Strict t -> Bool

Ix i => LookupMap (Array i e)

Methods

lookup :: Key (Array i e) -> Array i e -> Maybe (Value (Array i e))

index :: Key (Array i e) -> Array i e -> Value (Array i e)

unsafeIndex :: Key (Array i e) -> Array i e -> Value (Array i e)

member :: Key (Array i e) -> Array i e -> Bool

notMember :: Key (Array i e) -> Array i e -> Bool

Ord k => LookupMap (Map k v)

Methods

lookup :: Key (Map k v) -> Map k v -> Maybe (Value (Map k v))

index :: Key (Map k v) -> Map k v -> Value (Map k v)

unsafeIndex :: Key (Map k v) -> Map k v -> Value (Map k v)

member :: Key (Map k v) -> Map k v -> Bool

notMember :: Key (Map k v) -> Map k v -> Bool

class LookupMap t => SingletonMap t where

Data types you can produce a one element container of.

The reason why this is a separate class instead of just the default instance is that there are contrainers where one can trivially make a singleton of but they're not Monoids or AlterMaps, i.e. you can't append or add elements to them at arbitary keys.

For example, arrays certainly don't have the concept of "insert at key", only update, nor is it obvious how to append them, particularly if their ranges overlap.

But given a key, one should be able to produce a singleton array.

Hence this class.

Minimal complete definition

singleton

Methods

singleton :: Key t -> Value t -> t

Instances

SingletonMap IntSet

Methods

singleton :: Key IntSet -> Value IntSet -> IntSet

SingletonMap (IntMap v)

Methods

singleton :: Key (IntMap v) -> Value (IntMap v) -> IntMap v

Ord a => SingletonMap (Set a)

Methods

singleton :: Key (Set a) -> Value (Set a) -> Set a

SingletonMap (Lazy (IntMap v))

Methods

singleton :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v)

Ord k => SingletonMap (Lazy (Map k v))

Methods

singleton :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v)

Ix i => SingletonMap (Array i e)

Methods

singleton :: Key (Array i e) -> Value (Array i e) -> Array i e

Ord k => SingletonMap (Map k v)

Methods

singleton :: Key (Map k v) -> Value (Map k v) -> Map k v

class LookupMap t => InsertMap t where

InsertMap represents types where new key-values pairs can be inserted.

Minimal complete definition

unsafeInsert | insert | safeInsert

Methods

insert :: Key t -> Value t -> t -> t

Attempts to insert a value, calls error if the key already exists.

unsafeInsert :: Key t -> Value t -> t -> t

Like insert, but if the key already exists the behaviour is undefined.

maybeInsert :: Key t -> Value t -> t -> t

Like insert, but if the key already exists return the structure unchanged.

safeInsert :: Key t -> Value t -> t -> Maybe t

Like insert, but if the key already exists return Nothing.

safeInsert :: UpsertMap t => Key t -> Value t -> t -> Maybe t

Like insert, but if the key already exists return Nothing.

Instances

InsertMap IntSet

Methods

insert :: Key IntSet -> Value IntSet -> IntSet -> IntSet

unsafeInsert :: Key IntSet -> Value IntSet -> IntSet -> IntSet

maybeInsert :: Key IntSet -> Value IntSet -> IntSet -> IntSet

safeInsert :: Key IntSet -> Value IntSet -> IntSet -> Maybe IntSet

InsertMap (IntMap v)

Methods

insert :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

unsafeInsert :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

maybeInsert :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

safeInsert :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> Maybe (IntMap v)

Ord a => InsertMap (Set a)

Methods

insert :: Key (Set a) -> Value (Set a) -> Set a -> Set a

unsafeInsert :: Key (Set a) -> Value (Set a) -> Set a -> Set a

maybeInsert :: Key (Set a) -> Value (Set a) -> Set a -> Set a

safeInsert :: Key (Set a) -> Value (Set a) -> Set a -> Maybe (Set a)

(IsLazyMap t, InsertMap t) => InsertMap (Lazy t)

Methods

insert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

unsafeInsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

maybeInsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

safeInsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Maybe (Lazy t)

InsertMap (Lazy (IntMap v))

Methods

insert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeInsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

maybeInsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeInsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

Ord k => InsertMap (Lazy (Map k v))

Methods

insert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeInsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

maybeInsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeInsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

(IsStrictMap t, InsertMap t) => InsertMap (Strict t)

Methods

insert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

unsafeInsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

maybeInsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

safeInsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Maybe (Strict t)

Ord k => InsertMap (Map k v)

Methods

insert :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

unsafeInsert :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

maybeInsert :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

safeInsert :: Key (Map k v) -> Value (Map k v) -> Map k v -> Maybe (Map k v)

class LookupMap t => UpdateMap t where

UpdateMap represents types where existing values can be updated.

The ability for keys to be inserted or deleted is optional.

A good example of a type which conforms to this is Seq, which has Int keys of which their values can be updated in "O(log n)" time.

However Seq is not an instance of AlterMap as although one can insert/delete from Seq it alters all the other indexes which would be very unexpected.

Minimal complete definition

unsafeUpdate | update | safeUpdate | safeUpdateLookup | safeAdjustLookup | safeAdjustLookup | safeAdjustF_

Methods

update :: Key t -> Value t -> t -> t

Updates the value of a key, calls error if the key does not exist.

updateLookup :: Key t -> Value t -> t -> (Value t, t)

unsafeUpdate :: Key t -> Value t -> t -> t

Like update, but if the key does not exist the result is undefined.

unsafeUpdateLookup :: Key t -> Value t -> t -> (Value t, t)

maybeUpdate :: Key t -> Value t -> t -> t

safeUpdate :: Key t -> Value t -> t -> Maybe t

safeUpdateLookup :: Key t -> Value t -> t -> Maybe (Value t, t)

adjust :: (Value t -> Value t) -> Key t -> t -> t

adjust f k x applies f to the value at key k and puts that modified value in it's place.

If the key does not exist it should throw an error.

adjustLookup :: (Value t -> (r, Value t)) -> Key t -> t -> (r, t)

adjustF_ :: Functor f => (Value t -> Coyoneda f (Value t)) -> Key t -> t -> Coyoneda f t

unsafeAdjust :: (Value t -> Value t) -> Key t -> t -> t

unsafeAdjustLookup :: (Value t -> (r, Value t)) -> Key t -> t -> (r, t)

unsafeAdjustF_ :: Functor f => (Value t -> Coyoneda f (Value t)) -> Key t -> t -> Coyoneda f t

maybeAdjust :: (Value t -> Value t) -> Key t -> t -> t

safeAdjust :: (Value t -> Value t) -> Key t -> t -> Maybe t

safeAdjustLookup :: (Value t -> (r, Value t)) -> Key t -> t -> Maybe (r, t)

safeAdjustF_ :: Functor f => (Value t -> Coyoneda f (Value t)) -> Key t -> t -> Maybe (Coyoneda f t)

safeAdjustF_ :: (UpsertMap t, Functor f) => (Value t -> Coyoneda f (Value t)) -> Key t -> t -> Maybe (Coyoneda f t)

Instances

UpdateMap IntSet

Methods

update :: Key IntSet -> Value IntSet -> IntSet -> IntSet

updateLookup :: Key IntSet -> Value IntSet -> IntSet -> (Value IntSet, IntSet)

unsafeUpdate :: Key IntSet -> Value IntSet -> IntSet -> IntSet

unsafeUpdateLookup :: Key IntSet -> Value IntSet -> IntSet -> (Value IntSet, IntSet)

maybeUpdate :: Key IntSet -> Value IntSet -> IntSet -> IntSet

safeUpdate :: Key IntSet -> Value IntSet -> IntSet -> Maybe IntSet

safeUpdateLookup :: Key IntSet -> Value IntSet -> IntSet -> Maybe (Value IntSet, IntSet)

adjust :: (Value IntSet -> Value IntSet) -> Key IntSet -> IntSet -> IntSet

adjustLookup :: (Value IntSet -> (r, Value IntSet)) -> Key IntSet -> IntSet -> (r, IntSet)

adjustF_ :: Functor f => (Value IntSet -> Coyoneda f (Value IntSet)) -> Key IntSet -> IntSet -> Coyoneda f IntSet

unsafeAdjust :: (Value IntSet -> Value IntSet) -> Key IntSet -> IntSet -> IntSet

unsafeAdjustLookup :: (Value IntSet -> (r, Value IntSet)) -> Key IntSet -> IntSet -> (r, IntSet)

unsafeAdjustF_ :: Functor f => (Value IntSet -> Coyoneda f (Value IntSet)) -> Key IntSet -> IntSet -> Coyoneda f IntSet

maybeAdjust :: (Value IntSet -> Value IntSet) -> Key IntSet -> IntSet -> IntSet

safeAdjust :: (Value IntSet -> Value IntSet) -> Key IntSet -> IntSet -> Maybe IntSet

safeAdjustLookup :: (Value IntSet -> (r, Value IntSet)) -> Key IntSet -> IntSet -> Maybe (r, IntSet)

safeAdjustF_ :: Functor f => (Value IntSet -> Coyoneda f (Value IntSet)) -> Key IntSet -> IntSet -> Maybe (Coyoneda f IntSet)

UpdateMap (IntMap v)

Methods

update :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

updateLookup :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> (Value (IntMap v), IntMap v)

unsafeUpdate :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

unsafeUpdateLookup :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> (Value (IntMap v), IntMap v)

maybeUpdate :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

safeUpdate :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> Maybe (IntMap v)

safeUpdateLookup :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> Maybe (Value (IntMap v), IntMap v)

adjust :: (Value (IntMap v) -> Value (IntMap v)) -> Key (IntMap v) -> IntMap v -> IntMap v

adjustLookup :: (Value (IntMap v) -> (r, Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

adjustF_ :: Functor f => (Value (IntMap v) -> Coyoneda f (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

unsafeAdjust :: (Value (IntMap v) -> Value (IntMap v)) -> Key (IntMap v) -> IntMap v -> IntMap v

unsafeAdjustLookup :: (Value (IntMap v) -> (r, Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

unsafeAdjustF_ :: Functor f => (Value (IntMap v) -> Coyoneda f (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

maybeAdjust :: (Value (IntMap v) -> Value (IntMap v)) -> Key (IntMap v) -> IntMap v -> IntMap v

safeAdjust :: (Value (IntMap v) -> Value (IntMap v)) -> Key (IntMap v) -> IntMap v -> Maybe (IntMap v)

safeAdjustLookup :: (Value (IntMap v) -> (r, Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> Maybe (r, IntMap v)

safeAdjustF_ :: Functor f => (Value (IntMap v) -> Coyoneda f (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> Maybe (Coyoneda f (IntMap v))

UpdateMap (Seq a)

Methods

update :: Key (Seq a) -> Value (Seq a) -> Seq a -> Seq a

updateLookup :: Key (Seq a) -> Value (Seq a) -> Seq a -> (Value (Seq a), Seq a)

unsafeUpdate :: Key (Seq a) -> Value (Seq a) -> Seq a -> Seq a

unsafeUpdateLookup :: Key (Seq a) -> Value (Seq a) -> Seq a -> (Value (Seq a), Seq a)

maybeUpdate :: Key (Seq a) -> Value (Seq a) -> Seq a -> Seq a

safeUpdate :: Key (Seq a) -> Value (Seq a) -> Seq a -> Maybe (Seq a)

safeUpdateLookup :: Key (Seq a) -> Value (Seq a) -> Seq a -> Maybe (Value (Seq a), Seq a)

adjust :: (Value (Seq a) -> Value (Seq a)) -> Key (Seq a) -> Seq a -> Seq a

adjustLookup :: (Value (Seq a) -> (r, Value (Seq a))) -> Key (Seq a) -> Seq a -> (r, Seq a)

adjustF_ :: Functor f => (Value (Seq a) -> Coyoneda f (Value (Seq a))) -> Key (Seq a) -> Seq a -> Coyoneda f (Seq a)

unsafeAdjust :: (Value (Seq a) -> Value (Seq a)) -> Key (Seq a) -> Seq a -> Seq a

unsafeAdjustLookup :: (Value (Seq a) -> (r, Value (Seq a))) -> Key (Seq a) -> Seq a -> (r, Seq a)

unsafeAdjustF_ :: Functor f => (Value (Seq a) -> Coyoneda f (Value (Seq a))) -> Key (Seq a) -> Seq a -> Coyoneda f (Seq a)

maybeAdjust :: (Value (Seq a) -> Value (Seq a)) -> Key (Seq a) -> Seq a -> Seq a

safeAdjust :: (Value (Seq a) -> Value (Seq a)) -> Key (Seq a) -> Seq a -> Maybe (Seq a)

safeAdjustLookup :: (Value (Seq a) -> (r, Value (Seq a))) -> Key (Seq a) -> Seq a -> Maybe (r, Seq a)

safeAdjustF_ :: Functor f => (Value (Seq a) -> Coyoneda f (Value (Seq a))) -> Key (Seq a) -> Seq a -> Maybe (Coyoneda f (Seq a))

Ord a => UpdateMap (Set a)

Methods

update :: Key (Set a) -> Value (Set a) -> Set a -> Set a

updateLookup :: Key (Set a) -> Value (Set a) -> Set a -> (Value (Set a), Set a)

unsafeUpdate :: Key (Set a) -> Value (Set a) -> Set a -> Set a

unsafeUpdateLookup :: Key (Set a) -> Value (Set a) -> Set a -> (Value (Set a), Set a)

maybeUpdate :: Key (Set a) -> Value (Set a) -> Set a -> Set a

safeUpdate :: Key (Set a) -> Value (Set a) -> Set a -> Maybe (Set a)

safeUpdateLookup :: Key (Set a) -> Value (Set a) -> Set a -> Maybe (Value (Set a), Set a)

adjust :: (Value (Set a) -> Value (Set a)) -> Key (Set a) -> Set a -> Set a

adjustLookup :: (Value (Set a) -> (r, Value (Set a))) -> Key (Set a) -> Set a -> (r, Set a)

adjustF_ :: Functor f => (Value (Set a) -> Coyoneda f (Value (Set a))) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

unsafeAdjust :: (Value (Set a) -> Value (Set a)) -> Key (Set a) -> Set a -> Set a

unsafeAdjustLookup :: (Value (Set a) -> (r, Value (Set a))) -> Key (Set a) -> Set a -> (r, Set a)

unsafeAdjustF_ :: Functor f => (Value (Set a) -> Coyoneda f (Value (Set a))) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

maybeAdjust :: (Value (Set a) -> Value (Set a)) -> Key (Set a) -> Set a -> Set a

safeAdjust :: (Value (Set a) -> Value (Set a)) -> Key (Set a) -> Set a -> Maybe (Set a)

safeAdjustLookup :: (Value (Set a) -> (r, Value (Set a))) -> Key (Set a) -> Set a -> Maybe (r, Set a)

safeAdjustF_ :: Functor f => (Value (Set a) -> Coyoneda f (Value (Set a))) -> Key (Set a) -> Set a -> Maybe (Coyoneda f (Set a))

(IsLazyMap t, UpdateMap t) => UpdateMap (Lazy t)

Methods

update :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

updateLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

unsafeUpdate :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

unsafeUpdateLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

maybeUpdate :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

safeUpdate :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeUpdateLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Maybe (Value (Lazy t), Lazy t)

adjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

adjustLookup :: (Value (Lazy t) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

adjustF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

unsafeAdjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

unsafeAdjustLookup :: (Value (Lazy t) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

unsafeAdjustF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

maybeAdjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

safeAdjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeAdjustLookup :: (Value (Lazy t) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Maybe (r, Lazy t)

safeAdjustF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Maybe (Coyoneda f (Lazy t))

UpdateMap (Lazy (IntMap v))

Methods

update :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

updateLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

unsafeUpdate :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeUpdateLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

maybeUpdate :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeUpdate :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeUpdateLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Value (Lazy (IntMap v)), Lazy (IntMap v))

adjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

adjustLookup :: (Value (Lazy (IntMap v)) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

adjustF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

unsafeAdjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeAdjustLookup :: (Value (Lazy (IntMap v)) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

unsafeAdjustF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

maybeAdjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeAdjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeAdjustLookup :: (Value (Lazy (IntMap v)) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (r, Lazy (IntMap v))

safeAdjustF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Coyoneda f (Lazy (IntMap v)))

Ord k => UpdateMap (Lazy (Map k v))

Methods

update :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

updateLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

unsafeUpdate :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeUpdateLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

maybeUpdate :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeUpdate :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeUpdateLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Value (Lazy (Map k v)), Lazy (Map k v))

adjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

adjustLookup :: (Value (Lazy (Map k v)) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

adjustF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

unsafeAdjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeAdjustLookup :: (Value (Lazy (Map k v)) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

unsafeAdjustF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

maybeAdjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeAdjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeAdjustLookup :: (Value (Lazy (Map k v)) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (r, Lazy (Map k v))

safeAdjustF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Coyoneda f (Lazy (Map k v)))

(IsStrictMap t, UpdateMap t) => UpdateMap (Strict t)

Methods

update :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

updateLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> (Value (Strict t), Strict t)

unsafeUpdate :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

unsafeUpdateLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> (Value (Strict t), Strict t)

maybeUpdate :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

safeUpdate :: Key (Strict t) -> Value (Strict t) -> Strict t -> Maybe (Strict t)

safeUpdateLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> Maybe (Value (Strict t), Strict t)

adjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

adjustLookup :: (Value (Strict t) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> (r, Strict t)

adjustF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

unsafeAdjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

unsafeAdjustLookup :: (Value (Strict t) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> (r, Strict t)

unsafeAdjustF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

maybeAdjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

safeAdjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Maybe (Strict t)

safeAdjustLookup :: (Value (Strict t) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> Maybe (r, Strict t)

safeAdjustF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Maybe (Coyoneda f (Strict t))

Ord k => UpdateMap (Map k v)

Methods

update :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

updateLookup :: Key (Map k v) -> Value (Map k v) -> Map k v -> (Value (Map k v), Map k v)

unsafeUpdate :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

unsafeUpdateLookup :: Key (Map k v) -> Value (Map k v) -> Map k v -> (Value (Map k v), Map k v)

maybeUpdate :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

safeUpdate :: Key (Map k v) -> Value (Map k v) -> Map k v -> Maybe (Map k v)

safeUpdateLookup :: Key (Map k v) -> Value (Map k v) -> Map k v -> Maybe (Value (Map k v), Map k v)

adjust :: (Value (Map k v) -> Value (Map k v)) -> Key (Map k v) -> Map k v -> Map k v

adjustLookup :: (Value (Map k v) -> (r, Value (Map k v))) -> Key (Map k v) -> Map k v -> (r, Map k v)

adjustF_ :: Functor f => (Value (Map k v) -> Coyoneda f (Value (Map k v))) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

unsafeAdjust :: (Value (Map k v) -> Value (Map k v)) -> Key (Map k v) -> Map k v -> Map k v

unsafeAdjustLookup :: (Value (Map k v) -> (r, Value (Map k v))) -> Key (Map k v) -> Map k v -> (r, Map k v)

unsafeAdjustF_ :: Functor f => (Value (Map k v) -> Coyoneda f (Value (Map k v))) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

maybeAdjust :: (Value (Map k v) -> Value (Map k v)) -> Key (Map k v) -> Map k v -> Map k v

safeAdjust :: (Value (Map k v) -> Value (Map k v)) -> Key (Map k v) -> Map k v -> Maybe (Map k v)

safeAdjustLookup :: (Value (Map k v) -> (r, Value (Map k v))) -> Key (Map k v) -> Map k v -> Maybe (r, Map k v)

safeAdjustF_ :: Functor f => (Value (Map k v) -> Coyoneda f (Value (Map k v))) -> Key (Map k v) -> Map k v -> Maybe (Coyoneda f (Map k v))

adjustF :: (UpdateMap t, Functor f) => (Value t -> f (Value t)) -> Key t -> t -> f t

unsafeAdjustF :: (UpdateMap t, Functor f) => (Value t -> f (Value t)) -> Key t -> t -> f t

safeAdjustF :: (UpdateMap t, Functor f) => (Value t -> f (Value t)) -> Key t -> t -> Maybe (f t)

class LookupMap t => DeleteMap t where

DeleteMap represents types where keys can be deleted.

Minimal complete definition

unsafeDelete | delete | safeDelete | safeDeleteLookup

Methods

delete :: Key t -> t -> t

Attempt to delete a key and call error if it's not found.

deleteLookup :: Key t -> t -> (Value t, t)

Like delete, but also return the value at the key before deletion.

unsafeDelete :: Key t -> t -> t

Like delete but if the key isn't found the result is undefined

unsafeDeleteLookup :: Key t -> t -> (Value t, t)

Like deleteLookup but if the key isn't found the result is undefined

maybeDelete :: Key t -> t -> t

Like delete, but return the structure unmodified if the key does not exist.

safeDelete :: Key t -> t -> Maybe t

Like delete, but return Nothing the key does not exist.

safeDeleteLookup :: Key t -> t -> Maybe (Value t, t)

Like safeDelete, but also return the value of the key before the delete.

optDelete :: (Value t -> Bool) -> Key t -> t -> t

Attempt to optDelete a key based on it's value and call error if it's not found.

optDeleteLookup :: (Value t -> (r, Bool)) -> Key t -> t -> (r, t)

Like optDelete, but also return the value at the key before deletion.

optDeleteF_ :: Functor f => (Value t -> Coyoneda f Bool) -> Key t -> t -> Coyoneda f t

unsafeOptDelete :: (Value t -> Bool) -> Key t -> t -> t

Like optDelete but if the key isn't found the result is undefined

unsafeOptDeleteLookup :: (Value t -> (r, Bool)) -> Key t -> t -> (r, t)

Like optDeleteLookup but if the key isn't found the result is undefined

unsafeOptDeleteF_ :: Functor f => (Value t -> Coyoneda f Bool) -> Key t -> t -> Coyoneda f t

maybeOptDelete :: (Value t -> Bool) -> Key t -> t -> t

Like optDelete, but return the structure unmodified if the key does not exist.

safeOptDelete :: (Value t -> Bool) -> Key t -> t -> Maybe t

Like optDelete, but return Nothing the key does not exist.

safeOptDeleteLookup :: (Value t -> (r, Bool)) -> Key t -> t -> Maybe (r, t)

Like safeOptDelete, but also return the value of the key before the optDelete.

safeOptDeleteF_ :: Functor f => (Value t -> Coyoneda f Bool) -> Key t -> t -> Maybe (Coyoneda f t)

safeOptDeleteF_ :: (UpleteMap t, Functor f) => (Value t -> Coyoneda f Bool) -> Key t -> t -> Maybe (Coyoneda f t)

Instances

DeleteMap IntSet

Methods

delete :: Key IntSet -> IntSet -> IntSet

deleteLookup :: Key IntSet -> IntSet -> (Value IntSet, IntSet)

unsafeDelete :: Key IntSet -> IntSet -> IntSet

unsafeDeleteLookup :: Key IntSet -> IntSet -> (Value IntSet, IntSet)

maybeDelete :: Key IntSet -> IntSet -> IntSet

safeDelete :: Key IntSet -> IntSet -> Maybe IntSet

safeDeleteLookup :: Key IntSet -> IntSet -> Maybe (Value IntSet, IntSet)

optDelete :: (Value IntSet -> Bool) -> Key IntSet -> IntSet -> IntSet

optDeleteLookup :: (Value IntSet -> (r, Bool)) -> Key IntSet -> IntSet -> (r, IntSet)

optDeleteF_ :: Functor f => (Value IntSet -> Coyoneda f Bool) -> Key IntSet -> IntSet -> Coyoneda f IntSet

unsafeOptDelete :: (Value IntSet -> Bool) -> Key IntSet -> IntSet -> IntSet

unsafeOptDeleteLookup :: (Value IntSet -> (r, Bool)) -> Key IntSet -> IntSet -> (r, IntSet)

unsafeOptDeleteF_ :: Functor f => (Value IntSet -> Coyoneda f Bool) -> Key IntSet -> IntSet -> Coyoneda f IntSet

maybeOptDelete :: (Value IntSet -> Bool) -> Key IntSet -> IntSet -> IntSet

safeOptDelete :: (Value IntSet -> Bool) -> Key IntSet -> IntSet -> Maybe IntSet

safeOptDeleteLookup :: (Value IntSet -> (r, Bool)) -> Key IntSet -> IntSet -> Maybe (r, IntSet)

safeOptDeleteF_ :: Functor f => (Value IntSet -> Coyoneda f Bool) -> Key IntSet -> IntSet -> Maybe (Coyoneda f IntSet)

DeleteMap (IntMap v)

Methods

delete :: Key (IntMap v) -> IntMap v -> IntMap v

deleteLookup :: Key (IntMap v) -> IntMap v -> (Value (IntMap v), IntMap v)

unsafeDelete :: Key (IntMap v) -> IntMap v -> IntMap v

unsafeDeleteLookup :: Key (IntMap v) -> IntMap v -> (Value (IntMap v), IntMap v)

maybeDelete :: Key (IntMap v) -> IntMap v -> IntMap v

safeDelete :: Key (IntMap v) -> IntMap v -> Maybe (IntMap v)

safeDeleteLookup :: Key (IntMap v) -> IntMap v -> Maybe (Value (IntMap v), IntMap v)

optDelete :: (Value (IntMap v) -> Bool) -> Key (IntMap v) -> IntMap v -> IntMap v

optDeleteLookup :: (Value (IntMap v) -> (r, Bool)) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

optDeleteF_ :: Functor f => (Value (IntMap v) -> Coyoneda f Bool) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

unsafeOptDelete :: (Value (IntMap v) -> Bool) -> Key (IntMap v) -> IntMap v -> IntMap v

unsafeOptDeleteLookup :: (Value (IntMap v) -> (r, Bool)) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

unsafeOptDeleteF_ :: Functor f => (Value (IntMap v) -> Coyoneda f Bool) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

maybeOptDelete :: (Value (IntMap v) -> Bool) -> Key (IntMap v) -> IntMap v -> IntMap v

safeOptDelete :: (Value (IntMap v) -> Bool) -> Key (IntMap v) -> IntMap v -> Maybe (IntMap v)

safeOptDeleteLookup :: (Value (IntMap v) -> (r, Bool)) -> Key (IntMap v) -> IntMap v -> Maybe (r, IntMap v)

safeOptDeleteF_ :: Functor f => (Value (IntMap v) -> Coyoneda f Bool) -> Key (IntMap v) -> IntMap v -> Maybe (Coyoneda f (IntMap v))

Ord a => DeleteMap (Set a)

Methods

delete :: Key (Set a) -> Set a -> Set a

deleteLookup :: Key (Set a) -> Set a -> (Value (Set a), Set a)

unsafeDelete :: Key (Set a) -> Set a -> Set a

unsafeDeleteLookup :: Key (Set a) -> Set a -> (Value (Set a), Set a)

maybeDelete :: Key (Set a) -> Set a -> Set a

safeDelete :: Key (Set a) -> Set a -> Maybe (Set a)

safeDeleteLookup :: Key (Set a) -> Set a -> Maybe (Value (Set a), Set a)

optDelete :: (Value (Set a) -> Bool) -> Key (Set a) -> Set a -> Set a

optDeleteLookup :: (Value (Set a) -> (r, Bool)) -> Key (Set a) -> Set a -> (r, Set a)

optDeleteF_ :: Functor f => (Value (Set a) -> Coyoneda f Bool) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

unsafeOptDelete :: (Value (Set a) -> Bool) -> Key (Set a) -> Set a -> Set a

unsafeOptDeleteLookup :: (Value (Set a) -> (r, Bool)) -> Key (Set a) -> Set a -> (r, Set a)

unsafeOptDeleteF_ :: Functor f => (Value (Set a) -> Coyoneda f Bool) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

maybeOptDelete :: (Value (Set a) -> Bool) -> Key (Set a) -> Set a -> Set a

safeOptDelete :: (Value (Set a) -> Bool) -> Key (Set a) -> Set a -> Maybe (Set a)

safeOptDeleteLookup :: (Value (Set a) -> (r, Bool)) -> Key (Set a) -> Set a -> Maybe (r, Set a)

safeOptDeleteF_ :: Functor f => (Value (Set a) -> Coyoneda f Bool) -> Key (Set a) -> Set a -> Maybe (Coyoneda f (Set a))

(IsLazyMap t, DeleteMap t) => DeleteMap (Lazy t)

Methods

delete :: Key (Lazy t) -> Lazy t -> Lazy t

deleteLookup :: Key (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

unsafeDelete :: Key (Lazy t) -> Lazy t -> Lazy t

unsafeDeleteLookup :: Key (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

maybeDelete :: Key (Lazy t) -> Lazy t -> Lazy t

safeDelete :: Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeDeleteLookup :: Key (Lazy t) -> Lazy t -> Maybe (Value (Lazy t), Lazy t)

optDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Lazy t

optDeleteLookup :: (Value (Lazy t) -> (r, Bool)) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

optDeleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f Bool) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

unsafeOptDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Lazy t

unsafeOptDeleteLookup :: (Value (Lazy t) -> (r, Bool)) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

unsafeOptDeleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f Bool) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

maybeOptDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Lazy t

safeOptDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeOptDeleteLookup :: (Value (Lazy t) -> (r, Bool)) -> Key (Lazy t) -> Lazy t -> Maybe (r, Lazy t)

safeOptDeleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f Bool) -> Key (Lazy t) -> Lazy t -> Maybe (Coyoneda f (Lazy t))

DeleteMap (Lazy (IntMap v))

Methods

delete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

deleteLookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

unsafeDelete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeDeleteLookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

maybeDelete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeDelete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeDeleteLookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Value (Lazy (IntMap v)), Lazy (IntMap v))

optDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

optDeleteLookup :: (Value (Lazy (IntMap v)) -> (r, Bool)) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

optDeleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

unsafeOptDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeOptDeleteLookup :: (Value (Lazy (IntMap v)) -> (r, Bool)) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

unsafeOptDeleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

maybeOptDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeOptDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeOptDeleteLookup :: (Value (Lazy (IntMap v)) -> (r, Bool)) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (r, Lazy (IntMap v))

safeOptDeleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Coyoneda f (Lazy (IntMap v)))

Ord k => DeleteMap (Lazy (Map k v))

Methods

delete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

deleteLookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

unsafeDelete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeDeleteLookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

maybeDelete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeDelete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeDeleteLookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Value (Lazy (Map k v)), Lazy (Map k v))

optDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

optDeleteLookup :: (Value (Lazy (Map k v)) -> (r, Bool)) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

optDeleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

unsafeOptDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeOptDeleteLookup :: (Value (Lazy (Map k v)) -> (r, Bool)) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

unsafeOptDeleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

maybeOptDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeOptDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeOptDeleteLookup :: (Value (Lazy (Map k v)) -> (r, Bool)) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (r, Lazy (Map k v))

safeOptDeleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Coyoneda f (Lazy (Map k v)))

(IsStrictMap t, DeleteMap t) => DeleteMap (Strict t)

Methods

delete :: Key (Strict t) -> Strict t -> Strict t

deleteLookup :: Key (Strict t) -> Strict t -> (Value (Strict t), Strict t)

unsafeDelete :: Key (Strict t) -> Strict t -> Strict t

unsafeDeleteLookup :: Key (Strict t) -> Strict t -> (Value (Strict t), Strict t)

maybeDelete :: Key (Strict t) -> Strict t -> Strict t

safeDelete :: Key (Strict t) -> Strict t -> Maybe (Strict t)

safeDeleteLookup :: Key (Strict t) -> Strict t -> Maybe (Value (Strict t), Strict t)

optDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Strict t

optDeleteLookup :: (Value (Strict t) -> (r, Bool)) -> Key (Strict t) -> Strict t -> (r, Strict t)

optDeleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f Bool) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

unsafeOptDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Strict t

unsafeOptDeleteLookup :: (Value (Strict t) -> (r, Bool)) -> Key (Strict t) -> Strict t -> (r, Strict t)

unsafeOptDeleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f Bool) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

maybeOptDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Strict t

safeOptDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Maybe (Strict t)

safeOptDeleteLookup :: (Value (Strict t) -> (r, Bool)) -> Key (Strict t) -> Strict t -> Maybe (r, Strict t)

safeOptDeleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f Bool) -> Key (Strict t) -> Strict t -> Maybe (Coyoneda f (Strict t))

Ord k => DeleteMap (Map k v)

Methods

delete :: Key (Map k v) -> Map k v -> Map k v

deleteLookup :: Key (Map k v) -> Map k v -> (Value (Map k v), Map k v)

unsafeDelete :: Key (Map k v) -> Map k v -> Map k v

unsafeDeleteLookup :: Key (Map k v) -> Map k v -> (Value (Map k v), Map k v)

maybeDelete :: Key (Map k v) -> Map k v -> Map k v

safeDelete :: Key (Map k v) -> Map k v -> Maybe (Map k v)

safeDeleteLookup :: Key (Map k v) -> Map k v -> Maybe (Value (Map k v), Map k v)

optDelete :: (Value (Map k v) -> Bool) -> Key (Map k v) -> Map k v -> Map k v

optDeleteLookup :: (Value (Map k v) -> (r, Bool)) -> Key (Map k v) -> Map k v -> (r, Map k v)

optDeleteF_ :: Functor f => (Value (Map k v) -> Coyoneda f Bool) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

unsafeOptDelete :: (Value (Map k v) -> Bool) -> Key (Map k v) -> Map k v -> Map k v

unsafeOptDeleteLookup :: (Value (Map k v) -> (r, Bool)) -> Key (Map k v) -> Map k v -> (r, Map k v)

unsafeOptDeleteF_ :: Functor f => (Value (Map k v) -> Coyoneda f Bool) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

maybeOptDelete :: (Value (Map k v) -> Bool) -> Key (Map k v) -> Map k v -> Map k v

safeOptDelete :: (Value (Map k v) -> Bool) -> Key (Map k v) -> Map k v -> Maybe (Map k v)

safeOptDeleteLookup :: (Value (Map k v) -> (r, Bool)) -> Key (Map k v) -> Map k v -> Maybe (r, Map k v)

safeOptDeleteF_ :: Functor f => (Value (Map k v) -> Coyoneda f Bool) -> Key (Map k v) -> Map k v -> Maybe (Coyoneda f (Map k v))

optDeleteF :: (DeleteMap t, Functor f) => (Value t -> f Bool) -> Key t -> t -> f t

unsafeOptDeleteF :: (DeleteMap t, Functor f) => (Value t -> f Bool) -> Key t -> t -> f t

safeOptDeleteF :: (DeleteMap t, Functor f) => (Value t -> f Bool) -> Key t -> t -> Maybe (f t)

class (InsertMap t, UpdateMap t) => UpsertMap t where

Functions for doing inserts that don't fail on the keys being found but instead override existing values.

Methods

upsert :: Key t -> Value t -> t -> t

upsertLookup :: Key t -> Value t -> t -> (Maybe (Value t), t)

adsert :: (Maybe (Value t) -> Value t) -> Key t -> t -> t

adsertLookup :: (Maybe (Value t) -> (r, Value t)) -> Key t -> t -> (r, t)

adsertF_ :: Functor f => (Maybe (Value t) -> Coyoneda f (Value t)) -> Key t -> t -> Coyoneda f t

adsertF_ :: (AlterMap t, Functor f) => (Maybe (Value t) -> Coyoneda f (Value t)) -> Key t -> t -> Coyoneda f t

Instances

UpsertMap IntSet

Methods

upsert :: Key IntSet -> Value IntSet -> IntSet -> IntSet

upsertLookup :: Key IntSet -> Value IntSet -> IntSet -> (Maybe (Value IntSet), IntSet)

adsert :: (Maybe (Value IntSet) -> Value IntSet) -> Key IntSet -> IntSet -> IntSet

adsertLookup :: (Maybe (Value IntSet) -> (r, Value IntSet)) -> Key IntSet -> IntSet -> (r, IntSet)

adsertF_ :: Functor f => (Maybe (Value IntSet) -> Coyoneda f (Value IntSet)) -> Key IntSet -> IntSet -> Coyoneda f IntSet

UpsertMap (IntMap v)

Methods

upsert :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> IntMap v

upsertLookup :: Key (IntMap v) -> Value (IntMap v) -> IntMap v -> (Maybe (Value (IntMap v)), IntMap v)

adsert :: (Maybe (Value (IntMap v)) -> Value (IntMap v)) -> Key (IntMap v) -> IntMap v -> IntMap v

adsertLookup :: (Maybe (Value (IntMap v)) -> (r, Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

adsertF_ :: Functor f => (Maybe (Value (IntMap v)) -> Coyoneda f (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

Ord a => UpsertMap (Set a)

Methods

upsert :: Key (Set a) -> Value (Set a) -> Set a -> Set a

upsertLookup :: Key (Set a) -> Value (Set a) -> Set a -> (Maybe (Value (Set a)), Set a)

adsert :: (Maybe (Value (Set a)) -> Value (Set a)) -> Key (Set a) -> Set a -> Set a

adsertLookup :: (Maybe (Value (Set a)) -> (r, Value (Set a))) -> Key (Set a) -> Set a -> (r, Set a)

adsertF_ :: Functor f => (Maybe (Value (Set a)) -> Coyoneda f (Value (Set a))) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

(IsLazyMap t, UpsertMap t) => UpsertMap (Lazy t)

Methods

upsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

upsertLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> (Maybe (Value (Lazy t)), Lazy t)

adsert :: (Maybe (Value (Lazy t)) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

adsertLookup :: (Maybe (Value (Lazy t)) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

adsertF_ :: Functor f => (Maybe (Value (Lazy t)) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

UpsertMap (Lazy (IntMap v))

Methods

upsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

upsertLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Maybe (Value (Lazy (IntMap v))), Lazy (IntMap v))

adsert :: (Maybe (Value (Lazy (IntMap v))) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

adsertLookup :: (Maybe (Value (Lazy (IntMap v))) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

adsertF_ :: Functor f => (Maybe (Value (Lazy (IntMap v))) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

Ord k => UpsertMap (Lazy (Map k v))

Methods

upsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

upsertLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> (Maybe (Value (Lazy (Map k v))), Lazy (Map k v))

adsert :: (Maybe (Value (Lazy (Map k v))) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

adsertLookup :: (Maybe (Value (Lazy (Map k v))) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

adsertF_ :: Functor f => (Maybe (Value (Lazy (Map k v))) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

(IsStrictMap t, UpsertMap t) => UpsertMap (Strict t)

Methods

upsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

upsertLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> (Maybe (Value (Strict t)), Strict t)

adsert :: (Maybe (Value (Strict t)) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

adsertLookup :: (Maybe (Value (Strict t)) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> (r, Strict t)

adsertF_ :: Functor f => (Maybe (Value (Strict t)) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

Ord k => UpsertMap (Map k v)

Methods

upsert :: Key (Map k v) -> Value (Map k v) -> Map k v -> Map k v

upsertLookup :: Key (Map k v) -> Value (Map k v) -> Map k v -> (Maybe (Value (Map k v)), Map k v)

adsert :: (Maybe (Value (Map k v)) -> Value (Map k v)) -> Key (Map k v) -> Map k v -> Map k v

adsertLookup :: (Maybe (Value (Map k v)) -> (r, Value (Map k v))) -> Key (Map k v) -> Map k v -> (r, Map k v)

adsertF_ :: Functor f => (Maybe (Value (Map k v)) -> Coyoneda f (Value (Map k v))) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

adsertF :: (UpsertMap t, Functor f) => (Maybe (Value t) -> f (Value t)) -> Key t -> t -> f t

class (DeleteMap t, UpdateMap t) => UpleteMap t where

Methods

adlete :: (Value t -> Maybe (Value t)) -> Key t -> t -> t

adleteLookup :: (Value t -> (r, Maybe (Value t))) -> Key t -> t -> (r, t)

adleteF_ :: Functor f => (Value t -> Coyoneda f (Maybe (Value t))) -> Key t -> t -> Coyoneda f t

unsafeAdlete :: (Value t -> Maybe (Value t)) -> Key t -> t -> t

unsafeAdleteLookup :: (Value t -> (r, Maybe (Value t))) -> Key t -> t -> (r, t)

unsafeAdleteF_ :: Functor f => (Value t -> Coyoneda f (Maybe (Value t))) -> Key t -> t -> Coyoneda f t

maybeAdlete :: (Value t -> Maybe (Value t)) -> Key t -> t -> t

safeAdlete :: (Value t -> Maybe (Value t)) -> Key t -> t -> Maybe t

safeAdleteLookup :: (Value t -> (r, Maybe (Value t))) -> Key t -> t -> Maybe (r, t)

safeAdleteF_ :: Functor f => (Value t -> Coyoneda f (Maybe (Value t))) -> Key t -> t -> Maybe (Coyoneda f t)

safeAdleteF_ :: (AlterMap t, Functor f) => (Value t -> Coyoneda f (Maybe (Value t))) -> Key t -> t -> Maybe (Coyoneda f t)

Instances

UpleteMap IntSet

Methods

adlete :: (Value IntSet -> Maybe (Value IntSet)) -> Key IntSet -> IntSet -> IntSet

adleteLookup :: (Value IntSet -> (r, Maybe (Value IntSet))) -> Key IntSet -> IntSet -> (r, IntSet)

adleteF_ :: Functor f => (Value IntSet -> Coyoneda f (Maybe (Value IntSet))) -> Key IntSet -> IntSet -> Coyoneda f IntSet

unsafeAdlete :: (Value IntSet -> Maybe (Value IntSet)) -> Key IntSet -> IntSet -> IntSet

unsafeAdleteLookup :: (Value IntSet -> (r, Maybe (Value IntSet))) -> Key IntSet -> IntSet -> (r, IntSet)

unsafeAdleteF_ :: Functor f => (Value IntSet -> Coyoneda f (Maybe (Value IntSet))) -> Key IntSet -> IntSet -> Coyoneda f IntSet

maybeAdlete :: (Value IntSet -> Maybe (Value IntSet)) -> Key IntSet -> IntSet -> IntSet

safeAdlete :: (Value IntSet -> Maybe (Value IntSet)) -> Key IntSet -> IntSet -> Maybe IntSet

safeAdleteLookup :: (Value IntSet -> (r, Maybe (Value IntSet))) -> Key IntSet -> IntSet -> Maybe (r, IntSet)

safeAdleteF_ :: Functor f => (Value IntSet -> Coyoneda f (Maybe (Value IntSet))) -> Key IntSet -> IntSet -> Maybe (Coyoneda f IntSet)

UpleteMap (IntMap v)

Methods

adlete :: (Value (IntMap v) -> Maybe (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> IntMap v

adleteLookup :: (Value (IntMap v) -> (r, Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

adleteF_ :: Functor f => (Value (IntMap v) -> Coyoneda f (Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

unsafeAdlete :: (Value (IntMap v) -> Maybe (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> IntMap v

unsafeAdleteLookup :: (Value (IntMap v) -> (r, Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

unsafeAdleteF_ :: Functor f => (Value (IntMap v) -> Coyoneda f (Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

maybeAdlete :: (Value (IntMap v) -> Maybe (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> IntMap v

safeAdlete :: (Value (IntMap v) -> Maybe (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> Maybe (IntMap v)

safeAdleteLookup :: (Value (IntMap v) -> (r, Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> Maybe (r, IntMap v)

safeAdleteF_ :: Functor f => (Value (IntMap v) -> Coyoneda f (Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> Maybe (Coyoneda f (IntMap v))

Ord a => UpleteMap (Set a)

Methods

adlete :: (Value (Set a) -> Maybe (Value (Set a))) -> Key (Set a) -> Set a -> Set a

adleteLookup :: (Value (Set a) -> (r, Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> (r, Set a)

adleteF_ :: Functor f => (Value (Set a) -> Coyoneda f (Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

unsafeAdlete :: (Value (Set a) -> Maybe (Value (Set a))) -> Key (Set a) -> Set a -> Set a

unsafeAdleteLookup :: (Value (Set a) -> (r, Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> (r, Set a)

unsafeAdleteF_ :: Functor f => (Value (Set a) -> Coyoneda f (Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

maybeAdlete :: (Value (Set a) -> Maybe (Value (Set a))) -> Key (Set a) -> Set a -> Set a

safeAdlete :: (Value (Set a) -> Maybe (Value (Set a))) -> Key (Set a) -> Set a -> Maybe (Set a)

safeAdleteLookup :: (Value (Set a) -> (r, Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> Maybe (r, Set a)

safeAdleteF_ :: Functor f => (Value (Set a) -> Coyoneda f (Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> Maybe (Coyoneda f (Set a))

(IsLazyMap t, UpleteMap t) => UpleteMap (Lazy t)

Methods

adlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

adleteLookup :: (Value (Lazy t) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

adleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

unsafeAdlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

unsafeAdleteLookup :: (Value (Lazy t) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

unsafeAdleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

maybeAdlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

safeAdlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeAdleteLookup :: (Value (Lazy t) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Maybe (r, Lazy t)

safeAdleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Maybe (Coyoneda f (Lazy t))

UpleteMap (Lazy (IntMap v))

Methods

adlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

adleteLookup :: (Value (Lazy (IntMap v)) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

adleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

unsafeAdlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeAdleteLookup :: (Value (Lazy (IntMap v)) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

unsafeAdleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

maybeAdlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeAdlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeAdleteLookup :: (Value (Lazy (IntMap v)) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (r, Lazy (IntMap v))

safeAdleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Coyoneda f (Lazy (IntMap v)))

Ord k => UpleteMap (Lazy (Map k v))

Methods

adlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

adleteLookup :: (Value (Lazy (Map k v)) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

adleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

unsafeAdlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeAdleteLookup :: (Value (Lazy (Map k v)) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

unsafeAdleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

maybeAdlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeAdlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeAdleteLookup :: (Value (Lazy (Map k v)) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (r, Lazy (Map k v))

safeAdleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Coyoneda f (Lazy (Map k v)))

(IsStrictMap t, UpleteMap t) => UpleteMap (Strict t)

Methods

adlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

adleteLookup :: (Value (Strict t) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> (r, Strict t)

adleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

unsafeAdlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

unsafeAdleteLookup :: (Value (Strict t) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> (r, Strict t)

unsafeAdleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

maybeAdlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

safeAdlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Maybe (Strict t)

safeAdleteLookup :: (Value (Strict t) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Maybe (r, Strict t)

safeAdleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Maybe (Coyoneda f (Strict t))

Ord k => UpleteMap (Map k v)

Methods

adlete :: (Value (Map k v) -> Maybe (Value (Map k v))) -> Key (Map k v) -> Map k v -> Map k v

adleteLookup :: (Value (Map k v) -> (r, Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> (r, Map k v)

adleteF_ :: Functor f => (Value (Map k v) -> Coyoneda f (Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

unsafeAdlete :: (Value (Map k v) -> Maybe (Value (Map k v))) -> Key (Map k v) -> Map k v -> Map k v

unsafeAdleteLookup :: (Value (Map k v) -> (r, Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> (r, Map k v)

unsafeAdleteF_ :: Functor f => (Value (Map k v) -> Coyoneda f (Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

maybeAdlete :: (Value (Map k v) -> Maybe (Value (Map k v))) -> Key (Map k v) -> Map k v -> Map k v

safeAdlete :: (Value (Map k v) -> Maybe (Value (Map k v))) -> Key (Map k v) -> Map k v -> Maybe (Map k v)

safeAdleteLookup :: (Value (Map k v) -> (r, Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> Maybe (r, Map k v)

safeAdleteF_ :: Functor f => (Value (Map k v) -> Coyoneda f (Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> Maybe (Coyoneda f (Map k v))

adleteF :: (UpleteMap t, Functor f) => (Value t -> f (Maybe (Value t))) -> Key t -> t -> f t

unsafeAdleteF :: (UpleteMap t, Functor f) => (Value t -> f (Maybe (Value t))) -> Key t -> t -> f t

safeAdleteF :: (UpleteMap t, Functor f) => (Value t -> f (Maybe (Value t))) -> Key t -> t -> Maybe (f t)

class (UpsertMap t, UpleteMap t) => AlterMap t where

AlterMap is a class that represents key-value mappings where one can do inserts, deletes, updates, pretty much everything you expect from a simple key/value store.

Methods

alter :: (Maybe (Value t) -> Maybe (Value t)) -> Key t -> t -> t

alter f k x attempts to gets the value of the key k.

If key k exists, as say it is v, it passes Just v to f.

If key k does not exist, it passes Nothing to f.

If the result of f is Just something, then alter either inserts or updates the key k, inserting if key k previously didn't exist and updating if it did.

If the result of f is Nothing, and the key k did exist, we deleted it.

Otherwise, if the result of f is Nothing, nd the key k did not exist, then do nothing and simply return the structure unmodified.

alterLookup :: (Maybe (Value t) -> (r, Maybe (Value t))) -> Key t -> t -> (r, t)

Like alter, but returns the value both before and after the alteration.

alterF_ :: Functor f => (Maybe (Value t) -> Coyoneda f (Maybe (Value t))) -> Key t -> t -> Coyoneda f t

Instances

AlterMap IntSet

Methods

alter :: (Maybe (Value IntSet) -> Maybe (Value IntSet)) -> Key IntSet -> IntSet -> IntSet

alterLookup :: (Maybe (Value IntSet) -> (r, Maybe (Value IntSet))) -> Key IntSet -> IntSet -> (r, IntSet)

alterF_ :: Functor f => (Maybe (Value IntSet) -> Coyoneda f (Maybe (Value IntSet))) -> Key IntSet -> IntSet -> Coyoneda f IntSet

AlterMap (IntMap v)

Methods

alter :: (Maybe (Value (IntMap v)) -> Maybe (Value (IntMap v))) -> Key (IntMap v) -> IntMap v -> IntMap v

alterLookup :: (Maybe (Value (IntMap v)) -> (r, Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> (r, IntMap v)

alterF_ :: Functor f => (Maybe (Value (IntMap v)) -> Coyoneda f (Maybe (Value (IntMap v)))) -> Key (IntMap v) -> IntMap v -> Coyoneda f (IntMap v)

Ord a => AlterMap (Set a)

Methods

alter :: (Maybe (Value (Set a)) -> Maybe (Value (Set a))) -> Key (Set a) -> Set a -> Set a

alterLookup :: (Maybe (Value (Set a)) -> (r, Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> (r, Set a)

alterF_ :: Functor f => (Maybe (Value (Set a)) -> Coyoneda f (Maybe (Value (Set a)))) -> Key (Set a) -> Set a -> Coyoneda f (Set a)

(IsLazyMap t, AlterMap t) => AlterMap (Lazy t)

Methods

alter :: (Maybe (Value (Lazy t)) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

alterLookup :: (Maybe (Value (Lazy t)) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

alterF_ :: Functor f => (Maybe (Value (Lazy t)) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

AlterMap (Lazy (IntMap v))

Methods

alter :: (Maybe (Value (Lazy (IntMap v))) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

alterLookup :: (Maybe (Value (Lazy (IntMap v))) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

alterF_ :: Functor f => (Maybe (Value (Lazy (IntMap v))) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

Ord k => AlterMap (Lazy (Map k v))

Methods

alter :: (Maybe (Value (Lazy (Map k v))) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

alterLookup :: (Maybe (Value (Lazy (Map k v))) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

alterF_ :: Functor f => (Maybe (Value (Lazy (Map k v))) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

(IsStrictMap t, AlterMap t) => AlterMap (Strict t)

Methods

alter :: (Maybe (Value (Strict t)) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

alterLookup :: (Maybe (Value (Strict t)) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> (r, Strict t)

alterF_ :: Functor f => (Maybe (Value (Strict t)) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

Ord k => AlterMap (Map k v)

Methods

alter :: (Maybe (Value (Map k v)) -> Maybe (Value (Map k v))) -> Key (Map k v) -> Map k v -> Map k v

alterLookup :: (Maybe (Value (Map k v)) -> (r, Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> (r, Map k v)

alterF_ :: Functor f => (Maybe (Value (Map k v)) -> Coyoneda f (Maybe (Value (Map k v)))) -> Key (Map k v) -> Map k v -> Coyoneda f (Map k v)

alterF :: (AlterMap t, Functor f) => (Maybe (Value t) -> f (Maybe (Value t))) -> Key t -> t -> f t

newtype Strict t

For certain types like maps in the standard containers library that ships with GHC, the strict version of the data type: Map, and the lazy version of the data type: Map, are actually the exact same type. In this case, they're just reexports of the same type.

That's fine when one has two separate modules with strict and lazy versions one can explicitly use, but the choice can't be automatic based on the type.

As a result, there's no way one can tell whether to use strict or lazy functions on the data. Wrapping these types in either Strict or Lazy specifies how these types are intend to be worked on.

By default however, if one doesn't wrap, the Strict version is used.

Constructors

Strict

Fields

• getStrict :: t

Instances

(IsStrictMap t, AlterMap t) => AlterMap (Strict t)

Methods

alter :: (Maybe (Value (Strict t)) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

alterLookup :: (Maybe (Value (Strict t)) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> (r, Strict t)

alterF_ :: Functor f => (Maybe (Value (Strict t)) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

(IsStrictMap t, UpleteMap t) => UpleteMap (Strict t)

Methods

adlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

adleteLookup :: (Value (Strict t) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> (r, Strict t)

adleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

unsafeAdlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

unsafeAdleteLookup :: (Value (Strict t) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> (r, Strict t)

unsafeAdleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

maybeAdlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Strict t

safeAdlete :: (Value (Strict t) -> Maybe (Value (Strict t))) -> Key (Strict t) -> Strict t -> Maybe (Strict t)

safeAdleteLookup :: (Value (Strict t) -> (r, Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Maybe (r, Strict t)

safeAdleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Maybe (Value (Strict t)))) -> Key (Strict t) -> Strict t -> Maybe (Coyoneda f (Strict t))

(IsStrictMap t, UpsertMap t) => UpsertMap (Strict t)

Methods

upsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

upsertLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> (Maybe (Value (Strict t)), Strict t)

adsert :: (Maybe (Value (Strict t)) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

adsertLookup :: (Maybe (Value (Strict t)) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> (r, Strict t)

adsertF_ :: Functor f => (Maybe (Value (Strict t)) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

(IsStrictMap t, DeleteMap t) => DeleteMap (Strict t)

Methods

delete :: Key (Strict t) -> Strict t -> Strict t

deleteLookup :: Key (Strict t) -> Strict t -> (Value (Strict t), Strict t)

unsafeDelete :: Key (Strict t) -> Strict t -> Strict t

unsafeDeleteLookup :: Key (Strict t) -> Strict t -> (Value (Strict t), Strict t)

maybeDelete :: Key (Strict t) -> Strict t -> Strict t

safeDelete :: Key (Strict t) -> Strict t -> Maybe (Strict t)

safeDeleteLookup :: Key (Strict t) -> Strict t -> Maybe (Value (Strict t), Strict t)

optDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Strict t

optDeleteLookup :: (Value (Strict t) -> (r, Bool)) -> Key (Strict t) -> Strict t -> (r, Strict t)

optDeleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f Bool) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

unsafeOptDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Strict t

unsafeOptDeleteLookup :: (Value (Strict t) -> (r, Bool)) -> Key (Strict t) -> Strict t -> (r, Strict t)

unsafeOptDeleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f Bool) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

maybeOptDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Strict t

safeOptDelete :: (Value (Strict t) -> Bool) -> Key (Strict t) -> Strict t -> Maybe (Strict t)

safeOptDeleteLookup :: (Value (Strict t) -> (r, Bool)) -> Key (Strict t) -> Strict t -> Maybe (r, Strict t)

safeOptDeleteF_ :: Functor f => (Value (Strict t) -> Coyoneda f Bool) -> Key (Strict t) -> Strict t -> Maybe (Coyoneda f (Strict t))

(IsStrictMap t, InsertMap t) => InsertMap (Strict t)

Methods

insert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

unsafeInsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

maybeInsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

safeInsert :: Key (Strict t) -> Value (Strict t) -> Strict t -> Maybe (Strict t)

(IsStrictMap t, UpdateMap t) => UpdateMap (Strict t)

Methods

update :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

updateLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> (Value (Strict t), Strict t)

unsafeUpdate :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

unsafeUpdateLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> (Value (Strict t), Strict t)

maybeUpdate :: Key (Strict t) -> Value (Strict t) -> Strict t -> Strict t

safeUpdate :: Key (Strict t) -> Value (Strict t) -> Strict t -> Maybe (Strict t)

safeUpdateLookup :: Key (Strict t) -> Value (Strict t) -> Strict t -> Maybe (Value (Strict t), Strict t)

adjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

adjustLookup :: (Value (Strict t) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> (r, Strict t)

adjustF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

unsafeAdjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

unsafeAdjustLookup :: (Value (Strict t) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> (r, Strict t)

unsafeAdjustF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Coyoneda f (Strict t)

maybeAdjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Strict t

safeAdjust :: (Value (Strict t) -> Value (Strict t)) -> Key (Strict t) -> Strict t -> Maybe (Strict t)

safeAdjustLookup :: (Value (Strict t) -> (r, Value (Strict t))) -> Key (Strict t) -> Strict t -> Maybe (r, Strict t)

safeAdjustF_ :: Functor f => (Value (Strict t) -> Coyoneda f (Value (Strict t))) -> Key (Strict t) -> Strict t -> Maybe (Coyoneda f (Strict t))

(IsStrictMap t, LookupMap t) => LookupMap (Strict t)

Methods

lookup :: Key (Strict t) -> Strict t -> Maybe (Value (Strict t))

index :: Key (Strict t) -> Strict t -> Value (Strict t)

unsafeIndex :: Key (Strict t) -> Strict t -> Value (Strict t)

member :: Key (Strict t) -> Strict t -> Bool

notMember :: Key (Strict t) -> Strict t -> Bool

type Value (Strict t)

type Value (Strict t) = Value t

type Key (Strict t)

type Key (Strict t) = Key t

newtype Lazy t

See Strict documentation for a discussion of the Lazy wrapper.

Constructors

Lazy

Fields

• getLazy :: t

Instances

(IsLazyMap t, AlterMap t) => AlterMap (Lazy t)

Methods

alter :: (Maybe (Value (Lazy t)) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

alterLookup :: (Maybe (Value (Lazy t)) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

alterF_ :: Functor f => (Maybe (Value (Lazy t)) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

AlterMap (Lazy (IntMap v))

Methods

alter :: (Maybe (Value (Lazy (IntMap v))) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

alterLookup :: (Maybe (Value (Lazy (IntMap v))) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

alterF_ :: Functor f => (Maybe (Value (Lazy (IntMap v))) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

Ord k => AlterMap (Lazy (Map k v))

Methods

alter :: (Maybe (Value (Lazy (Map k v))) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

alterLookup :: (Maybe (Value (Lazy (Map k v))) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

alterF_ :: Functor f => (Maybe (Value (Lazy (Map k v))) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

(IsLazyMap t, UpleteMap t) => UpleteMap (Lazy t)

Methods

adlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

adleteLookup :: (Value (Lazy t) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

adleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

unsafeAdlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

unsafeAdleteLookup :: (Value (Lazy t) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

unsafeAdleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

maybeAdlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Lazy t

safeAdlete :: (Value (Lazy t) -> Maybe (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeAdleteLookup :: (Value (Lazy t) -> (r, Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Maybe (r, Lazy t)

safeAdleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Maybe (Value (Lazy t)))) -> Key (Lazy t) -> Lazy t -> Maybe (Coyoneda f (Lazy t))

UpleteMap (Lazy (IntMap v))

Methods

adlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

adleteLookup :: (Value (Lazy (IntMap v)) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

adleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

unsafeAdlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeAdleteLookup :: (Value (Lazy (IntMap v)) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

unsafeAdleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

maybeAdlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeAdlete :: (Value (Lazy (IntMap v)) -> Maybe (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeAdleteLookup :: (Value (Lazy (IntMap v)) -> (r, Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (r, Lazy (IntMap v))

safeAdleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Maybe (Value (Lazy (IntMap v))))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Coyoneda f (Lazy (IntMap v)))

Ord k => UpleteMap (Lazy (Map k v))

Methods

adlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

adleteLookup :: (Value (Lazy (Map k v)) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

adleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

unsafeAdlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeAdleteLookup :: (Value (Lazy (Map k v)) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

unsafeAdleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

maybeAdlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeAdlete :: (Value (Lazy (Map k v)) -> Maybe (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeAdleteLookup :: (Value (Lazy (Map k v)) -> (r, Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (r, Lazy (Map k v))

safeAdleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Maybe (Value (Lazy (Map k v))))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Coyoneda f (Lazy (Map k v)))

(IsLazyMap t, UpsertMap t) => UpsertMap (Lazy t)

Methods

upsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

upsertLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> (Maybe (Value (Lazy t)), Lazy t)

adsert :: (Maybe (Value (Lazy t)) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

adsertLookup :: (Maybe (Value (Lazy t)) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

adsertF_ :: Functor f => (Maybe (Value (Lazy t)) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

UpsertMap (Lazy (IntMap v))

Methods

upsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

upsertLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Maybe (Value (Lazy (IntMap v))), Lazy (IntMap v))

adsert :: (Maybe (Value (Lazy (IntMap v))) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

adsertLookup :: (Maybe (Value (Lazy (IntMap v))) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

adsertF_ :: Functor f => (Maybe (Value (Lazy (IntMap v))) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

Ord k => UpsertMap (Lazy (Map k v))

Methods

upsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

upsertLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> (Maybe (Value (Lazy (Map k v))), Lazy (Map k v))

adsert :: (Maybe (Value (Lazy (Map k v))) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

adsertLookup :: (Maybe (Value (Lazy (Map k v))) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

adsertF_ :: Functor f => (Maybe (Value (Lazy (Map k v))) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

(IsLazyMap t, DeleteMap t) => DeleteMap (Lazy t)

Methods

delete :: Key (Lazy t) -> Lazy t -> Lazy t

deleteLookup :: Key (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

unsafeDelete :: Key (Lazy t) -> Lazy t -> Lazy t

unsafeDeleteLookup :: Key (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

maybeDelete :: Key (Lazy t) -> Lazy t -> Lazy t

safeDelete :: Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeDeleteLookup :: Key (Lazy t) -> Lazy t -> Maybe (Value (Lazy t), Lazy t)

optDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Lazy t

optDeleteLookup :: (Value (Lazy t) -> (r, Bool)) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

optDeleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f Bool) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

unsafeOptDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Lazy t

unsafeOptDeleteLookup :: (Value (Lazy t) -> (r, Bool)) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

unsafeOptDeleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f Bool) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

maybeOptDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Lazy t

safeOptDelete :: (Value (Lazy t) -> Bool) -> Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeOptDeleteLookup :: (Value (Lazy t) -> (r, Bool)) -> Key (Lazy t) -> Lazy t -> Maybe (r, Lazy t)

safeOptDeleteF_ :: Functor f => (Value (Lazy t) -> Coyoneda f Bool) -> Key (Lazy t) -> Lazy t -> Maybe (Coyoneda f (Lazy t))

DeleteMap (Lazy (IntMap v))

Methods

delete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

deleteLookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

unsafeDelete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeDeleteLookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

maybeDelete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeDelete :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeDeleteLookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Value (Lazy (IntMap v)), Lazy (IntMap v))

optDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

optDeleteLookup :: (Value (Lazy (IntMap v)) -> (r, Bool)) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

optDeleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

unsafeOptDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeOptDeleteLookup :: (Value (Lazy (IntMap v)) -> (r, Bool)) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

unsafeOptDeleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

maybeOptDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeOptDelete :: (Value (Lazy (IntMap v)) -> Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeOptDeleteLookup :: (Value (Lazy (IntMap v)) -> (r, Bool)) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (r, Lazy (IntMap v))

safeOptDeleteF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f Bool) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Coyoneda f (Lazy (IntMap v)))

Ord k => DeleteMap (Lazy (Map k v))

Methods

delete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

deleteLookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

unsafeDelete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeDeleteLookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

maybeDelete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeDelete :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeDeleteLookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Value (Lazy (Map k v)), Lazy (Map k v))

optDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

optDeleteLookup :: (Value (Lazy (Map k v)) -> (r, Bool)) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

optDeleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

unsafeOptDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeOptDeleteLookup :: (Value (Lazy (Map k v)) -> (r, Bool)) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

unsafeOptDeleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

maybeOptDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeOptDelete :: (Value (Lazy (Map k v)) -> Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeOptDeleteLookup :: (Value (Lazy (Map k v)) -> (r, Bool)) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (r, Lazy (Map k v))

safeOptDeleteF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f Bool) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Coyoneda f (Lazy (Map k v)))

(IsLazyMap t, InsertMap t) => InsertMap (Lazy t)

Methods

insert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

unsafeInsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

maybeInsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

safeInsert :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Maybe (Lazy t)

InsertMap (Lazy (IntMap v))

Methods

insert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeInsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

maybeInsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeInsert :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

Ord k => InsertMap (Lazy (Map k v))

Methods

insert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeInsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

maybeInsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeInsert :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

(IsLazyMap t, UpdateMap t) => UpdateMap (Lazy t)

Methods

update :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

updateLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

unsafeUpdate :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

unsafeUpdateLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> (Value (Lazy t), Lazy t)

maybeUpdate :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Lazy t

safeUpdate :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeUpdateLookup :: Key (Lazy t) -> Value (Lazy t) -> Lazy t -> Maybe (Value (Lazy t), Lazy t)

adjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

adjustLookup :: (Value (Lazy t) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

adjustF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

unsafeAdjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

unsafeAdjustLookup :: (Value (Lazy t) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> (r, Lazy t)

unsafeAdjustF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Coyoneda f (Lazy t)

maybeAdjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Lazy t

safeAdjust :: (Value (Lazy t) -> Value (Lazy t)) -> Key (Lazy t) -> Lazy t -> Maybe (Lazy t)

safeAdjustLookup :: (Value (Lazy t) -> (r, Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Maybe (r, Lazy t)

safeAdjustF_ :: Functor f => (Value (Lazy t) -> Coyoneda f (Value (Lazy t))) -> Key (Lazy t) -> Lazy t -> Maybe (Coyoneda f (Lazy t))

UpdateMap (Lazy (IntMap v))

Methods

update :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

updateLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

unsafeUpdate :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeUpdateLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> (Value (Lazy (IntMap v)), Lazy (IntMap v))

maybeUpdate :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeUpdate :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeUpdateLookup :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Value (Lazy (IntMap v)), Lazy (IntMap v))

adjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

adjustLookup :: (Value (Lazy (IntMap v)) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

adjustF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

unsafeAdjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

unsafeAdjustLookup :: (Value (Lazy (IntMap v)) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> (r, Lazy (IntMap v))

unsafeAdjustF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Coyoneda f (Lazy (IntMap v))

maybeAdjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Lazy (IntMap v)

safeAdjust :: (Value (Lazy (IntMap v)) -> Value (Lazy (IntMap v))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Lazy (IntMap v))

safeAdjustLookup :: (Value (Lazy (IntMap v)) -> (r, Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (r, Lazy (IntMap v))

safeAdjustF_ :: Functor f => (Value (Lazy (IntMap v)) -> Coyoneda f (Value (Lazy (IntMap v)))) -> Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Coyoneda f (Lazy (IntMap v)))

Ord k => UpdateMap (Lazy (Map k v))

Methods

update :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

updateLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

unsafeUpdate :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeUpdateLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> (Value (Lazy (Map k v)), Lazy (Map k v))

maybeUpdate :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeUpdate :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeUpdateLookup :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Value (Lazy (Map k v)), Lazy (Map k v))

adjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

adjustLookup :: (Value (Lazy (Map k v)) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

adjustF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

unsafeAdjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

unsafeAdjustLookup :: (Value (Lazy (Map k v)) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> (r, Lazy (Map k v))

unsafeAdjustF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Coyoneda f (Lazy (Map k v))

maybeAdjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Lazy (Map k v)

safeAdjust :: (Value (Lazy (Map k v)) -> Value (Lazy (Map k v))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Lazy (Map k v))

safeAdjustLookup :: (Value (Lazy (Map k v)) -> (r, Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (r, Lazy (Map k v))

safeAdjustF_ :: Functor f => (Value (Lazy (Map k v)) -> Coyoneda f (Value (Lazy (Map k v)))) -> Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Coyoneda f (Lazy (Map k v)))

SingletonMap (Lazy (IntMap v))

Methods

singleton :: Key (Lazy (IntMap v)) -> Value (Lazy (IntMap v)) -> Lazy (IntMap v)

Ord k => SingletonMap (Lazy (Map k v))

Methods

singleton :: Key (Lazy (Map k v)) -> Value (Lazy (Map k v)) -> Lazy (Map k v)

(IsLazyMap t, LookupMap t) => LookupMap (Lazy t)

Methods

lookup :: Key (Lazy t) -> Lazy t -> Maybe (Value (Lazy t))

index :: Key (Lazy t) -> Lazy t -> Value (Lazy t)

unsafeIndex :: Key (Lazy t) -> Lazy t -> Value (Lazy t)

member :: Key (Lazy t) -> Lazy t -> Bool

notMember :: Key (Lazy t) -> Lazy t -> Bool

LookupMap (Lazy (IntMap v))

Methods

lookup :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Maybe (Value (Lazy (IntMap v)))

index :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Value (Lazy (IntMap v))

unsafeIndex :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Value (Lazy (IntMap v))

member :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Bool

notMember :: Key (Lazy (IntMap v)) -> Lazy (IntMap v) -> Bool

Ord k => LookupMap (Lazy (Map k v))

Methods

lookup :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Maybe (Value (Lazy (Map k v)))

index :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Value (Lazy (Map k v))

unsafeIndex :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Value (Lazy (Map k v))

member :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Bool

notMember :: Key (Lazy (Map k v)) -> Lazy (Map k v) -> Bool

type Value (Lazy t)

type Value (Lazy t) = Value t

type Value (Lazy t)

type Value (Lazy t) = Value t

type Key (Lazy t)

type Key (Lazy t) = Key t

type Key (Lazy t)

type Key (Lazy t) = Key t

(!) :: LookupMap t => t -> Key t -> Value t

fromCoyonedaTransform :: Functor f1 => ((a1 -> Coyoneda f2 a2) -> t1 -> t2 -> Coyoneda f1 a3) -> (a1 -> f2 a2) -> t1 -> t2 -> f1 a3

Hack to allow generalised newtype deriving from https://stackoverflow.com/questions/48848571/generalised-newtype-deriving-on-class-functions-with-functors/48849568#48849568

fromCoyonedaTransformF :: (Functor f1, Functor f3) => ((a1 -> Coyoneda f2 a2) -> t1 -> t2 -> f3 (Coyoneda f1 a3)) -> (a1 -> f2 a2) -> t1 -> t2 -> f3 (f1 a3)

toCoyonedaTransform :: Functor f => (forall f'. Functor f' => (a1 -> f' a2) -> t1 -> t2 -> f' a3) -> (a1 -> Coyoneda f a2) -> t1 -> t2 -> Coyoneda f a3

toCoyonedaTransformF :: Functor f => (forall f'. Functor f' => (a1 -> f' a2) -> t1 -> t2 -> f3 (f' a3)) -> (a1 -> Coyoneda f a2) -> t1 -> t2 -> f3 (Coyoneda f a3)