module IntLike.Map
  ( IntLikeMap (..)
  , empty
  , singleton
  , fromList
  , size
  , null
  , member
  , toList
  , keys
  , keysSet
  , elems
  , lookup
  , partialLookup
  , findWithDefault
  , insert
  , insertWith
  , adjust
  , alter
  , delete
  , minViewWithKey
  , filter
  , restrictKeys
  , map
  , insertState
  , mapWithKey
  ) where

import Control.DeepSeq (NFData)
import Data.Coerce (Coercible, coerce)
import Data.IntMap.Strict (IntMap)
import qualified Data.IntMap.Strict as IntMap
import IntLike.Set (IntLikeSet (..))
import Prelude hiding (filter, lookup, map, null)

newtype IntLikeMap x a = IntLikeMap { forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap :: IntMap a }
  deriving stock (Int -> IntLikeMap x a -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall x a. Show a => Int -> IntLikeMap x a -> ShowS
forall x a. Show a => [IntLikeMap x a] -> ShowS
forall x a. Show a => IntLikeMap x a -> String
showList :: [IntLikeMap x a] -> ShowS
$cshowList :: forall x a. Show a => [IntLikeMap x a] -> ShowS
show :: IntLikeMap x a -> String
$cshow :: forall x a. Show a => IntLikeMap x a -> String
showsPrec :: Int -> IntLikeMap x a -> ShowS
$cshowsPrec :: forall x a. Show a => Int -> IntLikeMap x a -> ShowS
Show, forall {x}. Functor (IntLikeMap x)
forall {x}. Foldable (IntLikeMap x)
forall x (m :: * -> *) a.
Monad m =>
IntLikeMap x (m a) -> m (IntLikeMap x a)
forall x (f :: * -> *) a.
Applicative f =>
IntLikeMap x (f a) -> f (IntLikeMap x a)
forall x (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IntLikeMap x a -> m (IntLikeMap x b)
forall x (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IntLikeMap x a -> f (IntLikeMap x b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IntLikeMap x a -> f (IntLikeMap x b)
sequence :: forall (m :: * -> *) a.
Monad m =>
IntLikeMap x (m a) -> m (IntLikeMap x a)
$csequence :: forall x (m :: * -> *) a.
Monad m =>
IntLikeMap x (m a) -> m (IntLikeMap x a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IntLikeMap x a -> m (IntLikeMap x b)
$cmapM :: forall x (m :: * -> *) a b.
Monad m =>
(a -> m b) -> IntLikeMap x a -> m (IntLikeMap x b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
IntLikeMap x (f a) -> f (IntLikeMap x a)
$csequenceA :: forall x (f :: * -> *) a.
Applicative f =>
IntLikeMap x (f a) -> f (IntLikeMap x a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IntLikeMap x a -> f (IntLikeMap x b)
$ctraverse :: forall x (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> IntLikeMap x a -> f (IntLikeMap x b)
Traversable)
  deriving newtype (IntLikeMap x a -> IntLikeMap x a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall x a. Eq a => IntLikeMap x a -> IntLikeMap x a -> Bool
/= :: IntLikeMap x a -> IntLikeMap x a -> Bool
$c/= :: forall x a. Eq a => IntLikeMap x a -> IntLikeMap x a -> Bool
== :: IntLikeMap x a -> IntLikeMap x a -> Bool
$c== :: forall x a. Eq a => IntLikeMap x a -> IntLikeMap x a -> Bool
Eq, forall a b. a -> IntLikeMap x b -> IntLikeMap x a
forall a b. (a -> b) -> IntLikeMap x a -> IntLikeMap x b
forall x a b. a -> IntLikeMap x b -> IntLikeMap x a
forall x a b. (a -> b) -> IntLikeMap x a -> IntLikeMap x b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> IntLikeMap x b -> IntLikeMap x a
$c<$ :: forall x a b. a -> IntLikeMap x b -> IntLikeMap x a
fmap :: forall a b. (a -> b) -> IntLikeMap x a -> IntLikeMap x b
$cfmap :: forall x a b. (a -> b) -> IntLikeMap x a -> IntLikeMap x b
Functor, forall a. Eq a => a -> IntLikeMap x a -> Bool
forall a. Num a => IntLikeMap x a -> a
forall a. Ord a => IntLikeMap x a -> a
forall m. Monoid m => IntLikeMap x m -> m
forall a. IntLikeMap x a -> Bool
forall a. IntLikeMap x a -> Int
forall a. IntLikeMap x a -> [a]
forall a. (a -> a -> a) -> IntLikeMap x a -> a
forall x a. Eq a => a -> IntLikeMap x a -> Bool
forall x a. Num a => IntLikeMap x a -> a
forall x a. Ord a => IntLikeMap x a -> a
forall m a. Monoid m => (a -> m) -> IntLikeMap x a -> m
forall x m. Monoid m => IntLikeMap x m -> m
forall x a. IntLikeMap x a -> Bool
forall x a. IntLikeMap x a -> Int
forall x a. IntLikeMap x a -> [a]
forall b a. (b -> a -> b) -> b -> IntLikeMap x a -> b
forall a b. (a -> b -> b) -> b -> IntLikeMap x a -> b
forall x a. (a -> a -> a) -> IntLikeMap x a -> a
forall x m a. Monoid m => (a -> m) -> IntLikeMap x a -> m
forall x b a. (b -> a -> b) -> b -> IntLikeMap x a -> b
forall x a b. (a -> b -> b) -> b -> IntLikeMap x a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => IntLikeMap x a -> a
$cproduct :: forall x a. Num a => IntLikeMap x a -> a
sum :: forall a. Num a => IntLikeMap x a -> a
$csum :: forall x a. Num a => IntLikeMap x a -> a
minimum :: forall a. Ord a => IntLikeMap x a -> a
$cminimum :: forall x a. Ord a => IntLikeMap x a -> a
maximum :: forall a. Ord a => IntLikeMap x a -> a
$cmaximum :: forall x a. Ord a => IntLikeMap x a -> a
elem :: forall a. Eq a => a -> IntLikeMap x a -> Bool
$celem :: forall x a. Eq a => a -> IntLikeMap x a -> Bool
length :: forall a. IntLikeMap x a -> Int
$clength :: forall x a. IntLikeMap x a -> Int
null :: forall a. IntLikeMap x a -> Bool
$cnull :: forall x a. IntLikeMap x a -> Bool
toList :: forall a. IntLikeMap x a -> [a]
$ctoList :: forall x a. IntLikeMap x a -> [a]
foldl1 :: forall a. (a -> a -> a) -> IntLikeMap x a -> a
$cfoldl1 :: forall x a. (a -> a -> a) -> IntLikeMap x a -> a
foldr1 :: forall a. (a -> a -> a) -> IntLikeMap x a -> a
$cfoldr1 :: forall x a. (a -> a -> a) -> IntLikeMap x a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> IntLikeMap x a -> b
$cfoldl' :: forall x b a. (b -> a -> b) -> b -> IntLikeMap x a -> b
foldl :: forall b a. (b -> a -> b) -> b -> IntLikeMap x a -> b
$cfoldl :: forall x b a. (b -> a -> b) -> b -> IntLikeMap x a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> IntLikeMap x a -> b
$cfoldr' :: forall x a b. (a -> b -> b) -> b -> IntLikeMap x a -> b
foldr :: forall a b. (a -> b -> b) -> b -> IntLikeMap x a -> b
$cfoldr :: forall x a b. (a -> b -> b) -> b -> IntLikeMap x a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> IntLikeMap x a -> m
$cfoldMap' :: forall x m a. Monoid m => (a -> m) -> IntLikeMap x a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> IntLikeMap x a -> m
$cfoldMap :: forall x m a. Monoid m => (a -> m) -> IntLikeMap x a -> m
fold :: forall m. Monoid m => IntLikeMap x m -> m
$cfold :: forall x m. Monoid m => IntLikeMap x m -> m
Foldable, IntLikeMap x a -> ()
forall a. (a -> ()) -> NFData a
forall x a. NFData a => IntLikeMap x a -> ()
rnf :: IntLikeMap x a -> ()
$crnf :: forall x a. NFData a => IntLikeMap x a -> ()
NFData, NonEmpty (IntLikeMap x a) -> IntLikeMap x a
IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
forall b. Integral b => b -> IntLikeMap x a -> IntLikeMap x a
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall x a. NonEmpty (IntLikeMap x a) -> IntLikeMap x a
forall x a. IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
forall x a b. Integral b => b -> IntLikeMap x a -> IntLikeMap x a
stimes :: forall b. Integral b => b -> IntLikeMap x a -> IntLikeMap x a
$cstimes :: forall x a b. Integral b => b -> IntLikeMap x a -> IntLikeMap x a
sconcat :: NonEmpty (IntLikeMap x a) -> IntLikeMap x a
$csconcat :: forall x a. NonEmpty (IntLikeMap x a) -> IntLikeMap x a
<> :: IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
$c<> :: forall x a. IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
Semigroup, IntLikeMap x a
[IntLikeMap x a] -> IntLikeMap x a
IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
forall a.
Semigroup a -> a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall x a. Semigroup (IntLikeMap x a)
forall x a. IntLikeMap x a
forall x a. [IntLikeMap x a] -> IntLikeMap x a
forall x a. IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
mconcat :: [IntLikeMap x a] -> IntLikeMap x a
$cmconcat :: forall x a. [IntLikeMap x a] -> IntLikeMap x a
mappend :: IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
$cmappend :: forall x a. IntLikeMap x a -> IntLikeMap x a -> IntLikeMap x a
mempty :: IntLikeMap x a
$cmempty :: forall x a. IntLikeMap x a
Monoid)

empty :: IntLikeMap x a
empty :: forall x a. IntLikeMap x a
empty = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall a. IntMap a
IntMap.empty
{-# INLINE empty #-}

singleton :: Coercible x Int => x -> a -> IntLikeMap x a
singleton :: forall x a. Coercible x Int => x -> a -> IntLikeMap x a
singleton x
x = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> a -> IntMap a
IntMap.singleton (coerce :: forall a b. Coercible a b => a -> b
coerce x
x)
{-# INLINE singleton #-}

fromList :: Coercible x Int => [(x, a)] -> IntLikeMap x a
fromList :: forall x a. Coercible x Int => [(x, a)] -> IntLikeMap x a
fromList = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [(Int, a)] -> IntMap a
IntMap.fromList forall b c a. (b -> c) -> (a -> b) -> a -> c
. coerce :: forall a b. Coercible a b => a -> b
coerce
{-# INLINE fromList #-}

size :: IntLikeMap x a -> Int
size :: forall x a. IntLikeMap x a -> Int
size = forall a. IntMap a -> Int
IntMap.size forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE size #-}

null :: IntLikeMap x a -> Bool
null :: forall x a. IntLikeMap x a -> Bool
null = forall a. IntMap a -> Bool
IntMap.null forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE null #-}

member :: Coercible x Int => x -> IntLikeMap x a -> Bool
member :: forall x a. Coercible x Int => x -> IntLikeMap x a -> Bool
member x
x = forall a. Int -> IntMap a -> Bool
IntMap.member (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE member #-}

toList :: Coercible x Int => IntLikeMap x a -> [(x, a)]
toList :: forall x a. Coercible x Int => IntLikeMap x a -> [(x, a)]
toList = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IntMap a -> [(Int, a)]
IntMap.toList forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE toList #-}

keys :: Coercible x Int => IntLikeMap x a -> [x]
keys :: forall x a. Coercible x Int => IntLikeMap x a -> [x]
keys = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IntMap a -> [Int]
IntMap.keys forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE keys #-}

keysSet :: IntLikeMap x a -> IntLikeSet x
keysSet :: forall x a. IntLikeMap x a -> IntLikeSet x
keysSet = forall x. IntSet -> IntLikeSet x
IntLikeSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IntMap a -> IntSet
IntMap.keysSet forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE keysSet #-}

elems :: IntLikeMap x a -> [a]
elems :: forall x a. IntLikeMap x a -> [a]
elems = forall a. IntMap a -> [a]
IntMap.elems forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE elems #-}

lookup :: Coercible x Int => x -> IntLikeMap x a -> Maybe a
lookup :: forall x a. Coercible x Int => x -> IntLikeMap x a -> Maybe a
lookup x
x = forall a. Int -> IntMap a -> Maybe a
IntMap.lookup (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE lookup #-}

partialLookup :: Coercible x Int => x -> IntLikeMap x a -> a
partialLookup :: forall x a. Coercible x Int => x -> IntLikeMap x a -> a
partialLookup x
x IntLikeMap x a
m = forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap IntLikeMap x a
m forall a. IntMap a -> Int -> a
IntMap.! coerce :: forall a b. Coercible a b => a -> b
coerce x
x
{-# INLINE partialLookup #-}

findWithDefault :: Coercible x Int => a -> x -> IntLikeMap x a -> a
findWithDefault :: forall x a. Coercible x Int => a -> x -> IntLikeMap x a -> a
findWithDefault a
a x
x = forall a. a -> Int -> IntMap a -> a
IntMap.findWithDefault a
a (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE findWithDefault #-}

insert :: Coercible x Int => x -> a -> IntLikeMap x a -> IntLikeMap x a
insert :: forall x a.
Coercible x Int =>
x -> a -> IntLikeMap x a -> IntLikeMap x a
insert x
x a
a = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> a -> IntMap a -> IntMap a
IntMap.insert (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) a
a forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE insert #-}

insertWith :: Coercible x Int => (a -> a -> a) -> x -> a -> IntLikeMap x a -> IntLikeMap x a
insertWith :: forall x a.
Coercible x Int =>
(a -> a -> a) -> x -> a -> IntLikeMap x a -> IntLikeMap x a
insertWith a -> a -> a
f x
x a
a = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a -> a) -> Int -> a -> IntMap a -> IntMap a
IntMap.insertWith a -> a -> a
f (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) a
a forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE insertWith #-}

adjust :: Coercible x Int => (a -> a) -> x -> IntLikeMap x a -> IntLikeMap x a
adjust :: forall x a.
Coercible x Int =>
(a -> a) -> x -> IntLikeMap x a -> IntLikeMap x a
adjust a -> a
f x
x = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> a) -> Int -> IntMap a -> IntMap a
IntMap.adjust a -> a
f (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE adjust #-}

alter :: Coercible x Int => (Maybe a -> Maybe a) -> x -> IntLikeMap x a -> IntLikeMap x a
alter :: forall x a.
Coercible x Int =>
(Maybe a -> Maybe a) -> x -> IntLikeMap x a -> IntLikeMap x a
alter Maybe a -> Maybe a
f x
x = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Maybe a -> Maybe a) -> Int -> IntMap a -> IntMap a
IntMap.alter Maybe a -> Maybe a
f (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE alter #-}

delete :: Coercible x Int => x -> IntLikeMap x a -> IntLikeMap x a
delete :: forall x a.
Coercible x Int =>
x -> IntLikeMap x a -> IntLikeMap x a
delete x
x = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Int -> IntMap a -> IntMap a
IntMap.delete (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE delete #-}

minViewWithKey :: Coercible x Int => IntLikeMap x a -> Maybe ((x, a), IntLikeMap x a)
minViewWithKey :: forall x a.
Coercible x Int =>
IntLikeMap x a -> Maybe ((x, a), IntLikeMap x a)
minViewWithKey = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. IntMap a -> Maybe ((Int, a), IntMap a)
IntMap.minViewWithKey forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE minViewWithKey #-}

filter :: (a -> Bool) -> IntLikeMap x a -> IntLikeMap x a
filter :: forall a x. (a -> Bool) -> IntLikeMap x a -> IntLikeMap x a
filter a -> Bool
f = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (a -> Bool) -> IntMap a -> IntMap a
IntMap.filter a -> Bool
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE filter #-}

restrictKeys :: IntLikeMap x a -> IntLikeSet x -> IntLikeMap x a
restrictKeys :: forall x a. IntLikeMap x a -> IntLikeSet x -> IntLikeMap x a
restrictKeys IntLikeMap x a
m IntLikeSet x
s = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap (forall a. IntMap a -> IntSet -> IntMap a
IntMap.restrictKeys (forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap IntLikeMap x a
m) (forall x. IntLikeSet x -> IntSet
unIntLikeSet IntLikeSet x
s))
{-# INLINE restrictKeys #-}

map :: (a -> b) -> IntLikeMap x a -> IntLikeMap x b
map :: forall a b x. (a -> b) -> IntLikeMap x a -> IntLikeMap x b
map a -> b
f = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> IntMap a -> IntMap b
IntMap.map a -> b
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE map #-}

insertState :: Coercible x Int => (Maybe a -> b) -> x -> a -> IntLikeMap x a -> (b, IntLikeMap x a)
insertState :: forall x a b.
Coercible x Int =>
(Maybe a -> b) -> x -> a -> IntLikeMap x a -> (b, IntLikeMap x a)
insertState Maybe a -> b
f x
x a
a = coerce :: forall a b. Coercible a b => a -> b
coerce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a.
Functor f =>
(Maybe a -> f (Maybe a)) -> Int -> IntMap a -> f (IntMap a)
IntMap.alterF (\Maybe a
m -> (Maybe a -> b
f Maybe a
m, forall a. a -> Maybe a
Just a
a)) (coerce :: forall a b. Coercible a b => a -> b
coerce x
x) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE insertState #-}

mapWithKey :: Coercible x Int => (x -> a -> b) -> IntLikeMap x a -> IntLikeMap x b
mapWithKey :: forall x a b.
Coercible x Int =>
(x -> a -> b) -> IntLikeMap x a -> IntLikeMap x b
mapWithKey x -> a -> b
f = forall x a. IntMap a -> IntLikeMap x a
IntLikeMap forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Int -> a -> b) -> IntMap a -> IntMap b
IntMap.mapWithKey (coerce :: forall a b. Coercible a b => a -> b
coerce x -> a -> b
f) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall x a. IntLikeMap x a -> IntMap a
unIntLikeMap
{-# INLINE mapWithKey #-}