Control.Class.Map

Exports the functions non instances writers should need.

If you want to write your own instances (or indeed just want a general readme for the class) see the module Control.Class.Impl.Map

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)

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

unsafeAdjustLookup :: (Value t -> (r, Value t)) -> Key t -> t -> (r, 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)

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.

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

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.

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)

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)

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

unsafeAdleteLookup :: (Value t -> (r, Maybe (Value t))) -> Key t -> t -> (r, 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)

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.

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 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 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