module Dict
(
Dict,
empty,
singleton,
insert,
update,
remove,
isEmpty,
member,
get,
size,
keys,
values,
toList,
fromList,
map,
foldl,
foldr,
filter,
partition,
union,
intersect,
diff,
merge,
)
where
import Basics
import qualified Data.Map.Strict
import List (List)
import qualified List
import Maybe (Maybe (..))
import Prelude (fromIntegral, otherwise)
type Dict k v =
Data.Map.Strict.Map k v
empty :: Dict k v
empty :: Dict k v
empty =
Dict k v
forall k a. Map k a
Data.Map.Strict.empty
get :: Ord comparable => comparable -> Dict comparable v -> Maybe v
get :: comparable -> Dict comparable v -> Maybe v
get =
comparable -> Dict comparable v -> Maybe v
forall k a. Ord k => k -> Map k a -> Maybe a
Data.Map.Strict.lookup
member :: Ord comparable => comparable -> Dict comparable v -> Bool
member :: comparable -> Dict comparable v -> Bool
member =
comparable -> Dict comparable v -> Bool
forall k a. Ord k => k -> Map k a -> Bool
Data.Map.Strict.member
size :: Dict k v -> Int
size :: Dict k v -> Int
size =
Dict k v -> Int
forall k a. Map k a -> Int
Data.Map.Strict.size (Dict k v -> Int) -> (Int -> Int) -> Dict k v -> Int
forall a b c. (a -> b) -> (b -> c) -> a -> c
>> Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral
isEmpty :: Dict k v -> Bool
isEmpty :: Dict k v -> Bool
isEmpty =
Dict k v -> Bool
forall k a. Map k a -> Bool
Data.Map.Strict.null
insert :: Ord comparable => comparable -> v -> Dict comparable v -> Dict comparable v
insert :: comparable -> v -> Dict comparable v -> Dict comparable v
insert =
comparable -> v -> Dict comparable v -> Dict comparable v
forall k a. Ord k => k -> a -> Map k a -> Map k a
Data.Map.Strict.insert
remove :: Ord comparable => comparable -> Dict comparable v -> Dict comparable v
remove :: comparable -> Dict comparable v -> Dict comparable v
remove =
comparable -> Dict comparable v -> Dict comparable v
forall k a. Ord k => k -> Map k a -> Map k a
Data.Map.Strict.delete
update :: Ord comparable => comparable -> (Maybe v -> Maybe v) -> Dict comparable v -> Dict comparable v
update :: comparable
-> (Maybe v -> Maybe v) -> Dict comparable v -> Dict comparable v
update comparable
targetKey Maybe v -> Maybe v
alter Dict comparable v
dictionary =
let maybeItemToSet :: Maybe v
maybeItemToSet =
comparable -> Dict comparable v -> Maybe v
forall k a. Ord k => k -> Map k a -> Maybe a
Data.Map.Strict.lookup comparable
targetKey Dict comparable v
dictionary Maybe v -> (Maybe v -> Maybe v) -> Maybe v
forall a b. a -> (a -> b) -> b
|> Maybe v -> Maybe v
alter
in case Maybe v
maybeItemToSet of
Just v
itemToSet ->
comparable -> v -> Dict comparable v -> Dict comparable v
forall k a. Ord k => k -> a -> Map k a -> Map k a
Data.Map.Strict.insert comparable
targetKey v
itemToSet Dict comparable v
dictionary
Maybe v
Nothing ->
comparable -> Dict comparable v -> Dict comparable v
forall k a. Ord k => k -> Map k a -> Map k a
Data.Map.Strict.delete comparable
targetKey Dict comparable v
dictionary
singleton :: comparable -> v -> Dict comparable v
singleton :: comparable -> v -> Dict comparable v
singleton =
comparable -> v -> Dict comparable v
forall k a. k -> a -> Map k a
Data.Map.Strict.singleton
union :: Ord comparable => Dict comparable v -> Dict comparable v -> Dict comparable v
union :: Dict comparable v -> Dict comparable v -> Dict comparable v
union =
Dict comparable v -> Dict comparable v -> Dict comparable v
forall k a. Ord k => Map k a -> Map k a -> Map k a
Data.Map.Strict.union
intersect :: Ord comparable => Dict comparable v -> Dict comparable v -> Dict comparable v
intersect :: Dict comparable v -> Dict comparable v -> Dict comparable v
intersect =
Dict comparable v -> Dict comparable v -> Dict comparable v
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Data.Map.Strict.intersection
diff :: Ord comparable => Dict comparable a -> Dict comparable b -> Dict comparable a
diff :: Dict comparable a -> Dict comparable b -> Dict comparable a
diff =
Dict comparable a -> Dict comparable b -> Dict comparable a
forall k a b. Ord k => Map k a -> Map k b -> Map k a
Data.Map.Strict.difference
merge ::
Ord comparable =>
(comparable -> a -> result -> result) ->
(comparable -> a -> b -> result -> result) ->
(comparable -> b -> result -> result) ->
Dict comparable a ->
Dict comparable b ->
result ->
result
merge :: (comparable -> a -> result -> result)
-> (comparable -> a -> b -> result -> result)
-> (comparable -> b -> result -> result)
-> Dict comparable a
-> Dict comparable b
-> result
-> result
merge comparable -> a -> result -> result
leftStep comparable -> a -> b -> result -> result
bothStep comparable -> b -> result -> result
rightStep Dict comparable a
leftDict Dict comparable b
rightDict result
initialResult =
let stepState :: comparable
-> b -> ([(comparable, a)], result) -> ([(comparable, a)], result)
stepState comparable
rKey b
rValue ([(comparable, a)]
list, result
result) =
case [(comparable, a)]
list of
[] ->
([(comparable, a)]
list, comparable -> b -> result -> result
rightStep comparable
rKey b
rValue result
result)
(comparable
lKey, a
lValue) : [(comparable, a)]
rest
| comparable
lKey comparable -> comparable -> Bool
forall comparable.
Ord comparable =>
comparable -> comparable -> Bool
< comparable
rKey -> comparable
-> b -> ([(comparable, a)], result) -> ([(comparable, a)], result)
stepState comparable
rKey b
rValue ([(comparable, a)]
rest, comparable -> a -> result -> result
leftStep comparable
lKey a
lValue result
result)
| comparable
lKey comparable -> comparable -> Bool
forall comparable.
Ord comparable =>
comparable -> comparable -> Bool
> comparable
rKey -> ([(comparable, a)]
list, comparable -> b -> result -> result
rightStep comparable
rKey b
rValue result
result)
| Bool
otherwise -> ([(comparable, a)]
rest, comparable -> a -> b -> result -> result
bothStep comparable
lKey a
lValue b
rValue result
result)
([(comparable, a)]
leftovers, result
intermediateResult) =
(comparable
-> b -> ([(comparable, a)], result) -> ([(comparable, a)], result))
-> ([(comparable, a)], result)
-> Dict comparable b
-> ([(comparable, a)], result)
forall k v b. (k -> v -> b -> b) -> b -> Dict k v -> b
foldl comparable
-> b -> ([(comparable, a)], result) -> ([(comparable, a)], result)
stepState (Dict comparable a -> [(comparable, a)]
forall k v. Dict k v -> List (k, v)
toList Dict comparable a
leftDict, result
initialResult) Dict comparable b
rightDict
in ((comparable, a) -> result -> result)
-> result -> [(comparable, a)] -> result
forall a b. (a -> b -> b) -> b -> List a -> b
List.foldl (\(comparable
k, a
v) result
result -> comparable -> a -> result -> result
leftStep comparable
k a
v result
result) result
intermediateResult [(comparable, a)]
leftovers
map :: (k -> a -> b) -> Dict k a -> Dict k b
map :: (k -> a -> b) -> Dict k a -> Dict k b
map = (k -> a -> b) -> Dict k a -> Dict k b
forall k a b. (k -> a -> b) -> Map k a -> Map k b
Data.Map.Strict.mapWithKey
foldl :: (k -> v -> b -> b) -> b -> Dict k v -> b
foldl :: (k -> v -> b -> b) -> b -> Dict k v -> b
foldl k -> v -> b -> b
fun =
(b -> k -> v -> b) -> b -> Dict k v -> b
forall a k b. (a -> k -> b -> a) -> a -> Map k b -> a
Data.Map.Strict.foldlWithKey' b -> k -> v -> b
flippedFun
where
flippedFun :: b -> k -> v -> b
flippedFun b
acc k
key v
value = k -> v -> b -> b
fun k
key v
value b
acc
foldr :: (k -> v -> b -> b) -> b -> Dict k v -> b
foldr :: (k -> v -> b -> b) -> b -> Dict k v -> b
foldr = (k -> v -> b -> b) -> b -> Dict k v -> b
forall k v b. (k -> v -> b -> b) -> b -> Dict k v -> b
Data.Map.Strict.foldrWithKey
filter :: (comparable -> v -> Bool) -> Dict comparable v -> Dict comparable v
filter :: (comparable -> v -> Bool) -> Dict comparable v -> Dict comparable v
filter = (comparable -> v -> Bool) -> Dict comparable v -> Dict comparable v
forall k a. (k -> a -> Bool) -> Map k a -> Map k a
Data.Map.Strict.filterWithKey
partition :: (comparable -> v -> Bool) -> Dict comparable v -> (Dict comparable v, Dict comparable v)
partition :: (comparable -> v -> Bool)
-> Dict comparable v -> (Dict comparable v, Dict comparable v)
partition = (comparable -> v -> Bool)
-> Dict comparable v -> (Dict comparable v, Dict comparable v)
forall k a. (k -> a -> Bool) -> Map k a -> (Map k a, Map k a)
Data.Map.Strict.partitionWithKey
keys :: Dict k v -> List k
keys :: Dict k v -> List k
keys = Dict k v -> List k
forall k a. Map k a -> [k]
Data.Map.Strict.keys
values :: Dict k v -> List v
values :: Dict k v -> List v
values = Dict k v -> List v
forall k a. Map k a -> [a]
Data.Map.Strict.elems
toList :: Dict k v -> List (k, v)
toList :: Dict k v -> List (k, v)
toList = Dict k v -> List (k, v)
forall k v. Dict k v -> List (k, v)
Data.Map.Strict.toList
fromList :: Ord comparable => List (comparable, v) -> Dict comparable v
fromList :: List (comparable, v) -> Dict comparable v
fromList = List (comparable, v) -> Dict comparable v
forall k a. Ord k => [(k, a)] -> Map k a
Data.Map.Strict.fromList