{-# LANGUAGE BangPatterns        #-}
{-# LANGUAGE CPP                 #-}
{-# LANGUAGE DeriveFoldable      #-}
{-# LANGUAGE DeriveFunctor       #-}
{-# LANGUAGE DeriveTraversable   #-}
{-# LANGUAGE Safe                #-}
{-# LANGUAGE ScopedTypeVariables #-}
module Data.OrdPSQ.Internal
    ( -- * Type
      OrdPSQ (..)
    , LTree (..)
    , Elem (..)

      -- * Query
    , null
    , size
    , member
    , lookup
    , findMin

      -- * Construction
    , empty
    , singleton

      -- * Insertion
    , insert

      -- * Delete/Update
    , delete
    , deleteMin
    , alter
    , alterMin

      -- * Conversion
    , fromList
    , toList
    , toAscList
    , keys

      -- * Views
    , insertView
    , deleteView
    , minView
    , atMostView

      -- * Traversals
    , map
    , unsafeMapMonotonic
    , fold'

      -- * Tournament view
    , TourView (..)
    , tourView
    , play

      -- * Balancing internals
    , left
    , right
    , maxKey
    , lsingleLeft
    , rsingleLeft
    , lsingleRight
    , rsingleRight
    , ldoubleLeft
    , rdoubleLeft
    , ldoubleRight
    , rdoubleRight

      -- * Validity check
    , valid
    ) where

import           Control.DeepSeq  (NFData (rnf))
import           Data.Foldable    (Foldable (foldl'))
import qualified Data.List        as List
import           Data.Maybe       (isJust)
import           Data.Traversable
#if MIN_VERSION_base(4,11,0)
import           Prelude          hiding (foldr, lookup, map, null, (<>))
#else
import           Prelude          hiding (foldr, lookup, map, null)
#endif

--------------------------------------------------------------------------------
-- Types
--------------------------------------------------------------------------------

-- | @E k p v@ binds the key @k@ to the value @v@ with priority @p@.
data Elem k p v = E !k !p !v
    deriving (forall a. Elem k p a -> Bool
forall m a. Monoid m => (a -> m) -> Elem k p a -> m
forall a b. (a -> b -> b) -> b -> Elem k p a -> b
forall k p a. Eq a => a -> Elem k p a -> Bool
forall k p a. Num a => Elem k p a -> a
forall k p a. Ord a => Elem k p a -> a
forall k p m. Monoid m => Elem k p m -> m
forall k p a. Elem k p a -> Bool
forall k p a. Elem k p a -> Int
forall k p a. Elem k p a -> [a]
forall k p a. (a -> a -> a) -> Elem k p a -> a
forall k p m a. Monoid m => (a -> m) -> Elem k p a -> m
forall k p b a. (b -> a -> b) -> b -> Elem k p a -> b
forall k p a b. (a -> b -> b) -> b -> Elem k p a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => Elem k p a -> a
$cproduct :: forall k p a. Num a => Elem k p a -> a
sum :: forall a. Num a => Elem k p a -> a
$csum :: forall k p a. Num a => Elem k p a -> a
minimum :: forall a. Ord a => Elem k p a -> a
$cminimum :: forall k p a. Ord a => Elem k p a -> a
maximum :: forall a. Ord a => Elem k p a -> a
$cmaximum :: forall k p a. Ord a => Elem k p a -> a
elem :: forall a. Eq a => a -> Elem k p a -> Bool
$celem :: forall k p a. Eq a => a -> Elem k p a -> Bool
length :: forall a. Elem k p a -> Int
$clength :: forall k p a. Elem k p a -> Int
null :: forall a. Elem k p a -> Bool
$cnull :: forall k p a. Elem k p a -> Bool
toList :: forall a. Elem k p a -> [a]
$ctoList :: forall k p a. Elem k p a -> [a]
foldl1 :: forall a. (a -> a -> a) -> Elem k p a -> a
$cfoldl1 :: forall k p a. (a -> a -> a) -> Elem k p a -> a
foldr1 :: forall a. (a -> a -> a) -> Elem k p a -> a
$cfoldr1 :: forall k p a. (a -> a -> a) -> Elem k p a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> Elem k p a -> b
$cfoldl' :: forall k p b a. (b -> a -> b) -> b -> Elem k p a -> b
foldl :: forall b a. (b -> a -> b) -> b -> Elem k p a -> b
$cfoldl :: forall k p b a. (b -> a -> b) -> b -> Elem k p a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> Elem k p a -> b
$cfoldr' :: forall k p a b. (a -> b -> b) -> b -> Elem k p a -> b
foldr :: forall a b. (a -> b -> b) -> b -> Elem k p a -> b
$cfoldr :: forall k p a b. (a -> b -> b) -> b -> Elem k p a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> Elem k p a -> m
$cfoldMap' :: forall k p m a. Monoid m => (a -> m) -> Elem k p a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> Elem k p a -> m
$cfoldMap :: forall k p m a. Monoid m => (a -> m) -> Elem k p a -> m
fold :: forall m. Monoid m => Elem k p m -> m
$cfold :: forall k p m. Monoid m => Elem k p m -> m
Foldable, forall a b. a -> Elem k p b -> Elem k p a
forall a b. (a -> b) -> Elem k p a -> Elem k p b
forall k p a b. a -> Elem k p b -> Elem k p a
forall k p a b. (a -> b) -> Elem k p a -> Elem k p b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> Elem k p b -> Elem k p a
$c<$ :: forall k p a b. a -> Elem k p b -> Elem k p a
fmap :: forall a b. (a -> b) -> Elem k p a -> Elem k p b
$cfmap :: forall k p a b. (a -> b) -> Elem k p a -> Elem k p b
Functor, Int -> Elem k p v -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k p v.
(Show k, Show p, Show v) =>
Int -> Elem k p v -> ShowS
forall k p v. (Show k, Show p, Show v) => [Elem k p v] -> ShowS
forall k p v. (Show k, Show p, Show v) => Elem k p v -> String
showList :: [Elem k p v] -> ShowS
$cshowList :: forall k p v. (Show k, Show p, Show v) => [Elem k p v] -> ShowS
show :: Elem k p v -> String
$cshow :: forall k p v. (Show k, Show p, Show v) => Elem k p v -> String
showsPrec :: Int -> Elem k p v -> ShowS
$cshowsPrec :: forall k p v.
(Show k, Show p, Show v) =>
Int -> Elem k p v -> ShowS
Show, forall k p. Functor (Elem k p)
forall k p. Foldable (Elem k p)
forall k p (m :: * -> *) a.
Monad m =>
Elem k p (m a) -> m (Elem k p a)
forall k p (f :: * -> *) a.
Applicative f =>
Elem k p (f a) -> f (Elem k p a)
forall k p (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Elem k p a -> m (Elem k p b)
forall k p (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Elem k p a -> f (Elem k p b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Elem k p a -> f (Elem k p b)
sequence :: forall (m :: * -> *) a. Monad m => Elem k p (m a) -> m (Elem k p a)
$csequence :: forall k p (m :: * -> *) a.
Monad m =>
Elem k p (m a) -> m (Elem k p a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Elem k p a -> m (Elem k p b)
$cmapM :: forall k p (m :: * -> *) a b.
Monad m =>
(a -> m b) -> Elem k p a -> m (Elem k p b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Elem k p (f a) -> f (Elem k p a)
$csequenceA :: forall k p (f :: * -> *) a.
Applicative f =>
Elem k p (f a) -> f (Elem k p a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Elem k p a -> f (Elem k p b)
$ctraverse :: forall k p (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Elem k p a -> f (Elem k p b)
Traversable)

instance (NFData k, NFData p, NFData v) => NFData (Elem k p v) where
    rnf :: Elem k p v -> ()
rnf (E k
k p
p v
v) = forall a. NFData a => a -> ()
rnf k
k seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf p
p seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf v
v

-- | A mapping from keys @k@ to priorites @p@ and values @v@. It is strict in
-- keys, priorities and values.
data OrdPSQ k p v
    = Void
    | Winner !(Elem k p v)
             !(LTree k p v)
             !k
    deriving (forall a. OrdPSQ k p a -> Bool
forall m a. Monoid m => (a -> m) -> OrdPSQ k p a -> m
forall a b. (a -> b -> b) -> b -> OrdPSQ k p a -> b
forall k p a. Eq a => a -> OrdPSQ k p a -> Bool
forall k p a. Num a => OrdPSQ k p a -> a
forall k p a. Ord a => OrdPSQ k p a -> a
forall k p m. Monoid m => OrdPSQ k p m -> m
forall k p a. OrdPSQ k p a -> Bool
forall k p a. OrdPSQ k p a -> Int
forall k p a. OrdPSQ k p a -> [a]
forall k p a. (a -> a -> a) -> OrdPSQ k p a -> a
forall k p m a. Monoid m => (a -> m) -> OrdPSQ k p a -> m
forall k p b a. (b -> a -> b) -> b -> OrdPSQ k p a -> b
forall k p a b. (a -> b -> b) -> b -> OrdPSQ k p a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => OrdPSQ k p a -> a
$cproduct :: forall k p a. Num a => OrdPSQ k p a -> a
sum :: forall a. Num a => OrdPSQ k p a -> a
$csum :: forall k p a. Num a => OrdPSQ k p a -> a
minimum :: forall a. Ord a => OrdPSQ k p a -> a
$cminimum :: forall k p a. Ord a => OrdPSQ k p a -> a
maximum :: forall a. Ord a => OrdPSQ k p a -> a
$cmaximum :: forall k p a. Ord a => OrdPSQ k p a -> a
elem :: forall a. Eq a => a -> OrdPSQ k p a -> Bool
$celem :: forall k p a. Eq a => a -> OrdPSQ k p a -> Bool
length :: forall a. OrdPSQ k p a -> Int
$clength :: forall k p a. OrdPSQ k p a -> Int
null :: forall a. OrdPSQ k p a -> Bool
$cnull :: forall k p a. OrdPSQ k p a -> Bool
toList :: forall a. OrdPSQ k p a -> [a]
$ctoList :: forall k p a. OrdPSQ k p a -> [a]
foldl1 :: forall a. (a -> a -> a) -> OrdPSQ k p a -> a
$cfoldl1 :: forall k p a. (a -> a -> a) -> OrdPSQ k p a -> a
foldr1 :: forall a. (a -> a -> a) -> OrdPSQ k p a -> a
$cfoldr1 :: forall k p a. (a -> a -> a) -> OrdPSQ k p a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> OrdPSQ k p a -> b
$cfoldl' :: forall k p b a. (b -> a -> b) -> b -> OrdPSQ k p a -> b
foldl :: forall b a. (b -> a -> b) -> b -> OrdPSQ k p a -> b
$cfoldl :: forall k p b a. (b -> a -> b) -> b -> OrdPSQ k p a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> OrdPSQ k p a -> b
$cfoldr' :: forall k p a b. (a -> b -> b) -> b -> OrdPSQ k p a -> b
foldr :: forall a b. (a -> b -> b) -> b -> OrdPSQ k p a -> b
$cfoldr :: forall k p a b. (a -> b -> b) -> b -> OrdPSQ k p a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> OrdPSQ k p a -> m
$cfoldMap' :: forall k p m a. Monoid m => (a -> m) -> OrdPSQ k p a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> OrdPSQ k p a -> m
$cfoldMap :: forall k p m a. Monoid m => (a -> m) -> OrdPSQ k p a -> m
fold :: forall m. Monoid m => OrdPSQ k p m -> m
$cfold :: forall k p m. Monoid m => OrdPSQ k p m -> m
Foldable, forall a b. a -> OrdPSQ k p b -> OrdPSQ k p a
forall a b. (a -> b) -> OrdPSQ k p a -> OrdPSQ k p b
forall k p a b. a -> OrdPSQ k p b -> OrdPSQ k p a
forall k p a b. (a -> b) -> OrdPSQ k p a -> OrdPSQ k p b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> OrdPSQ k p b -> OrdPSQ k p a
$c<$ :: forall k p a b. a -> OrdPSQ k p b -> OrdPSQ k p a
fmap :: forall a b. (a -> b) -> OrdPSQ k p a -> OrdPSQ k p b
$cfmap :: forall k p a b. (a -> b) -> OrdPSQ k p a -> OrdPSQ k p b
Functor, Int -> OrdPSQ k p v -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k p v.
(Show k, Show p, Show v) =>
Int -> OrdPSQ k p v -> ShowS
forall k p v. (Show k, Show p, Show v) => [OrdPSQ k p v] -> ShowS
forall k p v. (Show k, Show p, Show v) => OrdPSQ k p v -> String
showList :: [OrdPSQ k p v] -> ShowS
$cshowList :: forall k p v. (Show k, Show p, Show v) => [OrdPSQ k p v] -> ShowS
show :: OrdPSQ k p v -> String
$cshow :: forall k p v. (Show k, Show p, Show v) => OrdPSQ k p v -> String
showsPrec :: Int -> OrdPSQ k p v -> ShowS
$cshowsPrec :: forall k p v.
(Show k, Show p, Show v) =>
Int -> OrdPSQ k p v -> ShowS
Show, forall k p. Functor (OrdPSQ k p)
forall k p. Foldable (OrdPSQ k p)
forall k p (m :: * -> *) a.
Monad m =>
OrdPSQ k p (m a) -> m (OrdPSQ k p a)
forall k p (f :: * -> *) a.
Applicative f =>
OrdPSQ k p (f a) -> f (OrdPSQ k p a)
forall k p (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OrdPSQ k p a -> m (OrdPSQ k p b)
forall k p (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OrdPSQ k p a -> f (OrdPSQ k p b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OrdPSQ k p a -> f (OrdPSQ k p b)
sequence :: forall (m :: * -> *) a.
Monad m =>
OrdPSQ k p (m a) -> m (OrdPSQ k p a)
$csequence :: forall k p (m :: * -> *) a.
Monad m =>
OrdPSQ k p (m a) -> m (OrdPSQ k p a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OrdPSQ k p a -> m (OrdPSQ k p b)
$cmapM :: forall k p (m :: * -> *) a b.
Monad m =>
(a -> m b) -> OrdPSQ k p a -> m (OrdPSQ k p b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
OrdPSQ k p (f a) -> f (OrdPSQ k p a)
$csequenceA :: forall k p (f :: * -> *) a.
Applicative f =>
OrdPSQ k p (f a) -> f (OrdPSQ k p a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OrdPSQ k p a -> f (OrdPSQ k p b)
$ctraverse :: forall k p (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> OrdPSQ k p a -> f (OrdPSQ k p b)
Traversable)

instance (NFData k, NFData p, NFData v) => NFData (OrdPSQ k p v) where
    rnf :: OrdPSQ k p v -> ()
rnf OrdPSQ k p v
Void           = ()
    rnf (Winner Elem k p v
e LTree k p v
t k
m) = forall a. NFData a => a -> ()
rnf Elem k p v
e seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf k
m seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf LTree k p v
t

instance (Ord k, Ord p, Eq v) => Eq (OrdPSQ k p v) where
    OrdPSQ k p v
x == :: OrdPSQ k p v -> OrdPSQ k p v -> Bool
== OrdPSQ k p v
y = case (forall k p v.
(Ord k, Ord p) =>
OrdPSQ k p v -> Maybe (k, p, v, OrdPSQ k p v)
minView OrdPSQ k p v
x, forall k p v.
(Ord k, Ord p) =>
OrdPSQ k p v -> Maybe (k, p, v, OrdPSQ k p v)
minView OrdPSQ k p v
y) of
        (Maybe (k, p, v, OrdPSQ k p v)
Nothing              , Maybe (k, p, v, OrdPSQ k p v)
Nothing                ) -> Bool
True
        (Just (k
xk, p
xp, v
xv, OrdPSQ k p v
x'), (Just (k
yk, p
yp, v
yv, OrdPSQ k p v
y'))) ->
            k
xk forall a. Eq a => a -> a -> Bool
== k
yk Bool -> Bool -> Bool
&& p
xp forall a. Eq a => a -> a -> Bool
== p
yp Bool -> Bool -> Bool
&& v
xv forall a. Eq a => a -> a -> Bool
== v
yv Bool -> Bool -> Bool
&& OrdPSQ k p v
x' forall a. Eq a => a -> a -> Bool
== OrdPSQ k p v
y'
        (Just (k, p, v, OrdPSQ k p v)
_               , Maybe (k, p, v, OrdPSQ k p v)
Nothing                ) -> Bool
False
        (Maybe (k, p, v, OrdPSQ k p v)
Nothing              , Just (k, p, v, OrdPSQ k p v)
_                 ) -> Bool
False

type Size = Int

data LTree k p v
    = Start
    | LLoser {-# UNPACK #-} !Size
             {-# UNPACK #-} !(Elem k p v)
                            !(LTree k p v)
                            !k              -- split key
                            !(LTree k p v)
    | RLoser {-# UNPACK #-} !Size
             {-# UNPACK #-} !(Elem k p v)
                            !(LTree k p v)
                            !k              -- split key
                            !(LTree k p v)
    deriving (forall a. LTree k p a -> Bool
forall m a. Monoid m => (a -> m) -> LTree k p a -> m
forall a b. (a -> b -> b) -> b -> LTree k p a -> b
forall k p a. Eq a => a -> LTree k p a -> Bool
forall k p a. Num a => LTree k p a -> a
forall k p a. Ord a => LTree k p a -> a
forall k p m. Monoid m => LTree k p m -> m
forall k p a. LTree k p a -> Bool
forall k p a. LTree k p a -> Int
forall k p a. LTree k p a -> [a]
forall k p a. (a -> a -> a) -> LTree k p a -> a
forall k p m a. Monoid m => (a -> m) -> LTree k p a -> m
forall k p b a. (b -> a -> b) -> b -> LTree k p a -> b
forall k p a b. (a -> b -> b) -> b -> LTree k p a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
product :: forall a. Num a => LTree k p a -> a
$cproduct :: forall k p a. Num a => LTree k p a -> a
sum :: forall a. Num a => LTree k p a -> a
$csum :: forall k p a. Num a => LTree k p a -> a
minimum :: forall a. Ord a => LTree k p a -> a
$cminimum :: forall k p a. Ord a => LTree k p a -> a
maximum :: forall a. Ord a => LTree k p a -> a
$cmaximum :: forall k p a. Ord a => LTree k p a -> a
elem :: forall a. Eq a => a -> LTree k p a -> Bool
$celem :: forall k p a. Eq a => a -> LTree k p a -> Bool
length :: forall a. LTree k p a -> Int
$clength :: forall k p a. LTree k p a -> Int
null :: forall a. LTree k p a -> Bool
$cnull :: forall k p a. LTree k p a -> Bool
toList :: forall a. LTree k p a -> [a]
$ctoList :: forall k p a. LTree k p a -> [a]
foldl1 :: forall a. (a -> a -> a) -> LTree k p a -> a
$cfoldl1 :: forall k p a. (a -> a -> a) -> LTree k p a -> a
foldr1 :: forall a. (a -> a -> a) -> LTree k p a -> a
$cfoldr1 :: forall k p a. (a -> a -> a) -> LTree k p a -> a
foldl' :: forall b a. (b -> a -> b) -> b -> LTree k p a -> b
$cfoldl' :: forall k p b a. (b -> a -> b) -> b -> LTree k p a -> b
foldl :: forall b a. (b -> a -> b) -> b -> LTree k p a -> b
$cfoldl :: forall k p b a. (b -> a -> b) -> b -> LTree k p a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> LTree k p a -> b
$cfoldr' :: forall k p a b. (a -> b -> b) -> b -> LTree k p a -> b
foldr :: forall a b. (a -> b -> b) -> b -> LTree k p a -> b
$cfoldr :: forall k p a b. (a -> b -> b) -> b -> LTree k p a -> b
foldMap' :: forall m a. Monoid m => (a -> m) -> LTree k p a -> m
$cfoldMap' :: forall k p m a. Monoid m => (a -> m) -> LTree k p a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> LTree k p a -> m
$cfoldMap :: forall k p m a. Monoid m => (a -> m) -> LTree k p a -> m
fold :: forall m. Monoid m => LTree k p m -> m
$cfold :: forall k p m. Monoid m => LTree k p m -> m
Foldable, forall a b. a -> LTree k p b -> LTree k p a
forall a b. (a -> b) -> LTree k p a -> LTree k p b
forall k p a b. a -> LTree k p b -> LTree k p a
forall k p a b. (a -> b) -> LTree k p a -> LTree k p b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> LTree k p b -> LTree k p a
$c<$ :: forall k p a b. a -> LTree k p b -> LTree k p a
fmap :: forall a b. (a -> b) -> LTree k p a -> LTree k p b
$cfmap :: forall k p a b. (a -> b) -> LTree k p a -> LTree k p b
Functor, Int -> LTree k p v -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k p v.
(Show k, Show p, Show v) =>
Int -> LTree k p v -> ShowS
forall k p v. (Show k, Show p, Show v) => [LTree k p v] -> ShowS
forall k p v. (Show k, Show p, Show v) => LTree k p v -> String
showList :: [LTree k p v] -> ShowS
$cshowList :: forall k p v. (Show k, Show p, Show v) => [LTree k p v] -> ShowS
show :: LTree k p v -> String
$cshow :: forall k p v. (Show k, Show p, Show v) => LTree k p v -> String
showsPrec :: Int -> LTree k p v -> ShowS
$cshowsPrec :: forall k p v.
(Show k, Show p, Show v) =>
Int -> LTree k p v -> ShowS
Show, forall k p. Functor (LTree k p)
forall k p. Foldable (LTree k p)
forall k p (m :: * -> *) a.
Monad m =>
LTree k p (m a) -> m (LTree k p a)
forall k p (f :: * -> *) a.
Applicative f =>
LTree k p (f a) -> f (LTree k p a)
forall k p (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LTree k p a -> m (LTree k p b)
forall k p (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LTree k p a -> f (LTree k p b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LTree k p a -> f (LTree k p b)
sequence :: forall (m :: * -> *) a.
Monad m =>
LTree k p (m a) -> m (LTree k p a)
$csequence :: forall k p (m :: * -> *) a.
Monad m =>
LTree k p (m a) -> m (LTree k p a)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LTree k p a -> m (LTree k p b)
$cmapM :: forall k p (m :: * -> *) a b.
Monad m =>
(a -> m b) -> LTree k p a -> m (LTree k p b)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
LTree k p (f a) -> f (LTree k p a)
$csequenceA :: forall k p (f :: * -> *) a.
Applicative f =>
LTree k p (f a) -> f (LTree k p a)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LTree k p a -> f (LTree k p b)
$ctraverse :: forall k p (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> LTree k p a -> f (LTree k p b)
Traversable)

instance (NFData k, NFData p, NFData v) => NFData (LTree k p v) where
    rnf :: LTree k p v -> ()
rnf LTree k p v
Start              = ()
    rnf (LLoser Int
_ Elem k p v
e LTree k p v
l k
k LTree k p v
r) = forall a. NFData a => a -> ()
rnf Elem k p v
e seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf LTree k p v
l seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf k
k seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf LTree k p v
r
    rnf (RLoser Int
_ Elem k p v
e LTree k p v
l k
k LTree k p v
r) = forall a. NFData a => a -> ()
rnf Elem k p v
e seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf LTree k p v
l seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf k
k seq :: forall a b. a -> b -> b
`seq` forall a. NFData a => a -> ()
rnf LTree k p v
r


--------------------------------------------------------------------------------
-- Query
--------------------------------------------------------------------------------

-- | /O(1)/ True if the queue is empty.
null :: OrdPSQ k p v -> Bool
null :: forall k p a. OrdPSQ k p a -> Bool
null OrdPSQ k p v
Void           = Bool
True
null (Winner Elem k p v
_ LTree k p v
_ k
_) = Bool
False

-- | /O(1)/ The number of elements in a queue.
size :: OrdPSQ k p v -> Int
size :: forall k p a. OrdPSQ k p a -> Int
size OrdPSQ k p v
Void            = Int
0
size (Winner Elem k p v
_ LTree k p v
lt k
_) = Int
1 forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
size' LTree k p v
lt

-- | /O(log n)/ Check if a key is present in the the queue.
member :: Ord k => k -> OrdPSQ k p v -> Bool
member :: forall k p v. Ord k => k -> OrdPSQ k p v -> Bool
member k
k = forall a. Maybe a -> Bool
isJust forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k p v. Ord k => k -> OrdPSQ k p v -> Maybe (p, v)
lookup k
k

-- | /O(log n)/ The priority and value of a given key, or 'Nothing' if the key
-- is not bound.
lookup :: (Ord k) => k -> OrdPSQ k p v -> Maybe (p, v)
lookup :: forall k p v. Ord k => k -> OrdPSQ k p v -> Maybe (p, v)
lookup k
k = forall {p} {v}. OrdPSQ k p v -> Maybe (p, v)
go
  where
    go :: OrdPSQ k p v -> Maybe (p, v)
go OrdPSQ k p v
t = case forall k p v. OrdPSQ k p v -> TourView k p v
tourView OrdPSQ k p v
t of
        TourView k p v
Null                 -> forall a. Maybe a
Nothing
        Single (E k
k' p
p v
v)
            | k
k forall a. Eq a => a -> a -> Bool
== k
k'        -> forall a. a -> Maybe a
Just (p
p, v
v)
            | Bool
otherwise      -> forall a. Maybe a
Nothing
        Play OrdPSQ k p v
tl OrdPSQ k p v
tr
            | k
k forall a. Ord a => a -> a -> Bool
<= forall k p v. OrdPSQ k p v -> k
maxKey OrdPSQ k p v
tl -> OrdPSQ k p v -> Maybe (p, v)
go OrdPSQ k p v
tl
            | Bool
otherwise      -> OrdPSQ k p v -> Maybe (p, v)
go OrdPSQ k p v
tr

-- | /O(1)/ The element with the lowest priority.
findMin :: OrdPSQ k p v -> Maybe (k, p, v)
findMin :: forall k p v. OrdPSQ k p v -> Maybe (k, p, v)
findMin OrdPSQ k p v
Void                   = forall a. Maybe a
Nothing
findMin (Winner (E k
k p
p v
v) LTree k p v
_ k
_) = forall a. a -> Maybe a
Just (k
k, p
p, v
v)


--------------------------------------------------------------------------------
-- Construction
--------------------------------------------------------------------------------

-- | /O(1)/ The empty queue.
empty :: OrdPSQ k p v
empty :: forall k p v. OrdPSQ k p v
empty = forall k p v. OrdPSQ k p v
Void

-- | /O(1)/ Build a queue with one element.
singleton :: k -> p -> v -> OrdPSQ k p v
singleton :: forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k p
p v
v = forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner (forall k p v. k -> p -> v -> Elem k p v
E k
k p
p v
v) forall k p v. LTree k p v
Start k
k


--------------------------------------------------------------------------------
-- Insertion
--------------------------------------------------------------------------------

-- | /O(log n)/ Insert a new key, priority and value into the queue. If the key is
-- already present in the queue, the associated priority and value are replaced
-- with the supplied priority and value.
{-# INLINABLE insert #-}
insert :: (Ord k, Ord p) => k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert k
k p
p v
v = OrdPSQ k p v -> OrdPSQ k p v
go
  where
    go :: OrdPSQ k p v -> OrdPSQ k p v
go OrdPSQ k p v
t = case OrdPSQ k p v
t of
        OrdPSQ k p v
Void -> forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k p
p v
v
        Winner (E k
k' p
p' v
v') LTree k p v
Start k
_ -> case forall a. Ord a => a -> a -> Ordering
compare k
k k
k' of
            Ordering
LT -> forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k  p
p  v
v  forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k' p
p' v
v'
            Ordering
EQ -> forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k  p
p  v
v
            Ordering
GT -> forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k' p
p' v
v' forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k  p
p  v
v
        Winner Elem k p v
e (RLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m'
            | k
k forall a. Ord a => a -> a -> Bool
<= k
m    -> OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m')
            | Bool
otherwise -> (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m')
        Winner Elem k p v
e (LLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m'
            | k
k forall a. Ord a => a -> a -> Bool
<= k
m    -> OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m')
            | Bool
otherwise -> (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m')


--------------------------------------------------------------------------------
-- Delete/update
--------------------------------------------------------------------------------

-- | /O(log n)/ Delete a key and its priority and value from the queue. When the
-- key is not a member of the queue, the original queue is returned.
{-# INLINABLE delete #-}
delete :: (Ord k, Ord p) => k -> OrdPSQ k p v -> OrdPSQ k p v
delete :: forall k p v. (Ord k, Ord p) => k -> OrdPSQ k p v -> OrdPSQ k p v
delete k
k = forall {p} {v}. Ord p => OrdPSQ k p v -> OrdPSQ k p v
go
  where
    go :: OrdPSQ k p v -> OrdPSQ k p v
go OrdPSQ k p v
t = case OrdPSQ k p v
t of
        OrdPSQ k p v
Void -> forall k p v. OrdPSQ k p v
empty
        Winner (E k
k' p
p v
v) LTree k p v
Start k
_
            | k
k forall a. Eq a => a -> a -> Bool
== k
k'   -> forall k p v. OrdPSQ k p v
empty
            | Bool
otherwise -> forall k p v. k -> p -> v -> OrdPSQ k p v
singleton k
k' p
p v
v
        Winner Elem k p v
e (RLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m'
            | k
k forall a. Ord a => a -> a -> Bool
<= k
m    -> OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m')
            | Bool
otherwise -> (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m')
        Winner Elem k p v
e (LLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m'
            | k
k forall a. Ord a => a -> a -> Bool
<= k
m    -> OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m')
            | Bool
otherwise -> (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v -> OrdPSQ k p v
go (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m')

-- | /O(log n)/ Delete the binding with the least priority, and return the
-- rest of the queue stripped of that binding. In case the queue is empty, the
-- empty queue is returned again.
{-# INLINE deleteMin #-}
deleteMin
    :: (Ord k, Ord p) => OrdPSQ k p v -> OrdPSQ k p v
deleteMin :: forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> OrdPSQ k p v
deleteMin OrdPSQ k p v
t = case forall k p v.
(Ord k, Ord p) =>
OrdPSQ k p v -> Maybe (k, p, v, OrdPSQ k p v)
minView OrdPSQ k p v
t of
    Maybe (k, p, v, OrdPSQ k p v)
Nothing            -> OrdPSQ k p v
t
    Just (k
_, p
_, v
_, OrdPSQ k p v
t') -> OrdPSQ k p v
t'

-- | /O(log n)/ The expression @alter f k queue@ alters the value @x@ at @k@, or
-- absence thereof. 'alter' can be used to insert, delete, or update a value
-- in a queue. It also allows you to calculate an additional value @b@.
{-# INLINE alter #-}
alter
    :: (Ord k, Ord p)
    => (Maybe (p, v) -> (b, Maybe (p, v)))
    -> k
    -> OrdPSQ k p v
    -> (b, OrdPSQ k p v)
alter :: forall k p v b.
(Ord k, Ord p) =>
(Maybe (p, v) -> (b, Maybe (p, v)))
-> k -> OrdPSQ k p v -> (b, OrdPSQ k p v)
alter Maybe (p, v) -> (b, Maybe (p, v))
f k
k OrdPSQ k p v
psq0 =
    let (OrdPSQ k p v
psq1, Maybe (p, v)
mbPV) = case forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k OrdPSQ k p v
psq0 of
                         Maybe (p, v, OrdPSQ k p v)
Nothing          -> (OrdPSQ k p v
psq0, forall a. Maybe a
Nothing)
                         Just (p
p, v
v, OrdPSQ k p v
psq) -> (OrdPSQ k p v
psq, forall a. a -> Maybe a
Just (p
p, v
v))
        (!b
b, Maybe (p, v)
mbPV') = Maybe (p, v) -> (b, Maybe (p, v))
f Maybe (p, v)
mbPV
    in case Maybe (p, v)
mbPV' of
         Maybe (p, v)
Nothing     -> (b
b, OrdPSQ k p v
psq1)
         Just (p
p, v
v) -> (b
b, forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert k
k p
p v
v OrdPSQ k p v
psq1)

-- | /O(log n)/ A variant of 'alter' which works on the element with the minimum
-- priority. Unlike 'alter', this variant also allows you to change the key of
-- the element.
{-# INLINE alterMin #-}
alterMin :: (Ord k, Ord p)
         => (Maybe (k, p, v) -> (b, Maybe (k, p, v)))
         -> OrdPSQ k p v
         -> (b, OrdPSQ k p v)
alterMin :: forall k p v b.
(Ord k, Ord p) =>
(Maybe (k, p, v) -> (b, Maybe (k, p, v)))
-> OrdPSQ k p v -> (b, OrdPSQ k p v)
alterMin Maybe (k, p, v) -> (b, Maybe (k, p, v))
f OrdPSQ k p v
psq0 =
    case forall k p v.
(Ord k, Ord p) =>
OrdPSQ k p v -> Maybe (k, p, v, OrdPSQ k p v)
minView OrdPSQ k p v
psq0 of
        Maybe (k, p, v, OrdPSQ k p v)
Nothing -> let (!b
b, Maybe (k, p, v)
mbKPV) = Maybe (k, p, v) -> (b, Maybe (k, p, v))
f forall a. Maybe a
Nothing
                   in (b
b, forall {k} {p} {v}.
(Ord k, Ord p) =>
Maybe (k, p, v) -> OrdPSQ k p v -> OrdPSQ k p v
insertMay Maybe (k, p, v)
mbKPV OrdPSQ k p v
psq0)
        Just (k
k,p
p,v
v, OrdPSQ k p v
psq1) -> let (!b
b, Maybe (k, p, v)
mbKPV) = Maybe (k, p, v) -> (b, Maybe (k, p, v))
f forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (k
k, p
p, v
v)
                              in (b
b, forall {k} {p} {v}.
(Ord k, Ord p) =>
Maybe (k, p, v) -> OrdPSQ k p v -> OrdPSQ k p v
insertMay Maybe (k, p, v)
mbKPV OrdPSQ k p v
psq1)
  where
    insertMay :: Maybe (k, p, v) -> OrdPSQ k p v -> OrdPSQ k p v
insertMay Maybe (k, p, v)
Nothing          OrdPSQ k p v
psq = OrdPSQ k p v
psq
    insertMay (Just (k
k, p
p, v
v)) OrdPSQ k p v
psq = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert k
k p
p v
v OrdPSQ k p v
psq


--------------------------------------------------------------------------------
-- Conversion
--------------------------------------------------------------------------------

-- | /O(n*log n)/ Build a queue from a list of (key, priority, value) tuples.
-- If the list contains more than one priority and value for the same key, the
-- last priority and value for the key is retained.
{-# INLINABLE fromList #-}
fromList :: (Ord k, Ord p) => [(k, p, v)] -> OrdPSQ k p v
fromList :: forall k p v. (Ord k, Ord p) => [(k, p, v)] -> OrdPSQ k p v
fromList = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (\OrdPSQ k p v
q (k
k, p
p, v
v) -> forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert k
k p
p v
v OrdPSQ k p v
q) forall k p v. OrdPSQ k p v
empty

-- | /O(n)/ Convert a queue to a list of (key, priority, value) tuples. The
-- order of the list is not specified.
toList :: OrdPSQ k p v -> [(k, p, v)]
toList :: forall k p v. OrdPSQ k p v -> [(k, p, v)]
toList = forall k p v. OrdPSQ k p v -> [(k, p, v)]
toAscList

-- | /O(n)/ Obtain the list of present keys in the queue.
keys :: OrdPSQ k p v -> [k]
keys :: forall k p v. OrdPSQ k p v -> [k]
keys OrdPSQ k p v
t = [k
k | (k
k, p
_, v
_) <- forall k p v. OrdPSQ k p v -> [(k, p, v)]
toList OrdPSQ k p v
t]
-- TODO (jaspervdj): There must be faster implementations.

-- | /O(n)/ Convert to a list in ascending order by key.
toAscList :: OrdPSQ k p v -> [(k, p, v)]
toAscList :: forall k p v. OrdPSQ k p v -> [(k, p, v)]
toAscList OrdPSQ k p v
q  = forall a. Sequ a -> [a]
seqToList (forall k p v. OrdPSQ k p v -> Sequ (k, p, v)
toAscLists OrdPSQ k p v
q)
  where
    toAscLists :: OrdPSQ k p v -> Sequ (k, p, v)
    toAscLists :: forall k p v. OrdPSQ k p v -> Sequ (k, p, v)
toAscLists OrdPSQ k p v
t = case forall k p v. OrdPSQ k p v -> TourView k p v
tourView OrdPSQ k p v
t of
        TourView k p v
Null             -> forall a. Sequ a
emptySequ
        Single (E k
k p
p v
v) -> forall a. a -> Sequ a
singleSequ (k
k, p
p, v
v)
        Play OrdPSQ k p v
tl OrdPSQ k p v
tr       -> forall k p v. OrdPSQ k p v -> Sequ (k, p, v)
toAscLists OrdPSQ k p v
tl forall a. Sequ a -> Sequ a -> Sequ a
`appendSequ` forall k p v. OrdPSQ k p v -> Sequ (k, p, v)
toAscLists OrdPSQ k p v
tr


--------------------------------------------------------------------------------
-- Views
--------------------------------------------------------------------------------

-- | /O(log n)/ Insert a new key, priority and value into the queue. If the key is
-- already present in the queue, then the evicted priority and value can be
-- found the first element of the returned tuple.
{-# INLINABLE insertView #-}
insertView
    :: (Ord k, Ord p)
    => k -> p -> v -> OrdPSQ k p v -> (Maybe (p, v), OrdPSQ k p v)
insertView :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> (Maybe (p, v), OrdPSQ k p v)
insertView k
k p
p v
x OrdPSQ k p v
t = case forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k OrdPSQ k p v
t of
    Maybe (p, v, OrdPSQ k p v)
Nothing          -> (forall a. Maybe a
Nothing,       forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert k
k p
p v
x OrdPSQ k p v
t)
    Just (p
p', v
x', OrdPSQ k p v
_) -> (forall a. a -> Maybe a
Just (p
p', v
x'), forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> OrdPSQ k p v -> OrdPSQ k p v
insert k
k p
p v
x OrdPSQ k p v
t)

-- | /O(log n)/ Delete a key and its priority and value from the queue. If the
-- key was present, the associated priority and value are returned in addition
-- to the updated queue.
{-# INLINABLE deleteView #-}
deleteView :: (Ord k, Ord p) => k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView :: forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k OrdPSQ k p v
psq = case OrdPSQ k p v
psq of
    OrdPSQ k p v
Void            -> forall a. Maybe a
Nothing
    Winner (E k
k' p
p v
v) LTree k p v
Start k
_
        | k
k forall a. Eq a => a -> a -> Bool
== k
k'   -> forall a. a -> Maybe a
Just (p
p, v
v, forall k p v. OrdPSQ k p v
empty)
        | Bool
otherwise -> forall a. Maybe a
Nothing
    Winner Elem k p v
e (RLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m'
        | k
k forall a. Ord a => a -> a -> Bool
<= k
m    -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(p
p,v
v,OrdPSQ k p v
q) -> (p
p, v
v,  OrdPSQ k p v
q forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m'))) (forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m))
        | Bool
otherwise -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(p
p,v
v,OrdPSQ k p v
q) -> (p
p, v
v,  (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v
q  )) (forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m'))
    Winner Elem k p v
e (LLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m'
        | k
k forall a. Ord a => a -> a -> Bool
<= k
m    -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(p
p,v
v,OrdPSQ k p v
q) -> (p
p, v
v, OrdPSQ k p v
q forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m'))) (forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m))
        | Bool
otherwise -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(p
p,v
v,OrdPSQ k p v
q) -> (p
p, v
v, (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m) forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v
q )) (forall k p v.
(Ord k, Ord p) =>
k -> OrdPSQ k p v -> Maybe (p, v, OrdPSQ k p v)
deleteView k
k (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m'))

-- | /O(log n)/ Retrieve the binding with the least priority, and the
-- rest of the queue stripped of that binding.
{-# INLINABLE minView #-}
minView :: (Ord k, Ord p) => OrdPSQ k p v -> Maybe (k, p, v, OrdPSQ k p v)
minView :: forall k p v.
(Ord k, Ord p) =>
OrdPSQ k p v -> Maybe (k, p, v, OrdPSQ k p v)
minView OrdPSQ k p v
Void                   = forall a. Maybe a
Nothing
minView (Winner (E k
k p
p v
v) LTree k p v
t k
m) = forall a. a -> Maybe a
Just (k
k, p
p, v
v, forall k p v. (Ord k, Ord p) => LTree k p v -> k -> OrdPSQ k p v
secondBest LTree k p v
t k
m)

{-# INLINABLE secondBest #-}
secondBest :: (Ord k, Ord p) => LTree k p v -> k -> OrdPSQ k p v
secondBest :: forall k p v. (Ord k, Ord p) => LTree k p v -> k -> OrdPSQ k p v
secondBest LTree k p v
Start k
_                 = forall k p v. OrdPSQ k p v
Void
secondBest (LLoser Int
_ Elem k p v
e LTree k p v
tl k
m LTree k p v
tr) k
m' = forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` forall k p v. (Ord k, Ord p) => LTree k p v -> k -> OrdPSQ k p v
secondBest LTree k p v
tr k
m'
secondBest (RLoser Int
_ Elem k p v
e LTree k p v
tl k
m LTree k p v
tr) k
m' = forall k p v. (Ord k, Ord p) => LTree k p v -> k -> OrdPSQ k p v
secondBest LTree k p v
tl k
m forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m'

-- | Return a list of elements ordered by key whose priorities are at most @pt@,
-- and the rest of the queue stripped of these elements.  The returned list of
-- elements can be in any order: no guarantees there.
{-# INLINABLE atMostView #-}
atMostView :: (Ord k, Ord p) => p -> OrdPSQ k p v -> ([(k, p, v)], OrdPSQ k p v)
atMostView :: forall k p v.
(Ord k, Ord p) =>
p -> OrdPSQ k p v -> ([(k, p, v)], OrdPSQ k p v)
atMostView p
pt = forall {a} {c}.
Ord a =>
[(a, p, c)] -> OrdPSQ a p c -> ([(a, p, c)], OrdPSQ a p c)
go []
  where
    go :: [(a, p, c)] -> OrdPSQ a p c -> ([(a, p, c)], OrdPSQ a p c)
go [(a, p, c)]
acc t :: OrdPSQ a p c
t@(Winner (E a
_ p
p c
_) LTree a p c
_ a
_)
        | p
p forall a. Ord a => a -> a -> Bool
> p
pt                                       = ([(a, p, c)]
acc, OrdPSQ a p c
t)
    go [(a, p, c)]
acc OrdPSQ a p c
Void                                        = ([(a, p, c)]
acc, forall k p v. OrdPSQ k p v
Void)
    go [(a, p, c)]
acc (Winner (E a
k p
p c
v) LTree a p c
Start                 a
_)  = ((a
k, p
p, c
v) forall a. a -> [a] -> [a]
: [(a, p, c)]
acc, forall k p v. OrdPSQ k p v
Void)
    go [(a, p, c)]
acc (Winner Elem a p c
e         (RLoser Int
_ Elem a p c
e' LTree a p c
tl a
m LTree a p c
tr) a
m') =
        let ([(a, p, c)]
acc',  OrdPSQ a p c
t')  = [(a, p, c)] -> OrdPSQ a p c -> ([(a, p, c)], OrdPSQ a p c)
go [(a, p, c)]
acc  (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem a p c
e  LTree a p c
tl a
m)
            ([(a, p, c)]
acc'', OrdPSQ a p c
t'') = [(a, p, c)] -> OrdPSQ a p c -> ([(a, p, c)], OrdPSQ a p c)
go [(a, p, c)]
acc' (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem a p c
e' LTree a p c
tr a
m') in
        ([(a, p, c)]
acc'', OrdPSQ a p c
t' forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ a p c
t'')
    go [(a, p, c)]
acc (Winner Elem a p c
e         (LLoser Int
_ Elem a p c
e' LTree a p c
tl a
m LTree a p c
tr) a
m') =
        let ([(a, p, c)]
acc',  OrdPSQ a p c
t')  = [(a, p, c)] -> OrdPSQ a p c -> ([(a, p, c)], OrdPSQ a p c)
go [(a, p, c)]
acc  (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem a p c
e' LTree a p c
tl a
m)
            ([(a, p, c)]
acc'', OrdPSQ a p c
t'') = [(a, p, c)] -> OrdPSQ a p c -> ([(a, p, c)], OrdPSQ a p c)
go [(a, p, c)]
acc' (forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem a p c
e  LTree a p c
tr a
m') in
        ([(a, p, c)]
acc'', OrdPSQ a p c
t' forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ a p c
t'')


--------------------------------------------------------------------------------
-- Traversals
--------------------------------------------------------------------------------

-- | /O(n)/ Modify every value in the queue.
{-# INLINABLE map #-}
map :: forall k p v w. (k -> p -> v -> w) -> OrdPSQ k p v -> OrdPSQ k p w
map :: forall k p v w. (k -> p -> v -> w) -> OrdPSQ k p v -> OrdPSQ k p w
map k -> p -> v -> w
f =
    OrdPSQ k p v -> OrdPSQ k p w
goPSQ
  where
    goPSQ :: OrdPSQ k p v -> OrdPSQ k p w
    goPSQ :: OrdPSQ k p v -> OrdPSQ k p w
goPSQ OrdPSQ k p v
Void           = forall k p v. OrdPSQ k p v
Void
    goPSQ (Winner Elem k p v
e LTree k p v
l k
k) = forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner (Elem k p v -> Elem k p w
goElem Elem k p v
e) (LTree k p v -> LTree k p w
goLTree LTree k p v
l) k
k

    goElem :: Elem k p v -> Elem k p w
    goElem :: Elem k p v -> Elem k p w
goElem (E k
k p
p v
x) = forall k p v. k -> p -> v -> Elem k p v
E k
k p
p (k -> p -> v -> w
f k
k p
p v
x)

    goLTree :: LTree k p v -> LTree k p w
    goLTree :: LTree k p v -> LTree k p w
goLTree LTree k p v
Start              = forall k p v. LTree k p v
Start
    goLTree (LLoser Int
s Elem k p v
e LTree k p v
l k
k LTree k p v
r) = forall k p v.
Int -> Elem k p v -> LTree k p v -> k -> LTree k p v -> LTree k p v
LLoser Int
s (Elem k p v -> Elem k p w
goElem Elem k p v
e) (LTree k p v -> LTree k p w
goLTree LTree k p v
l) k
k (LTree k p v -> LTree k p w
goLTree LTree k p v
r)
    goLTree (RLoser Int
s Elem k p v
e LTree k p v
l k
k LTree k p v
r) = forall k p v.
Int -> Elem k p v -> LTree k p v -> k -> LTree k p v -> LTree k p v
RLoser Int
s (Elem k p v -> Elem k p w
goElem Elem k p v
e) (LTree k p v -> LTree k p w
goLTree LTree k p v
l) k
k (LTree k p v -> LTree k p w
goLTree LTree k p v
r)

-- | /O(n)/ Maps a function over the values and priorities of the queue.
-- The function @f@ must be monotonic with respect to the priorities. I.e. if
-- @x < y@, then @fst (f k x v) < fst (f k y v)@.
-- /The precondition is not checked./ If @f@ is not monotonic, then the result
-- will be invalid.
{-# INLINABLE unsafeMapMonotonic #-}
unsafeMapMonotonic
    :: forall k p q v w.
       (k -> p -> v -> (q, w))
    -> OrdPSQ k p v
    -> OrdPSQ k q w
unsafeMapMonotonic :: forall k p q v w.
(k -> p -> v -> (q, w)) -> OrdPSQ k p v -> OrdPSQ k q w
unsafeMapMonotonic k -> p -> v -> (q, w)
f = OrdPSQ k p v -> OrdPSQ k q w
goPSQ
  where
    goPSQ :: OrdPSQ k p v -> OrdPSQ k q w
    goPSQ :: OrdPSQ k p v -> OrdPSQ k q w
goPSQ OrdPSQ k p v
Void           = forall k p v. OrdPSQ k p v
Void
    goPSQ (Winner Elem k p v
e LTree k p v
l k
k) = forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner (Elem k p v -> Elem k q w
goElem Elem k p v
e) (LTree k p v -> LTree k q w
goLTree LTree k p v
l) k
k

    goElem :: Elem k p v -> Elem k q w
    goElem :: Elem k p v -> Elem k q w
goElem (E k
k p
p v
x) = let (q
p', w
x') = k -> p -> v -> (q, w)
f k
k p
p v
x
                       in forall k p v. k -> p -> v -> Elem k p v
E k
k q
p' w
x'

    goLTree :: LTree k p v -> LTree k q w
    goLTree :: LTree k p v -> LTree k q w
goLTree LTree k p v
Start              = forall k p v. LTree k p v
Start
    goLTree (LLoser Int
s Elem k p v
e LTree k p v
l k
k LTree k p v
r) = forall k p v.
Int -> Elem k p v -> LTree k p v -> k -> LTree k p v -> LTree k p v
LLoser Int
s (Elem k p v -> Elem k q w
goElem Elem k p v
e) (LTree k p v -> LTree k q w
goLTree LTree k p v
l) k
k (LTree k p v -> LTree k q w
goLTree LTree k p v
r)
    goLTree (RLoser Int
s Elem k p v
e LTree k p v
l k
k LTree k p v
r) = forall k p v.
Int -> Elem k p v -> LTree k p v -> k -> LTree k p v -> LTree k p v
RLoser Int
s (Elem k p v -> Elem k q w
goElem Elem k p v
e) (LTree k p v -> LTree k q w
goLTree LTree k p v
l) k
k (LTree k p v -> LTree k q w
goLTree LTree k p v
r)

-- | /O(n)/ Strict fold over every key, priority and value in the queue. The order
-- in which the fold is performed is not specified.
{-# INLINE fold' #-}
fold' :: (k -> p -> v -> a -> a) -> a -> OrdPSQ k p v -> a
fold' :: forall k p v a. (k -> p -> v -> a -> a) -> a -> OrdPSQ k p v -> a
fold' k -> p -> v -> a -> a
f =
    \a
acc0 OrdPSQ k p v
psq -> case OrdPSQ k p v
psq of
                   OrdPSQ k p v
Void                   -> a
acc0
                   (Winner (E k
k p
p v
v) LTree k p v
t k
_) ->
                        let !acc1 :: a
acc1 = k -> p -> v -> a -> a
f k
k p
p v
v a
acc0
                        in  a -> LTree k p v -> a
go a
acc1 LTree k p v
t
  where
    go :: a -> LTree k p v -> a
go !a
acc LTree k p v
Start                        = a
acc
    go !a
acc (LLoser Int
_ (E k
k p
p v
v) LTree k p v
lt k
_ LTree k p v
rt) = a -> LTree k p v -> a
go (k -> p -> v -> a -> a
f k
k p
p v
v (a -> LTree k p v -> a
go a
acc LTree k p v
lt)) LTree k p v
rt
    go !a
acc (RLoser Int
_ (E k
k p
p v
v) LTree k p v
lt k
_ LTree k p v
rt) = a -> LTree k p v -> a
go (k -> p -> v -> a -> a
f k
k p
p v
v (a -> LTree k p v -> a
go a
acc LTree k p v
lt)) LTree k p v
rt


--------------------------------------------------------------------------------
-- Tournament view
--------------------------------------------------------------------------------

data TourView k p v
    = Null
    | Single {-# UNPACK #-} !(Elem k p v)
    | Play !(OrdPSQ k p v) !(OrdPSQ k p v)

tourView :: OrdPSQ k p v -> TourView k p v
tourView :: forall k p v. OrdPSQ k p v -> TourView k p v
tourView OrdPSQ k p v
Void               = forall k p v. TourView k p v
Null
tourView (Winner Elem k p v
e LTree k p v
Start k
_) = forall k p v. Elem k p v -> TourView k p v
Single Elem k p v
e
tourView (Winner Elem k p v
e (RLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m') =
    forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tl k
m forall k p v. OrdPSQ k p v -> OrdPSQ k p v -> TourView k p v
`Play` forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tr k
m'
tourView (Winner Elem k p v
e (LLoser Int
_ Elem k p v
e' LTree k p v
tl k
m LTree k p v
tr) k
m') =
    forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' LTree k p v
tl k
m forall k p v. OrdPSQ k p v -> OrdPSQ k p v -> TourView k p v
`Play` forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e LTree k p v
tr k
m'

-- | Take two pennants and returns a new pennant that is the union of
-- the two with the precondition that the keys in the first tree are
-- strictly smaller than the keys in the second tree.
{-# INLINABLE play #-}
play :: (Ord p, Ord k) => OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
OrdPSQ k p v
Void play :: forall p k v.
(Ord p, Ord k) =>
OrdPSQ k p v -> OrdPSQ k p v -> OrdPSQ k p v
`play` OrdPSQ k p v
t' = OrdPSQ k p v
t'
OrdPSQ k p v
t `play` OrdPSQ k p v
Void  = OrdPSQ k p v
t
Winner e :: Elem k p v
e@(E k
k p
p v
v) LTree k p v
t k
m `play` Winner e' :: Elem k p v
e'@(E k
k' p
p' v
v') LTree k p v
t' k
m'
    | (p
p, k
k) forall p k. (Ord p, Ord k) => (p, k) -> (p, k) -> Bool
`beats` (p
p', k
k') = forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e (forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalance k
k' p
p' v
v' LTree k p v
t k
m LTree k p v
t') k
m'
    | Bool
otherwise               = forall k p v. Elem k p v -> LTree k p v -> k -> OrdPSQ k p v
Winner Elem k p v
e' (forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalance k
k p
p v
v LTree k p v
t k
m LTree k p v
t') k
m'

-- | When priorities are equal, the tree with the lowest key wins. This is
-- important to have a deterministic `==`, which requires on `minView` pulling
-- out the elements in the right order.
beats :: (Ord p, Ord k) => (p, k) -> (p, k) -> Bool
beats :: forall p k. (Ord p, Ord k) => (p, k) -> (p, k) -> Bool
beats (p
p, !k
k) (p
p', !k
k') = p
p forall a. Ord a => a -> a -> Bool
< p
p' Bool -> Bool -> Bool
|| (p
p forall a. Eq a => a -> a -> Bool
== p
p' Bool -> Bool -> Bool
&& k
k forall a. Ord a => a -> a -> Bool
< k
k')
{-# INLINE beats #-}


--------------------------------------------------------------------------------
-- Balancing internals
--------------------------------------------------------------------------------

-- | Balance factor
omega :: Int
omega :: Int
omega = Int
4  -- Has to be greater than 3.75 because Hinze's paper said so.

size' :: LTree k p v -> Size
size' :: forall k p a. LTree k p a -> Int
size' LTree k p v
Start              = Int
0
size' (LLoser Int
s Elem k p v
_ LTree k p v
_ k
_ LTree k p v
_) = Int
s
size' (RLoser Int
s Elem k p v
_ LTree k p v
_ k
_ LTree k p v
_) = Int
s

left, right :: LTree k p v -> LTree k p v

left :: forall k p v. LTree k p v -> LTree k p v
left LTree k p v
Start                = forall a. String -> String -> a
moduleError String
"left" String
"empty loser tree"
left (LLoser Int
_ Elem k p v
_ LTree k p v
tl k
_ LTree k p v
_ ) = LTree k p v
tl
left (RLoser Int
_ Elem k p v
_ LTree k p v
tl k
_ LTree k p v
_ ) = LTree k p v
tl

right :: forall k p v. LTree k p v -> LTree k p v
right LTree k p v
Start                = forall a. String -> String -> a
moduleError String
"right" String
"empty loser tree"
right (LLoser Int
_ Elem k p v
_ LTree k p v
_  k
_ LTree k p v
tr) = LTree k p v
tr
right (RLoser Int
_ Elem k p v
_ LTree k p v
_  k
_ LTree k p v
tr) = LTree k p v
tr

maxKey :: OrdPSQ k p v -> k
maxKey :: forall k p v. OrdPSQ k p v -> k
maxKey OrdPSQ k p v
Void           = forall a. String -> String -> a
moduleError String
"maxKey" String
"empty queue"
maxKey (Winner Elem k p v
_ LTree k p v
_ k
m) = k
m

lloser, rloser :: k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser :: forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k p
p v
v LTree k p v
tl k
m LTree k p v
tr = forall k p v.
Int -> Elem k p v -> LTree k p v -> k -> LTree k p v -> LTree k p v
LLoser (Int
1 forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
size' LTree k p v
tl forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
size' LTree k p v
tr) (forall k p v. k -> p -> v -> Elem k p v
E k
k p
p v
v) LTree k p v
tl k
m LTree k p v
tr
rloser :: forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k p
p v
v LTree k p v
tl k
m LTree k p v
tr = forall k p v.
Int -> Elem k p v -> LTree k p v -> k -> LTree k p v -> LTree k p v
RLoser (Int
1 forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
size' LTree k p v
tl forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
size' LTree k p v
tr) (forall k p v. k -> p -> v -> Elem k p v
E k
k p
p v
v) LTree k p v
tl k
m LTree k p v
tr

{-# INLINABLE lbalance #-}
{-# INLINABLE rbalance #-}
lbalance, rbalance
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalance :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalance k
k p
p v
v LTree k p v
Start k
m LTree k p v
r        = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser        k
k p
p v
v forall k p v. LTree k p v
Start k
m LTree k p v
r
lbalance k
k p
p v
v LTree k p v
l k
m LTree k p v
Start        = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser        k
k p
p v
v LTree k p v
l k
m forall k p v. LTree k p v
Start
lbalance k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' LTree k p v
r forall a. Ord a => a -> a -> Bool
> Int
omega forall a. Num a => a -> a -> a
* forall k p a. LTree k p a -> Int
size' LTree k p v
l = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalanceLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' LTree k p v
l forall a. Ord a => a -> a -> Bool
> Int
omega forall a. Num a => a -> a -> a
* forall k p a. LTree k p a -> Int
size' LTree k p v
r = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalanceRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | Bool
otherwise                 = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser        k
k p
p v
v LTree k p v
l k
m LTree k p v
r

rbalance :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalance k
k p
p v
v LTree k p v
Start k
m LTree k p v
r        = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser        k
k p
p v
v forall k p v. LTree k p v
Start k
m LTree k p v
r
rbalance k
k p
p v
v LTree k p v
l k
m LTree k p v
Start        = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser        k
k p
p v
v LTree k p v
l k
m forall k p v. LTree k p v
Start
rbalance k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' LTree k p v
r forall a. Ord a => a -> a -> Bool
> Int
omega forall a. Num a => a -> a -> a
* forall k p a. LTree k p a -> Int
size' LTree k p v
l = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalanceLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' LTree k p v
l forall a. Ord a => a -> a -> Bool
> Int
omega forall a. Num a => a -> a -> a
* forall k p a. LTree k p a -> Int
size' LTree k p v
r = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalanceRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | Bool
otherwise                 = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser        k
k p
p v
v LTree k p v
l k
m LTree k p v
r

{-# INLINABLE lbalanceLeft #-}
lbalanceLeft
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalanceLeft :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalanceLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
left LTree k p v
r) forall a. Ord a => a -> a -> Bool
< forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
right LTree k p v
r) = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | Bool
otherwise                        = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
ldoubleLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r

{-# INLINABLE lbalanceRight #-}
lbalanceRight
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalanceRight :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lbalanceRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
left LTree k p v
l) forall a. Ord a => a -> a -> Bool
> forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
right LTree k p v
l) = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | Bool
otherwise                        = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
ldoubleRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r

{-# INLINABLE rbalanceLeft #-}
rbalanceLeft
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalanceLeft :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalanceLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
left LTree k p v
r) forall a. Ord a => a -> a -> Bool
< forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
right LTree k p v
r) = forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | Bool
otherwise                        = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rdoubleLeft  k
k p
p v
v LTree k p v
l k
m LTree k p v
r

{-# INLINABLE rbalanceRight #-}
rbalanceRight
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalanceRight :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rbalanceRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
left LTree k p v
l) forall a. Ord a => a -> a -> Bool
> forall k p a. LTree k p a -> Int
size' (forall k p v. LTree k p v -> LTree k p v
right LTree k p v
l) = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r
    | Bool
otherwise                        = forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rdoubleRight k
k p
p v
v LTree k p v
l k
m LTree k p v
r

{-# INLINABLE lsingleLeft #-}
lsingleLeft
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3)
    | (p
p1, k
k1) forall p k. (Ord p, Ord k) => (p, k) -> (p, k) -> Bool
`beats` (p
p2, k
k2) =
        forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k1 p
p1 v
v1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
    | Bool
otherwise                 =
        forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k2 p
p2 v
v2 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
lsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k2 p
p2 v
v2 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
lsingleLeft k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"lsingleLeft" String
"malformed tree"

rsingleLeft :: k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft :: forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k1 p
p1 v
v1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
rsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k2 p
p2 v
v2 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
rsingleLeft k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"rsingleLeft" String
"malformed tree"

lsingleRight :: k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight :: forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight k
k1 p
p1 v
v1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k1 p
p1 v
v1 LTree k p v
t2 k
m2 LTree k p v
t3)
lsingleRight k
k1 p
p1 v
v1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k2 p
p2 v
v2 LTree k p v
t2 k
m2 LTree k p v
t3)
lsingleRight k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"lsingleRight" String
"malformed tree"

{-# INLINABLE rsingleRight #-}
rsingleRight
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight k
k1 p
p1 v
v1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k1 p
p1 v
v1 LTree k p v
t2 k
m2 LTree k p v
t3)
rsingleRight k
k1 p
p1 v
v1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
    | (p
p1, k
k1) forall p k. (Ord p, Ord k) => (p, k) -> (p, k) -> Bool
`beats` (p
p2, k
k2) =
        forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lloser k
k2 p
p2 v
v2 LTree k p v
t2 k
m2 LTree k p v
t3)
    | Bool
otherwise                 =
        forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rloser k
k1 p
p1 v
v1 LTree k p v
t2 k
m2 LTree k p v
t3)
rsingleRight k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"rsingleRight" String
"malformed tree"

{-# INLINABLE ldoubleLeft #-}
ldoubleLeft
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
ldoubleLeft :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
ldoubleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight k
k2 p
p2 v
v2 LTree k p v
t2 k
m2 LTree k p v
t3)
ldoubleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight k
k2 p
p2 v
v2 LTree k p v
t2 k
m2 LTree k p v
t3)
ldoubleLeft k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"ldoubleLeft" String
"malformed tree"

{-# INLINABLE ldoubleRight #-}
ldoubleRight
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
ldoubleRight :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
ldoubleRight k
k1 p
p1 v
v1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight k
k1 p
p1 v
v1 (forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
ldoubleRight k
k1 p
p1 v
v1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight k
k1 p
p1 v
v1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
ldoubleRight k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"ldoubleRight" String
"malformed tree"

{-# INLINABLE rdoubleLeft #-}
rdoubleLeft
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rdoubleLeft :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rdoubleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleRight k
k2 p
p2 v
v2 LTree k p v
t2 k
m2 LTree k p v
t3)
rdoubleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t2 k
m2 LTree k p v
t3) =
    forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft k
k1 p
p1 v
v1 LTree k p v
t1 k
m1 (forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight k
k2 p
p2 v
v2 LTree k p v
t2 k
m2 LTree k p v
t3)
rdoubleLeft k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"rdoubleLeft" String
"malformed tree"

{-# INLINABLE rdoubleRight #-}
rdoubleRight
    :: (Ord k, Ord p)
    => k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rdoubleRight :: forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rdoubleRight k
k1 p
p1 v
v1 (LLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight k
k1 p
p1 v
v1 (forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
lsingleLeft k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
rdoubleRight k
k1 p
p1 v
v1 (RLoser Int
_ (E k
k2 p
p2 v
v2) LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3 =
    forall k p v.
(Ord k, Ord p) =>
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleRight k
k1 p
p1 v
v1 (forall k p v.
k -> p -> v -> LTree k p v -> k -> LTree k p v -> LTree k p v
rsingleLeft k
k2 p
p2 v
v2 LTree k p v
t1 k
m1 LTree k p v
t2) k
m2 LTree k p v
t3
rdoubleRight k
_ p
_ v
_ LTree k p v
_ k
_ LTree k p v
_ = forall a. String -> String -> a
moduleError String
"rdoubleRight" String
"malformed tree"


--------------------------------------------------------------------------------
-- Validity check
--------------------------------------------------------------------------------

-- | /O(n^2)/ Internal function to check if the 'OrdPSQ' is valid, i.e. if all
-- invariants hold. This should always be the case.
valid :: (Ord k, Ord p) => OrdPSQ k p v -> Bool
valid :: forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
valid OrdPSQ k p v
t =
    Bool -> Bool
not (forall k p v. Ord k => OrdPSQ k p v -> Bool
hasDuplicateKeys OrdPSQ k p v
t)      Bool -> Bool -> Bool
&&
    forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasMinHeapProperty OrdPSQ k p v
t          Bool -> Bool -> Bool
&&
    forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasBinarySearchTreeProperty OrdPSQ k p v
t Bool -> Bool -> Bool
&&
    forall k p a. OrdPSQ k p a -> Bool
hasCorrectSizeAnnotations OrdPSQ k p v
t

hasDuplicateKeys :: Ord k => OrdPSQ k p v -> Bool
hasDuplicateKeys :: forall k p v. Ord k => OrdPSQ k p v -> Bool
hasDuplicateKeys = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any (forall a. Ord a => a -> a -> Bool
> Int
1) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a -> b) -> [a] -> [b]
List.map forall (t :: * -> *) a. Foldable t => t a -> Int
length forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Eq a => [a] -> [[a]]
List.group forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> [a]
List.sort forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall k p v. OrdPSQ k p v -> [k]
keys

hasMinHeapProperty :: forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasMinHeapProperty :: forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasMinHeapProperty OrdPSQ k p v
Void                      = Bool
True
hasMinHeapProperty (Winner (E k
k0 p
p0 v
_) LTree k p v
t0 k
_) = k -> p -> LTree k p v -> Bool
go k
k0 p
p0 LTree k p v
t0
  where
    go :: k -> p -> LTree k p v -> Bool
    go :: k -> p -> LTree k p v -> Bool
go k
_ p
_ LTree k p v
Start                        = Bool
True
    go k
k p
p (LLoser Int
_ (E k
k' p
p' v
_) LTree k p v
l k
_ LTree k p v
r) =
        (p
p, k
k) forall a. Ord a => a -> a -> Bool
< (p
p', k
k') Bool -> Bool -> Bool
&& k -> p -> LTree k p v -> Bool
go k
k' p
p' LTree k p v
l Bool -> Bool -> Bool
&& k -> p -> LTree k p v -> Bool
go k
k  p
p  LTree k p v
r
    go k
k p
p (RLoser Int
_ (E k
k' p
p' v
_) LTree k p v
l k
_ LTree k p v
r) =
        (p
p, k
k) forall a. Ord a => a -> a -> Bool
< (p
p', k
k') Bool -> Bool -> Bool
&& k -> p -> LTree k p v -> Bool
go k
k  p
p  LTree k p v
l Bool -> Bool -> Bool
&& k -> p -> LTree k p v -> Bool
go k
k' p
p' LTree k p v
r

hasBinarySearchTreeProperty
    :: forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasBinarySearchTreeProperty :: forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasBinarySearchTreeProperty OrdPSQ k p v
t = case forall k p v. OrdPSQ k p v -> TourView k p v
tourView OrdPSQ k p v
t of
    TourView k p v
Null      -> Bool
True
    Single Elem k p v
_  -> Bool
True
    Play OrdPSQ k p v
l OrdPSQ k p v
r  ->
        forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall a. Ord a => a -> a -> Bool
<= k
k) (forall k p v. OrdPSQ k p v -> [k]
keys OrdPSQ k p v
l)           Bool -> Bool -> Bool
&&
        forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (forall a. Ord a => a -> a -> Bool
>= k
k) (forall k p v. OrdPSQ k p v -> [k]
keys OrdPSQ k p v
r)           Bool -> Bool -> Bool
&&
        forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasBinarySearchTreeProperty OrdPSQ k p v
l Bool -> Bool -> Bool
&&
        forall k p v. (Ord k, Ord p) => OrdPSQ k p v -> Bool
hasBinarySearchTreeProperty OrdPSQ k p v
r
      where
        k :: k
k = forall k p v. OrdPSQ k p v -> k
maxKey OrdPSQ k p v
l

hasCorrectSizeAnnotations :: OrdPSQ k p v -> Bool
hasCorrectSizeAnnotations :: forall k p a. OrdPSQ k p a -> Bool
hasCorrectSizeAnnotations OrdPSQ k p v
Void            = Bool
True
hasCorrectSizeAnnotations (Winner Elem k p v
_ LTree k p v
t0 k
_) = forall k p a. LTree k p a -> Bool
go LTree k p v
t0
  where
    go :: LTree k p v -> Bool
    go :: forall k p a. LTree k p a -> Bool
go t :: LTree k p v
t@LTree k p v
Start              = forall k p a. LTree k p a -> Int
calculateSize LTree k p v
t forall a. Eq a => a -> a -> Bool
== Int
0
    go t :: LTree k p v
t@(LLoser Int
s Elem k p v
_ LTree k p v
l k
_ LTree k p v
r) = forall k p a. LTree k p a -> Int
calculateSize LTree k p v
t forall a. Eq a => a -> a -> Bool
== Int
s Bool -> Bool -> Bool
&& forall k p a. LTree k p a -> Bool
go LTree k p v
l Bool -> Bool -> Bool
&& forall k p a. LTree k p a -> Bool
go LTree k p v
r
    go t :: LTree k p v
t@(RLoser Int
s Elem k p v
_ LTree k p v
l k
_ LTree k p v
r) = forall k p a. LTree k p a -> Int
calculateSize LTree k p v
t forall a. Eq a => a -> a -> Bool
== Int
s Bool -> Bool -> Bool
&& forall k p a. LTree k p a -> Bool
go LTree k p v
l Bool -> Bool -> Bool
&& forall k p a. LTree k p a -> Bool
go LTree k p v
r

    calculateSize :: LTree k p v -> Int
    calculateSize :: forall k p a. LTree k p a -> Int
calculateSize LTree k p v
Start              = Int
0
    calculateSize (LLoser Int
_ Elem k p v
_ LTree k p v
l k
_ LTree k p v
r) = Int
1 forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
calculateSize LTree k p v
l forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
calculateSize LTree k p v
r
    calculateSize (RLoser Int
_ Elem k p v
_ LTree k p v
l k
_ LTree k p v
r) = Int
1 forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
calculateSize LTree k p v
l forall a. Num a => a -> a -> a
+ forall k p a. LTree k p a -> Int
calculateSize LTree k p v
r


--------------------------------------------------------------------------------
-- Utility functions
--------------------------------------------------------------------------------

moduleError :: String -> String -> a
moduleError :: forall a. String -> String -> a
moduleError String
fun String
msg = forall a. HasCallStack => String -> a
error (String
"Data.OrdPSQ.Internal." forall a. [a] -> [a] -> [a]
++ String
fun forall a. [a] -> [a] -> [a]
++ Char
':' forall a. a -> [a] -> [a]
: Char
' ' forall a. a -> [a] -> [a]
: String
msg)
{-# NOINLINE moduleError #-}

-- | Hughes's efficient sequence type
newtype Sequ a = Sequ ([a] -> [a])

emptySequ :: Sequ a
emptySequ :: forall a. Sequ a
emptySequ = forall a. ([a] -> [a]) -> Sequ a
Sequ (\[a]
as -> [a]
as)

singleSequ :: a -> Sequ a
singleSequ :: forall a. a -> Sequ a
singleSequ a
a = forall a. ([a] -> [a]) -> Sequ a
Sequ (\[a]
as -> a
a forall a. a -> [a] -> [a]
: [a]
as)

appendSequ :: Sequ a -> Sequ a -> Sequ a
appendSequ :: forall a. Sequ a -> Sequ a -> Sequ a
appendSequ (Sequ [a] -> [a]
x1) (Sequ [a] -> [a]
x2) = forall a. ([a] -> [a]) -> Sequ a
Sequ (\[a]
as -> [a] -> [a]
x1 ([a] -> [a]
x2 [a]
as))

seqToList :: Sequ a -> [a]
seqToList :: forall a. Sequ a -> [a]
seqToList (Sequ [a] -> [a]
x) = [a] -> [a]
x []