-- Ported from GetShopTV/swagger2 (pull request #262) to apply the same
-- insert-ordered-containers-0.3 compatibility fix to openapi3.
-- Credit for the design and implementation belongs to the swagger2 authors.
{-# LANGUAGE CPP #-}
-- |
-- Module:      Data.HashMap.Strict.InsOrd.Compat
-- Maintainer:  Nickolay Kudasov <nickolay@getshoptv.com>
-- Stability:   experimental
--
-- Compatibility wrapper around @insert-ordered-containers@ to mitigate the
-- breaking changes introduced in @insert-ordered-containers-0.3.0@:
-- <https://github.com/erikd/insert-ordered-containers/pull/8>.
--
-- That change fixed 'Eq' and Aeson instances in the upstream package, but it is
-- a behavioral break for @swagger2@ where we need stable Swagger Schema
-- generation and JSON object-like encoding.
--
-- This module keeps the old @swagger2@ expectations:
--
-- * 'InsOrdHashMap' values are encoded as JSON objects (not arrays of key/value
--   tuples), so field names remain first-class object keys.
-- * Equality intentionally ignores insertion order (compares as plain hash
--   maps), which matches how many tests currently assert JSON equality.
--
-- Simple encoding examples:
--
-- >>> import Data.Aeson (encode, eitherDecode)
-- >>> import qualified Data.ByteString.Lazy.Char8 as BSL8
-- >>> import qualified Data.HashMap.Strict as HM
-- >>> import qualified Data.HashMap.Strict.InsOrd.Compat as IOHM
-- >>> let decodeIOHM s = either error id (eitherDecode (BSL8.pack s) :: Either String (IOHM.InsOrdHashMap String Int))
--
-- A regular hash map has no insertion order guarantee:
--
-- >>> encode (HM.fromList [("a", 1 :: Int), ("b", 2)])
-- "{\"a\":1,\"b\":2}"
-- >>> encode (HM.fromList [("b", 1 :: Int), ("a", 2)])
-- "{\"a\":2,\"b\":1}"
--
-- Our compat 'InsOrdHashMap' encodes to a JSON object as well, but preserves insertion order:
--
-- >>> encode (IOHM.fromList [("a", 1 :: Int), ("b", 2)])
-- "{\"a\":1,\"b\":2}"
-- >>> encode (IOHM.fromList [("b", 1 :: Int), ("a", 2)])
-- "{\"b\":1,\"a\":2}"
--
-- Round-tripping through decode/encode demonstrates the caveat: encoding
-- preserves insertion order, but decoded object key order is not guaranteed.
--
-- >>> encode (decodeIOHM "{\"a\":1,\"b\":2}")
-- "{\"a\":1,\"b\":2}"
-- >>> encode (decodeIOHM "{\"b\":1,\"a\":2}")
-- "{\"a\":2,\"b\":1}"
--
-- This object encoding is what @swagger2@ wants for generated Swagger
-- definitions/properties because it keeps emitted schemas easy to consume and
-- stable in practice.
--
-- Important caveat: decoding cannot be fully stable with respect to insertion
-- order due to @aeson@ limitations. In particular, object parsing goes through
-- structures that do not preserve all ordering guarantees end-to-end. We accept
-- this trade-off for now because the primary requirement is deterministic
-- /encoding/ for generated Swagger Schema artifacts.
--
-- Many tests rely on @aesonQQ@-style JSON equality, where semantic object
-- equality matters more than insertion order. Comparing via plain hash maps
-- makes those tests robust under benign key-order variation. This is a weaker
-- notion of equality and hopefully will be revisited later.
module Data.HashMap.Strict.InsOrd.Compat (
  InsOrdHashMap,
  -- * Construction
  empty,
  singleton,
  -- * Basic interface
  null,
  size,
  member,
  lookup,
  lookupDefault,
  insert,
  insertWith,
  delete,
  adjust,
  update,
  alter,
  -- * Combine
  union,
  unionWith,
  unionWithKey,
  unions,
  -- * Transformations
  map,
  mapKeys,
  traverseKeys,
  mapWithKey,
  traverseWithKey,
  -- ** Unordered
  unorderedTraverse,
  unorderedTraverseWithKey,
  -- * Difference and intersection
  difference,
  intersection,
  intersectionWith,
  intersectionWithKey,
  -- * Folds
  foldl',
  foldlWithKey',
  foldr,
  foldrWithKey,
  foldMapWithKey,
  -- ** Unordered
  unorderedFoldMap,
  unorderedFoldMapWithKey,
  -- * Filter
  filter,
  filterWithKey,
  mapMaybe,
  mapMaybeWithKey,
  -- * Conversions
  keys,
  elems,
  toList,
  toRevList,
  fromList,
  toHashMap,
  fromHashMap,
  -- * Lenses
  hashMap,
  unorderedTraversal,
  -- * Debugging
  valid,
  ) where

#if !MIN_VERSION_insert_ordered_containers(0,3,0)
import Prelude hiding (null, lookup, map, foldl', foldr, filter)
import Data.HashMap.Strict.InsOrd
#else
import qualified Data.HashMap.Strict.InsOrd as InsOrdHashMap

import Prelude hiding (null, size, member, lookup, lookupDefault, map, foldl', filter)
import qualified Prelude

import qualified Data.Aeson as A
import qualified Data.Aeson.Encoding as E
import           Data.HashMap.Strict (HashMap)
import qualified Data.HashMap.Strict as HashMap

import qualified GHC.Exts as Exts

import Data.Data                       (Data)
import Data.Foldable                   (Foldable (foldMap))
import Data.Hashable                   (Hashable (..))

import qualified Control.Lens        as Lens
import Control.Lens
       (At (..), Index, Iso, IxValue, Ixed (..), Traversal, _1, _2, iso, (<&>))

import qualified Optics.Core         as Optics

newtype InsOrdHashMap k v = InsOrdHashMap { forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap :: InsOrdHashMap.InsOrdHashMap k v }
  deriving (Int -> InsOrdHashMap k v -> ShowS
[InsOrdHashMap k v] -> ShowS
InsOrdHashMap k v -> String
(Int -> InsOrdHashMap k v -> ShowS)
-> (InsOrdHashMap k v -> String)
-> ([InsOrdHashMap k v] -> ShowS)
-> Show (InsOrdHashMap k v)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> InsOrdHashMap k v -> ShowS
forall k v. (Show k, Show v) => [InsOrdHashMap k v] -> ShowS
forall k v. (Show k, Show v) => InsOrdHashMap k v -> String
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> InsOrdHashMap k v -> ShowS
showsPrec :: Int -> InsOrdHashMap k v -> ShowS
$cshow :: forall k v. (Show k, Show v) => InsOrdHashMap k v -> String
show :: InsOrdHashMap k v -> String
$cshowList :: forall k v. (Show k, Show v) => [InsOrdHashMap k v] -> ShowS
showList :: [InsOrdHashMap k v] -> ShowS
Show, ReadPrec [InsOrdHashMap k v]
ReadPrec (InsOrdHashMap k v)
Int -> ReadS (InsOrdHashMap k v)
ReadS [InsOrdHashMap k v]
(Int -> ReadS (InsOrdHashMap k v))
-> ReadS [InsOrdHashMap k v]
-> ReadPrec (InsOrdHashMap k v)
-> ReadPrec [InsOrdHashMap k v]
-> Read (InsOrdHashMap k v)
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
forall k v.
(Hashable k, Read k, Read v) =>
ReadPrec [InsOrdHashMap k v]
forall k v.
(Hashable k, Read k, Read v) =>
ReadPrec (InsOrdHashMap k v)
forall k v.
(Hashable k, Read k, Read v) =>
Int -> ReadS (InsOrdHashMap k v)
forall k v.
(Hashable k, Read k, Read v) =>
ReadS [InsOrdHashMap k v]
$creadsPrec :: forall k v.
(Hashable k, Read k, Read v) =>
Int -> ReadS (InsOrdHashMap k v)
readsPrec :: Int -> ReadS (InsOrdHashMap k v)
$creadList :: forall k v.
(Hashable k, Read k, Read v) =>
ReadS [InsOrdHashMap k v]
readList :: ReadS [InsOrdHashMap k v]
$creadPrec :: forall k v.
(Hashable k, Read k, Read v) =>
ReadPrec (InsOrdHashMap k v)
readPrec :: ReadPrec (InsOrdHashMap k v)
$creadListPrec :: forall k v.
(Hashable k, Read k, Read v) =>
ReadPrec [InsOrdHashMap k v]
readListPrec :: ReadPrec [InsOrdHashMap k v]
Read, Typeable (InsOrdHashMap k v)
Typeable (InsOrdHashMap k v) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> InsOrdHashMap k v
 -> c (InsOrdHashMap k v))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> Constr)
-> (InsOrdHashMap k v -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c (InsOrdHashMap k v)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (InsOrdHashMap k v)))
-> ((forall b. Data b => b -> b)
    -> InsOrdHashMap k v -> InsOrdHashMap k v)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> InsOrdHashMap k v -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> InsOrdHashMap k v -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> InsOrdHashMap k v -> m (InsOrdHashMap k v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InsOrdHashMap k v -> m (InsOrdHashMap k v))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> InsOrdHashMap k v -> m (InsOrdHashMap k v))
-> Data (InsOrdHashMap k v)
InsOrdHashMap k v -> Constr
InsOrdHashMap k v -> DataType
(forall b. Data b => b -> b)
-> InsOrdHashMap k v -> InsOrdHashMap k v
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> InsOrdHashMap k v -> u
forall u. (forall d. Data d => d -> u) -> InsOrdHashMap k v -> [u]
forall k v.
(Data k, Data v, Hashable k) =>
Typeable (InsOrdHashMap k v)
forall k v.
(Data k, Data v, Hashable k) =>
InsOrdHashMap k v -> Constr
forall k v.
(Data k, Data v, Hashable k) =>
InsOrdHashMap k v -> DataType
forall k v.
(Data k, Data v, Hashable k) =>
(forall b. Data b => b -> b)
-> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v u.
(Data k, Data v, Hashable k) =>
Int -> (forall d. Data d => d -> u) -> InsOrdHashMap k v -> u
forall k v u.
(Data k, Data v, Hashable k) =>
(forall d. Data d => d -> u) -> InsOrdHashMap k v -> [u]
forall k v r r'.
(Data k, Data v, Hashable k) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
forall k v r r'.
(Data k, Data v, Hashable k) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
forall k v (m :: * -> *).
(Data k, Data v, Hashable k, Monad m) =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
forall k v (m :: * -> *).
(Data k, Data v, Hashable k, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
forall k v (c :: * -> *).
(Data k, Data v, Hashable k) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InsOrdHashMap k v)
forall k v (c :: * -> *).
(Data k, Data v, Hashable k) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InsOrdHashMap k v
-> c (InsOrdHashMap k v)
forall k v (t :: * -> *) (c :: * -> *).
(Data k, Data v, Hashable k, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InsOrdHashMap k v))
forall k v (t :: * -> * -> *) (c :: * -> *).
(Data k, Data v, Hashable k, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InsOrdHashMap k v))
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InsOrdHashMap k v)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InsOrdHashMap k v
-> c (InsOrdHashMap k v)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InsOrdHashMap k v))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InsOrdHashMap k v))
$cgfoldl :: forall k v (c :: * -> *).
(Data k, Data v, Hashable k) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InsOrdHashMap k v
-> c (InsOrdHashMap k v)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> InsOrdHashMap k v
-> c (InsOrdHashMap k v)
$cgunfold :: forall k v (c :: * -> *).
(Data k, Data v, Hashable k) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InsOrdHashMap k v)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c (InsOrdHashMap k v)
$ctoConstr :: forall k v.
(Data k, Data v, Hashable k) =>
InsOrdHashMap k v -> Constr
toConstr :: InsOrdHashMap k v -> Constr
$cdataTypeOf :: forall k v.
(Data k, Data v, Hashable k) =>
InsOrdHashMap k v -> DataType
dataTypeOf :: InsOrdHashMap k v -> DataType
$cdataCast1 :: forall k v (t :: * -> *) (c :: * -> *).
(Data k, Data v, Hashable k, Typeable t) =>
(forall d. Data d => c (t d)) -> Maybe (c (InsOrdHashMap k v))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c (InsOrdHashMap k v))
$cdataCast2 :: forall k v (t :: * -> * -> *) (c :: * -> *).
(Data k, Data v, Hashable k, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InsOrdHashMap k v))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (InsOrdHashMap k v))
$cgmapT :: forall k v.
(Data k, Data v, Hashable k) =>
(forall b. Data b => b -> b)
-> InsOrdHashMap k v -> InsOrdHashMap k v
gmapT :: (forall b. Data b => b -> b)
-> InsOrdHashMap k v -> InsOrdHashMap k v
$cgmapQl :: forall k v r r'.
(Data k, Data v, Hashable k) =>
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
$cgmapQr :: forall k v r r'.
(Data k, Data v, Hashable k) =>
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> InsOrdHashMap k v -> r
$cgmapQ :: forall k v u.
(Data k, Data v, Hashable k) =>
(forall d. Data d => d -> u) -> InsOrdHashMap k v -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> InsOrdHashMap k v -> [u]
$cgmapQi :: forall k v u.
(Data k, Data v, Hashable k) =>
Int -> (forall d. Data d => d -> u) -> InsOrdHashMap k v -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> InsOrdHashMap k v -> u
$cgmapM :: forall k v (m :: * -> *).
(Data k, Data v, Hashable k, Monad m) =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
$cgmapMp :: forall k v (m :: * -> *).
(Data k, Data v, Hashable k, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
$cgmapMo :: forall k v (m :: * -> *).
(Data k, Data v, Hashable k, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> InsOrdHashMap k v -> m (InsOrdHashMap k v)
Data, (forall a b. (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b)
-> (forall a b. a -> InsOrdHashMap k b -> InsOrdHashMap k a)
-> Functor (InsOrdHashMap k)
forall a b. a -> InsOrdHashMap k b -> InsOrdHashMap k a
forall a b. (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b
forall k a b. a -> InsOrdHashMap k b -> InsOrdHashMap k a
forall k a b. (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall k a b. (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b
fmap :: forall a b. (a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b
$c<$ :: forall k a b. a -> InsOrdHashMap k b -> InsOrdHashMap k a
<$ :: forall a b. a -> InsOrdHashMap k b -> InsOrdHashMap k a
Functor, (forall m. Monoid m => InsOrdHashMap k m -> m)
-> (forall m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m)
-> (forall m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m)
-> (forall a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b)
-> (forall a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b)
-> (forall b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b)
-> (forall b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b)
-> (forall a. (a -> a -> a) -> InsOrdHashMap k a -> a)
-> (forall a. (a -> a -> a) -> InsOrdHashMap k a -> a)
-> (forall a. InsOrdHashMap k a -> [a])
-> (forall a. InsOrdHashMap k a -> Bool)
-> (forall a. InsOrdHashMap k a -> Int)
-> (forall a. Eq a => a -> InsOrdHashMap k a -> Bool)
-> (forall a. Ord a => InsOrdHashMap k a -> a)
-> (forall a. Ord a => InsOrdHashMap k a -> a)
-> (forall a. Num a => InsOrdHashMap k a -> a)
-> (forall a. Num a => InsOrdHashMap k a -> a)
-> Foldable (InsOrdHashMap k)
forall a. Eq a => a -> InsOrdHashMap k a -> Bool
forall a. Num a => InsOrdHashMap k a -> a
forall a. Ord a => InsOrdHashMap k a -> a
forall m. Monoid m => InsOrdHashMap k m -> m
forall a. InsOrdHashMap k a -> Bool
forall a. InsOrdHashMap k a -> Int
forall a. InsOrdHashMap k a -> [a]
forall a. (a -> a -> a) -> InsOrdHashMap k a -> a
forall k a. Eq a => a -> InsOrdHashMap k a -> Bool
forall k a. Num a => InsOrdHashMap k a -> a
forall k a. Ord a => InsOrdHashMap k a -> a
forall k m. Monoid m => InsOrdHashMap k m -> m
forall m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
forall k a. InsOrdHashMap k a -> Bool
forall k a. InsOrdHashMap k a -> Int
forall k a. InsOrdHashMap k a -> [a]
forall b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b
forall a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b
forall k a. (a -> a -> a) -> InsOrdHashMap k a -> a
forall k m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
forall k b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b
forall k a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall k m. Monoid m => InsOrdHashMap k m -> m
fold :: forall m. Monoid m => InsOrdHashMap k m -> m
$cfoldMap :: forall k m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
$cfoldMap' :: forall k m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
$cfoldr :: forall k a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b
foldr :: forall a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b
$cfoldr' :: forall k a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> InsOrdHashMap k a -> b
$cfoldl :: forall k b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b
foldl :: forall b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b
$cfoldl' :: forall k b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> InsOrdHashMap k a -> b
$cfoldr1 :: forall k a. (a -> a -> a) -> InsOrdHashMap k a -> a
foldr1 :: forall a. (a -> a -> a) -> InsOrdHashMap k a -> a
$cfoldl1 :: forall k a. (a -> a -> a) -> InsOrdHashMap k a -> a
foldl1 :: forall a. (a -> a -> a) -> InsOrdHashMap k a -> a
$ctoList :: forall k a. InsOrdHashMap k a -> [a]
toList :: forall a. InsOrdHashMap k a -> [a]
$cnull :: forall k a. InsOrdHashMap k a -> Bool
null :: forall a. InsOrdHashMap k a -> Bool
$clength :: forall k a. InsOrdHashMap k a -> Int
length :: forall a. InsOrdHashMap k a -> Int
$celem :: forall k a. Eq a => a -> InsOrdHashMap k a -> Bool
elem :: forall a. Eq a => a -> InsOrdHashMap k a -> Bool
$cmaximum :: forall k a. Ord a => InsOrdHashMap k a -> a
maximum :: forall a. Ord a => InsOrdHashMap k a -> a
$cminimum :: forall k a. Ord a => InsOrdHashMap k a -> a
minimum :: forall a. Ord a => InsOrdHashMap k a -> a
$csum :: forall k a. Num a => InsOrdHashMap k a -> a
sum :: forall a. Num a => InsOrdHashMap k a -> a
$cproduct :: forall k a. Num a => InsOrdHashMap k a -> a
product :: forall a. Num a => InsOrdHashMap k a -> a
Foldable, Functor (InsOrdHashMap k)
Foldable (InsOrdHashMap k)
(Functor (InsOrdHashMap k), Foldable (InsOrdHashMap k)) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    InsOrdHashMap k (f a) -> f (InsOrdHashMap k a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> InsOrdHashMap k a -> m (InsOrdHashMap k b))
-> (forall (m :: * -> *) a.
    Monad m =>
    InsOrdHashMap k (m a) -> m (InsOrdHashMap k a))
-> Traversable (InsOrdHashMap k)
forall k. Functor (InsOrdHashMap k)
forall k. Foldable (InsOrdHashMap k)
forall k (m :: * -> *) a.
Monad m =>
InsOrdHashMap k (m a) -> m (InsOrdHashMap k a)
forall k (f :: * -> *) a.
Applicative f =>
InsOrdHashMap k (f a) -> f (InsOrdHashMap k a)
forall k (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InsOrdHashMap k a -> m (InsOrdHashMap k b)
forall k (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
forall (t :: * -> *).
(Functor t, Foldable t) =>
(forall (f :: * -> *) a b.
 Applicative f =>
 (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
InsOrdHashMap k (m a) -> m (InsOrdHashMap k a)
forall (f :: * -> *) a.
Applicative f =>
InsOrdHashMap k (f a) -> f (InsOrdHashMap k a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InsOrdHashMap k a -> m (InsOrdHashMap k b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
$ctraverse :: forall k (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
$csequenceA :: forall k (f :: * -> *) a.
Applicative f =>
InsOrdHashMap k (f a) -> f (InsOrdHashMap k a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
InsOrdHashMap k (f a) -> f (InsOrdHashMap k a)
$cmapM :: forall k (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InsOrdHashMap k a -> m (InsOrdHashMap k b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> InsOrdHashMap k a -> m (InsOrdHashMap k b)
$csequence :: forall k (m :: * -> *) a.
Monad m =>
InsOrdHashMap k (m a) -> m (InsOrdHashMap k a)
sequence :: forall (m :: * -> *) a.
Monad m =>
InsOrdHashMap k (m a) -> m (InsOrdHashMap k a)
Traversable, NonEmpty (InsOrdHashMap k v) -> InsOrdHashMap k v
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
(InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v)
-> (NonEmpty (InsOrdHashMap k v) -> InsOrdHashMap k v)
-> (forall b.
    Integral b =>
    b -> InsOrdHashMap k v -> InsOrdHashMap k v)
-> Semigroup (InsOrdHashMap k v)
forall b. Integral b => b -> InsOrdHashMap k v -> InsOrdHashMap k v
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
forall k v.
Hashable k =>
NonEmpty (InsOrdHashMap k v) -> InsOrdHashMap k v
forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v b.
(Hashable k, Integral b) =>
b -> InsOrdHashMap k v -> InsOrdHashMap k v
$c<> :: forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
<> :: InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
$csconcat :: forall k v.
Hashable k =>
NonEmpty (InsOrdHashMap k v) -> InsOrdHashMap k v
sconcat :: NonEmpty (InsOrdHashMap k v) -> InsOrdHashMap k v
$cstimes :: forall k v b.
(Hashable k, Integral b) =>
b -> InsOrdHashMap k v -> InsOrdHashMap k v
stimes :: forall b. Integral b => b -> InsOrdHashMap k v -> InsOrdHashMap k v
Semigroup, Semigroup (InsOrdHashMap k v)
InsOrdHashMap k v
Semigroup (InsOrdHashMap k v) =>
InsOrdHashMap k v
-> (InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v)
-> ([InsOrdHashMap k v] -> InsOrdHashMap k v)
-> Monoid (InsOrdHashMap k v)
[InsOrdHashMap k v] -> InsOrdHashMap k v
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
forall k v. Hashable k => Semigroup (InsOrdHashMap k v)
forall k v. Hashable k => InsOrdHashMap k v
forall k v. Hashable k => [InsOrdHashMap k v] -> InsOrdHashMap k v
forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
$cmempty :: forall k v. Hashable k => InsOrdHashMap k v
mempty :: InsOrdHashMap k v
$cmappend :: forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
mappend :: InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
$cmconcat :: forall k v. Hashable k => [InsOrdHashMap k v] -> InsOrdHashMap k v
mconcat :: [InsOrdHashMap k v] -> InsOrdHashMap k v
Monoid)

instance (Eq k, Eq v) => Eq (InsOrdHashMap k v) where
    InsOrdHashMap k v
a == :: InsOrdHashMap k v -> InsOrdHashMap k v -> Bool
== InsOrdHashMap k v
b = InsOrdHashMap k v -> HashMap k v
forall k v. InsOrdHashMap k v -> HashMap k v
toHashMap InsOrdHashMap k v
a HashMap k v -> HashMap k v -> Bool
forall a. Eq a => a -> a -> Bool
== InsOrdHashMap k v -> HashMap k v
forall k v. InsOrdHashMap k v -> HashMap k v
toHashMap InsOrdHashMap k v
b

instance (Eq k, Hashable k) => Exts.IsList (InsOrdHashMap k v) where
    type Item (InsOrdHashMap k v) = Exts.Item (InsOrdHashMap.InsOrdHashMap k v)
    fromList :: [Item (InsOrdHashMap k v)] -> InsOrdHashMap k v
fromList = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> ([(k, v)] -> InsOrdHashMap k v) -> [(k, v)] -> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(k, v)] -> InsOrdHashMap k v
forall k v. (Eq k, Hashable k) => [(k, v)] -> InsOrdHashMap k v
InsOrdHashMap.fromList
    toList :: InsOrdHashMap k v -> [Item (InsOrdHashMap k v)]
toList   = InsOrdHashMap k v -> [(k, v)]
forall k v. InsOrdHashMap k v -> [(k, v)]
InsOrdHashMap.toList (InsOrdHashMap k v -> [(k, v)])
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> [(k, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-------------------------------------------------------------------------------
-- Aeson
-------------------------------------------------------------------------------

instance (A.ToJSONKey k) => A.ToJSON1 (InsOrdHashMap k) where
    liftToJSON :: forall a.
(a -> Bool)
-> (a -> Value) -> ([a] -> Value) -> InsOrdHashMap k a -> Value
liftToJSON a -> Bool
_ a -> Value
t [a] -> Value
_ = case ToJSONKeyFunction k
forall a. ToJSONKey a => ToJSONKeyFunction a
A.toJSONKey :: A.ToJSONKeyFunction k of
      A.ToJSONKeyText k -> Key
f k -> Encoding' Key
_ -> [Pair] -> Value
A.object ([Pair] -> Value)
-> (InsOrdHashMap k a -> [Pair]) -> InsOrdHashMap k a -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, a) -> Pair) -> [(k, a)] -> [Pair]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(k
k, a
v) -> (k -> Key
f k
k, a -> Value
t a
v)) ([(k, a)] -> [Pair])
-> (InsOrdHashMap k a -> [(k, a)]) -> InsOrdHashMap k a -> [Pair]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k a -> [(k, a)]
forall k v. InsOrdHashMap k v -> [(k, v)]
toList
      A.ToJSONKeyValue k -> Value
f k -> Encoding
_ -> [Value] -> Value
forall a. ToJSON a => a -> Value
A.toJSON ([Value] -> Value)
-> (InsOrdHashMap k a -> [Value]) -> InsOrdHashMap k a -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((k, a) -> Value) -> [(k, a)] -> [Value]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(k
k,a
v) -> (Value, Value) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (k -> Value
f k
k, a -> Value
t a
v)) ([(k, a)] -> [Value])
-> (InsOrdHashMap k a -> [(k, a)]) -> InsOrdHashMap k a -> [Value]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k a -> [(k, a)]
forall k v. InsOrdHashMap k v -> [(k, v)]
toList

    liftToEncoding :: forall a.
(a -> Bool)
-> (a -> Encoding)
-> ([a] -> Encoding)
-> InsOrdHashMap k a
-> Encoding
liftToEncoding a -> Bool
o a -> Encoding
t [a] -> Encoding
_ = case ToJSONKeyFunction k
forall a. ToJSONKey a => ToJSONKeyFunction a
A.toJSONKey :: A.ToJSONKeyFunction k of
      A.ToJSONKeyText k -> Key
_ k -> Encoding' Key
f ->  (k -> Encoding' Key)
-> (a -> Encoding)
-> (forall a. (k -> a -> a -> a) -> a -> InsOrdHashMap k a -> a)
-> InsOrdHashMap k a
-> Encoding
forall k v m.
(k -> Encoding' Key)
-> (v -> Encoding)
-> (forall a. (k -> v -> a -> a) -> a -> m -> a)
-> m
-> Encoding
E.dict k -> Encoding' Key
f a -> Encoding
t (k -> a -> a -> a) -> a -> InsOrdHashMap k a -> a
forall a. (k -> a -> a -> a) -> a -> InsOrdHashMap k a -> a
forall k v a. (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a
foldrWithKey
      A.ToJSONKeyValue k -> Value
_ k -> Encoding
f -> ((k, a) -> Encoding) -> [(k, a)] -> Encoding
forall a. (a -> Encoding) -> [a] -> Encoding
E.list ((k -> Bool)
-> (k -> Encoding)
-> ([k] -> Encoding)
-> (a -> Bool)
-> (a -> Encoding)
-> ([a] -> Encoding)
-> (k, a)
-> Encoding
forall a b.
(a -> Bool)
-> (a -> Encoding)
-> ([a] -> Encoding)
-> (b -> Bool)
-> (b -> Encoding)
-> ([b] -> Encoding)
-> (a, b)
-> Encoding
forall (f :: * -> * -> *) a b.
ToJSON2 f =>
(a -> Bool)
-> (a -> Encoding)
-> ([a] -> Encoding)
-> (b -> Bool)
-> (b -> Encoding)
-> ([b] -> Encoding)
-> f a b
-> Encoding
A.liftToEncoding2 (Bool -> k -> Bool
forall a b. a -> b -> a
const Bool
False) k -> Encoding
f ((k -> Encoding) -> [k] -> Encoding
forall a. (a -> Encoding) -> [a] -> Encoding
E.list k -> Encoding
f) a -> Bool
o a -> Encoding
t ((a -> Encoding) -> [a] -> Encoding
forall a. (a -> Encoding) -> [a] -> Encoding
E.list a -> Encoding
t)) ([(k, a)] -> Encoding)
-> (InsOrdHashMap k a -> [(k, a)]) -> InsOrdHashMap k a -> Encoding
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k a -> [(k, a)]
forall k v. InsOrdHashMap k v -> [(k, v)]
toList

instance (A.ToJSONKey k, A.ToJSON v) => A.ToJSON (InsOrdHashMap k v) where
    toJSON :: InsOrdHashMap k v -> Value
toJSON = InsOrdHashMap k v -> Value
forall (f :: * -> *) a. (ToJSON1 f, ToJSON a) => f a -> Value
A.toJSON1
    toEncoding :: InsOrdHashMap k v -> Encoding
toEncoding = InsOrdHashMap k v -> Encoding
forall (f :: * -> *) a. (ToJSON1 f, ToJSON a) => f a -> Encoding
A.toEncoding1

-------------------------------------------------------------------------------

instance (Eq k, Hashable k, A.FromJSONKey k) => A.FromJSON1 (InsOrdHashMap k) where
    liftParseJSON :: forall a.
Maybe a
-> (Value -> Parser a)
-> (Value -> Parser [a])
-> Value
-> Parser (InsOrdHashMap k a)
liftParseJSON Maybe a
o Value -> Parser a
p Value -> Parser [a]
pl Value
v = [(k, a)] -> InsOrdHashMap k a
forall k v. Hashable k => [(k, v)] -> InsOrdHashMap k v
fromList ([(k, a)] -> InsOrdHashMap k a)
-> (HashMap k a -> [(k, a)]) -> HashMap k a -> InsOrdHashMap k a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap k a -> [(k, a)]
forall k v. HashMap k v -> [(k, v)]
HashMap.toList (HashMap k a -> InsOrdHashMap k a)
-> Parser (HashMap k a) -> Parser (InsOrdHashMap k a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe a
-> (Value -> Parser a)
-> (Value -> Parser [a])
-> Value
-> Parser (HashMap k a)
forall a.
Maybe a
-> (Value -> Parser a)
-> (Value -> Parser [a])
-> Value
-> Parser (HashMap k a)
forall (f :: * -> *) a.
FromJSON1 f =>
Maybe a
-> (Value -> Parser a)
-> (Value -> Parser [a])
-> Value
-> Parser (f a)
A.liftParseJSON Maybe a
o Value -> Parser a
p Value -> Parser [a]
pl Value
v

instance (Eq k, Hashable k, A.FromJSONKey k, A.FromJSON v) => A.FromJSON (InsOrdHashMap k v) where
    parseJSON :: Value -> Parser (InsOrdHashMap k v)
parseJSON = Value -> Parser (InsOrdHashMap k v)
forall (f :: * -> *) a.
(FromJSON1 f, FromJSON a) =>
Value -> Parser (f a)
A.parseJSON1

-------------------------------------------------------------------------------
-- indexed-traversals
-------------------------------------------------------------------------------

instance (Eq k, Hashable k) => Optics.FunctorWithIndex k (InsOrdHashMap k) where
    imap :: forall a b. (k -> a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b
imap = (k -> a -> b) -> InsOrdHashMap k a -> InsOrdHashMap k b
forall k v1 v2.
(k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
mapWithKey
instance (Eq k, Hashable k) => Optics.FoldableWithIndex k (InsOrdHashMap k) where
    ifoldMap :: forall m a. Monoid m => (k -> a -> m) -> InsOrdHashMap k a -> m
ifoldMap = (k -> a -> m) -> InsOrdHashMap k a -> m
forall m k v. Monoid m => (k -> v -> m) -> InsOrdHashMap k v -> m
foldMapWithKey
    ifoldr :: forall a b. (k -> a -> b -> b) -> b -> InsOrdHashMap k a -> b
ifoldr   = (k -> a -> b -> b) -> b -> InsOrdHashMap k a -> b
forall k v a. (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a
foldrWithKey
instance (Eq k, Hashable k) => Optics.TraversableWithIndex k (InsOrdHashMap k) where
    itraverse :: forall (f :: * -> *) a b.
Applicative f =>
(k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
itraverse = (k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
forall (f :: * -> *) k v1 v2.
(Applicative f, Hashable k) =>
(k -> v1 -> f v2) -> InsOrdHashMap k v1 -> f (InsOrdHashMap k v2)
traverseWithKey

-------------------------------------------------------------------------------
-- Lens
-------------------------------------------------------------------------------

type instance Index (InsOrdHashMap k v) = k
type instance IxValue (InsOrdHashMap k v) = v

instance (Eq k, Hashable k) => Ixed (InsOrdHashMap k v) where
    ix :: Index (InsOrdHashMap k v)
-> Traversal' (InsOrdHashMap k v) (IxValue (InsOrdHashMap k v))
ix Index (InsOrdHashMap k v)
k IxValue (InsOrdHashMap k v) -> f (IxValue (InsOrdHashMap k v))
f InsOrdHashMap k v
m = k
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (v -> f v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall k (f :: * -> *) v.
(Eq k, Hashable k, Functor f) =>
k
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (v -> f v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
ixImpl k
Index (InsOrdHashMap k v)
k InsOrdHashMap k v -> f (InsOrdHashMap k v)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure v -> f v
IxValue (InsOrdHashMap k v) -> f (IxValue (InsOrdHashMap k v))
f InsOrdHashMap k v
m
    {-# INLINABLE ix #-}

ixImpl
  :: (Eq k, Hashable k, Functor f)
  => k
  -> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
  -> (v -> f v)
  -> InsOrdHashMap k v
  -> f (InsOrdHashMap k v)
ixImpl :: forall k (f :: * -> *) v.
(Eq k, Hashable k, Functor f) =>
k
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (v -> f v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
ixImpl k
k InsOrdHashMap k v -> f (InsOrdHashMap k v)
point v -> f v
f InsOrdHashMap k v
m = case k -> InsOrdHashMap k v -> Maybe v
forall k v. Hashable k => k -> InsOrdHashMap k v -> Maybe v
lookup k
k InsOrdHashMap k v
m of
    Just v
v  -> v -> f v
f v
v f v -> (v -> InsOrdHashMap k v) -> f (InsOrdHashMap k v)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \v
v' -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
Hashable k =>
k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insert k
k v
v' InsOrdHashMap k v
m
    Maybe v
Nothing -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
point InsOrdHashMap k v
m
{-# INLINE ixImpl #-}

instance (Eq k, Hashable k) => At (InsOrdHashMap k a) where
    at :: Index (InsOrdHashMap k a)
-> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a)))
at Index (InsOrdHashMap k a)
k Maybe (IxValue (InsOrdHashMap k a))
-> f (Maybe (IxValue (InsOrdHashMap k a)))
f InsOrdHashMap k a
m = Maybe (IxValue (InsOrdHashMap k a))
-> f (Maybe (IxValue (InsOrdHashMap k a)))
f Maybe a
Maybe (IxValue (InsOrdHashMap k a))
mv f (Maybe a)
-> (Maybe a -> InsOrdHashMap k a) -> f (InsOrdHashMap k a)
forall (f :: * -> *) a b. Functor f => f a -> (a -> b) -> f b
<&> \Maybe a
r -> case Maybe a
r of
        Maybe a
Nothing -> InsOrdHashMap k a
-> (a -> InsOrdHashMap k a) -> Maybe a -> InsOrdHashMap k a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe InsOrdHashMap k a
m (InsOrdHashMap k a -> a -> InsOrdHashMap k a
forall a b. a -> b -> a
const (k -> InsOrdHashMap k a -> InsOrdHashMap k a
forall k v.
Hashable k =>
k -> InsOrdHashMap k v -> InsOrdHashMap k v
delete k
Index (InsOrdHashMap k a)
k InsOrdHashMap k a
m)) Maybe a
mv
        Just a
v' -> k -> a -> InsOrdHashMap k a -> InsOrdHashMap k a
forall k v.
Hashable k =>
k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insert k
Index (InsOrdHashMap k a)
k a
v' InsOrdHashMap k a
m
      where mv :: Maybe a
mv = k -> InsOrdHashMap k a -> Maybe a
forall k v. Hashable k => k -> InsOrdHashMap k v -> Maybe v
lookup k
Index (InsOrdHashMap k a)
k InsOrdHashMap k a
m
    {-# INLINABLE at #-}

-------------------------------------------------------------------------------
-- Optics
-------------------------------------------------------------------------------

type instance Optics.Index (InsOrdHashMap k v) = k
type instance Optics.IxValue (InsOrdHashMap k v) = v

instance (Eq k, Hashable k) => Optics.Ixed (InsOrdHashMap k v) where
    ix :: Index (InsOrdHashMap k v)
-> Optic'
     (IxKind (InsOrdHashMap k v))
     NoIx
     (InsOrdHashMap k v)
     (IxValue (InsOrdHashMap k v))
ix Index (InsOrdHashMap k v)
k = AffineTraversalVL
  (InsOrdHashMap k v)
  (InsOrdHashMap k v)
  (IxValue (InsOrdHashMap k v))
  (IxValue (InsOrdHashMap k v))
-> AffineTraversal
     (InsOrdHashMap k v)
     (InsOrdHashMap k v)
     (IxValue (InsOrdHashMap k v))
     (IxValue (InsOrdHashMap k v))
forall s t a b.
AffineTraversalVL s t a b -> AffineTraversal s t a b
Optics.atraversalVL (AffineTraversalVL
   (InsOrdHashMap k v)
   (InsOrdHashMap k v)
   (IxValue (InsOrdHashMap k v))
   (IxValue (InsOrdHashMap k v))
 -> AffineTraversal
      (InsOrdHashMap k v)
      (InsOrdHashMap k v)
      (IxValue (InsOrdHashMap k v))
      (IxValue (InsOrdHashMap k v)))
-> AffineTraversalVL
     (InsOrdHashMap k v)
     (InsOrdHashMap k v)
     (IxValue (InsOrdHashMap k v))
     (IxValue (InsOrdHashMap k v))
-> AffineTraversal
     (InsOrdHashMap k v)
     (InsOrdHashMap k v)
     (IxValue (InsOrdHashMap k v))
     (IxValue (InsOrdHashMap k v))
forall a b. (a -> b) -> a -> b
$ \forall r. r -> f r
point IxValue (InsOrdHashMap k v) -> f (IxValue (InsOrdHashMap k v))
f InsOrdHashMap k v
m -> k
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (v -> f v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall k (f :: * -> *) v.
(Eq k, Hashable k, Functor f) =>
k
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (v -> f v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
ixImpl k
Index (InsOrdHashMap k v)
k InsOrdHashMap k v -> f (InsOrdHashMap k v)
forall r. r -> f r
point v -> f v
IxValue (InsOrdHashMap k v) -> f (IxValue (InsOrdHashMap k v))
f InsOrdHashMap k v
m
    {-# INLINE ix #-}

instance (Eq k, Hashable k) => Optics.At (InsOrdHashMap k a) where
    at :: Index (InsOrdHashMap k a)
-> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a)))
at Index (InsOrdHashMap k a)
k = LensVL
  (InsOrdHashMap k a)
  (InsOrdHashMap k a)
  (Maybe (IxValue (InsOrdHashMap k a)))
  (Maybe (IxValue (InsOrdHashMap k a)))
-> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a)))
forall s t a b. LensVL s t a b -> Lens s t a b
Optics.lensVL (LensVL
   (InsOrdHashMap k a)
   (InsOrdHashMap k a)
   (Maybe (IxValue (InsOrdHashMap k a)))
   (Maybe (IxValue (InsOrdHashMap k a)))
 -> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a))))
-> LensVL
     (InsOrdHashMap k a)
     (InsOrdHashMap k a)
     (Maybe (IxValue (InsOrdHashMap k a)))
     (Maybe (IxValue (InsOrdHashMap k a)))
-> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a)))
forall a b. (a -> b) -> a -> b
$ \Maybe (IxValue (InsOrdHashMap k a))
-> f (Maybe (IxValue (InsOrdHashMap k a)))
f InsOrdHashMap k a
m -> Index (InsOrdHashMap k a)
-> Lens' (InsOrdHashMap k a) (Maybe (IxValue (InsOrdHashMap k a)))
forall m. At m => Index m -> Lens' m (Maybe (IxValue m))
Lens.at Index (InsOrdHashMap k a)
Index (InsOrdHashMap k a)
k Maybe (IxValue (InsOrdHashMap k a))
-> f (Maybe (IxValue (InsOrdHashMap k a)))
Maybe (IxValue (InsOrdHashMap k a))
-> f (Maybe (IxValue (InsOrdHashMap k a)))
f InsOrdHashMap k a
m
    {-# INLINE at #-}

-------------------------------------------------------------------------------

-- | This is a slight lie, as roundtrip doesn't preserve ordering.
hashMap :: Iso (InsOrdHashMap k a) (InsOrdHashMap k b) (HashMap k a) (HashMap k b)
hashMap :: forall k a b (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (HashMap k a) (f (HashMap k b))
-> p (InsOrdHashMap k a) (f (InsOrdHashMap k b))
hashMap = (InsOrdHashMap k a -> HashMap k a)
-> (HashMap k b -> InsOrdHashMap k b)
-> Iso
     (InsOrdHashMap k a) (InsOrdHashMap k b) (HashMap k a) (HashMap k b)
forall s a b t. (s -> a) -> (b -> t) -> Iso s t a b
iso InsOrdHashMap k a -> HashMap k a
forall k v. InsOrdHashMap k v -> HashMap k v
toHashMap HashMap k b -> InsOrdHashMap k b
forall k v. HashMap k v -> InsOrdHashMap k v
fromHashMap

unorderedTraversal :: Traversal (InsOrdHashMap k a) (InsOrdHashMap k b) a b
unorderedTraversal :: forall k a b (f :: * -> *).
Applicative f =>
(a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
unorderedTraversal = (HashMap k a -> f (HashMap k b))
-> InsOrdHashMap k a -> f (InsOrdHashMap k b)
forall k a b (p :: * -> * -> *) (f :: * -> *).
(Profunctor p, Functor f) =>
p (HashMap k a) (f (HashMap k b))
-> p (InsOrdHashMap k a) (f (InsOrdHashMap k b))
hashMap ((HashMap k a -> f (HashMap k b))
 -> InsOrdHashMap k a -> f (InsOrdHashMap k b))
-> ((a -> f b) -> HashMap k a -> f (HashMap k b))
-> (a -> f b)
-> InsOrdHashMap k a
-> f (InsOrdHashMap k b)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> f b) -> HashMap k a -> f (HashMap k b)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> HashMap k a -> f (HashMap k b)
traverse

-------------------------------------------------------------------------------
-- * Construction
-------------------------------------------------------------------------------

empty :: InsOrdHashMap k v
empty :: forall k v. InsOrdHashMap k v
empty = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap InsOrdHashMap k v
forall k v. InsOrdHashMap k v
InsOrdHashMap.empty

singleton :: Hashable k => k -> v -> InsOrdHashMap k v
singleton :: forall k v. Hashable k => k -> v -> InsOrdHashMap k v
singleton k
k v
v = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (k -> v -> InsOrdHashMap k v
forall k v. Hashable k => k -> v -> InsOrdHashMap k v
InsOrdHashMap.singleton k
k v
v)

-------------------------------------------------------------------------------
-- * Basic interface
-------------------------------------------------------------------------------

null :: InsOrdHashMap k v -> Bool
null :: forall k a. InsOrdHashMap k a -> Bool
null = InsOrdHashMap k v -> Bool
forall k v. InsOrdHashMap k v -> Bool
InsOrdHashMap.null (InsOrdHashMap k v -> Bool)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

size :: InsOrdHashMap k v -> Int
size :: forall k a. InsOrdHashMap k a -> Int
size = InsOrdHashMap k v -> Int
forall k v. InsOrdHashMap k v -> Int
InsOrdHashMap.size (InsOrdHashMap k v -> Int)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

insert :: Hashable k => k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insert :: forall k v.
Hashable k =>
k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insert k
k v
v = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.insert k
k v
v (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

insertWith :: Hashable k => (v -> v -> v) -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insertWith :: forall k v.
Hashable k =>
(v -> v -> v) -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
insertWith v -> v -> v
f k
k v
v = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> v -> v) -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v) -> k -> v -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.insertWith v -> v -> v
f k
k v
v (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

delete :: Hashable k => k -> InsOrdHashMap k v -> InsOrdHashMap k v
delete :: forall k v.
Hashable k =>
k -> InsOrdHashMap k v -> InsOrdHashMap k v
delete k
k = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. k -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
k -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.delete k
k (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

adjust :: Hashable k => (v -> v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
adjust :: forall k v.
Hashable k =>
(v -> v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
adjust v -> v
f k
k = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
(v -> v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.adjust v -> v
f k
k (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

update :: Hashable k => (v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
update :: forall k v.
Hashable k =>
(v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
update v -> Maybe v
f k
k = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k a.
(Eq k, Hashable k) =>
(a -> Maybe a) -> k -> InsOrdHashMap k a -> InsOrdHashMap k a
InsOrdHashMap.update v -> Maybe v
f k
k (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

alter :: Hashable k => (Maybe v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
alter :: forall k v.
Hashable k =>
(Maybe v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
alter Maybe v -> Maybe v
f k
k = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Maybe v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
(Maybe v -> Maybe v) -> k -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.alter Maybe v -> Maybe v
f k
k (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

member :: Hashable k => k -> InsOrdHashMap k v -> Bool
member :: forall k v. Hashable k => k -> InsOrdHashMap k v -> Bool
member k
k = k -> InsOrdHashMap k v -> Bool
forall k a. (Eq k, Hashable k) => k -> InsOrdHashMap k a -> Bool
InsOrdHashMap.member k
k (InsOrdHashMap k v -> Bool)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

lookup :: Hashable k => k -> InsOrdHashMap k v -> Maybe v
lookup :: forall k v. Hashable k => k -> InsOrdHashMap k v -> Maybe v
lookup k
k = k -> InsOrdHashMap k v -> Maybe v
forall k v. (Eq k, Hashable k) => k -> InsOrdHashMap k v -> Maybe v
InsOrdHashMap.lookup k
k (InsOrdHashMap k v -> Maybe v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> Maybe v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

lookupDefault :: Hashable k => v -> k -> InsOrdHashMap k v -> v
lookupDefault :: forall k v. Hashable k => v -> k -> InsOrdHashMap k v -> v
lookupDefault v
k k
def = v -> k -> InsOrdHashMap k v -> v
forall k v. (Eq k, Hashable k) => v -> k -> InsOrdHashMap k v -> v
InsOrdHashMap.lookupDefault v
k k
def (InsOrdHashMap k v -> v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-- * Combine

union :: Hashable k => InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
union :: forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
union InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.union (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

unionWith :: Hashable k => (v -> v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
unionWith :: forall k v.
Hashable k =>
(v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
unionWith v -> v -> v
f InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap ((v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
(v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.unionWith v -> v -> v
f (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

unionWithKey :: Hashable k => (k -> v -> v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
unionWithKey :: forall k v.
Hashable k =>
(k -> v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
unionWithKey k -> v -> v -> v
f InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap ((k -> v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(Eq k, Hashable k) =>
(k -> v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.unionWithKey k -> v -> v -> v
f (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

unions :: Hashable k => [InsOrdHashMap k v] -> InsOrdHashMap k v
unions :: forall k v. Hashable k => [InsOrdHashMap k v] -> InsOrdHashMap k v
unions = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> ([InsOrdHashMap k v] -> InsOrdHashMap k v)
-> [InsOrdHashMap k v]
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [InsOrdHashMap k v] -> InsOrdHashMap k v
forall k (f :: * -> *) v.
(Eq k, Hashable k, Foldable f) =>
f (InsOrdHashMap k v) -> InsOrdHashMap k v
InsOrdHashMap.unions ([InsOrdHashMap k v] -> InsOrdHashMap k v)
-> ([InsOrdHashMap k v] -> [InsOrdHashMap k v])
-> [InsOrdHashMap k v]
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (InsOrdHashMap k v -> InsOrdHashMap k v)
-> [InsOrdHashMap k v] -> [InsOrdHashMap k v]
forall a b. (a -> b) -> [a] -> [b]
Prelude.map InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-------------------------------------------------------------------------------
-- * Transformations
-------------------------------------------------------------------------------

map :: (v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v
map :: forall v k. (v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v
map v -> v
f = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v
forall v1 v2 k.
(v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
InsOrdHashMap.map v -> v
f (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

mapKeys :: Hashable k => (k -> k) -> InsOrdHashMap k v -> InsOrdHashMap k v
mapKeys :: forall k v.
Hashable k =>
(k -> k) -> InsOrdHashMap k v -> InsOrdHashMap k v
mapKeys k -> k
f = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> k) -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k' k v.
(Eq k', Hashable k') =>
(k -> k') -> InsOrdHashMap k v -> InsOrdHashMap k' v
InsOrdHashMap.mapKeys k -> k
f (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

traverseKeys :: (Applicative f, Hashable k) => (k -> f k) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
traverseKeys :: forall (f :: * -> *) k v.
(Applicative f, Hashable k) =>
(k -> f k) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
traverseKeys k -> f k
f = (InsOrdHashMap k v -> InsOrdHashMap k v)
-> f (InsOrdHashMap k v) -> f (InsOrdHashMap k v)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (f (InsOrdHashMap k v) -> f (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> f k) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
forall k' (f :: * -> *) k v.
(Eq k', Hashable k', Applicative f) =>
(k -> f k') -> InsOrdHashMap k v -> f (InsOrdHashMap k' v)
InsOrdHashMap.traverseKeys k -> f k
f (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

mapWithKey :: (k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
mapWithKey :: forall k v1 v2.
(k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
mapWithKey k -> v1 -> v2
f = InsOrdHashMap k v2 -> InsOrdHashMap k v2
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v2 -> InsOrdHashMap k v2)
-> (InsOrdHashMap k v1 -> InsOrdHashMap k v2)
-> InsOrdHashMap k v1
-> InsOrdHashMap k v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
forall k v1 v2.
(k -> v1 -> v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
InsOrdHashMap.mapWithKey k -> v1 -> v2
f (InsOrdHashMap k v1 -> InsOrdHashMap k v2)
-> (InsOrdHashMap k v1 -> InsOrdHashMap k v1)
-> InsOrdHashMap k v1
-> InsOrdHashMap k v2
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v1 -> InsOrdHashMap k v1
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

traverseWithKey :: (Applicative f, Hashable k) => (k -> v1 -> f v2) -> InsOrdHashMap k v1 -> f (InsOrdHashMap k v2)
traverseWithKey :: forall (f :: * -> *) k v1 v2.
(Applicative f, Hashable k) =>
(k -> v1 -> f v2) -> InsOrdHashMap k v1 -> f (InsOrdHashMap k v2)
traverseWithKey k -> v1 -> f v2
f = (InsOrdHashMap k v2 -> InsOrdHashMap k v2)
-> f (InsOrdHashMap k v2) -> f (InsOrdHashMap k v2)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap InsOrdHashMap k v2 -> InsOrdHashMap k v2
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (f (InsOrdHashMap k v2) -> f (InsOrdHashMap k v2))
-> (InsOrdHashMap k v1 -> f (InsOrdHashMap k v2))
-> InsOrdHashMap k v1
-> f (InsOrdHashMap k v2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v1 -> f v2) -> InsOrdHashMap k v1 -> f (InsOrdHashMap k v2)
forall (f :: * -> *) k a b.
Applicative f =>
(k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
InsOrdHashMap.traverseWithKey k -> v1 -> f v2
f (InsOrdHashMap k v1 -> f (InsOrdHashMap k v2))
-> (InsOrdHashMap k v1 -> InsOrdHashMap k v1)
-> InsOrdHashMap k v1
-> f (InsOrdHashMap k v2)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v1 -> InsOrdHashMap k v1
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-- ** Unordered

unorderedTraverse :: (Applicative f, Hashable k) => (v -> f v) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
unorderedTraverse :: forall (f :: * -> *) k v.
(Applicative f, Hashable k) =>
(v -> f v) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
unorderedTraverse v -> f v
f = (InsOrdHashMap k v -> InsOrdHashMap k v)
-> f (InsOrdHashMap k v) -> f (InsOrdHashMap k v)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (f (InsOrdHashMap k v) -> f (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> f v) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
forall (f :: * -> *) a b k.
Applicative f =>
(a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
InsOrdHashMap.unorderedTraverse v -> f v
f (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

unorderedTraverseWithKey :: (Applicative f, Hashable k) => (k -> v -> f v) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
unorderedTraverseWithKey :: forall (f :: * -> *) k v.
(Applicative f, Hashable k) =>
(k -> v -> f v) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
unorderedTraverseWithKey k -> v -> f v
f = (InsOrdHashMap k v -> InsOrdHashMap k v)
-> f (InsOrdHashMap k v) -> f (InsOrdHashMap k v)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (f (InsOrdHashMap k v) -> f (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v -> f v) -> InsOrdHashMap k v -> f (InsOrdHashMap k v)
forall (f :: * -> *) k a b.
Applicative f =>
(k -> a -> f b) -> InsOrdHashMap k a -> f (InsOrdHashMap k b)
InsOrdHashMap.unorderedTraverseWithKey k -> v -> f v
f (InsOrdHashMap k v -> f (InsOrdHashMap k v))
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> f (InsOrdHashMap k v)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-------------------------------------------------------------------------------
-- * Difference and intersection
-------------------------------------------------------------------------------

difference :: Hashable k => InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
difference :: forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
difference InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v w.
(Eq k, Hashable k) =>
InsOrdHashMap k v -> InsOrdHashMap k w -> InsOrdHashMap k v
InsOrdHashMap.difference (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

intersection :: Hashable k => InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
intersection :: forall k v.
Hashable k =>
InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
intersection InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v w.
(Eq k, Hashable k) =>
InsOrdHashMap k v -> InsOrdHashMap k w -> InsOrdHashMap k v
InsOrdHashMap.intersection (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

intersectionWith :: Hashable k => (v -> v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
intersectionWith :: forall k v.
Hashable k =>
(v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
intersectionWith v -> v -> v
f InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap ((v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(v1 -> v2 -> v3)
-> InsOrdHashMap k v1 -> InsOrdHashMap k v2 -> InsOrdHashMap k v3
InsOrdHashMap.intersectionWith v -> v -> v
f (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

intersectionWithKey :: Hashable k => (k -> v -> v -> v) -> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
intersectionWithKey :: forall k v.
Hashable k =>
(k -> v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
intersectionWithKey k -> v -> v -> v
f InsOrdHashMap k v
m1 InsOrdHashMap k v
m2 = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap ((k -> v -> v -> v)
-> InsOrdHashMap k v -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v1 v2 v3.
(Eq k, Hashable k) =>
(k -> v1 -> v2 -> v3)
-> InsOrdHashMap k v1 -> InsOrdHashMap k v2 -> InsOrdHashMap k v3
InsOrdHashMap.intersectionWithKey k -> v -> v -> v
f (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m1) (InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap InsOrdHashMap k v
m2))

-------------------------------------------------------------------------------
-- * Folds
-------------------------------------------------------------------------------

foldl' :: (a -> v -> a) -> a -> InsOrdHashMap k v -> a
foldl' :: forall a v k. (a -> v -> a) -> a -> InsOrdHashMap k v -> a
foldl' a -> v -> a
f a
z = (a -> v -> a) -> a -> InsOrdHashMap k v -> a
forall a v k. (a -> v -> a) -> a -> InsOrdHashMap k v -> a
InsOrdHashMap.foldl' a -> v -> a
f a
z (InsOrdHashMap k v -> a)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

foldlWithKey' :: (a -> k -> v -> a) -> a -> InsOrdHashMap k v -> a
foldlWithKey' :: forall a k v. (a -> k -> v -> a) -> a -> InsOrdHashMap k v -> a
foldlWithKey' a -> k -> v -> a
f a
z = (a -> k -> v -> a) -> a -> InsOrdHashMap k v -> a
forall a k v. (a -> k -> v -> a) -> a -> InsOrdHashMap k v -> a
InsOrdHashMap.foldlWithKey' a -> k -> v -> a
f a
z (InsOrdHashMap k v -> a)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

foldMapWithKey :: Monoid m => (k -> v -> m) -> InsOrdHashMap k v -> m
foldMapWithKey :: forall m k v. Monoid m => (k -> v -> m) -> InsOrdHashMap k v -> m
foldMapWithKey k -> v -> m
f = (k -> v -> m) -> InsOrdHashMap k v -> m
forall m k a. Monoid m => (k -> a -> m) -> InsOrdHashMap k a -> m
InsOrdHashMap.foldMapWithKey k -> v -> m
f (InsOrdHashMap k v -> m)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

foldrWithKey :: (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a
foldrWithKey :: forall k v a. (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a
foldrWithKey k -> v -> a -> a
f a
z = (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a
forall k v a. (k -> v -> a -> a) -> a -> InsOrdHashMap k v -> a
InsOrdHashMap.foldrWithKey k -> v -> a -> a
f a
z (InsOrdHashMap k v -> a)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-- ** Unordered

unorderedFoldMap :: Monoid m => (v -> m) -> InsOrdHashMap k v -> m
unorderedFoldMap :: forall m v k. Monoid m => (v -> m) -> InsOrdHashMap k v -> m
unorderedFoldMap v -> m
f = (v -> m) -> InsOrdHashMap k v -> m
forall m a k. Monoid m => (a -> m) -> InsOrdHashMap k a -> m
InsOrdHashMap.unorderedFoldMap v -> m
f (InsOrdHashMap k v -> m)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

unorderedFoldMapWithKey :: Monoid m => (k -> v -> m) -> InsOrdHashMap k v -> m
unorderedFoldMapWithKey :: forall m k v. Monoid m => (k -> v -> m) -> InsOrdHashMap k v -> m
unorderedFoldMapWithKey k -> v -> m
f = (k -> v -> m) -> InsOrdHashMap k v -> m
forall m k a. Monoid m => (k -> a -> m) -> InsOrdHashMap k a -> m
InsOrdHashMap.unorderedFoldMapWithKey k -> v -> m
f (InsOrdHashMap k v -> m)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> m
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-------------------------------------------------------------------------------
-- * Filter
-------------------------------------------------------------------------------

filter :: (v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
filter :: forall v k. (v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
filter v -> Bool
f = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
forall v k. (v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.filter v -> Bool
f (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

filterWithKey :: (k -> v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
filterWithKey :: forall k v.
(k -> v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
filterWithKey k -> v -> Bool
f = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v.
(k -> v -> Bool) -> InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap.filterWithKey k -> v -> Bool
f (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

mapMaybe :: (v -> Maybe v) -> InsOrdHashMap k v -> InsOrdHashMap k v
mapMaybe :: forall v k.
(v -> Maybe v) -> InsOrdHashMap k v -> InsOrdHashMap k v
mapMaybe v -> Maybe v
f = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (v -> Maybe v) -> InsOrdHashMap k v -> InsOrdHashMap k v
forall v1 v2 k.
(v1 -> Maybe v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
InsOrdHashMap.mapMaybe v -> Maybe v
f (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

mapMaybeWithKey :: (k -> v -> Maybe v) -> InsOrdHashMap k v -> InsOrdHashMap k v
mapMaybeWithKey :: forall k v.
(k -> v -> Maybe v) -> InsOrdHashMap k v -> InsOrdHashMap k v
mapMaybeWithKey k -> v -> Maybe v
f = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (k -> v -> Maybe v) -> InsOrdHashMap k v -> InsOrdHashMap k v
forall k v1 v2.
(k -> v1 -> Maybe v2) -> InsOrdHashMap k v1 -> InsOrdHashMap k v2
InsOrdHashMap.mapMaybeWithKey k -> v -> Maybe v
f (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

-------------------------------------------------------------------------------
-- * Conversions
-------------------------------------------------------------------------------

keys :: InsOrdHashMap k v -> [k]
keys :: forall k v. InsOrdHashMap k v -> [k]
keys = InsOrdHashMap k v -> [k]
forall k v. InsOrdHashMap k v -> [k]
InsOrdHashMap.keys (InsOrdHashMap k v -> [k])
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> [k]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

elems :: InsOrdHashMap k v -> [v]
elems :: forall k a. InsOrdHashMap k a -> [a]
elems = InsOrdHashMap k v -> [v]
forall k v. InsOrdHashMap k v -> [v]
InsOrdHashMap.elems (InsOrdHashMap k v -> [v])
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> [v]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

toRevList :: InsOrdHashMap k v -> [(k, v)]
toRevList :: forall k v. InsOrdHashMap k v -> [(k, v)]
toRevList = InsOrdHashMap k v -> [(k, v)]
forall k v. InsOrdHashMap k v -> [(k, v)]
InsOrdHashMap.toRevList (InsOrdHashMap k v -> [(k, v)])
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> [(k, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

fromList :: Hashable k => [(k, v)] -> InsOrdHashMap k v
fromList :: forall k v. Hashable k => [(k, v)] -> InsOrdHashMap k v
fromList = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> ([(k, v)] -> InsOrdHashMap k v) -> [(k, v)] -> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(k, v)] -> InsOrdHashMap k v
forall k v. (Eq k, Hashable k) => [(k, v)] -> InsOrdHashMap k v
InsOrdHashMap.fromList

toList :: InsOrdHashMap k v -> [(k, v)]
toList :: forall k v. InsOrdHashMap k v -> [(k, v)]
toList = InsOrdHashMap k v -> [(k, v)]
forall k v. InsOrdHashMap k v -> [(k, v)]
InsOrdHashMap.toList (InsOrdHashMap k v -> [(k, v)])
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> [(k, v)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

toHashMap :: InsOrdHashMap k v -> HashMap k v
toHashMap :: forall k v. InsOrdHashMap k v -> HashMap k v
toHashMap = InsOrdHashMap k v -> HashMap k v
forall k v. InsOrdHashMap k v -> HashMap k v
InsOrdHashMap.toHashMap (InsOrdHashMap k v -> HashMap k v)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> HashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

fromHashMap :: HashMap k v -> InsOrdHashMap k v
fromHashMap :: forall k v. HashMap k v -> InsOrdHashMap k v
fromHashMap = InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
InsOrdHashMap (InsOrdHashMap k v -> InsOrdHashMap k v)
-> (HashMap k v -> InsOrdHashMap k v)
-> HashMap k v
-> InsOrdHashMap k v
forall b c a. (b -> c) -> (a -> b) -> a -> c
. HashMap k v -> InsOrdHashMap k v
forall k v. HashMap k v -> InsOrdHashMap k v
InsOrdHashMap.fromHashMap

-------------------------------------------------------------------------------
-- * Debugging
-------------------------------------------------------------------------------

valid :: (Eq k, Hashable k) => InsOrdHashMap k v -> Bool
valid :: forall k v. (Eq k, Hashable k) => InsOrdHashMap k v -> Bool
valid = InsOrdHashMap k v -> Bool
forall k v. InsOrdHashMap k v -> Bool
InsOrdHashMap.valid (InsOrdHashMap k v -> Bool)
-> (InsOrdHashMap k v -> InsOrdHashMap k v)
-> InsOrdHashMap k v
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. InsOrdHashMap k v -> InsOrdHashMap k v
forall k v. InsOrdHashMap k v -> InsOrdHashMap k v
unCompatInsOrdHashMap

#endif