-- |
--   Module      :  Data.Edison.Assoc.Defaults
--   Copyright   :  Copyright (c) 1998, 2008 Chris Okasaki
--   License     :  MIT; see COPYRIGHT file for terms and conditions
--
--   Maintainer  :  robdockins AT fastmail DOT fm
--   Stability   :  internal (unstable)
--   Portability :  GHC, Hugs (MPTC and FD)
--
--   This module provides default implementations of many of the associative
--   collection operations.  These function are used to fill in collection
--   implementations and are not intended to be used directly by end users.

module Data.Edison.Assoc.Defaults where

import Prelude hiding (null,map,lookup,foldr,foldl,foldr1,foldl1,foldl',filter)

import qualified Control.Monad.Fail as Fail

import Data.Edison.Assoc
import qualified Data.Edison.Seq as S
import qualified Data.Edison.Seq.ListSeq as L
import Data.Edison.Seq.Defaults (tokenMatch,maybeParens)

singletonUsingInsert :: (Assoc m k) => k -> a -> m a
singletonUsingInsert :: forall (m :: * -> *) k a. Assoc m k => k -> a -> m a
singletonUsingInsert k
k a
v = k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k a
v m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty

fromSeqUsingInsertSeq :: (AssocX m k,S.Sequence seq) => seq (k,a) -> m a
fromSeqUsingInsertSeq :: forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq (k, a) -> m a
fromSeqUsingInsertSeq seq (k, a)
kvs = seq (k, a) -> m a -> m a
forall (seq :: * -> *) a. Sequence seq => seq (k, a) -> m a -> m a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq (k, a) -> m a -> m a
insertSeq seq (k, a)
kvs m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty

insertSeqUsingFoldr ::
    (AssocX m k,S.Sequence seq) => seq (k,a) -> m a -> m a
insertSeqUsingFoldr :: forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq (k, a) -> m a -> m a
insertSeqUsingFoldr seq (k, a)
kvs m a
m = ((k, a) -> m a -> m a) -> m a -> seq (k, a) -> m a
forall a b. (a -> b -> b) -> b -> seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr ((k -> a -> m a -> m a) -> (k, a) -> m a -> m a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert) m a
m seq (k, a)
kvs

unionSeqUsingReduce :: (AssocX m k,S.Sequence seq) => seq (m a) -> m a
unionSeqUsingReduce :: forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq (m a) -> m a
unionSeqUsingReduce seq (m a)
ms = (m a -> m a -> m a) -> m a -> seq (m a) -> m a
forall a. (a -> a -> a) -> a -> seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducel m a -> m a -> m a
forall a. m a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => m a -> m a -> m a
union m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty seq (m a)
ms

deleteSeqUsingFoldr :: (AssocX m k,S.Sequence seq) => seq k -> m a -> m a
deleteSeqUsingFoldr :: forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
seq k -> m a -> m a
deleteSeqUsingFoldr seq k
ks m a
m = (k -> m a -> m a) -> m a -> seq k -> m a
forall a b. (a -> b -> b) -> b -> seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr k -> m a -> m a
forall a. k -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> m a -> m a
delete m a
m seq k
ks

memberUsingLookupM :: (AssocX m k) => k -> m a -> Bool
memberUsingLookupM :: forall (m :: * -> *) k a. AssocX m k => k -> m a -> Bool
memberUsingLookupM k
k m a
m
  = case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m of
        Just a
_  -> Bool
True
        Maybe a
Nothing -> Bool
False

countUsingMember :: AssocX m k => k -> m a -> Int
countUsingMember :: forall (m :: * -> *) k a. AssocX m k => k -> m a -> Int
countUsingMember k
k m a
m = if k -> m a -> Bool
forall a. k -> m a -> Bool
forall (m :: * -> *) k a. AssocX m k => k -> m a -> Bool
member k
k m a
m then Int
1 else Int
0

lookupAllUsingLookupM :: (AssocX m k,S.Sequence seq) => k -> m a -> seq a
lookupAllUsingLookupM :: forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
k -> m a -> seq a
lookupAllUsingLookupM k
k m a
m = case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m of
                              Just a
x -> a -> seq a
forall (s :: * -> *) a. Sequence s => a -> s a
S.singleton a
x
                              Maybe a
Nothing -> seq a
forall (s :: * -> *) a. Sequence s => s a
S.empty

lookupWithDefaultUsingLookupM :: AssocX m k => a -> k -> m a -> a
lookupWithDefaultUsingLookupM :: forall (m :: * -> *) k a. AssocX m k => a -> k -> m a -> a
lookupWithDefaultUsingLookupM a
d k
k m a
m = case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m of
                                        Just a
x -> a
x
                                        Maybe a
Nothing -> a
d

partitionUsingFilter :: AssocX m k => (a -> Bool) -> m a -> (m a,m a)
partitionUsingFilter :: forall (m :: * -> *) k a.
AssocX m k =>
(a -> Bool) -> m a -> (m a, m a)
partitionUsingFilter a -> Bool
f m a
m = ((a -> Bool) -> m a -> m a
forall a. (a -> Bool) -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => (a -> Bool) -> m a -> m a
filter a -> Bool
f m a
m, (a -> Bool) -> m a -> m a
forall a. (a -> Bool) -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => (a -> Bool) -> m a -> m a
filter (Bool -> Bool
not (Bool -> Bool) -> (a -> Bool) -> a -> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> Bool
f) m a
m)

fold1UsingElements :: (AssocX m k) => (a -> a -> a) -> m a -> a
fold1UsingElements :: forall (m :: * -> *) k a. AssocX m k => (a -> a -> a) -> m a -> a
fold1UsingElements a -> a -> a
op m a
m = (a -> a -> a) -> [a] -> a
forall a. (a -> a -> a) -> [a] -> a
L.foldr1 a -> a -> a
op (m a -> [a]
forall (seq :: * -> *) a. Sequence seq => m a -> seq a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
m a -> seq a
elements m a
m)

elementsUsingFold :: (AssocX m k,S.Sequence seq) => m a -> seq a
elementsUsingFold :: forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
m a -> seq a
elementsUsingFold = (a -> seq a -> seq a) -> seq a -> m a -> seq a
forall a b. (a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
AssocX m k =>
(a -> b -> b) -> b -> m a -> b
fold a -> seq a -> seq a
forall a. a -> seq a -> seq a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
S.lcons seq a
forall (s :: * -> *) a. Sequence s => s a
S.empty

nullUsingElements :: (AssocX m k) => m a -> Bool
nullUsingElements :: forall (m :: * -> *) k a. AssocX m k => m a -> Bool
nullUsingElements m a
m
  = case m a -> [a]
forall (seq :: * -> *) a. Sequence seq => m a -> seq a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
m a -> seq a
elements m a
m of
        [] -> Bool
True
        [a]
_  -> Bool
False

insertWithUsingLookupM ::
    FiniteMapX m k => (a -> a -> a) -> k -> a -> m a -> m a
insertWithUsingLookupM :: forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> a) -> k -> a -> m a -> m a
insertWithUsingLookupM a -> a -> a
f k
k a
x m a
m =
    case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m of
      Maybe a
Nothing -> k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k a
x m a
m
      Just a
y  -> k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k (a -> a -> a
f a
x a
y) m a
m

fromSeqWithUsingInsertSeqWith ::
    (FiniteMapX m k,S.Sequence seq) => (a -> a -> a) -> seq (k,a) -> m a
fromSeqWithUsingInsertSeqWith :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> m a
fromSeqWithUsingInsertSeqWith a -> a -> a
f seq (k, a)
kvs = (a -> a -> a) -> seq (k, a) -> m a -> m a
forall (seq :: * -> *) a.
Sequence seq =>
(a -> a -> a) -> seq (k, a) -> m a -> m a
forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> m a -> m a
insertSeqWith a -> a -> a
f seq (k, a)
kvs m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty

fromSeqWithKeyUsingInsertSeqWithKey ::
    (FiniteMapX m k,S.Sequence seq) => (k -> a -> a -> a) -> seq (k,a) -> m a
fromSeqWithKeyUsingInsertSeqWithKey :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> m a
fromSeqWithKeyUsingInsertSeqWithKey k -> a -> a -> a
f seq (k, a)
kvs = (k -> a -> a -> a) -> seq (k, a) -> m a -> m a
forall (seq :: * -> *) a.
Sequence seq =>
(k -> a -> a -> a) -> seq (k, a) -> m a -> m a
forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> m a -> m a
insertSeqWithKey k -> a -> a -> a
f seq (k, a)
kvs m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty

insertWithKeyUsingInsertWith ::
    FiniteMapX m k => (k -> a -> a -> a) -> k -> a -> m a -> m a
insertWithKeyUsingInsertWith :: forall (m :: * -> *) k a.
FiniteMapX m k =>
(k -> a -> a -> a) -> k -> a -> m a -> m a
insertWithKeyUsingInsertWith k -> a -> a -> a
f k
k = (a -> a -> a) -> k -> a -> m a -> m a
forall a. (a -> a -> a) -> k -> a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> a) -> k -> a -> m a -> m a
insertWith (k -> a -> a -> a
f k
k) k
k

insertSeqWithUsingInsertWith ::
    (FiniteMapX m k,S.Sequence seq) =>
      (a -> a -> a) -> seq (k,a) -> m a -> m a
insertSeqWithUsingInsertWith :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (k, a) -> m a -> m a
insertSeqWithUsingInsertWith a -> a -> a
f seq (k, a)
kvs m a
m =
    ((k, a) -> m a -> m a) -> m a -> seq (k, a) -> m a
forall a b. (a -> b -> b) -> b -> seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr ((k -> a -> m a -> m a) -> (k, a) -> m a -> m a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((a -> a -> a) -> k -> a -> m a -> m a
forall a. (a -> a -> a) -> k -> a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> a) -> k -> a -> m a -> m a
insertWith a -> a -> a
f)) m a
m seq (k, a)
kvs

insertSeqWithKeyUsingInsertWithKey ::
    (FiniteMapX m k,S.Sequence seq) =>
      (k -> a -> a -> a) -> seq (k,a) -> m a -> m a
insertSeqWithKeyUsingInsertWithKey :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (k, a) -> m a -> m a
insertSeqWithKeyUsingInsertWithKey k -> a -> a -> a
f seq (k, a)
kvs m a
m =
    ((k, a) -> m a -> m a) -> m a -> seq (k, a) -> m a
forall a b. (a -> b -> b) -> b -> seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr ((k -> a -> m a -> m a) -> (k, a) -> m a -> m a
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry ((k -> a -> a -> a) -> k -> a -> m a -> m a
forall a. (k -> a -> a -> a) -> k -> a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(k -> a -> a -> a) -> k -> a -> m a -> m a
insertWithKey k -> a -> a -> a
f)) m a
m seq (k, a)
kvs

unionSeqWithUsingReduce ::
    (FiniteMapX m k,S.Sequence seq) => (a -> a -> a) -> seq (m a) -> m a
unionSeqWithUsingReduce :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (m a) -> m a
unionSeqWithUsingReduce a -> a -> a
f seq (m a)
ms = (m a -> m a -> m a) -> m a -> seq (m a) -> m a
forall a. (a -> a -> a) -> a -> seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducel ((a -> a -> a) -> m a -> m a -> m a
forall a. (a -> a -> a) -> m a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> a) -> m a -> m a -> m a
unionWith a -> a -> a
f) m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty seq (m a)
ms

unionSeqWithUsingFoldr ::
    (FiniteMapX m k,S.Sequence seq) => (a -> a -> a) -> seq (m a) -> m a
unionSeqWithUsingFoldr :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMapX m k, Sequence seq) =>
(a -> a -> a) -> seq (m a) -> m a
unionSeqWithUsingFoldr a -> a -> a
f seq (m a)
ms = (m a -> m a -> m a) -> m a -> seq (m a) -> m a
forall a b. (a -> b -> b) -> b -> seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr ((a -> a -> a) -> m a -> m a -> m a
forall a. (a -> a -> a) -> m a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> a) -> m a -> m a -> m a
unionWith a -> a -> a
f) m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty seq (m a)
ms

toSeqUsingFoldWithKey :: (Assoc m k,S.Sequence seq) => m a -> seq (k,a)
toSeqUsingFoldWithKey :: forall (m :: * -> *) k (seq :: * -> *) a.
(Assoc m k, Sequence seq) =>
m a -> seq (k, a)
toSeqUsingFoldWithKey = (k -> a -> seq (k, a) -> seq (k, a))
-> seq (k, a) -> m a -> seq (k, a)
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> a -> seq (k, a) -> seq (k, a)
forall {s :: * -> *} {a} {b}.
Sequence s =>
a -> b -> s (a, b) -> s (a, b)
conspair seq (k, a)
forall (s :: * -> *) a. Sequence s => s a
S.empty
  where conspair :: a -> b -> s (a, b) -> s (a, b)
conspair a
k b
v s (a, b)
kvs = (a, b) -> s (a, b) -> s (a, b)
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
S.lcons (a
k,b
v) s (a, b)
kvs

keysUsingFoldWithKey :: (Assoc m k,S.Sequence seq) => m a -> seq k
keysUsingFoldWithKey :: forall (m :: * -> *) k (seq :: * -> *) a.
(Assoc m k, Sequence seq) =>
m a -> seq k
keysUsingFoldWithKey = (k -> a -> seq k -> seq k) -> seq k -> m a -> seq k
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> a -> seq k -> seq k
forall {s :: * -> *} {a} {p}. Sequence s => a -> p -> s a -> s a
conskey seq k
forall (s :: * -> *) a. Sequence s => s a
S.empty
  where conskey :: a -> p -> s a -> s a
conskey a
k p
_ s a
ks = a -> s a -> s a
forall a. a -> s a -> s a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
S.lcons a
k s a
ks

unionWithUsingInsertWith ::
    FiniteMap m k => (a -> a -> a) -> m a -> m a -> m a
unionWithUsingInsertWith :: forall (m :: * -> *) k a.
FiniteMap m k =>
(a -> a -> a) -> m a -> m a -> m a
unionWithUsingInsertWith a -> a -> a
f m a
m1 m a
m2 = (k -> a -> m a -> m a) -> m a -> m a -> m a
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey ((a -> a -> a) -> k -> a -> m a -> m a
forall a. (a -> a -> a) -> k -> a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> a) -> k -> a -> m a -> m a
insertWith a -> a -> a
f) m a
m2 m a
m1

unionWithKeyUsingInsertWithKey ::
    FiniteMap m k => (k -> a -> a -> a) -> m a -> m a -> m a
unionWithKeyUsingInsertWithKey :: forall (m :: * -> *) k a.
FiniteMap m k =>
(k -> a -> a -> a) -> m a -> m a -> m a
unionWithKeyUsingInsertWithKey k -> a -> a -> a
f m a
m1 m a
m2 = (k -> a -> m a -> m a) -> m a -> m a -> m a
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey ((k -> a -> a -> a) -> k -> a -> m a -> m a
forall a. (k -> a -> a -> a) -> k -> a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMapX m k =>
(k -> a -> a -> a) -> k -> a -> m a -> m a
insertWithKey k -> a -> a -> a
f) m a
m2 m a
m1

unionSeqWithKeyUsingReduce ::
    (FiniteMap m k,S.Sequence seq) =>
      (k -> a -> a -> a) -> seq (m a) -> m a
unionSeqWithKeyUsingReduce :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMap m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (m a) -> m a
unionSeqWithKeyUsingReduce k -> a -> a -> a
f seq (m a)
ms = (m a -> m a -> m a) -> m a -> seq (m a) -> m a
forall a. (a -> a -> a) -> a -> seq a -> a
forall (s :: * -> *) a.
Sequence s =>
(a -> a -> a) -> a -> s a -> a
S.reducel ((k -> a -> a -> a) -> m a -> m a -> m a
forall a. (k -> a -> a -> a) -> m a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMap m k =>
(k -> a -> a -> a) -> m a -> m a -> m a
unionWithKey k -> a -> a -> a
f) m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty seq (m a)
ms

unionSeqWithKeyUsingFoldr ::
    (FiniteMap m k,S.Sequence seq) =>
      (k -> a -> a -> a) -> seq (m a) -> m a
unionSeqWithKeyUsingFoldr :: forall (m :: * -> *) k (seq :: * -> *) a.
(FiniteMap m k, Sequence seq) =>
(k -> a -> a -> a) -> seq (m a) -> m a
unionSeqWithKeyUsingFoldr k -> a -> a -> a
f seq (m a)
ms = (m a -> m a -> m a) -> m a -> seq (m a) -> m a
forall a b. (a -> b -> b) -> b -> seq a -> b
forall (s :: * -> *) a b.
Sequence s =>
(a -> b -> b) -> b -> s a -> b
S.foldr ((k -> a -> a -> a) -> m a -> m a -> m a
forall a. (k -> a -> a -> a) -> m a -> m a -> m a
forall (m :: * -> *) k a.
FiniteMap m k =>
(k -> a -> a -> a) -> m a -> m a -> m a
unionWithKey k -> a -> a -> a
f) m a
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty seq (m a)
ms

intersectionWithUsingLookupM ::
    FiniteMap m k => (a -> b -> c) -> m a -> m b -> m c
intersectionWithUsingLookupM :: forall (m :: * -> *) k a b c.
FiniteMap m k =>
(a -> b -> c) -> m a -> m b -> m c
intersectionWithUsingLookupM a -> b -> c
f m a
m1 m b
m2 = (k -> a -> m c -> m c) -> m c -> m a -> m c
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> a -> m c -> m c
forall {m :: * -> *}. AssocX m k => k -> a -> m c -> m c
ins m c
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty m a
m1
  where ins :: k -> a -> m c -> m c
ins k
k a
x m c
m = case k -> m b -> Maybe b
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m b
m2 of
                      Maybe b
Nothing -> m c
m
                      Just b
y  -> k -> c -> m c -> m c
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k (a -> b -> c
f a
x b
y) m c
m

intersectionWithKeyUsingLookupM ::
    FiniteMap m k => (k -> a -> b -> c) -> m a -> m b -> m c
intersectionWithKeyUsingLookupM :: forall (m :: * -> *) k a b c.
FiniteMap m k =>
(k -> a -> b -> c) -> m a -> m b -> m c
intersectionWithKeyUsingLookupM k -> a -> b -> c
f m a
m1 m b
m2 = (k -> a -> m c -> m c) -> m c -> m a -> m c
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> a -> m c -> m c
forall {m :: * -> *}. AssocX m k => k -> a -> m c -> m c
ins m c
forall a. m a
forall (m :: * -> *) k a. AssocX m k => m a
empty m a
m1
  where ins :: k -> a -> m c -> m c
ins k
k a
x m c
m = case k -> m b -> Maybe b
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m b
m2 of
                      Maybe b
Nothing -> m c
m
                      Just b
y  -> k -> c -> m c -> m c
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k (k -> a -> b -> c
f k
k a
x b
y) m c
m

differenceUsingDelete :: FiniteMap m k => m a -> m b -> m a
differenceUsingDelete :: forall (m :: * -> *) k a b. FiniteMap m k => m a -> m b -> m a
differenceUsingDelete m a
m1 m b
m2 = (k -> b -> m a -> m a) -> m a -> m b -> m a
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> b -> m a -> m a
forall {m :: * -> *} {k} {p} {a}.
AssocX m k =>
k -> p -> m a -> m a
del m a
m1 m b
m2
  where del :: k -> p -> m a -> m a
del k
k p
_ m a
m = k -> m a -> m a
forall a. k -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> m a -> m a
delete k
k m a
m

properSubsetUsingSubset :: FiniteMapX m k => m a -> m b -> Bool
properSubsetUsingSubset :: forall (m :: * -> *) k a b. FiniteMapX m k => m a -> m b -> Bool
properSubsetUsingSubset m a
m1 m b
m2 = m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< m b -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m b
m2 Bool -> Bool -> Bool
&& m a -> m b -> Bool
forall a b. m a -> m b -> Bool
forall (m :: * -> *) k a b. FiniteMapX m k => m a -> m b -> Bool
subset m a
m1 m b
m2

subsetUsingMember :: FiniteMap m k => m a -> m b -> Bool
subsetUsingMember :: forall (m :: * -> *) k a b. FiniteMap m k => m a -> m b -> Bool
subsetUsingMember m a
m1 m b
m2 = (k -> a -> Bool -> Bool) -> Bool -> m a -> Bool
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> a -> Bool -> Bool
forall {p}. k -> p -> Bool -> Bool
mem Bool
True m a
m1
  where mem :: k -> p -> Bool -> Bool
mem k
k p
_ Bool
b = k -> m b -> Bool
forall a. k -> m a -> Bool
forall (m :: * -> *) k a. AssocX m k => k -> m a -> Bool
member k
k m b
m2 Bool -> Bool -> Bool
&& Bool
b

submapByUsingLookupM :: FiniteMap m k
                     => (a -> a -> Bool) -> m a -> m a -> Bool
submapByUsingLookupM :: forall (m :: * -> *) k a.
FiniteMap m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
submapByUsingLookupM  a -> a -> Bool
f m a
m1 m a
m2 = (k -> a -> Bool -> Bool) -> Bool -> m a -> Bool
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
Assoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldWithKey k -> a -> Bool -> Bool
aux Bool
True m a
m1
  where aux :: k -> a -> Bool -> Bool
aux k
k a
x Bool
b =
          case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m2 of
             Maybe a
Nothing -> Bool
False
             Just a
y  -> a -> a -> Bool
f a
x a
y Bool -> Bool -> Bool
&& Bool
b

properSubmapByUsingSubmapBy :: FiniteMapX m k
                            => (a -> a -> Bool) -> m a -> m a -> Bool
properSubmapByUsingSubmapBy :: forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
properSubmapByUsingSubmapBy a -> a -> Bool
f m a
m1 m a
m2 = m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m1 Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
< m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m2 Bool -> Bool -> Bool
&& (a -> a -> Bool) -> m a -> m a -> Bool
forall a. (a -> a -> Bool) -> m a -> m a -> Bool
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
submapBy a -> a -> Bool
f m a
m1 m a
m2

sameMapByUsingOrdLists :: OrdFiniteMap m k
                       => (a -> a -> Bool) -> m a -> m a -> Bool
sameMapByUsingOrdLists :: forall (m :: * -> *) k a.
OrdFiniteMap m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
sameMapByUsingOrdLists a -> a -> Bool
f m a
m1 m a
m2 =
   let comp :: (a, a) -> (a, a) -> Bool
comp (a
k1,a
x1) (a
k2,a
x2) = a
k1 a -> a -> Bool
forall a. Eq a => a -> a -> Bool
== a
k2 Bool -> Bool -> Bool
&& a -> a -> Bool
f a
x1 a
x2
   in (Bool -> Bool -> Bool) -> Bool -> [Bool] -> Bool
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr Bool -> Bool -> Bool
(&&) (m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m2) (((k, a) -> (k, a) -> Bool) -> [(k, a)] -> [(k, a)] -> [Bool]
forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
L.zipWith (k, a) -> (k, a) -> Bool
forall {a}. Eq a => (a, a) -> (a, a) -> Bool
comp (m a -> [(k, a)]
forall (m :: * -> *) k a. OrdAssoc m k => m a -> [(k, a)]
toOrdList m a
m1) (m a -> [(k, a)]
forall (m :: * -> *) k a. OrdAssoc m k => m a -> [(k, a)]
toOrdList m a
m2))


sameMapByUsingSubmapBy :: FiniteMapX m k
                       => (a -> a -> Bool) -> m a -> m a -> Bool
sameMapByUsingSubmapBy :: forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
sameMapByUsingSubmapBy a -> a -> Bool
f m a
m1 m a
m2 = m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m1 Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== m a -> Int
forall a. m a -> Int
forall (m :: * -> *) k a. AssocX m k => m a -> Int
size m a
m2 Bool -> Bool -> Bool
&& (a -> a -> Bool) -> m a -> m a -> Bool
forall a. (a -> a -> Bool) -> m a -> m a -> Bool
forall (m :: * -> *) k a.
FiniteMapX m k =>
(a -> a -> Bool) -> m a -> m a -> Bool
submapBy a -> a -> Bool
f m a
m1 m a
m2


lookupAndDeleteDefault :: AssocX m k => k -> m a -> (a, m a)
lookupAndDeleteDefault :: forall (m :: * -> *) k a. AssocX m k => k -> m a -> (a, m a)
lookupAndDeleteDefault k
k m a
m =
  case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m of
     Maybe a
Nothing -> [Char] -> (a, m a)
forall a. HasCallStack => [Char] -> a
error (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
m [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".lookupAndDelete: lookup failed")
     Just a
x  -> (a
x, k -> m a -> m a
forall a. k -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> m a -> m a
delete k
k m a
m)

lookupAndDeleteMDefault :: (Fail.MonadFail rm, AssocX m k) => k -> m a -> rm (a, m a)
lookupAndDeleteMDefault :: forall (rm :: * -> *) (m :: * -> *) k a.
(MonadFail rm, AssocX m k) =>
k -> m a -> rm (a, m a)
lookupAndDeleteMDefault k
k m a
m =
  case k -> m a -> Maybe a
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm a
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm a
lookupM k
k m a
m of
     Maybe a
Nothing -> [Char] -> rm (a, m a)
forall a. [Char] -> rm a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
m [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".lookupAndDelete: lookup failed")
     Just a
x  -> (a, m a) -> rm (a, m a)
forall a. a -> rm a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
x, k -> m a -> m a
forall a. k -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> m a -> m a
delete k
k m a
m)

lookupAndDeleteAllDefault :: (S.Sequence seq, AssocX m k) => k -> m a -> (seq a,m a)
lookupAndDeleteAllDefault :: forall (seq :: * -> *) (m :: * -> *) k a.
(Sequence seq, AssocX m k) =>
k -> m a -> (seq a, m a)
lookupAndDeleteAllDefault k
k m a
m = (k -> m a -> seq a
forall (seq :: * -> *) a. Sequence seq => k -> m a -> seq a
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
k -> m a -> seq a
lookupAll k
k m a
m,k -> m a -> m a
forall a. k -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> m a -> m a
deleteAll k
k m a
m)

adjustOrInsertUsingMember :: AssocX m k => (a -> a) -> a -> k -> m a -> m a
adjustOrInsertUsingMember :: forall (m :: * -> *) k a.
AssocX m k =>
(a -> a) -> a -> k -> m a -> m a
adjustOrInsertUsingMember a -> a
f a
z k
k m a
m =
  if k -> m a -> Bool
forall a. k -> m a -> Bool
forall (m :: * -> *) k a. AssocX m k => k -> m a -> Bool
member k
k m a
m
     then (a -> a) -> k -> m a -> m a
forall a. (a -> a) -> k -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => (a -> a) -> k -> m a -> m a
adjust a -> a
f k
k m a
m
     else k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k a
z m a
m

adjustOrDeleteDefault :: AssocX m k => (a -> Maybe a) -> k -> m a -> m a
adjustOrDeleteDefault :: forall (m :: * -> *) k a.
AssocX m k =>
(a -> Maybe a) -> k -> m a -> m a
adjustOrDeleteDefault a -> Maybe a
f k
k m a
m =
  case k -> m a -> Maybe (a, m a)
forall (rm :: * -> *) a. MonadFail rm => k -> m a -> rm (a, m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(AssocX m k, MonadFail rm) =>
k -> m a -> rm (a, m a)
lookupAndDeleteM k
k m a
m of
    Maybe (a, m a)
Nothing -> m a
m
    Just (a
element,m a
m') ->
      case a -> Maybe a
f a
element of
         Maybe a
Nothing -> m a
m'
         Just a
x  -> k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k a
x m a
m'

adjustOrDeleteAllDefault :: AssocX m k => (a -> Maybe a) -> k -> m a -> m a
adjustOrDeleteAllDefault :: forall (m :: * -> *) k a.
AssocX m k =>
(a -> Maybe a) -> k -> m a -> m a
adjustOrDeleteAllDefault a -> Maybe a
f k
k m a
m =
  let ([a]
elems,m a
m') = k -> m a -> ([a], m a)
forall (seq :: * -> *) a. Sequence seq => k -> m a -> (seq a, m a)
forall (m :: * -> *) k (seq :: * -> *) a.
(AssocX m k, Sequence seq) =>
k -> m a -> (seq a, m a)
lookupAndDeleteAll k
k m a
m
      adjSeq :: [Maybe a]
adjSeq = (a -> Maybe a) -> [a] -> [Maybe a]
forall (s :: * -> *) a b. Sequence s => (a -> b) -> s a -> s b
S.map a -> Maybe a
f [a]
elems
      ins :: Maybe a -> m a -> m a
ins Maybe a
Nothing  m a
n = m a
n
      ins (Just a
x) m a
n = k -> a -> m a -> m a
forall a. k -> a -> m a -> m a
forall (m :: * -> *) k a. AssocX m k => k -> a -> m a -> m a
insert k
k a
x m a
n
  in (Maybe a -> m a -> m a) -> m a -> [Maybe a] -> m a
forall a b. (a -> b -> b) -> b -> [a] -> b
L.foldr Maybe a -> m a -> m a
forall {m :: * -> *} {a}. AssocX m k => Maybe a -> m a -> m a
ins m a
m' [Maybe a]
adjSeq

minElemUsingMinView :: OrdAssocX m k => m a -> a
minElemUsingMinView :: forall (m :: * -> *) k a. OrdAssocX m k => m a -> a
minElemUsingMinView m a
fm =
  case m a -> Maybe (a, m a)
forall (rm :: * -> *) a. MonadFail rm => m a -> rm (a, m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(OrdAssocX m k, MonadFail rm) =>
m a -> rm (a, m a)
minView m a
fm of
     Maybe (a, m a)
Nothing    -> [Char] -> a
forall a. HasCallStack => [Char] -> a
error ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
fm)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".minElem: empty map"
     Just (a
x,m a
_) -> a
x

deleteMinUsingMinView :: OrdAssocX m k => m a -> m a
deleteMinUsingMinView :: forall (m :: * -> *) k a. OrdAssocX m k => m a -> m a
deleteMinUsingMinView m a
fm =
  case m a -> Maybe (a, m a)
forall (rm :: * -> *) a. MonadFail rm => m a -> rm (a, m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(OrdAssocX m k, MonadFail rm) =>
m a -> rm (a, m a)
minView m a
fm of
     Maybe (a, m a)
Nothing    -> [Char] -> m a
forall a. HasCallStack => [Char] -> a
error ([Char] -> m a) -> [Char] -> m a
forall a b. (a -> b) -> a -> b
$ (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
fm)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".deleteMin: empty map"
     Just (a
_,m a
m) -> m a
m

minElemWithKeyUsingMinViewWithKey :: OrdAssoc m k => m a -> (k,a)
minElemWithKeyUsingMinViewWithKey :: forall (m :: * -> *) k a. OrdAssoc m k => m a -> (k, a)
minElemWithKeyUsingMinViewWithKey m a
fm =
  case m a -> Maybe ((k, a), m a)
forall (rm :: * -> *) a. MonadFail rm => m a -> rm ((k, a), m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(OrdAssoc m k, MonadFail rm) =>
m a -> rm ((k, a), m a)
minViewWithKey m a
fm of
     Maybe ((k, a), m a)
Nothing    -> [Char] -> (k, a)
forall a. HasCallStack => [Char] -> a
error ([Char] -> (k, a)) -> [Char] -> (k, a)
forall a b. (a -> b) -> a -> b
$ (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
fm)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".minElemWithKey: empty map"
     Just ((k, a)
x,m a
_) -> (k, a)
x

maxElemUsingMaxView :: OrdAssocX m k => m a -> a
maxElemUsingMaxView :: forall (m :: * -> *) k a. OrdAssocX m k => m a -> a
maxElemUsingMaxView m a
fm =
  case m a -> Maybe (a, m a)
forall (rm :: * -> *) a. MonadFail rm => m a -> rm (a, m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(OrdAssocX m k, MonadFail rm) =>
m a -> rm (a, m a)
maxView m a
fm of
     Maybe (a, m a)
Nothing    -> [Char] -> a
forall a. HasCallStack => [Char] -> a
error ([Char] -> a) -> [Char] -> a
forall a b. (a -> b) -> a -> b
$ (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
fm)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".maxElem: empty map"
     Just (a
x,m a
_) -> a
x

deleteMaxUsingMaxView :: OrdAssocX m k => m a -> m a
deleteMaxUsingMaxView :: forall (m :: * -> *) k a. OrdAssocX m k => m a -> m a
deleteMaxUsingMaxView m a
fm =
  case m a -> Maybe (a, m a)
forall (rm :: * -> *) a. MonadFail rm => m a -> rm (a, m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(OrdAssocX m k, MonadFail rm) =>
m a -> rm (a, m a)
maxView m a
fm of
     Maybe (a, m a)
Nothing    -> [Char] -> m a
forall a. HasCallStack => [Char] -> a
error ([Char] -> m a) -> [Char] -> m a
forall a b. (a -> b) -> a -> b
$ (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
fm)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".deleteMax: empty map"
     Just (a
_,m a
m) -> m a
m

maxElemWithKeyUsingMaxViewWithKey :: OrdAssoc m k => m a -> (k,a)
maxElemWithKeyUsingMaxViewWithKey :: forall (m :: * -> *) k a. OrdAssoc m k => m a -> (k, a)
maxElemWithKeyUsingMaxViewWithKey m a
fm =
  case m a -> Maybe ((k, a), m a)
forall (rm :: * -> *) a. MonadFail rm => m a -> rm ((k, a), m a)
forall (m :: * -> *) k (rm :: * -> *) a.
(OrdAssoc m k, MonadFail rm) =>
m a -> rm ((k, a), m a)
maxViewWithKey m a
fm of
     Maybe ((k, a), m a)
Nothing    -> [Char] -> (k, a)
forall a. HasCallStack => [Char] -> a
error ([Char] -> (k, a)) -> [Char] -> (k, a)
forall a b. (a -> b) -> a -> b
$ (m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
fm)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".maxElemWithKey: empty map"
     Just ((k, a)
x,m a
_) -> (k, a)
x

toOrdSeqUsingFoldrWithKey :: (OrdAssoc m k,S.Sequence seq) => m a -> seq (k,a)
toOrdSeqUsingFoldrWithKey :: forall (m :: * -> *) k (seq :: * -> *) a.
(OrdAssoc m k, Sequence seq) =>
m a -> seq (k, a)
toOrdSeqUsingFoldrWithKey = (k -> a -> seq (k, a) -> seq (k, a))
-> seq (k, a) -> m a -> seq (k, a)
forall a b. (k -> a -> b -> b) -> b -> m a -> b
forall (m :: * -> *) k a b.
OrdAssoc m k =>
(k -> a -> b -> b) -> b -> m a -> b
foldrWithKey (\k
k a
x seq (k, a)
z -> (k, a) -> seq (k, a) -> seq (k, a)
forall a. a -> seq a -> seq a
forall (s :: * -> *) a. Sequence s => a -> s a -> s a
S.lcons (k
k,a
x) seq (k, a)
z) seq (k, a)
forall (s :: * -> *) a. Sequence s => s a
S.empty

showsPrecUsingToList :: (Show k, Show a, Assoc m k) => Int -> m a -> ShowS
showsPrecUsingToList :: forall k a (m :: * -> *).
(Show k, Show a, Assoc m k) =>
Int -> m a -> [Char] -> [Char]
showsPrecUsingToList Int
i m a
xs [Char]
rest
   | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0    = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [    m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
xs,[Char]
".fromSeq ",Int -> [(k, a)] -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
10 (m a -> [(k, a)]
forall (m :: * -> *) k a. Assoc m k => m a -> [(k, a)]
toList m a
xs) [Char]
rest]
   | Bool
otherwise = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Char]
"(",m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
xs,[Char]
".fromSeq ",Int -> [(k, a)] -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
10 (m a -> [(k, a)]
forall (m :: * -> *) k a. Assoc m k => m a -> [(k, a)]
toList m a
xs) (Char
')'Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
:[Char]
rest)]

readsPrecUsingFromList :: (Read k, Read a, AssocX m k) => Int -> ReadS (m a)
readsPrecUsingFromList :: forall k a (m :: * -> *).
(Read k, Read a, AssocX m k) =>
Int -> ReadS (m a)
readsPrecUsingFromList Int
_ [Char]
xs =
   let result :: [(m a, [Char])]
result = ReadS (m a) -> ReadS (m a)
forall a. ReadS a -> ReadS a
maybeParens ReadS (m a)
p [Char]
xs
       p :: ReadS (m a)
p [Char]
ys = [Char] -> [Char] -> [[Char]]
forall (m :: * -> *). MonadPlus m => [Char] -> [Char] -> m [Char]
tokenMatch ((m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
x)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".fromSeq") [Char]
ys
                [[Char]]
-> ([Char] -> [([(k, a)], [Char])]) -> [([(k, a)], [Char])]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> [Char] -> [([(k, a)], [Char])]
forall a. Read a => Int -> ReadS a
readsPrec Int
10
                [([(k, a)], [Char])]
-> (([(k, a)], [Char]) -> [(m a, [Char])]) -> [(m a, [Char])]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([(k, a)]
l,[Char]
rest) -> (m a, [Char]) -> [(m a, [Char])]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([(k, a)] -> m a
forall (m :: * -> *) k a. AssocX m k => [(k, a)] -> m a
fromList [(k, a)]
l,[Char]
rest)

       -- play games with the typechecker so we don't have to use
       -- extensions for scoped type variables
       ~[(m a
x,[Char]
_)] = [(m a, [Char])]
result

   in [(m a, [Char])]
result

showsPrecUsingToOrdList :: (Show k,Show a,OrdAssoc m k) => Int -> m a -> ShowS
showsPrecUsingToOrdList :: forall k a (m :: * -> *).
(Show k, Show a, OrdAssoc m k) =>
Int -> m a -> [Char] -> [Char]
showsPrecUsingToOrdList Int
i m a
xs [Char]
rest
   | Int
i Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
0    = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [    m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
xs,[Char]
".unsafeFromOrdSeq ",Int -> [(k, a)] -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
10 (m a -> [(k, a)]
forall (m :: * -> *) k a. OrdAssoc m k => m a -> [(k, a)]
toOrdList m a
xs) [Char]
rest]
   | Bool
otherwise = [[Char]] -> [Char]
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat [[Char]
"(",m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
xs,[Char]
".unsafeFromOrdSeq ",Int -> [(k, a)] -> [Char] -> [Char]
forall a. Show a => Int -> a -> [Char] -> [Char]
showsPrec Int
10 (m a -> [(k, a)]
forall (m :: * -> *) k a. OrdAssoc m k => m a -> [(k, a)]
toOrdList m a
xs) (Char
')'Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
:[Char]
rest)]

readsPrecUsingUnsafeFromOrdSeq :: (Read k,Read a,OrdAssoc m k) => Int -> ReadS (m a)
readsPrecUsingUnsafeFromOrdSeq :: forall k a (m :: * -> *).
(Read k, Read a, OrdAssoc m k) =>
Int -> ReadS (m a)
readsPrecUsingUnsafeFromOrdSeq Int
i [Char]
xs =
   let result :: [(m a, [Char])]
result = ReadS (m a) -> ReadS (m a)
forall a. ReadS a -> ReadS a
maybeParens ReadS (m a)
p [Char]
xs
       p :: ReadS (m a)
p [Char]
ys = [Char] -> [Char] -> [[Char]]
forall (m :: * -> *). MonadPlus m => [Char] -> [Char] -> m [Char]
tokenMatch ((m a -> [Char]
forall a. m a -> [Char]
forall (m :: * -> *) k a. AssocX m k => m a -> [Char]
instanceName m a
x)[Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++[Char]
".unsafeFromOrdSeq") [Char]
ys
                [[Char]]
-> ([Char] -> [([(k, a)], [Char])]) -> [([(k, a)], [Char])]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> [Char] -> [([(k, a)], [Char])]
forall a. Read a => Int -> ReadS a
readsPrec Int
i
                [([(k, a)], [Char])]
-> (([(k, a)], [Char]) -> [(m a, [Char])]) -> [(m a, [Char])]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \([(k, a)]
l,[Char]
rest) -> (m a, [Char]) -> [(m a, [Char])]
forall a. a -> [a]
forall (m :: * -> *) a. Monad m => a -> m a
return ([(k, a)] -> m a
forall (m :: * -> *) k a. OrdAssocX m k => [(k, a)] -> m a
unsafeFromOrdList [(k, a)]
l,[Char]
rest)

       -- play games with the typechecker so we don't have to use
       -- extensions for scoped type variables
       ~[(m a
x,[Char]
_)] = [(m a, [Char])]
result

   in [(m a, [Char])]
result

compareUsingToOrdList :: (Ord a, OrdAssoc m k) => m a -> m a -> Ordering
compareUsingToOrdList :: forall a (m :: * -> *) k.
(Ord a, OrdAssoc m k) =>
m a -> m a -> Ordering
compareUsingToOrdList m a
xs m a
ys = [(k, a)] -> [(k, a)] -> Ordering
forall {a}. Ord a => [a] -> [a] -> Ordering
cmp (m a -> [(k, a)]
forall (m :: * -> *) k a. OrdAssoc m k => m a -> [(k, a)]
toOrdList m a
xs) (m a -> [(k, a)]
forall (m :: * -> *) k a. OrdAssoc m k => m a -> [(k, a)]
toOrdList m a
ys)
 where
  cmp :: [a] -> [a] -> Ordering
cmp [] [] = Ordering
EQ
  cmp [] [a]
_  = Ordering
LT
  cmp [a]
_  [] = Ordering
GT
  cmp (a
v:[a]
vs) (a
z:[a]
zs) =
      case a -> a -> Ordering
forall a. Ord a => a -> a -> Ordering
compare a
v a
z of
         Ordering
EQ -> [a] -> [a] -> Ordering
cmp [a]
vs [a]
zs
         Ordering
c -> Ordering
c