{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE PolyKinds #-}
{-# LANGUAGE QuantifiedConstraints #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# LANGUAGE StandaloneKindSignatures #-}
{-# LANGUAGE TypeApplications #-}
{-# LANGUAGE TypeFamilies #-}
module Data.Dependent.EnumMap.Strict.Internal where

import Prelude hiding (lookup, map)

import Control.Exception
import Data.Bifunctor (bimap, second)
import Data.Coerce
import Data.Dependent.Sum
import qualified Data.Foldable as Foldable
import qualified Data.IntMap.Strict as IM
import Data.Kind (Type)
import Data.Proxy
import Data.Some
import Data.Type.Equality
import Text.Show (showListWith)
import Unsafe.Coerce (unsafeCoerce)

type KV :: forall kind. (kind -> Type) -> (kind -> Type) -> Type
data KV k v = forall a. KV !(Enum1Info k) !(v a)

-- Invariant: the key-value pairs in a DEnumMap are type-consistent. That is to
-- say: they have the same type-index. Any other type equalities, like between
-- the key argument to 'lookup' and the key-value pairs in the map argument to
-- 'lookup', may /not/ hold, and should be type-checked as much as we're able.
newtype DEnumMap k v = DEnumMap (IM.IntMap (KV k v))

instance (Enum1 k, forall a. Show (k a), forall a. Show (v a))
      => Show (DEnumMap k v) where
  showsPrec :: Int -> DEnumMap k v -> ShowS
showsPrec Int
d DEnumMap k v
mp = Bool -> ShowS -> ShowS
showParen (Int
d Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
> Int
10) (ShowS -> ShowS) -> ShowS -> ShowS
forall a b. (a -> b) -> a -> b
$
    String -> ShowS
showString String
"fromList " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (DSum k v -> ShowS) -> [DSum k v] -> ShowS
forall a. (a -> ShowS) -> [a] -> ShowS
showListWith (\(k a
k :=> v a
v) -> Int -> k a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
2 k a
k ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ShowS
showString String
" :=> " ShowS -> ShowS -> ShowS
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> v a -> ShowS
forall a. Show a => Int -> a -> ShowS
showsPrec Int
1 v a
v) (DEnumMap k v -> [DSum k v]
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [DSum k v]
toList DEnumMap k v
mp)

-- | This class attempts to generalise 'Enum' to indexed data types: data types
-- with a GADT-like type parameter. Conversion to an 'Int' naturally loses type
-- information, and furthermore it is common to actually need some additional
-- data alongside the 'Int' to be able to reconstruct the original (in
-- 'toEnum1'). This additional data lives in 'Enum1Info'. The laws are:
--
-- [Unique IDs]
--   If @'fst' ('fromEnum1' x) == 'fst' ('fromEnum1' y)@ then @'testEquality' x y == 'Just' 'Refl' && x '==' y@
-- [Persistent IDs]
--   @'fst' ('fromEnum1' ('uncurry' 'toEnum1' ('fromEnum1' x))) == 'fst' ('fromEnum1' x)@
--
-- The "Unique IDs" law states that if the IDs of two values are equal, then
-- the values themselves must have the same type index, and furthermore be
-- equal. If @f@ does not implement 'TestEquality' or 'Eq', the law should
-- morally hold (but most of the API will be unusable).
--
-- The "Persistent IDs" law states that reconstructing a value using 'toEnum1'
-- does not change its ID.
--
-- __Note__: The methods on 'DEnumMap' attempt to check these laws using
-- 'assert' assertions (which are by default __disabled__ when optimisations
-- are on!), but full consistency cannot always be checked; if you break these
-- laws in a sufficiently clever way, the internals of 'DEnumMap' may
-- 'unsafeCoerce' unequal things and engage nasal demons, including crashes and
-- worse.
class Enum1 f where
  type Enum1Info f
  fromEnum1 :: f a -> (Int, Enum1Info f)
  toEnum1 :: Int -> Enum1Info f -> Some f

dSumToKV :: Enum1 k => DSum k v -> (Int, KV k v)
dSumToKV :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (k a
k :=> v a
v) = let (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k in (Int
i, Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf v a
v)

-- | Assumes that the input was obtained via 'fromEnum1'.
kVToDSum :: Enum1 k => (Int, KV k v) -> DSum k v
kVToDSum :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum (Int
i, KV Enum1Info k
inf v a
v) = case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a
k k a -> v a -> DSum k v
forall {k} (tag :: k -> *) (f :: k -> *) (a :: k).
tag a -> f a -> DSum tag f
:=> v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v

-- * Construction

empty :: DEnumMap k v
empty :: forall {kind} (k :: kind -> *) (v :: kind -> *). DEnumMap k v
empty = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v)
forall a. IntMap a
IM.empty

singleton :: Enum1 k => k a -> v a -> DEnumMap k v
singleton :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> v a -> DEnumMap k v
singleton k a
k v a
v =
  let (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (Int -> KV k v -> IntMap (KV k v)
forall a. Int -> a -> IntMap a
IM.singleton Int
i (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf v a
v))

-- TODO: Wait for DEnumSet.
-- fromSet

-- ** From Unordered Lists

fromList :: Enum1 k => [DSum k v] -> DEnumMap k v
fromList :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
[DSum k v] -> DEnumMap k v
fromList [DSum k v]
l = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ([(Int, KV k v)] -> IntMap (KV k v)
forall a. [(Int, a)] -> IntMap a
IM.fromList (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

fromListWith :: (Enum1 k, TestEquality k)
             => (forall a. v a -> v a -> v a)
             -> [DSum k v] -> DEnumMap k v
fromListWith :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v a -> v a -> v a)
-> [DSum k v] -> DEnumMap k v
fromListWith forall (a :: kind). v a -> v a -> v a
f ([DSum k v]
l :: [DSum k v]) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> KV k v -> KV k v)
-> [(Int, KV k v)] -> IntMap (KV k v)
forall a. (Int -> a -> a -> a) -> [(Int, a)] -> IntMap a
IM.fromListWithKey
             (\Int
i (KV Enum1Info k
inf1 v a
v1) (KV Enum1Info k
inf2 v a
v2) ->
                Proxy k -> Int -> Enum1Info k -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (proxy :: (k -> *) -> *) r.
(Enum1 k, TestEquality k) =>
proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 (forall {k} (t :: k). Proxy t
forall (t :: kind -> *). Proxy t
Proxy @k) Int
i Enum1Info k
inf1 Enum1Info k
inf2 (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$
                  Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v a -> v a -> v a
forall (a :: kind). v a -> v a -> v a
f v a
v1 (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2)))
             (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

fromListWithKey :: (Enum1 k, TestEquality k)
                => (forall a. k a -> v a -> v a -> v a)
                -> [DSum k v] -> DEnumMap k v
fromListWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). k a -> v a -> v a -> v a)
-> [DSum k v] -> DEnumMap k v
fromListWithKey forall (a :: kind). k a -> v a -> v a -> v a
f [DSum k v]
l =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> KV k v -> KV k v)
-> [(Int, KV k v)] -> IntMap (KV k v)
forall a. (Int -> a -> a -> a) -> [(Int, a)] -> IntMap a
IM.fromListWithKey
             (\Int
i (KV Enum1Info k
inf1 v a
v1) (KV Enum1Info k
inf2 v a
v2) ->
                case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf1 of
                  Some k a
k1 -> k a -> Int -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (k a -> v a -> v a -> v a
forall (a :: kind). k a -> v a -> v a -> v a
f k a
k1 (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v1) (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2)))
             (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

-- ** From Ascending Lists

fromAscList :: Enum1 k => [DSum k v] -> DEnumMap k v
fromAscList :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
[DSum k v] -> DEnumMap k v
fromAscList [DSum k v]
l = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ([(Int, KV k v)] -> IntMap (KV k v)
forall a. [(Int, a)] -> IntMap a
IM.fromAscList (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

fromAscListWith :: (Enum1 k, TestEquality k)
                => (forall a. v a -> v a -> v a)
                -> [DSum k v] -> DEnumMap k v
fromAscListWith :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v a -> v a -> v a)
-> [DSum k v] -> DEnumMap k v
fromAscListWith forall (a :: kind). v a -> v a -> v a
f ([DSum k v]
l :: [DSum k v]) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> KV k v -> KV k v)
-> [(Int, KV k v)] -> IntMap (KV k v)
forall a. (Int -> a -> a -> a) -> [(Int, a)] -> IntMap a
IM.fromAscListWithKey
             (\Int
i (KV Enum1Info k
inf1 v a
v1) (KV Enum1Info k
inf2 v a
v2) ->
               Proxy k -> Int -> Enum1Info k -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (proxy :: (k -> *) -> *) r.
(Enum1 k, TestEquality k) =>
proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 (forall {k} (t :: k). Proxy t
forall (t :: kind -> *). Proxy t
Proxy @k) Int
i Enum1Info k
inf1 Enum1Info k
inf2 (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$
                 Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v a -> v a -> v a
forall (a :: kind). v a -> v a -> v a
f v a
v1 (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2)))
             (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

fromAscListWithKey :: (Enum1 k, TestEquality k)
                   => (forall a. k a -> v a -> v a -> v a)
                   -> [DSum k v] -> DEnumMap k v
fromAscListWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). k a -> v a -> v a -> v a)
-> [DSum k v] -> DEnumMap k v
fromAscListWithKey forall (a :: kind). k a -> v a -> v a -> v a
f [DSum k v]
l =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> KV k v -> KV k v)
-> [(Int, KV k v)] -> IntMap (KV k v)
forall a. (Int -> a -> a -> a) -> [(Int, a)] -> IntMap a
IM.fromAscListWithKey
             (\Int
i (KV Enum1Info k
inf1 v a
v1) (KV Enum1Info k
inf2 v a
v2) ->
               case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf1 of
                 Some k a
k1 -> k a -> Int -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (k a -> v a -> v a -> v a
forall (a :: kind). k a -> v a -> v a -> v a
f k a
k1 (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v1) (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2)))
             (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

fromDistinctAscList :: Enum1 k => [DSum k v] -> DEnumMap k v
fromDistinctAscList :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
[DSum k v] -> DEnumMap k v
fromDistinctAscList [DSum k v]
l = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ([(Int, KV k v)] -> IntMap (KV k v)
forall a. [(Int, a)] -> IntMap a
IM.fromDistinctAscList (DSum k v -> (Int, KV k v)
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DSum k v -> (Int, KV k v)
dSumToKV (DSum k v -> (Int, KV k v)) -> [DSum k v] -> [(Int, KV k v)]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [DSum k v]
l))

-- * Insertion

insert :: Enum1 k => k a -> v a -> DEnumMap k v -> DEnumMap k v
insert :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> v a -> DEnumMap k v -> DEnumMap k v
insert k a
k v a
v (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (Int -> KV k v -> IntMap (KV k v) -> IntMap (KV k v)
forall a. Int -> a -> IntMap a -> IntMap a
IM.insert Int
i (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf v a
v) IntMap (KV k v)
m)

insertWith :: (Enum1 k, TestEquality k)
           => (v a -> v a -> v a)
           -> k a -> v a -> DEnumMap k v -> DEnumMap k v
insertWith :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
(v a -> v a -> v a) -> k a -> v a -> DEnumMap k v -> DEnumMap k v
insertWith = (k a -> v a -> v a -> v a)
-> k a -> v a -> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> v a -> v a)
-> k a -> v a -> DEnumMap k v -> DEnumMap k v
insertWithKey ((k a -> v a -> v a -> v a)
 -> k a -> v a -> DEnumMap k v -> DEnumMap k v)
-> ((v a -> v a -> v a) -> k a -> v a -> v a -> v a)
-> (v a -> v a -> v a)
-> k a
-> v a
-> DEnumMap k v
-> DEnumMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v a -> v a -> v a) -> k a -> v a -> v a -> v a
forall a b. a -> b -> a
const

insertWithKey :: (Enum1 k, TestEquality k)
              => (k a -> v a -> v a -> v a)
              -> k a -> v a -> DEnumMap k v -> DEnumMap k v
insertWithKey :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> v a -> v a)
-> k a -> v a -> DEnumMap k v -> DEnumMap k v
insertWithKey k a -> v a -> v a -> v a
f k a
k v a
v (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v -> KV k v -> KV k v)
-> Int -> KV k v -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (a -> a -> a) -> Int -> a -> IntMap a -> IntMap a
IM.insertWith
                (\KV k v
_ (KV Enum1Info k
inf' v a
v2) -> k a -> Int -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf' (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (k a -> v a -> v a -> v a
f k a
k v a
v (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2)))
                Int
i (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf v a
v) IntMap (KV k v)
m)

insertLookupWithKey :: (Enum1 k, TestEquality k)
                    => (k a -> v a -> v a -> v a)
                    -> k a -> v a -> DEnumMap k v -> (Maybe (v a), DEnumMap k v)
insertLookupWithKey :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> v a -> v a)
-> k a -> v a -> DEnumMap k v -> (Maybe (v a), DEnumMap k v)
insertLookupWithKey k a -> v a -> v a -> v a
f k a
k v a
v (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
      (!Maybe (KV k v)
mx, !IntMap (KV k v)
m') =
        (Int -> KV k v -> KV k v -> KV k v)
-> Int
-> KV k v
-> IntMap (KV k v)
-> (Maybe (KV k v), IntMap (KV k v))
forall a.
(Int -> a -> a -> a) -> Int -> a -> IntMap a -> (Maybe a, IntMap a)
IM.insertLookupWithKey
          (\Int
_ KV k v
_ (KV Enum1Info k
inf' v a
v2) -> k a -> Int -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf' (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (k a -> v a -> v a -> v a
f k a
k v a
v (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2)))
          Int
i (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf v a
v) IntMap (KV k v)
m
     -- Note: type checking unnecessary here, because by the BangPatterns,
     -- evaluating mx evaluates dmap, and the IntMap is strict, so the lambda
     -- will have run and typechecked the old value already.
     -- Second note: the BangPatterns don't do anything operationally because
     -- with the current implementation of IM.insertLookupWithKey, the pair
     -- components are already strict.
  in ((\(KV Enum1Info k
_ v a
v2) -> v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2) (KV k v -> v a) -> Maybe (KV k v) -> Maybe (v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (KV k v)
mx, IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v)
m')

-- * Deletion\/Update

delete :: Enum1 k => k a -> DEnumMap k v -> DEnumMap k v
delete :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> DEnumMap k v -> DEnumMap k v
delete k a
k (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (Int -> IntMap (KV k v) -> IntMap (KV k v)
forall a. Int -> IntMap a -> IntMap a
IM.delete ((Int, Enum1Info k) -> Int
forall a b. (a, b) -> a
fst (k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k)) IntMap (KV k v)
m)

adjust :: (Enum1 k, TestEquality k) => (v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v
adjust :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
(v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v
adjust = (k a -> v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v
adjustWithKey ((k a -> v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v)
-> ((v a -> v a) -> k a -> v a -> v a)
-> (v a -> v a)
-> k a
-> DEnumMap k v
-> DEnumMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v a -> v a) -> k a -> v a -> v a
forall a b. a -> b -> a
const

adjustWithKey :: (Enum1 k, TestEquality k) => (k a -> v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v
adjustWithKey :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> v a) -> k a -> DEnumMap k v -> DEnumMap k v
adjustWithKey k a -> v a -> v a
f k a
k (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v -> KV k v) -> Int -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (a -> a) -> Int -> IntMap a -> IntMap a
IM.adjust (\(KV Enum1Info k
inf v a
v) -> k a -> Int -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (k a -> v a -> v a
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v))) Int
i IntMap (KV k v)
m)

update :: (Enum1 k, TestEquality k) => (v a -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
update :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
(v a -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
update = (k a -> v a -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
updateWithKey ((k a -> v a -> Maybe (v a))
 -> k a -> DEnumMap k v -> DEnumMap k v)
-> ((v a -> Maybe (v a)) -> k a -> v a -> Maybe (v a))
-> (v a -> Maybe (v a))
-> k a
-> DEnumMap k v
-> DEnumMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v a -> Maybe (v a)) -> k a -> v a -> Maybe (v a)
forall a b. a -> b -> a
const

updateWithKey :: (Enum1 k, TestEquality k)
              => (k a -> v a -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
updateWithKey :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
updateWithKey k a -> v a -> Maybe (v a)
f k a
k (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v -> Maybe (KV k v))
-> Int -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (a -> Maybe a) -> Int -> IntMap a -> IntMap a
IM.update (\(KV Enum1Info k
inf v a
v) -> k a -> Int -> Enum1Info k -> Maybe (KV k v) -> Maybe (KV k v)
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf (Maybe (KV k v) -> Maybe (KV k v))
-> Maybe (KV k v) -> Maybe (KV k v)
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v a -> Maybe (v a)
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) Int
i IntMap (KV k v)
m)

updateLookupWithKey :: (Enum1 k, TestEquality k)
                    => (k a -> v a -> Maybe (v a)) -> k a -> DEnumMap k v -> (Maybe (v a), DEnumMap k v)
updateLookupWithKey :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(k a -> v a -> Maybe (v a))
-> k a -> DEnumMap k v -> (Maybe (v a), DEnumMap k v)
updateLookupWithKey k a -> v a -> Maybe (v a)
f k a
k (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
      (!Maybe (KV k v)
mx, !IntMap (KV k v)
m') =
        (Int -> KV k v -> Maybe (KV k v))
-> Int -> IntMap (KV k v) -> (Maybe (KV k v), IntMap (KV k v))
forall a.
(Int -> a -> Maybe a) -> Int -> IntMap a -> (Maybe a, IntMap a)
IM.updateLookupWithKey
          (\Int
_ (KV Enum1Info k
inf v a
v) -> k a -> Int -> Enum1Info k -> Maybe (KV k v) -> Maybe (KV k v)
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf (Maybe (KV k v) -> Maybe (KV k v))
-> Maybe (KV k v) -> Maybe (KV k v)
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v a -> Maybe (v a)
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v))
          Int
i IntMap (KV k v)
m
     -- Note: type checking unnecessary here for the same reason as insertLookupWithKey
  in ((\(KV Enum1Info k
_ v a
v2) -> v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2) (KV k v -> v a) -> Maybe (KV k v) -> Maybe (v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (KV k v)
mx, IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v)
m')

alter :: forall k v a. (Enum1 k, TestEquality k)
      => (Maybe (v a) -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
alter :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
(Maybe (v a) -> Maybe (v a)) -> k a -> DEnumMap k v -> DEnumMap k v
alter Maybe (v a) -> Maybe (v a)
f k a
k (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Maybe (KV k v) -> Maybe (KV k v))
-> Int -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Maybe a -> Maybe a) -> Int -> IntMap a -> IntMap a
IM.alter Maybe (KV k v) -> Maybe (KV k v)
f' Int
i IntMap (KV k v)
m)
  where
    (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k

    f' :: Maybe (KV k v) -> Maybe (KV k v)
    f' :: Maybe (KV k v) -> Maybe (KV k v)
f' Maybe (KV k v)
Nothing = Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (v a) -> Maybe (v a)
f Maybe (v a)
forall a. Maybe a
Nothing
    f' (Just (KV Enum1Info k
inf' v a
v)) = k a -> Int -> Enum1Info k -> Maybe (KV k v) -> Maybe (KV k v)
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf' (Maybe (KV k v) -> Maybe (KV k v))
-> Maybe (KV k v) -> Maybe (KV k v)
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (v a) -> Maybe (v a)
f (v a -> Maybe (v a)
forall a. a -> Maybe a
Just (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v))

alterF :: forall k v a f. (Functor f, Enum1 k, TestEquality k)
       => (Maybe (v a) -> f (Maybe (v a))) -> k a -> DEnumMap k v -> f (DEnumMap k v)
alterF :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind)
       (f :: * -> *).
(Functor f, Enum1 k, TestEquality k) =>
(Maybe (v a) -> f (Maybe (v a)))
-> k a -> DEnumMap k v -> f (DEnumMap k v)
alterF Maybe (v a) -> f (Maybe (v a))
f k a
k (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v) -> DEnumMap k v)
-> f (IntMap (KV k v)) -> f (DEnumMap k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe (KV k v) -> f (Maybe (KV k v)))
-> Int -> IntMap (KV k v) -> f (IntMap (KV k v))
forall (f :: * -> *) a.
Functor f =>
(Maybe a -> f (Maybe a)) -> Int -> IntMap a -> f (IntMap a)
IM.alterF Maybe (KV k v) -> f (Maybe (KV k v))
f' Int
i IntMap (KV k v)
m
  where
    (Int
i, Enum1Info k
inf) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k

    f' :: Maybe (KV k v) -> f (Maybe (KV k v))
    f' :: Maybe (KV k v) -> f (Maybe (KV k v))
f' Maybe (KV k v)
Nothing = (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) (Maybe (v a) -> Maybe (KV k v))
-> f (Maybe (v a)) -> f (Maybe (KV k v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (v a) -> f (Maybe (v a))
f Maybe (v a)
forall a. Maybe a
Nothing
    f' (Just (KV Enum1Info k
inf' v a
v)) = k a
-> Int -> Enum1Info k -> f (Maybe (KV k v)) -> f (Maybe (KV k v))
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf' (f (Maybe (KV k v)) -> f (Maybe (KV k v)))
-> f (Maybe (KV k v)) -> f (Maybe (KV k v))
forall a b. (a -> b) -> a -> b
$ (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) (Maybe (v a) -> Maybe (KV k v))
-> f (Maybe (v a)) -> f (Maybe (KV k v))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (v a) -> f (Maybe (v a))
f (v a -> Maybe (v a)
forall a. a -> Maybe a
Just (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v))

-- * Query
-- ** Lookup

lookup :: (Enum1 k, TestEquality k) => k a -> DEnumMap k v -> Maybe (v a)
lookup :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
k a -> DEnumMap k v -> Maybe (v a)
lookup k a
k (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in (\(KV Enum1Info k
inf v a
v) -> k a -> Int -> Enum1Info k -> v a -> v a
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v) (KV k v -> v a) -> Maybe (KV k v) -> Maybe (v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IntMap (KV k v) -> Maybe (KV k v)
forall a. Int -> IntMap a -> Maybe a
IM.lookup Int
i IntMap (KV k v)
m

(!?) :: (Enum1 k, TestEquality k) => DEnumMap k v -> k a -> Maybe (v a)
!? :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
DEnumMap k v -> k a -> Maybe (v a)
(!?) DEnumMap k v
m k a
k = k a -> DEnumMap k v -> Maybe (v a)
forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
k a -> DEnumMap k v -> Maybe (v a)
lookup k a
k DEnumMap k v
m

findWithDefault :: (Enum1 k, TestEquality k) => v a -> k a -> DEnumMap k v -> v a
findWithDefault :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
v a -> k a -> DEnumMap k v -> v a
findWithDefault v a
def k a
k (DEnumMap IntMap (KV k v)
m) =
  let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k
  in case KV k v -> Int -> IntMap (KV k v) -> KV k v
forall a. a -> Int -> IntMap a -> a
IM.findWithDefault (Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
forall a. HasCallStack => a
undefined v a
def) Int
i IntMap (KV k v)
m of
       KV Enum1Info k
inf' v a
v -> k a -> Int -> Enum1Info k -> v a -> v a
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k Int
i Enum1Info k
inf' (v a -> v a) -> v a -> v a
forall a b. (a -> b) -> a -> b
$ v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v

find :: (Enum1 k, TestEquality k) => k a -> DEnumMap k v -> v a
find :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
k a -> DEnumMap k v -> v a
find k a
k = v a -> k a -> DEnumMap k v -> v a
forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
v a -> k a -> DEnumMap k v -> v a
findWithDefault (String -> v a
forall a. HasCallStack => String -> a
error (String
"Data.Dependent.EnumMap.!: key " String -> ShowS
forall a. [a] -> [a] -> [a]
++ Int -> String
forall a. Show a => a -> String
show ((Int, Enum1Info k) -> Int
forall a b. (a, b) -> a
fst (k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k)) String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
" is not an element of the map")) k a
k

(!) :: (Enum1 k, TestEquality k) => DEnumMap k v -> k a -> v a
! :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
DEnumMap k v -> k a -> v a
(!) DEnumMap k v
m k a
k = k a -> DEnumMap k v -> v a
forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
k a -> DEnumMap k v -> v a
find k a
k DEnumMap k v
m

member :: Enum1 k => k a -> DEnumMap k v -> Bool
member :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> DEnumMap k v -> Bool
member k a
k (DEnumMap IntMap (KV k v)
m) = Int -> IntMap (KV k v) -> Bool
forall a. Int -> IntMap a -> Bool
IM.member ((Int, Enum1Info k) -> Int
forall a b. (a, b) -> a
fst (k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k)) IntMap (KV k v)
m

notMember :: Enum1 k => k a -> DEnumMap k v -> Bool
notMember :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> DEnumMap k v -> Bool
notMember k a
k DEnumMap k v
m = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ k a -> DEnumMap k v -> Bool
forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> DEnumMap k v -> Bool
member k a
k DEnumMap k v
m

lookupLT, lookupGT, lookupLE, lookupGE :: Enum1 k => k a -> DEnumMap k v -> Maybe (DSum k v)
lookupLT :: forall {k} (k :: k -> *) (a :: k) (v :: k -> *).
Enum1 k =>
k a -> DEnumMap k v -> Maybe (DSum k v)
lookupLT k a
k (DEnumMap IntMap (KV k v)
m) = let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: k). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k in (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v)
-> Maybe (Int, KV k v) -> Maybe (DSum k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IntMap (KV k v) -> Maybe (Int, KV k v)
forall a. Int -> IntMap a -> Maybe (Int, a)
IM.lookupLT Int
i IntMap (KV k v)
m
lookupGT :: forall {k} (k :: k -> *) (a :: k) (v :: k -> *).
Enum1 k =>
k a -> DEnumMap k v -> Maybe (DSum k v)
lookupGT k a
k (DEnumMap IntMap (KV k v)
m) = let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: k). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k in (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v)
-> Maybe (Int, KV k v) -> Maybe (DSum k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IntMap (KV k v) -> Maybe (Int, KV k v)
forall a. Int -> IntMap a -> Maybe (Int, a)
IM.lookupGT Int
i IntMap (KV k v)
m
lookupLE :: forall {k} (k :: k -> *) (a :: k) (v :: k -> *).
Enum1 k =>
k a -> DEnumMap k v -> Maybe (DSum k v)
lookupLE k a
k (DEnumMap IntMap (KV k v)
m) = let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: k). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k in (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v)
-> Maybe (Int, KV k v) -> Maybe (DSum k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IntMap (KV k v) -> Maybe (Int, KV k v)
forall a. Int -> IntMap a -> Maybe (Int, a)
IM.lookupLE Int
i IntMap (KV k v)
m
lookupGE :: forall {k} (k :: k -> *) (a :: k) (v :: k -> *).
Enum1 k =>
k a -> DEnumMap k v -> Maybe (DSum k v)
lookupGE k a
k (DEnumMap IntMap (KV k v)
m) = let (Int
i, Enum1Info k
_) = k a -> (Int, Enum1Info k)
forall (a :: k). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k in (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v)
-> Maybe (Int, KV k v) -> Maybe (DSum k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> IntMap (KV k v) -> Maybe (Int, KV k v)
forall a. Int -> IntMap a -> Maybe (Int, a)
IM.lookupGE Int
i IntMap (KV k v)
m

-- ** Size

null :: DEnumMap k v -> Bool
null :: forall {kind} (k :: kind -> *) (v :: kind -> *).
DEnumMap k v -> Bool
null (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> Bool
forall a. IntMap a -> Bool
IM.null IntMap (KV k v)
m

size :: DEnumMap k v -> Int
size :: forall {kind} (k :: kind -> *) (v :: kind -> *).
DEnumMap k v -> Int
size (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> Int
forall a. IntMap a -> Int
IM.size IntMap (KV k v)
m

-- * Combine

-- ** Union

union :: (Enum1 k, TestEquality k) => DEnumMap k v -> DEnumMap k v -> DEnumMap k v
union :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
DEnumMap k v -> DEnumMap k v -> DEnumMap k v
union = (forall (a :: kind). v a -> v a -> v a)
-> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v a -> v a -> v a)
-> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
unionWith v a -> v a -> v a
forall (a :: kind). v a -> v a -> v a
forall a b. a -> b -> a
const  -- if we're type checking, we need unionWith anyway, so might as well just delegate here already

unionWith :: (Enum1 k, TestEquality k)
          => (forall a. v a -> v a -> v a) -> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
unionWith :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v a -> v a -> v a)
-> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
unionWith forall (a :: kind). v a -> v a -> v a
f (DEnumMap IntMap (KV k v)
m1 :: DEnumMap k v) (DEnumMap IntMap (KV k v)
m2) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> KV k v -> KV k v)
-> IntMap (KV k v) -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
IM.unionWithKey Int -> KV k v -> KV k v -> KV k v
f' IntMap (KV k v)
m1 IntMap (KV k v)
m2)
  where
    f' :: Int -> KV k v -> KV k v -> KV k v
    f' :: Int -> KV k v -> KV k v -> KV k v
f' Int
i (KV Enum1Info k
inf1 v a
v1) (KV Enum1Info k
inf2 v a
v2) = Proxy k -> Int -> Enum1Info k -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (proxy :: (k -> *) -> *) r.
(Enum1 k, TestEquality k) =>
proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 (forall {k} (t :: k). Proxy t
forall (t :: kind -> *). Proxy t
Proxy @k) Int
i Enum1Info k
inf1 Enum1Info k
inf2 (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v a -> v a -> v a
forall (a :: kind). v a -> v a -> v a
f v a
v1 (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2))

unionWithKey :: (Enum1 k, TestEquality k)
             => (forall a. k a -> v a -> v a -> v a) -> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
unionWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). k a -> v a -> v a -> v a)
-> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
unionWithKey forall (a :: kind). k a -> v a -> v a -> v a
f (DEnumMap IntMap (KV k v)
m1 :: DEnumMap k v) (DEnumMap IntMap (KV k v)
m2) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> KV k v -> KV k v)
-> IntMap (KV k v) -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> a -> a -> a) -> IntMap a -> IntMap a -> IntMap a
IM.unionWithKey Int -> KV k v -> KV k v -> KV k v
f' IntMap (KV k v)
m1 IntMap (KV k v)
m2)
  where
    f' :: Int -> KV k v -> KV k v -> KV k v
    f' :: Int -> KV k v -> KV k v -> KV k v
f' Int
i (KV Enum1Info k
inf1 v a
v1) (KV Enum1Info k
inf2 v a
v2) = case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf1 of
      Some k a
k1 -> k a -> Int -> Enum1Info k -> KV k v -> KV k v
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 (KV k v -> KV k v) -> KV k v -> KV k v
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (k a -> v a -> v a -> v a
forall (a :: kind). k a -> v a -> v a -> v a
f k a
k1 (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v1) (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2))

unions :: (Foldable f, Enum1 k, TestEquality k) => f (DEnumMap k v) -> DEnumMap k v
unions :: forall {kind} (f :: * -> *) (k :: kind -> *) (v :: kind -> *).
(Foldable f, Enum1 k, TestEquality k) =>
f (DEnumMap k v) -> DEnumMap k v
unions = (DEnumMap k v -> DEnumMap k v -> DEnumMap k v)
-> DEnumMap k v -> f (DEnumMap k v) -> DEnumMap k v
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl' DEnumMap k v -> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
DEnumMap k v -> DEnumMap k v -> DEnumMap k v
union DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *). DEnumMap k v
empty

unionsWith :: (Foldable f, Enum1 k, TestEquality k)
           => (forall a. v a -> v a -> v a) -> f (DEnumMap k v) -> DEnumMap k v
unionsWith :: forall {kind} (f :: * -> *) (k :: kind -> *) (v :: kind -> *).
(Foldable f, Enum1 k, TestEquality k) =>
(forall (a :: kind). v a -> v a -> v a)
-> f (DEnumMap k v) -> DEnumMap k v
unionsWith forall (a :: kind). v a -> v a -> v a
f = (DEnumMap k v -> DEnumMap k v -> DEnumMap k v)
-> DEnumMap k v -> f (DEnumMap k v) -> DEnumMap k v
forall b a. (b -> a -> b) -> b -> f a -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
Foldable.foldl' ((forall (a :: kind). v a -> v a -> v a)
-> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v a -> v a -> v a)
-> DEnumMap k v -> DEnumMap k v -> DEnumMap k v
unionWith v a -> v a -> v a
forall (a :: kind). v a -> v a -> v a
f) DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *). DEnumMap k v
empty

-- ** Difference

difference :: DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
difference :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
difference (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v1) -> DEnumMap k v1
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v1) -> IntMap (KV k v2) -> IntMap (KV k v1)
forall a b. IntMap a -> IntMap b -> IntMap a
IM.difference IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)

(\\) :: DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
DEnumMap k v1
m1 \\ :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
\\ DEnumMap k v2
m2 = DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
difference DEnumMap k v1
m1 DEnumMap k v2
m2

differenceWith :: forall k v1 v2. (Enum1 k, TestEquality k)
               => (forall a. v1 a -> v2 a -> Maybe (v1 a)) -> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
differenceWith :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v1 a -> v2 a -> Maybe (v1 a))
-> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
differenceWith forall (a :: kind). v1 a -> v2 a -> Maybe (v1 a)
f (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v1) -> DEnumMap k v1
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1))
-> IntMap (KV k v1) -> IntMap (KV k v2) -> IntMap (KV k v1)
forall a b.
(Int -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
IM.differenceWithKey Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1)
f' IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)
  where
    f' :: Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1)
    f' :: Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1)
f' Int
i (KV Enum1Info k
inf1 v1 a
v1) (KV Enum1Info k
inf2 v2 a
v2) =
      Proxy k
-> Int
-> Enum1Info k
-> Enum1Info k
-> Maybe (KV k v1)
-> Maybe (KV k v1)
forall {k} (k :: k -> *) (proxy :: (k -> *) -> *) r.
(Enum1 k, TestEquality k) =>
proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 (forall {k} (t :: k). Proxy t
forall (t :: kind -> *). Proxy t
Proxy @k) Int
i Enum1Info k
inf1 Enum1Info k
inf2 (Maybe (KV k v1) -> Maybe (KV k v1))
-> Maybe (KV k v1) -> Maybe (KV k v1)
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v1 Any -> KV k v1
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v1 Any -> KV k v1) -> Maybe (v1 Any) -> Maybe (KV k v1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> v1 Any -> v2 Any -> Maybe (v1 Any)
forall (a :: kind). v1 a -> v2 a -> Maybe (v1 a)
f (v1 a -> v1 Any
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) (v2 a -> v2 Any
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

differenceWithKey :: forall k v1 v2. (Enum1 k, TestEquality k)
                  => (forall a. k a -> v1 a -> v2 a -> Maybe (v1 a)) -> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
differenceWithKey :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). k a -> v1 a -> v2 a -> Maybe (v1 a))
-> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
differenceWithKey forall (a :: kind). k a -> v1 a -> v2 a -> Maybe (v1 a)
f (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v1) -> DEnumMap k v1
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1))
-> IntMap (KV k v1) -> IntMap (KV k v2) -> IntMap (KV k v1)
forall a b.
(Int -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
IM.differenceWithKey Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1)
f' IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)
  where
    f' :: Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1)
    f' :: Int -> KV k v1 -> KV k v2 -> Maybe (KV k v1)
f' Int
i (KV Enum1Info k
inf1 v1 a
v1) (KV Enum1Info k
inf2 v2 a
v2) = case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf1 of
      Some k a
k1 -> k a -> Int -> Enum1Info k -> Maybe (KV k v1) -> Maybe (KV k v1)
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 (Maybe (KV k v1) -> Maybe (KV k v1))
-> Maybe (KV k v1) -> Maybe (KV k v1)
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v1 a -> KV k v1
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v1 a -> KV k v1) -> Maybe (v1 a) -> Maybe (KV k v1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v1 a -> v2 a -> Maybe (v1 a)
forall (a :: kind). k a -> v1 a -> v2 a -> Maybe (v1 a)
f k a
k1 (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

-- | Because the underlying maps are keyed on integers, it is possible to
-- subtract a map from another even if the key types differ. This function
-- assumes that the @Int@ identifiers of @k1@ and @k2@ are compatible, i.e.
-- that "2" in @k1@ somehow means the same thing as "2" in @k2@.
--
-- Because the key types are different, there is no guarantee whatsoever (even
-- not by 'Enum1' laws) that equal key IDs in @k1@ and @k2@ actually have the
-- same type index (@a@). Hence, the combining function gets key-value pairs
-- with potentially distinct type indices.
differenceWithKey' :: forall k1 k2 v1 v2. (Enum1 k1, Enum1 k2)
                   => (forall a b. k1 a -> v1 a -> k2 b -> v2 b -> Maybe (v1 a))
                   -> DEnumMap k1 v1 -> DEnumMap k2 v2 -> DEnumMap k1 v1
differenceWithKey' :: forall {kind} {kind} (k1 :: kind -> *) (k2 :: kind -> *)
       (v1 :: kind -> *) (v2 :: kind -> *).
(Enum1 k1, Enum1 k2) =>
(forall (a :: kind) (b :: kind).
 k1 a -> v1 a -> k2 b -> v2 b -> Maybe (v1 a))
-> DEnumMap k1 v1 -> DEnumMap k2 v2 -> DEnumMap k1 v1
differenceWithKey' forall (a :: kind) (b :: kind).
k1 a -> v1 a -> k2 b -> v2 b -> Maybe (v1 a)
f (DEnumMap IntMap (KV k1 v1)
m1) (DEnumMap IntMap (KV k2 v2)
m2) = IntMap (KV k1 v1) -> DEnumMap k1 v1
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k1 v1 -> KV k2 v2 -> Maybe (KV k1 v1))
-> IntMap (KV k1 v1) -> IntMap (KV k2 v2) -> IntMap (KV k1 v1)
forall a b.
(Int -> a -> b -> Maybe a) -> IntMap a -> IntMap b -> IntMap a
IM.differenceWithKey Int -> KV k1 v1 -> KV k2 v2 -> Maybe (KV k1 v1)
f' IntMap (KV k1 v1)
m1 IntMap (KV k2 v2)
m2)
  where
    f' :: Int -> KV k1 v1 -> KV k2 v2 -> Maybe (KV k1 v1)
    f' :: Int -> KV k1 v1 -> KV k2 v2 -> Maybe (KV k1 v1)
f' Int
i (KV Enum1Info k1
inf1 v1 a
v1) (KV Enum1Info k2
inf2 v2 a
v2) = case (Int -> Enum1Info k1 -> Some k1
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k1
inf1, Int -> Enum1Info k2 -> Some k2
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k2
inf2) of
      (Some k1 a
k1, Some k2 a
k2) -> Enum1Info k1 -> v1 a -> KV k1 v1
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k1
inf1 (v1 a -> KV k1 v1) -> Maybe (v1 a) -> Maybe (KV k1 v1)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k1 a -> v1 a -> k2 a -> v2 a -> Maybe (v1 a)
forall (a :: kind) (b :: kind).
k1 a -> v1 a -> k2 b -> v2 b -> Maybe (v1 a)
f k1 a
k1 (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) k2 a
k2 (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

-- ** Intersection

intersection :: DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
intersection :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v1
intersection (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v1) -> DEnumMap k v1
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v1) -> IntMap (KV k v2) -> IntMap (KV k v1)
forall a b. IntMap a -> IntMap b -> IntMap a
IM.intersection IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)

intersectionWith :: forall k v1 v2 v3. (Enum1 k, TestEquality k)
                 => (forall a. v1 a -> v2 a -> v3 a) -> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v3
intersectionWith :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *)
       (v3 :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). v1 a -> v2 a -> v3 a)
-> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v3
intersectionWith forall (a :: kind). v1 a -> v2 a -> v3 a
f (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v3) -> DEnumMap k v3
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> KV k v2 -> KV k v3)
-> IntMap (KV k v1) -> IntMap (KV k v2) -> IntMap (KV k v3)
forall a b c.
(Int -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWithKey Int -> KV k v1 -> KV k v2 -> KV k v3
f' IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)
  where
    f' :: Int -> KV k v1 -> KV k v2 -> KV k v3
    f' :: Int -> KV k v1 -> KV k v2 -> KV k v3
f' Int
i (KV Enum1Info k
inf1 v1 a
v1) (KV Enum1Info k
inf2 v2 a
v2) =
      Proxy k -> Int -> Enum1Info k -> Enum1Info k -> KV k v3 -> KV k v3
forall {k} (k :: k -> *) (proxy :: (k -> *) -> *) r.
(Enum1 k, TestEquality k) =>
proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 (forall {k} (t :: k). Proxy t
forall (t :: kind -> *). Proxy t
Proxy @k) Int
i Enum1Info k
inf1 Enum1Info k
inf2 (KV k v3 -> KV k v3) -> KV k v3 -> KV k v3
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v3 Any -> KV k v3
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v3 Any -> KV k v3) -> v3 Any -> KV k v3
forall a b. (a -> b) -> a -> b
$ v1 Any -> v2 Any -> v3 Any
forall (a :: kind). v1 a -> v2 a -> v3 a
f (v1 a -> v1 Any
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) (v2 a -> v2 Any
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

intersectionWithKey :: forall k v1 v2 v3. (Enum1 k, TestEquality k)
                    => (forall a. k a -> v1 a -> v2 a -> v3 a) -> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v3
intersectionWithKey :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *)
       (v3 :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). k a -> v1 a -> v2 a -> v3 a)
-> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v3
intersectionWithKey forall (a :: kind). k a -> v1 a -> v2 a -> v3 a
f (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v3) -> DEnumMap k v3
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> KV k v2 -> KV k v3)
-> IntMap (KV k v1) -> IntMap (KV k v2) -> IntMap (KV k v3)
forall a b c.
(Int -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWithKey Int -> KV k v1 -> KV k v2 -> KV k v3
f' IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)
  where
    f' :: Int -> KV k v1 -> KV k v2 -> KV k v3
    f' :: Int -> KV k v1 -> KV k v2 -> KV k v3
f' Int
i (KV Enum1Info k
inf1 v1 a
v1) (KV Enum1Info k
inf2 v2 a
v2) = case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf1 of
      Some k a
k1 -> k a -> Int -> Enum1Info k -> KV k v3 -> KV k v3
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 (KV k v3 -> KV k v3) -> KV k v3 -> KV k v3
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v3 a -> KV k v3
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v3 a -> KV k v3) -> v3 a -> KV k v3
forall a b. (a -> b) -> a -> b
$ k a -> v1 a -> v2 a -> v3 a
forall (a :: kind). k a -> v1 a -> v2 a -> v3 a
f k a
k1 (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

-- | Generalises 'intersectionWithKey' in the same way as 'differenceWithKey''
-- generalises 'differenceWithKey'.
intersectionWithKey' :: forall k1 k2 v1 v2 v3. (Enum1 k1, Enum1 k2)
                     => (forall a b. k1 a -> v1 a -> k2 b -> v2 b -> v3 a)
                     -> DEnumMap k1 v1 -> DEnumMap k2 v2 -> DEnumMap k1 v3
intersectionWithKey' :: forall {kind} {kind} (k1 :: kind -> *) (k2 :: kind -> *)
       (v1 :: kind -> *) (v2 :: kind -> *) (v3 :: kind -> *).
(Enum1 k1, Enum1 k2) =>
(forall (a :: kind) (b :: kind).
 k1 a -> v1 a -> k2 b -> v2 b -> v3 a)
-> DEnumMap k1 v1 -> DEnumMap k2 v2 -> DEnumMap k1 v3
intersectionWithKey' forall (a :: kind) (b :: kind).
k1 a -> v1 a -> k2 b -> v2 b -> v3 a
f (DEnumMap IntMap (KV k1 v1)
m1) (DEnumMap IntMap (KV k2 v2)
m2) = IntMap (KV k1 v3) -> DEnumMap k1 v3
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k1 v1 -> KV k2 v2 -> KV k1 v3)
-> IntMap (KV k1 v1) -> IntMap (KV k2 v2) -> IntMap (KV k1 v3)
forall a b c.
(Int -> a -> b -> c) -> IntMap a -> IntMap b -> IntMap c
IM.intersectionWithKey Int -> KV k1 v1 -> KV k2 v2 -> KV k1 v3
f' IntMap (KV k1 v1)
m1 IntMap (KV k2 v2)
m2)
  where
    f' :: Int -> KV k1 v1 -> KV k2 v2 -> KV k1 v3
    f' :: Int -> KV k1 v1 -> KV k2 v2 -> KV k1 v3
f' Int
i (KV Enum1Info k1
inf1 v1 a
v1) (KV Enum1Info k2
inf2 v2 a
v2) = case (Int -> Enum1Info k1 -> Some k1
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k1
inf1, Int -> Enum1Info k2 -> Some k2
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k2
inf2) of
      (Some k1 a
k1, Some k2 a
k2) -> Enum1Info k1 -> v3 a -> KV k1 v3
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k1
inf1 (v3 a -> KV k1 v3) -> v3 a -> KV k1 v3
forall a b. (a -> b) -> a -> b
$ k1 a -> v1 a -> k2 a -> v2 a -> v3 a
forall (a :: kind) (b :: kind).
k1 a -> v1 a -> k2 b -> v2 b -> v3 a
f k1 a
k1 (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) k2 a
k2 (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

-- ** Disjoint

disjoint :: DEnumMap k v1 -> DEnumMap k v2 -> Bool
disjoint :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
DEnumMap k v1 -> DEnumMap k v2 -> Bool
disjoint (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) = IntMap (KV k v1) -> IntMap (KV k v2) -> Bool
forall a b. IntMap a -> IntMap b -> Bool
IM.disjoint IntMap (KV k v1)
m1 IntMap (KV k v2)
m2

-- ** Compose

compose :: (Enum1 k2, TestEquality k2) => DEnumMap k2 v -> DEnumMap k1 k2 -> DEnumMap k1 v
compose :: forall {kind} (k2 :: kind -> *) (v :: kind -> *) (k1 :: kind -> *).
(Enum1 k2, TestEquality k2) =>
DEnumMap k2 v -> DEnumMap k1 k2 -> DEnumMap k1 v
compose DEnumMap k2 v
m2v (DEnumMap IntMap (KV k1 k2)
m12) =
  IntMap (KV k1 v) -> DEnumMap k1 v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k1 k2 -> Maybe (KV k1 v))
-> IntMap (KV k1 k2) -> IntMap (KV k1 v)
forall a b. (a -> Maybe b) -> IntMap a -> IntMap b
IM.mapMaybe (\(KV Enum1Info k1
inf1 k2 a
k2) -> Enum1Info k1 -> v a -> KV k1 v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k1
inf1 (v a -> KV k1 v) -> Maybe (v a) -> Maybe (KV k1 v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DEnumMap k2 v
m2v DEnumMap k2 v -> k2 a -> Maybe (v a)
forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
(Enum1 k, TestEquality k) =>
DEnumMap k v -> k a -> Maybe (v a)
!? k2 a
k2) IntMap (KV k1 k2)
m12)

-- ** Universal combining function

mergeWithKey :: forall k v1 v2 v3. (Enum1 k, TestEquality k)
             => (forall a. k a -> v1 a -> v2 a -> Maybe (v3 a))
             -> (DEnumMap k v1 -> DEnumMap k v3)
             -> (DEnumMap k v2 -> DEnumMap k v3)
             -> DEnumMap k v1 -> DEnumMap k v2 -> DEnumMap k v3
mergeWithKey :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *)
       (v3 :: kind -> *).
(Enum1 k, TestEquality k) =>
(forall (a :: kind). k a -> v1 a -> v2 a -> Maybe (v3 a))
-> (DEnumMap k v1 -> DEnumMap k v3)
-> (DEnumMap k v2 -> DEnumMap k v3)
-> DEnumMap k v1
-> DEnumMap k v2
-> DEnumMap k v3
mergeWithKey forall (a :: kind). k a -> v1 a -> v2 a -> Maybe (v3 a)
f DEnumMap k v1 -> DEnumMap k v3
g1 DEnumMap k v2 -> DEnumMap k v3
g2 (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) =
  IntMap (KV k v3) -> DEnumMap k v3
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> KV k v2 -> Maybe (KV k v3))
-> (IntMap (KV k v1) -> IntMap (KV k v3))
-> (IntMap (KV k v2) -> IntMap (KV k v3))
-> IntMap (KV k v1)
-> IntMap (KV k v2)
-> IntMap (KV k v3)
forall a b c.
(Int -> a -> b -> Maybe c)
-> (IntMap a -> IntMap c)
-> (IntMap b -> IntMap c)
-> IntMap a
-> IntMap b
-> IntMap c
IM.mergeWithKey Int -> KV k v1 -> KV k v2 -> Maybe (KV k v3)
f' ((DEnumMap k v1 -> DEnumMap k v3)
-> IntMap (KV k v1) -> IntMap (KV k v3)
forall a b. Coercible a b => a -> b
coerce DEnumMap k v1 -> DEnumMap k v3
g1) ((DEnumMap k v2 -> DEnumMap k v3)
-> IntMap (KV k v2) -> IntMap (KV k v3)
forall a b. Coercible a b => a -> b
coerce DEnumMap k v2 -> DEnumMap k v3
g2) IntMap (KV k v1)
m1 IntMap (KV k v2)
m2)
  where
    f' :: Int -> KV k v1 -> KV k v2 -> Maybe (KV k v3)
    f' :: Int -> KV k v1 -> KV k v2 -> Maybe (KV k v3)
f' Int
i (KV Enum1Info k
inf1 v1 a
v1) (KV Enum1Info k
inf2 v2 a
v2) = case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf1 of
      Some k a
k1 -> k a -> Int -> Enum1Info k -> Maybe (KV k v3) -> Maybe (KV k v3)
forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 (Maybe (KV k v3) -> Maybe (KV k v3))
-> Maybe (KV k v3) -> Maybe (KV k v3)
forall a b. (a -> b) -> a -> b
$ Enum1Info k -> v3 a -> KV k v3
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf1 (v3 a -> KV k v3) -> Maybe (v3 a) -> Maybe (KV k v3)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v1 a -> v2 a -> Maybe (v3 a)
forall (a :: kind). k a -> v1 a -> v2 a -> Maybe (v3 a)
f k a
k1 (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v1) (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)

-- * Traversal
-- ** Map

map :: Enum1 k => (forall a. v1 a -> v2 a) -> DEnumMap k v1 -> DEnumMap k v2
map :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). v1 a -> v2 a)
-> DEnumMap k v1 -> DEnumMap k v2
map forall (a :: kind). v1 a -> v2 a
f = (forall (a :: kind). k a -> v1 a -> v2 a)
-> DEnumMap k v1 -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v1 a -> v2 a)
-> DEnumMap k v1 -> DEnumMap k v2
mapWithKey ((v1 a -> v2 a) -> k a -> v1 a -> v2 a
forall a b. a -> b -> a
const v1 a -> v2 a
forall (a :: kind). v1 a -> v2 a
f)

mapWithKey :: Enum1 k => (forall a. k a -> v1 a -> v2 a) -> DEnumMap k v1 -> DEnumMap k v2
mapWithKey :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v1 a -> v2 a)
-> DEnumMap k v1 -> DEnumMap k v2
mapWithKey forall (a :: kind). k a -> v1 a -> v2 a
f (DEnumMap IntMap (KV k v1)
m) =
  IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> KV k v2) -> IntMap (KV k v1) -> IntMap (KV k v2)
forall a b. (Int -> a -> b) -> IntMap a -> IntMap b
IM.mapWithKey (\Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v2 a -> KV k v2) -> v2 a -> KV k v2
forall a b. (a -> b) -> a -> b
$ k a -> v1 a -> v2 a
forall (a :: kind). k a -> v1 a -> v2 a
f k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) IntMap (KV k v1)
m)

traverseWithKey :: (Applicative f, Enum1 k)
                => (forall a. k a -> v1 a -> f (v2 a)) -> DEnumMap k v1 -> f (DEnumMap k v2)
traverseWithKey :: forall {kind} (f :: * -> *) (k :: kind -> *) (v1 :: kind -> *)
       (v2 :: kind -> *).
(Applicative f, Enum1 k) =>
(forall (a :: kind). k a -> v1 a -> f (v2 a))
-> DEnumMap k v1 -> f (DEnumMap k v2)
traverseWithKey forall (a :: kind). k a -> v1 a -> f (v2 a)
f (DEnumMap IntMap (KV k v1)
m) =
  IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v2) -> DEnumMap k v2)
-> f (IntMap (KV k v2)) -> f (DEnumMap k v2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> KV k v1 -> f (KV k v2))
-> IntMap (KV k v1) -> f (IntMap (KV k v2))
forall (t :: * -> *) a b.
Applicative t =>
(Int -> a -> t b) -> IntMap a -> t (IntMap b)
IM.traverseWithKey (\Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v2 a -> KV k v2) -> f (v2 a) -> f (KV k v2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v1 a -> f (v2 a)
forall (a :: kind). k a -> v1 a -> f (v2 a)
f k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) IntMap (KV k v1)
m

traverseMaybeWithKey :: (Applicative f, Enum1 k)
                     => (forall a. k a -> v1 a -> f (Maybe (v2 a))) -> DEnumMap k v1 -> f (DEnumMap k v2)
traverseMaybeWithKey :: forall {kind} (f :: * -> *) (k :: kind -> *) (v1 :: kind -> *)
       (v2 :: kind -> *).
(Applicative f, Enum1 k) =>
(forall (a :: kind). k a -> v1 a -> f (Maybe (v2 a)))
-> DEnumMap k v1 -> f (DEnumMap k v2)
traverseMaybeWithKey forall (a :: kind). k a -> v1 a -> f (Maybe (v2 a))
f (DEnumMap IntMap (KV k v1)
m) =
  IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v2) -> DEnumMap k v2)
-> f (IntMap (KV k v2)) -> f (DEnumMap k v2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Int -> KV k v1 -> f (Maybe (KV k v2)))
-> IntMap (KV k v1) -> f (IntMap (KV k v2))
forall (f :: * -> *) a b.
Applicative f =>
(Int -> a -> f (Maybe b)) -> IntMap a -> f (IntMap b)
IM.traverseMaybeWithKey (\Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> (v2 a -> KV k v2) -> Maybe (v2 a) -> Maybe (KV k v2)
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) (Maybe (v2 a) -> Maybe (KV k v2))
-> f (Maybe (v2 a)) -> f (Maybe (KV k v2))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v1 a -> f (Maybe (v2 a))
forall (a :: kind). k a -> v1 a -> f (Maybe (v2 a))
f k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) IntMap (KV k v1)
m

mapAccum :: Enum1 k => (forall a. acc -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccum :: forall {kind} (k :: kind -> *) acc (v1 :: kind -> *)
       (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). acc -> v1 a -> (acc, v2 a))
-> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccum forall (a :: kind). acc -> v1 a -> (acc, v2 a)
f = (forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a))
-> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
forall {kind} (k :: kind -> *) acc (v1 :: kind -> *)
       (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a))
-> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccumWithKey (\acc
x k a
_ v1 a
y -> acc -> v1 a -> (acc, v2 a)
forall (a :: kind). acc -> v1 a -> (acc, v2 a)
f acc
x v1 a
y)

mapAccumWithKey :: Enum1 k => (forall a. acc -> k a -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccumWithKey :: forall {kind} (k :: kind -> *) acc (v1 :: kind -> *)
       (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a))
-> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccumWithKey forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a)
f acc
acc0 (DEnumMap IntMap (KV k v1)
m) =
  (IntMap (KV k v2) -> DEnumMap k v2)
-> (acc, IntMap (KV k v2)) -> (acc, DEnumMap k v2)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((acc, IntMap (KV k v2)) -> (acc, DEnumMap k v2))
-> (acc, IntMap (KV k v2)) -> (acc, DEnumMap k v2)
forall a b. (a -> b) -> a -> b
$ (acc -> Int -> KV k v1 -> (acc, KV k v2))
-> acc -> IntMap (KV k v1) -> (acc, IntMap (KV k v2))
forall a b c.
(a -> Int -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
IM.mapAccumWithKey (\acc
acc Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> (v2 a -> KV k v2) -> (acc, v2 a) -> (acc, KV k v2)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) ((acc, v2 a) -> (acc, KV k v2)) -> (acc, v2 a) -> (acc, KV k v2)
forall a b. (a -> b) -> a -> b
$ acc -> k a -> v1 a -> (acc, v2 a)
forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a)
f acc
acc k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) acc
acc0 IntMap (KV k v1)
m

mapAccumRWithKey :: Enum1 k => (forall a. acc -> k a -> v1 a -> (acc, v2 a)) -> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccumRWithKey :: forall {kind} (k :: kind -> *) acc (v1 :: kind -> *)
       (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a))
-> acc -> DEnumMap k v1 -> (acc, DEnumMap k v2)
mapAccumRWithKey forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a)
f acc
acc0 (DEnumMap IntMap (KV k v1)
m) =
  (IntMap (KV k v2) -> DEnumMap k v2)
-> (acc, IntMap (KV k v2)) -> (acc, DEnumMap k v2)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((acc, IntMap (KV k v2)) -> (acc, DEnumMap k v2))
-> (acc, IntMap (KV k v2)) -> (acc, DEnumMap k v2)
forall a b. (a -> b) -> a -> b
$ (acc -> Int -> KV k v1 -> (acc, KV k v2))
-> acc -> IntMap (KV k v1) -> (acc, IntMap (KV k v2))
forall a b c.
(a -> Int -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)
IM.mapAccumRWithKey (\acc
acc Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> (v2 a -> KV k v2) -> (acc, v2 a) -> (acc, KV k v2)
forall b c a. (b -> c) -> (a, b) -> (a, c)
forall (p :: * -> * -> *) b c a.
Bifunctor p =>
(b -> c) -> p a b -> p a c
second (Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) ((acc, v2 a) -> (acc, KV k v2)) -> (acc, v2 a) -> (acc, KV k v2)
forall a b. (a -> b) -> a -> b
$ acc -> k a -> v1 a -> (acc, v2 a)
forall (a :: kind). acc -> k a -> v1 a -> (acc, v2 a)
f acc
acc k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) acc
acc0 IntMap (KV k v1)
m

-- TODO: These are hard. Probably we can't avoid using a fold, analogously as in IntMap.
-- mapKeys
-- mapKeysWith
-- mapKeysMonotonic

-- * Folds

foldr :: (forall a. v a -> acc -> acc) -> acc -> DEnumMap k v -> acc
foldr :: forall {kind} (v :: kind -> *) acc (k :: kind -> *).
(forall (a :: kind). v a -> acc -> acc)
-> acc -> DEnumMap k v -> acc
foldr forall (a :: kind). v a -> acc -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) = (KV k v -> acc -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (a -> b -> b) -> b -> IntMap a -> b
IM.foldr (\(KV Enum1Info k
_ v a
v) acc
acc -> v a -> acc -> acc
forall (a :: kind). v a -> acc -> acc
f v a
v acc
acc) acc
acc0 IntMap (KV k v)
m

foldl :: (forall a. acc -> v a -> acc) -> acc -> DEnumMap k v -> acc
foldl :: forall {kind} acc (v :: kind -> *) (k :: kind -> *).
(forall (a :: kind). acc -> v a -> acc)
-> acc -> DEnumMap k v -> acc
foldl forall (a :: kind). acc -> v a -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) = (acc -> KV k v -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (a -> b -> a) -> a -> IntMap b -> a
IM.foldl (\acc
acc (KV Enum1Info k
_ v a
v) -> acc -> v a -> acc
forall (a :: kind). acc -> v a -> acc
f acc
acc v a
v) acc
acc0 IntMap (KV k v)
m

foldrWithKey :: Enum1 k => (forall a. k a -> v a -> acc -> acc) -> acc -> DEnumMap k v -> acc
foldrWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *) acc.
Enum1 k =>
(forall (a :: kind). k a -> v a -> acc -> acc)
-> acc -> DEnumMap k v -> acc
foldrWithKey forall (a :: kind). k a -> v a -> acc -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) =
  (Int -> KV k v -> acc -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (Int -> a -> b -> b) -> b -> IntMap a -> b
IM.foldrWithKey (\Int
i (KV Enum1Info k
inf v a
v) acc
acc -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> v a -> acc -> acc
forall (a :: kind). k a -> v a -> acc -> acc
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v) acc
acc) acc
acc0 IntMap (KV k v)
m

foldlWithKey :: Enum1 k => (forall a. acc -> k a -> v a -> acc) -> acc -> DEnumMap k v -> acc
foldlWithKey :: forall {kind} (k :: kind -> *) acc (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). acc -> k a -> v a -> acc)
-> acc -> DEnumMap k v -> acc
foldlWithKey forall (a :: kind). acc -> k a -> v a -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) =
  (acc -> Int -> KV k v -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (a -> Int -> b -> a) -> a -> IntMap b -> a
IM.foldlWithKey (\acc
acc Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> acc -> k a -> v a -> acc
forall (a :: kind). acc -> k a -> v a -> acc
f acc
acc k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) acc
acc0 IntMap (KV k v)
m

foldMapWithKey :: (Monoid m, Enum1 k) => (forall a. k a -> v a -> m) -> DEnumMap k v -> m
foldMapWithKey :: forall {kind} m (k :: kind -> *) (v :: kind -> *).
(Monoid m, Enum1 k) =>
(forall (a :: kind). k a -> v a -> m) -> DEnumMap k v -> m
foldMapWithKey forall (a :: kind). k a -> v a -> m
f (DEnumMap IntMap (KV k v)
m) =
  (Int -> KV k v -> m) -> IntMap (KV k v) -> m
forall m a. Monoid m => (Int -> a -> m) -> IntMap a -> m
IM.foldMapWithKey (\Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> v a -> m
forall (a :: kind). k a -> v a -> m
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) IntMap (KV k v)
m

-- ** Strict folds

foldr' :: (forall a. v a -> acc -> acc) -> acc -> DEnumMap k v -> acc
foldr' :: forall {kind} (v :: kind -> *) acc (k :: kind -> *).
(forall (a :: kind). v a -> acc -> acc)
-> acc -> DEnumMap k v -> acc
foldr' forall (a :: kind). v a -> acc -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) = (KV k v -> acc -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (a -> b -> b) -> b -> IntMap a -> b
IM.foldr' (\(KV Enum1Info k
_ v a
v) acc
acc -> v a -> acc -> acc
forall (a :: kind). v a -> acc -> acc
f v a
v acc
acc) acc
acc0 IntMap (KV k v)
m

foldl' :: (forall a. acc -> v a -> acc) -> acc -> DEnumMap k v -> acc
foldl' :: forall {kind} acc (v :: kind -> *) (k :: kind -> *).
(forall (a :: kind). acc -> v a -> acc)
-> acc -> DEnumMap k v -> acc
foldl' forall (a :: kind). acc -> v a -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) = (acc -> KV k v -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (a -> b -> a) -> a -> IntMap b -> a
IM.foldl' (\acc
acc (KV Enum1Info k
_ v a
v) -> acc -> v a -> acc
forall (a :: kind). acc -> v a -> acc
f acc
acc v a
v) acc
acc0 IntMap (KV k v)
m

foldrWithKey' :: Enum1 k => (forall a. k a -> v a -> acc -> acc) -> acc -> DEnumMap k v -> acc
foldrWithKey' :: forall {kind} (k :: kind -> *) (v :: kind -> *) acc.
Enum1 k =>
(forall (a :: kind). k a -> v a -> acc -> acc)
-> acc -> DEnumMap k v -> acc
foldrWithKey' forall (a :: kind). k a -> v a -> acc -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) =
  (Int -> KV k v -> acc -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (Int -> a -> b -> b) -> b -> IntMap a -> b
IM.foldrWithKey' (\Int
i (KV Enum1Info k
inf v a
v) acc
acc -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> v a -> acc -> acc
forall (a :: kind). k a -> v a -> acc -> acc
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v) acc
acc) acc
acc0 IntMap (KV k v)
m

foldlWithKey' :: Enum1 k => (forall a. acc -> k a -> v a -> acc) -> acc -> DEnumMap k v -> acc
foldlWithKey' :: forall {kind} (k :: kind -> *) acc (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). acc -> k a -> v a -> acc)
-> acc -> DEnumMap k v -> acc
foldlWithKey' forall (a :: kind). acc -> k a -> v a -> acc
f acc
acc0 (DEnumMap IntMap (KV k v)
m) =
  (acc -> Int -> KV k v -> acc) -> acc -> IntMap (KV k v) -> acc
forall a b. (a -> Int -> b -> a) -> a -> IntMap b -> a
IM.foldlWithKey' (\acc
acc Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> acc -> k a -> v a -> acc
forall (a :: kind). acc -> k a -> v a -> acc
f acc
acc k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) acc
acc0 IntMap (KV k v)
m

-- * Conversion

elems :: DEnumMap k v -> [Some v]
elems :: forall {k} (k :: k -> *) (v :: k -> *). DEnumMap k v -> [Some v]
elems (DEnumMap IntMap (KV k v)
m) = (\(KV Enum1Info k
_ v a
v) -> v a -> Some v
forall {k} (tag :: k -> *) (a :: k). tag a -> Some tag
Some v a
v) (KV k v -> Some v) -> [KV k v] -> [Some v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> [KV k v]
forall a. IntMap a -> [a]
IM.elems IntMap (KV k v)
m

keys :: Enum1 k => DEnumMap k v -> [Some k]
keys :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [Some k]
keys (DEnumMap IntMap (KV k v)
m) = (\(Int
k, KV Enum1Info k
inf v a
_) -> Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
k Enum1Info k
inf) ((Int, KV k v) -> Some k) -> [(Int, KV k v)] -> [Some k]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> [(Int, KV k v)]
forall a. IntMap a -> [(Int, a)]
IM.assocs IntMap (KV k v)
m

assocs :: Enum1 k => DEnumMap k v -> [DSum k v]
assocs :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [DSum k v]
assocs (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v) -> [(Int, KV k v)] -> [DSum k v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> [(Int, KV k v)]
forall a. IntMap a -> [(Int, a)]
IM.assocs IntMap (KV k v)
m

-- TODO: Wait for DEnumSet.
-- keysSet

-- ** Lists

toList :: Enum1 k => DEnumMap k v -> [DSum k v]
toList :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [DSum k v]
toList = DEnumMap k v -> [DSum k v]
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [DSum k v]
toAscList

-- ** Ordered lists

toAscList :: Enum1 k => DEnumMap k v -> [DSum k v]
toAscList :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [DSum k v]
toAscList (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v) -> [(Int, KV k v)] -> [DSum k v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> [(Int, KV k v)]
forall a. IntMap a -> [(Int, a)]
IM.toAscList IntMap (KV k v)
m

toDescList :: Enum1 k => DEnumMap k v -> [DSum k v]
toDescList :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> [DSum k v]
toDescList (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v) -> [(Int, KV k v)] -> [DSum k v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> [(Int, KV k v)]
forall a. IntMap a -> [(Int, a)]
IM.toDescList IntMap (KV k v)
m

-- * Filter

filter :: (forall a. v a -> Bool) -> DEnumMap k v -> DEnumMap k v
filter :: forall {kind} (v :: kind -> *) (k :: kind -> *).
(forall (a :: kind). v a -> Bool) -> DEnumMap k v -> DEnumMap k v
filter forall (a :: kind). v a -> Bool
f (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v -> Bool) -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (a -> Bool) -> IntMap a -> IntMap a
IM.filter (\(KV Enum1Info k
_ v a
v) -> v a -> Bool
forall (a :: kind). v a -> Bool
f v a
v) IntMap (KV k v)
m)

filterWithKey :: Enum1 k => (forall a. k a -> v a -> Bool) -> DEnumMap k v -> DEnumMap k v
filterWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v a -> Bool)
-> DEnumMap k v -> DEnumMap k v
filterWithKey forall (a :: kind). k a -> v a -> Bool
f (DEnumMap IntMap (KV k v)
m) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> Bool) -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> a -> Bool) -> IntMap a -> IntMap a
IM.filterWithKey (\Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> v a -> Bool
forall (a :: kind). k a -> v a -> Bool
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) IntMap (KV k v)
m)

-- TODO: Wait for DEnumSet.
-- restrictKeys
-- withoutKeys

partition :: (forall a. v a -> Bool) -> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
partition :: forall {kind} (v :: kind -> *) (k :: kind -> *).
(forall (a :: kind). v a -> Bool)
-> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
partition forall (a :: kind). v a -> Bool
f (DEnumMap IntMap (KV k v)
m) =
  (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v), IntMap (KV k v))
-> (DEnumMap k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v -> Bool)
-> IntMap (KV k v) -> (IntMap (KV k v), IntMap (KV k v))
forall a. (a -> Bool) -> IntMap a -> (IntMap a, IntMap a)
IM.partition (\(KV Enum1Info k
_ v a
v) -> v a -> Bool
forall (a :: kind). v a -> Bool
f v a
v) IntMap (KV k v)
m)

partitionWithKey :: Enum1 k => (forall a. k a -> v a -> Bool) -> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
partitionWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v a -> Bool)
-> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
partitionWithKey forall (a :: kind). k a -> v a -> Bool
f (DEnumMap IntMap (KV k v)
m) =
  (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v), IntMap (KV k v))
-> (DEnumMap k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> Bool)
-> IntMap (KV k v) -> (IntMap (KV k v), IntMap (KV k v))
forall a. (Int -> a -> Bool) -> IntMap a -> (IntMap a, IntMap a)
IM.partitionWithKey (\Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> v a -> Bool
forall (a :: kind). k a -> v a -> Bool
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) IntMap (KV k v)
m)

-- | \(O(\min(n,W)^2)\). Because of the lack of a @takeWhileAntitoneWithValue@
-- operation on 'Data.IntMap.Strict.IntMap', this function performs additional lookups to
-- reconstruct the full keys to pass to the predicate, resulting in a somewhat
-- worse complexity than 'IM.takeWhileAntitone'.
takeWhileAntitone :: Enum1 k => (forall a. k a -> Bool) -> DEnumMap k v -> DEnumMap k v
takeWhileAntitone :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> Bool) -> DEnumMap k v -> DEnumMap k v
takeWhileAntitone forall (a :: kind). k a -> Bool
f (DEnumMap IntMap (KV k v)
m) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> Bool) -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> Bool) -> IntMap a -> IntMap a
IM.takeWhileAntitone (\Int
i -> case IntMap (KV k v)
m IntMap (KV k v) -> Int -> KV k v
forall a. IntMap a -> Int -> a
IM.! Int
i of KV Enum1Info k
inf v a
_ -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> Bool
forall (a :: kind). k a -> Bool
f k a
k) IntMap (KV k v)
m)

-- | \(O(\min(n,W)^2)\). See 'takeWhileAntitone'.
dropWhileAntitone :: Enum1 k => (forall a. k a -> Bool) -> DEnumMap k v -> DEnumMap k v
dropWhileAntitone :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> Bool) -> DEnumMap k v -> DEnumMap k v
dropWhileAntitone forall (a :: kind). k a -> Bool
f (DEnumMap IntMap (KV k v)
m) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> Bool) -> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> Bool) -> IntMap a -> IntMap a
IM.dropWhileAntitone (\Int
i -> case IntMap (KV k v)
m IntMap (KV k v) -> Int -> KV k v
forall a. IntMap a -> Int -> a
IM.! Int
i of KV Enum1Info k
inf v a
_ -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> Bool
forall (a :: kind). k a -> Bool
f k a
k) IntMap (KV k v)
m)

-- | \(O(\min(n,W)^2)\). See 'takeWhileAntitone'.
spanAntitone :: Enum1 k => (forall a. k a -> Bool) -> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
spanAntitone :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> Bool)
-> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
spanAntitone forall (a :: kind). k a -> Bool
f (DEnumMap IntMap (KV k v)
m) =
  (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v), IntMap (KV k v))
-> (DEnumMap k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> Bool)
-> IntMap (KV k v) -> (IntMap (KV k v), IntMap (KV k v))
forall a. (Int -> Bool) -> IntMap a -> (IntMap a, IntMap a)
IM.spanAntitone (\Int
i -> case IntMap (KV k v)
m IntMap (KV k v) -> Int -> KV k v
forall a. IntMap a -> Int -> a
IM.! Int
i of KV Enum1Info k
inf v a
_ -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> k a -> Bool
forall (a :: kind). k a -> Bool
f k a
k) IntMap (KV k v)
m)

mapMaybe :: Enum1 k => (forall a. v1 a -> Maybe (v2 a)) -> DEnumMap k v1 -> DEnumMap k v2
mapMaybe :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). v1 a -> Maybe (v2 a))
-> DEnumMap k v1 -> DEnumMap k v2
mapMaybe forall (a :: kind). v1 a -> Maybe (v2 a)
f = (forall (a :: kind). k a -> v1 a -> Maybe (v2 a))
-> DEnumMap k v1 -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v1 a -> Maybe (v2 a))
-> DEnumMap k v1 -> DEnumMap k v2
mapMaybeWithKey ((v1 a -> Maybe (v2 a)) -> k a -> v1 a -> Maybe (v2 a)
forall a b. a -> b -> a
const v1 a -> Maybe (v2 a)
forall (a :: kind). v1 a -> Maybe (v2 a)
f)

mapMaybeWithKey :: Enum1 k
                => (forall a. k a -> v1 a -> Maybe (v2 a)) -> DEnumMap k v1 -> DEnumMap k v2
mapMaybeWithKey :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v1 a -> Maybe (v2 a))
-> DEnumMap k v1 -> DEnumMap k v2
mapMaybeWithKey forall (a :: kind). k a -> v1 a -> Maybe (v2 a)
f (DEnumMap IntMap (KV k v1)
m) =
  IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> Maybe (KV k v2))
-> IntMap (KV k v1) -> IntMap (KV k v2)
forall a b. (Int -> a -> Maybe b) -> IntMap a -> IntMap b
IM.mapMaybeWithKey (\Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v2 a -> KV k v2) -> Maybe (v2 a) -> Maybe (KV k v2)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v1 a -> Maybe (v2 a)
forall (a :: kind). k a -> v1 a -> Maybe (v2 a)
f k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) IntMap (KV k v1)
m)

mapEither :: Enum1 k
          => (forall a. v1 a -> Either (v2 a) (v3 a)) -> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
mapEither :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *)
       (v3 :: kind -> *).
Enum1 k =>
(forall (a :: kind). v1 a -> Either (v2 a) (v3 a))
-> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
mapEither forall (a :: kind). v1 a -> Either (v2 a) (v3 a)
f = (forall (a :: kind). k a -> v1 a -> Either (v2 a) (v3 a))
-> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *)
       (v3 :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v1 a -> Either (v2 a) (v3 a))
-> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
mapEitherWithKey ((v1 a -> Either (v2 a) (v3 a))
-> k a -> v1 a -> Either (v2 a) (v3 a)
forall a b. a -> b -> a
const v1 a -> Either (v2 a) (v3 a)
forall (a :: kind). v1 a -> Either (v2 a) (v3 a)
f)

mapEitherWithKey :: Enum1 k
                 => (forall a. k a -> v1 a -> Either (v2 a) (v3 a)) -> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
mapEitherWithKey :: forall {kind} (k :: kind -> *) (v1 :: kind -> *) (v2 :: kind -> *)
       (v3 :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v1 a -> Either (v2 a) (v3 a))
-> DEnumMap k v1 -> (DEnumMap k v2, DEnumMap k v3)
mapEitherWithKey forall (a :: kind). k a -> v1 a -> Either (v2 a) (v3 a)
f (DEnumMap IntMap (KV k v1)
m) =
  (IntMap (KV k v2) -> DEnumMap k v2)
-> (IntMap (KV k v3) -> DEnumMap k v3)
-> (IntMap (KV k v2), IntMap (KV k v3))
-> (DEnumMap k v2, DEnumMap k v3)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap IntMap (KV k v2) -> DEnumMap k v2
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v3) -> DEnumMap k v3
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v1 -> Either (KV k v2) (KV k v3))
-> IntMap (KV k v1) -> (IntMap (KV k v2), IntMap (KV k v3))
forall a b c.
(Int -> a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)
IM.mapEitherWithKey (\Int
i (KV Enum1Info k
inf v1 a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> (v2 a -> KV k v2)
-> (v3 a -> KV k v3)
-> Either (v2 a) (v3 a)
-> Either (KV k v2) (KV k v3)
forall a b c d. (a -> b) -> (c -> d) -> Either a c -> Either b d
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (Enum1Info k -> v2 a -> KV k v2
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) (Enum1Info k -> v3 a -> KV k v3
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf) (Either (v2 a) (v3 a) -> Either (KV k v2) (KV k v3))
-> Either (v2 a) (v3 a) -> Either (KV k v2) (KV k v3)
forall a b. (a -> b) -> a -> b
$ k a -> v1 a -> Either (v2 a) (v3 a)
forall (a :: kind). k a -> v1 a -> Either (v2 a) (v3 a)
f k a
k (v1 a -> v1 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v1 a
v)) IntMap (KV k v1)
m)

split :: Enum1 k => k a -> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
split :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> DEnumMap k v -> (DEnumMap k v, DEnumMap k v)
split k a
k (DEnumMap IntMap (KV k v)
m) = (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> (IntMap (KV k v), IntMap (KV k v))
-> (DEnumMap k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (Int -> IntMap (KV k v) -> (IntMap (KV k v), IntMap (KV k v))
forall a. Int -> IntMap a -> (IntMap a, IntMap a)
IM.split ((Int, Enum1Info k) -> Int
forall a b. (a, b) -> a
fst ((Int, Enum1Info k) -> Int) -> (Int, Enum1Info k) -> Int
forall a b. (a -> b) -> a -> b
$ k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k) IntMap (KV k v)
m)

splitLookup :: Enum1 k => k a -> DEnumMap k v -> (DEnumMap k v, Maybe (v a), DEnumMap k v)
splitLookup :: forall {kind} (k :: kind -> *) (a :: kind) (v :: kind -> *).
Enum1 k =>
k a -> DEnumMap k v -> (DEnumMap k v, Maybe (v a), DEnumMap k v)
splitLookup k a
k (DEnumMap IntMap (KV k v)
m) =
  let (IntMap (KV k v)
m1, Maybe (KV k v)
mkv, IntMap (KV k v)
m2) = Int
-> IntMap (KV k v)
-> (IntMap (KV k v), Maybe (KV k v), IntMap (KV k v))
forall a. Int -> IntMap a -> (IntMap a, Maybe a, IntMap a)
IM.splitLookup ((Int, Enum1Info k) -> Int
forall a b. (a, b) -> a
fst ((Int, Enum1Info k) -> Int) -> (Int, Enum1Info k) -> Int
forall a b. (a -> b) -> a -> b
$ k a -> (Int, Enum1Info k)
forall (a :: kind). k a -> (Int, Enum1Info k)
forall {k} (f :: k -> *) (a :: k).
Enum1 f =>
f a -> (Int, Enum1Info f)
fromEnum1 k a
k) IntMap (KV k v)
m
     -- Note: this coe1 is fine because of the invariant on DEnumMap.
  in (IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v)
m1, (\(KV Enum1Info k
_ v a
v) -> v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v) (KV k v -> v a) -> Maybe (KV k v) -> Maybe (v a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (KV k v)
mkv, IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap IntMap (KV k v)
m2)

splitRoot :: DEnumMap k v -> [DEnumMap k v]
splitRoot :: forall {kind} (k :: kind -> *) (v :: kind -> *).
DEnumMap k v -> [DEnumMap k v]
splitRoot (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v) -> DEnumMap k v)
-> [IntMap (KV k v)] -> [DEnumMap k v]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> [IntMap (KV k v)]
forall a. IntMap a -> [IntMap a]
IM.splitRoot IntMap (KV k v)
m

-- * Submap

-- TODO: the submap operations can't check any laws because there is no IM.isSubmapOfByKey.
isSubmapOf :: (forall a. Eq (v a)) => DEnumMap k v -> DEnumMap k v -> Bool
isSubmapOf :: forall {kind} (v :: kind -> *) (k :: kind -> *).
(forall (a :: kind). Eq (v a)) =>
DEnumMap k v -> DEnumMap k v -> Bool
isSubmapOf (DEnumMap IntMap (KV k v)
m1) (DEnumMap IntMap (KV k v)
m2) = (KV k v -> KV k v -> Bool)
-> IntMap (KV k v) -> IntMap (KV k v) -> Bool
forall a b. (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
IM.isSubmapOfBy (\(KV Enum1Info k
_ v a
v1) (KV Enum1Info k
_ v a
v2) -> v a
v1 v a -> v a -> Bool
forall a. Eq a => a -> a -> Bool
== v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2) IntMap (KV k v)
m1 IntMap (KV k v)
m2

isSubmapOfBy :: (forall a. v1 a -> v2 a -> Bool) -> DEnumMap k v1 -> DEnumMap k v2 -> Bool
isSubmapOfBy :: forall {kind} (v1 :: kind -> *) (v2 :: kind -> *) (k :: kind -> *).
(forall (a :: kind). v1 a -> v2 a -> Bool)
-> DEnumMap k v1 -> DEnumMap k v2 -> Bool
isSubmapOfBy forall (a :: kind). v1 a -> v2 a -> Bool
f (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) =
  (KV k v1 -> KV k v2 -> Bool)
-> IntMap (KV k v1) -> IntMap (KV k v2) -> Bool
forall a b. (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
IM.isSubmapOfBy (\(KV Enum1Info k
_ v1 a
v1) (KV Enum1Info k
_ v2 a
v2) -> v1 a -> v2 a -> Bool
forall (a :: kind). v1 a -> v2 a -> Bool
f v1 a
v1 (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)) IntMap (KV k v1)
m1 IntMap (KV k v2)
m2

isProperSubmapOf :: (forall a. Eq (v a)) => DEnumMap k v -> DEnumMap k v -> Bool
isProperSubmapOf :: forall {kind} (v :: kind -> *) (k :: kind -> *).
(forall (a :: kind). Eq (v a)) =>
DEnumMap k v -> DEnumMap k v -> Bool
isProperSubmapOf (DEnumMap IntMap (KV k v)
m1) (DEnumMap IntMap (KV k v)
m2) = (KV k v -> KV k v -> Bool)
-> IntMap (KV k v) -> IntMap (KV k v) -> Bool
forall a b. (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
IM.isProperSubmapOfBy (\(KV Enum1Info k
_ v a
v1) (KV Enum1Info k
_ v a
v2) -> v a
v1 v a -> v a -> Bool
forall a. Eq a => a -> a -> Bool
== v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v2) IntMap (KV k v)
m1 IntMap (KV k v)
m2

isProperSubmapOfBy :: (forall a. v1 a -> v2 a -> Bool) -> DEnumMap k v1 -> DEnumMap k v2 -> Bool
isProperSubmapOfBy :: forall {kind} (v1 :: kind -> *) (v2 :: kind -> *) (k :: kind -> *).
(forall (a :: kind). v1 a -> v2 a -> Bool)
-> DEnumMap k v1 -> DEnumMap k v2 -> Bool
isProperSubmapOfBy forall (a :: kind). v1 a -> v2 a -> Bool
f (DEnumMap IntMap (KV k v1)
m1) (DEnumMap IntMap (KV k v2)
m2) =
  (KV k v1 -> KV k v2 -> Bool)
-> IntMap (KV k v1) -> IntMap (KV k v2) -> Bool
forall a b. (a -> b -> Bool) -> IntMap a -> IntMap b -> Bool
IM.isProperSubmapOfBy (\(KV Enum1Info k
_ v1 a
v1) (KV Enum1Info k
_ v2 a
v2) -> v1 a -> v2 a -> Bool
forall (a :: kind). v1 a -> v2 a -> Bool
f v1 a
v1 (v2 a -> v2 a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v2 a
v2)) IntMap (KV k v1)
m1 IntMap (KV k v2)
m2

-- * Min\/Max

lookupMin :: Enum1 k => DEnumMap k v -> Maybe (DSum k v)
lookupMin :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> Maybe (DSum k v)
lookupMin (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v)
-> Maybe (Int, KV k v) -> Maybe (DSum k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> Maybe (Int, KV k v)
forall a. IntMap a -> Maybe (Int, a)
IM.lookupMin IntMap (KV k v)
m

lookupMax :: Enum1 k => DEnumMap k v -> Maybe (DSum k v)
lookupMax :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> Maybe (DSum k v)
lookupMax (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v)
-> Maybe (Int, KV k v) -> Maybe (DSum k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> Maybe (Int, KV k v)
forall a. IntMap a -> Maybe (Int, a)
IM.lookupMax IntMap (KV k v)
m

findMin :: Enum1 k => DEnumMap k v -> DSum k v
findMin :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> DSum k v
findMin (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v) -> (Int, KV k v) -> DSum k v
forall a b. (a -> b) -> a -> b
$ IntMap (KV k v) -> (Int, KV k v)
forall a. IntMap a -> (Int, a)
IM.findMin IntMap (KV k v)
m

findMax :: Enum1 k => DEnumMap k v -> DSum k v
findMax :: forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
DEnumMap k v -> DSum k v
findMax (DEnumMap IntMap (KV k v)
m) = (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum ((Int, KV k v) -> DSum k v) -> (Int, KV k v) -> DSum k v
forall a b. (a -> b) -> a -> b
$ IntMap (KV k v) -> (Int, KV k v)
forall a. IntMap a -> (Int, a)
IM.findMax IntMap (KV k v)
m

deleteMin :: DEnumMap k v -> DEnumMap k v
deleteMin :: forall {kind} (k :: kind -> *) (v :: kind -> *).
DEnumMap k v -> DEnumMap k v
deleteMin (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v) -> DEnumMap k v)
-> IntMap (KV k v) -> DEnumMap k v
forall a b. (a -> b) -> a -> b
$ IntMap (KV k v) -> IntMap (KV k v)
forall a. IntMap a -> IntMap a
IM.deleteMin IntMap (KV k v)
m

deleteMax :: DEnumMap k v -> DEnumMap k v
deleteMax :: forall {kind} (k :: kind -> *) (v :: kind -> *).
DEnumMap k v -> DEnumMap k v
deleteMax (DEnumMap IntMap (KV k v)
m) = IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (IntMap (KV k v) -> DEnumMap k v)
-> IntMap (KV k v) -> DEnumMap k v
forall a b. (a -> b) -> a -> b
$ IntMap (KV k v) -> IntMap (KV k v)
forall a. IntMap a -> IntMap a
IM.deleteMax IntMap (KV k v)
m

deleteFindMin :: Enum1 k => DEnumMap k v -> (DSum k v, DEnumMap k v)
deleteFindMin :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DEnumMap k v -> (DSum k v, DEnumMap k v)
deleteFindMin (DEnumMap IntMap (KV k v)
m) = ((Int, KV k v) -> DSum k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> ((Int, KV k v), IntMap (KV k v))
-> (DSum k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (((Int, KV k v), IntMap (KV k v)) -> (DSum k v, DEnumMap k v))
-> ((Int, KV k v), IntMap (KV k v)) -> (DSum k v, DEnumMap k v)
forall a b. (a -> b) -> a -> b
$ IntMap (KV k v) -> ((Int, KV k v), IntMap (KV k v))
forall a. IntMap a -> ((Int, a), IntMap a)
IM.deleteFindMin IntMap (KV k v)
m

deleteFindMax :: Enum1 k => DEnumMap k v -> (DSum k v, DEnumMap k v)
deleteFindMax :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DEnumMap k v -> (DSum k v, DEnumMap k v)
deleteFindMax (DEnumMap IntMap (KV k v)
m) = ((Int, KV k v) -> DSum k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> ((Int, KV k v), IntMap (KV k v))
-> (DSum k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (((Int, KV k v), IntMap (KV k v)) -> (DSum k v, DEnumMap k v))
-> ((Int, KV k v), IntMap (KV k v)) -> (DSum k v, DEnumMap k v)
forall a b. (a -> b) -> a -> b
$ IntMap (KV k v) -> ((Int, KV k v), IntMap (KV k v))
forall a. IntMap a -> ((Int, a), IntMap a)
IM.deleteFindMax IntMap (KV k v)
m

updateMin :: Enum1 k => (forall a. v a -> Maybe (v a)) -> DEnumMap k v -> DEnumMap k v
updateMin :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
updateMin forall (a :: kind). v a -> Maybe (v a)
f = (forall (a :: kind). k a -> v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
updateMinWithKey ((v a -> Maybe (v a)) -> k a -> v a -> Maybe (v a)
forall a b. a -> b -> a
const v a -> Maybe (v a)
forall (a :: kind). v a -> Maybe (v a)
f)

updateMinWithKey :: Enum1 k => (forall a. k a -> v a -> Maybe (v a)) -> DEnumMap k v -> DEnumMap k v
updateMinWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
updateMinWithKey forall (a :: kind). k a -> v a -> Maybe (v a)
f (DEnumMap IntMap (KV k v)
m) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> Maybe (KV k v))
-> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> a -> Maybe a) -> IntMap a -> IntMap a
IM.updateMinWithKey (\Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v a -> Maybe (v a)
forall (a :: kind). k a -> v a -> Maybe (v a)
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) IntMap (KV k v)
m)

updateMax :: Enum1 k => (forall a. v a -> Maybe (v a)) -> DEnumMap k v -> DEnumMap k v
updateMax :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
updateMax forall (a :: kind). v a -> Maybe (v a)
f = (forall (a :: kind). k a -> v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
updateMaxWithKey ((v a -> Maybe (v a)) -> k a -> v a -> Maybe (v a)
forall a b. a -> b -> a
const v a -> Maybe (v a)
forall (a :: kind). v a -> Maybe (v a)
f)

updateMaxWithKey :: Enum1 k => (forall a. k a -> v a -> Maybe (v a)) -> DEnumMap k v -> DEnumMap k v
updateMaxWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
(forall (a :: kind). k a -> v a -> Maybe (v a))
-> DEnumMap k v -> DEnumMap k v
updateMaxWithKey forall (a :: kind). k a -> v a -> Maybe (v a)
f (DEnumMap IntMap (KV k v)
m) =
  IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((Int -> KV k v -> Maybe (KV k v))
-> IntMap (KV k v) -> IntMap (KV k v)
forall a. (Int -> a -> Maybe a) -> IntMap a -> IntMap a
IM.updateMaxWithKey (\Int
i (KV Enum1Info k
inf v a
v) -> case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf of Some k a
k -> Enum1Info k -> v a -> KV k v
forall kind (k :: kind -> *) (v :: kind -> *) (a :: kind).
Enum1Info k -> v a -> KV k v
KV Enum1Info k
inf (v a -> KV k v) -> Maybe (v a) -> Maybe (KV k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> k a -> v a -> Maybe (v a)
forall (a :: kind). k a -> v a -> Maybe (v a)
f k a
k (v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v)) IntMap (KV k v)
m)

minView :: DEnumMap k v -> Maybe (v a, DEnumMap k v)
minView :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
DEnumMap k v -> Maybe (v a, DEnumMap k v)
minView (DEnumMap IntMap (KV k v)
m) = (KV k v -> v a)
-> (IntMap (KV k v) -> DEnumMap k v)
-> (KV k v, IntMap (KV k v))
-> (v a, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (\(KV Enum1Info k
_ v a
v) -> v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v) IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v, IntMap (KV k v)) -> (v a, DEnumMap k v))
-> Maybe (KV k v, IntMap (KV k v)) -> Maybe (v a, DEnumMap k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> Maybe (KV k v, IntMap (KV k v))
forall a. IntMap a -> Maybe (a, IntMap a)
IM.minView IntMap (KV k v)
m

maxView :: DEnumMap k v -> Maybe (v a, DEnumMap k v)
maxView :: forall {kind} (k :: kind -> *) (v :: kind -> *) (a :: kind).
DEnumMap k v -> Maybe (v a, DEnumMap k v)
maxView (DEnumMap IntMap (KV k v)
m) = (KV k v -> v a)
-> (IntMap (KV k v) -> DEnumMap k v)
-> (KV k v, IntMap (KV k v))
-> (v a, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (\(KV Enum1Info k
_ v a
v) -> v a -> v a
forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 v a
v) IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap ((KV k v, IntMap (KV k v)) -> (v a, DEnumMap k v))
-> Maybe (KV k v, IntMap (KV k v)) -> Maybe (v a, DEnumMap k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> Maybe (KV k v, IntMap (KV k v))
forall a. IntMap a -> Maybe (a, IntMap a)
IM.maxView IntMap (KV k v)
m

minViewWithKey :: Enum1 k => DEnumMap k v -> Maybe (DSum k v, DEnumMap k v)
minViewWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DEnumMap k v -> Maybe (DSum k v, DEnumMap k v)
minViewWithKey (DEnumMap IntMap (KV k v)
m) = ((Int, KV k v) -> DSum k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> ((Int, KV k v), IntMap (KV k v))
-> (DSum k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (((Int, KV k v), IntMap (KV k v)) -> (DSum k v, DEnumMap k v))
-> Maybe ((Int, KV k v), IntMap (KV k v))
-> Maybe (DSum k v, DEnumMap k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> Maybe ((Int, KV k v), IntMap (KV k v))
forall a. IntMap a -> Maybe ((Int, a), IntMap a)
IM.minViewWithKey IntMap (KV k v)
m

maxViewWithKey :: Enum1 k => DEnumMap k v -> Maybe (DSum k v, DEnumMap k v)
maxViewWithKey :: forall {kind} (k :: kind -> *) (v :: kind -> *).
Enum1 k =>
DEnumMap k v -> Maybe (DSum k v, DEnumMap k v)
maxViewWithKey (DEnumMap IntMap (KV k v)
m) = ((Int, KV k v) -> DSum k v)
-> (IntMap (KV k v) -> DEnumMap k v)
-> ((Int, KV k v), IntMap (KV k v))
-> (DSum k v, DEnumMap k v)
forall a b c d. (a -> b) -> (c -> d) -> (a, c) -> (b, d)
forall (p :: * -> * -> *) a b c d.
Bifunctor p =>
(a -> b) -> (c -> d) -> p a c -> p b d
bimap (Int, KV k v) -> DSum k v
forall {k} (k :: k -> *) (v :: k -> *).
Enum1 k =>
(Int, KV k v) -> DSum k v
kVToDSum IntMap (KV k v) -> DEnumMap k v
forall {kind} (k :: kind -> *) (v :: kind -> *).
IntMap (KV k v) -> DEnumMap k v
DEnumMap (((Int, KV k v), IntMap (KV k v)) -> (DSum k v, DEnumMap k v))
-> Maybe ((Int, KV k v), IntMap (KV k v))
-> Maybe (DSum k v, DEnumMap k v)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IntMap (KV k v) -> Maybe ((Int, KV k v), IntMap (KV k v))
forall a. IntMap a -> Maybe ((Int, a), IntMap a)
IM.maxViewWithKey IntMap (KV k v)
m


-- * Helpers

coe1 :: v a -> v b
coe1 :: forall {k} (v :: k -> *) (a :: k) (b :: k). v a -> v b
coe1 = v a -> v b
forall a b. a -> b
unsafeCoerce

typeCheck1 :: (Enum1 k, TestEquality k)
           => k a -> Int -> Enum1Info k -> r -> r
typeCheck1 :: forall {k} (k :: k -> *) (a :: k) r.
(Enum1 k, TestEquality k) =>
k a -> Int -> Enum1Info k -> r -> r
typeCheck1 k a
k1 Int
i Enum1Info k
inf2 r
x =
  Bool -> r -> r
forall a. HasCallStack => Bool -> a -> a
assert (case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf2 of { Some k a
k2 ->
          case k a -> k a -> Maybe (a :~: a)
forall (a :: k) (b :: k). k a -> k b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality k a
k1 k a
k2 of
            Just a :~: a
Refl -> Bool
True
            Maybe (a :~: a)
Nothing -> Bool
False })
         r
x

typeCheck2 :: forall k proxy r. (Enum1 k, TestEquality k)
           => proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 :: forall {k} (k :: k -> *) (proxy :: (k -> *) -> *) r.
(Enum1 k, TestEquality k) =>
proxy k -> Int -> Enum1Info k -> Enum1Info k -> r -> r
typeCheck2 proxy k
_ Int
i Enum1Info k
inf1 Enum1Info k
inf2 r
x =
  Bool -> r -> r
forall a. HasCallStack => Bool -> a -> a
assert (case forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
forall (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 @k Int
i Enum1Info k
inf1 of { Some k a
k1 ->
          case Int -> Enum1Info k -> Some k
forall {k} (f :: k -> *). Enum1 f => Int -> Enum1Info f -> Some f
toEnum1 Int
i Enum1Info k
inf2 of { Some k a
k2 ->
          case k a -> k a -> Maybe (a :~: a)
forall (a :: k) (b :: k). k a -> k b -> Maybe (a :~: b)
forall {k} (f :: k -> *) (a :: k) (b :: k).
TestEquality f =>
f a -> f b -> Maybe (a :~: b)
testEquality k a
k1 k a
k2 of
            Just a :~: a
Refl -> Bool
True
            Maybe (a :~: a)
Nothing -> Bool
False }})
         r
x