pmap -package:plutarch -package:Cabal -is:module -is:exact -is:exact

pmapWithKey :: forall (k :: PType) (a :: PType) (b :: PType) (keysort :: KeyGuarantees) (s :: S) . (PIsData k, PIsData a, PIsData b) => Term s ((k :--> (a :--> b)) :--> (PMap keysort k a :--> PMap 'Unsorted k b))
plutarch-extra Plutarch.Extra.Map
Like regular fmap but it provides key of each element that is being modified.
pmapMaybe :: forall (listO :: (S -> Type) -> S -> Type) (b :: S -> Type) (listI :: (S -> Type) -> S -> Type) (a :: S -> Type) (s :: S) . (PIsListLike listI a, PIsListLike listO b) => Term s ((a :--> PMaybe b) :--> (listI a :--> listO b))
liqwid-plutarch-extra Plutarch.Extra.List
Similar to pmap, but allows elements to be thrown out. More precisely, for elements where the function argument returns PNothing, the corresponding element is removed, while for elements where the function argument returns PJust, the value is used in the result.
pmapComparator :: forall (a :: S -> Type) (b :: S -> Type) (s :: S) . Term s ((b :--> a) :--> (PComparator a :--> PComparator b))
liqwid-plutarch-extra Plutarch.Extra.Ord
Given a projection from a type to another type which we have a PComparator for, construct a new PComparator.
dropMap :: Dropper s -> Dropper s -> Dropper s
cardano-binary Cardano.Binary
data TypeRepMap (f :: k -> Type)
typerep-map Data.TypeRepMap Data.TypeRepMap.Internal
TypeRepMap is a heterogeneous data structure similar in its essence to Map with types as keys, where each value has the type of its key. In addition to that, each value is wrapped in an interpretation f. Here is an example of using Maybe as an interpretation, with a comparison to Map: 
Map String (Maybe String)          TypeRepMap Maybe
---------------------------       ---------------------
"Int"  -> Just "5"                 Int  -> Just 5
"Bool" -> Just "True"              Bool -> Just True
"Char" -> Nothing                  Char -> Nothing
The runtime representation of TypeRepMap is an array, not a tree. This makes lookup significantly more efficient.
TypeRepMap :: {-# UNPACK #-} !PrimArray Word64 -> {-# UNPACK #-} !PrimArray Word64 -> {-# UNPACK #-} !Array Any -> {-# UNPACK #-} !Array Any -> TypeRepMap (f :: k -> Type)
typerep-map Data.TypeRepMap.Internal
mapMap :: IsMap map => (a -> b) -> map a -> map b
ghc GHC.Cmm.Dataflow.Collections
mapMapWithKey :: IsMap map => (KeyOf map -> a -> b) -> map a -> map b
ghc GHC.Cmm.Dataflow.Collections