module Table(table, mapTable, listTable, tableUpdate, tableLookup, emptyTable,
             Table) where
import Tree234
import HbcUtils(apSnd)

newtype Table k v = T (Tree234 (k,v)) deriving (Table k v -> Table k v -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall k v. (Eq k, Eq v) => Table k v -> Table k v -> Bool
/= :: Table k v -> Table k v -> Bool
$c/= :: forall k v. (Eq k, Eq v) => Table k v -> Table k v -> Bool
== :: Table k v -> Table k v -> Bool
$c== :: forall k v. (Eq k, Eq v) => Table k v -> Table k v -> Bool
Eq, Table k v -> Table k v -> Bool
Table k v -> Table k v -> Ordering
Table k v -> Table k v -> Table k v
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall {k} {v}. (Ord k, Ord v) => Eq (Table k v)
forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Bool
forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Ordering
forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Table k v
min :: Table k v -> Table k v -> Table k v
$cmin :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Table k v
max :: Table k v -> Table k v -> Table k v
$cmax :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Table k v
>= :: Table k v -> Table k v -> Bool
$c>= :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Bool
> :: Table k v -> Table k v -> Bool
$c> :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Bool
<= :: Table k v -> Table k v -> Bool
$c<= :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Bool
< :: Table k v -> Table k v -> Bool
$c< :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Bool
compare :: Table k v -> Table k v -> Ordering
$ccompare :: forall k v. (Ord k, Ord v) => Table k v -> Table k v -> Ordering
Ord,Int -> Table k v -> ShowS
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall k v. (Show k, Show v) => Int -> Table k v -> ShowS
forall k v. (Show k, Show v) => [Table k v] -> ShowS
forall k v. (Show k, Show v) => Table k v -> String
showList :: [Table k v] -> ShowS
$cshowList :: forall k v. (Show k, Show v) => [Table k v] -> ShowS
show :: Table k v -> String
$cshow :: forall k v. (Show k, Show v) => Table k v -> String
showsPrec :: Int -> Table k v -> ShowS
$cshowsPrec :: forall k v. (Show k, Show v) => Int -> Table k v -> ShowS
Show)

emptyTable :: Table k v
emptyTable = forall k v. Tree234 (k, v) -> Table k v
T forall {a}. Tree234 a
initTree234

tableLookup :: t3 -> ((a, b) -> t3) -> a -> Table a b -> t3
tableLookup t3
n (a, b) -> t3
j a
x (T Tree234 (a, b)
t) = forall {t1} {t2} {t3}.
t1
-> (t2 -> t3) -> (t2 -> t1 -> t3 -> t1 -> t1) -> Tree234 t2 -> t1
treeSearch t3
n (a, b) -> t3
j (forall {a} {b} {b} {p}.
Ord a =>
(a, b) -> (a, b) -> p -> p -> p -> p
keyCmp (a
x,())) Tree234 (a, b)
t

tableUpdate :: (k, v) -> Table k v -> Table k v
tableUpdate (k, v)
x (T Tree234 (k, v)
t) = forall k v. Tree234 (k, v) -> Table k v
T (forall {a} {b}. Ord a => (a, b) -> Tree234 (a, b) -> Tree234 (a, b)
update' (k, v)
x Tree234 (k, v)
t)

update' :: (a, b) -> Tree234 (a, b) -> Tree234 (a, b)
update' (a, b)
x = forall {a}.
(a -> a -> a)
-> (a -> a -> Tree234 a -> Tree234 a -> Tree234 a -> Tree234 a)
-> a
-> Tree234 a
-> Tree234 a
treeAdd forall a b. a -> b -> a
const forall {a} {b} {b} {p}.
Ord a =>
(a, b) -> (a, b) -> p -> p -> p -> p
keyCmp (a, b)
x

mapTable :: (t -> v) -> Table k t -> Table k v
mapTable t -> v
f (T Tree234 (k, t)
t) = forall k v. Tree234 (k, v) -> Table k v
T (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall {t} {b} {a}. (t -> b) -> (a, t) -> (a, b)
apSnd t -> v
f) Tree234 (k, t)
t)

listTable :: Table k v -> [(k, v)]
listTable (T Tree234 (k, v)
t) = forall {a}. Tree234 a -> [a]
treeList Tree234 (k, v)
t

table :: [(k, v)] -> Table k v
table [(k, v)]
xs = forall k v. Tree234 (k, v) -> Table k v
T (forall {a}.
(a -> a -> a)
-> (a -> a -> Tree234 a -> Tree234 a -> Tree234 a -> Tree234 a)
-> [a]
-> Tree234 a
treeFromList forall a b. a -> b -> a
const forall {a} {b} {b} {p}.
Ord a =>
(a, b) -> (a, b) -> p -> p -> p -> p
keyCmp [(k, v)]
xs)

keyCmp :: (a, b) -> (a, b) -> p -> p -> p -> p
keyCmp (a
a, b
_) (a
b, b
_) p
lt p
eq p
gt =
    if a
a forall a. Eq a => a -> a -> Bool
== a
b then p
eq else if a
a forall a. Ord a => a -> a -> Bool
< a
b then p
lt else p
gt