README

wqbcs/moon_collections/sortedmap does not have a README file

#
SortedMap

pub struct SortedMap[K, V] {
entries : Array[(K, V)]
fp_cache : UInt64
fp_dirty : Bool
}

impl Eq for SortedMap[K, V]
impl Collection for SortedMap[K, V]
impl Deterministic for SortedMap[K, V]

#
SortedMap::ceil

fn[K : Compare + Eq, V] SortedMap::ceil(self : SortedMap[K, V], key : K) -> (K, V)?

#
SortedMap::clear

fn[K, V] SortedMap::clear(self : SortedMap[K, V]) -> Unit

#
SortedMap::clone

fn[K : Compare + Eq, V] SortedMap::clone(self : SortedMap[K, V]) -> SortedMap[K, V]

#
SortedMap::contains

fn[K : Compare + Eq, V] SortedMap::contains(self : SortedMap[K, V], key : K) -> Bool

#
SortedMap::each

fn[K, V] SortedMap::each(self : SortedMap[K, V], f : (K, V) -> Unit) -> Unit

#
SortedMap::filter

fn[K, V] SortedMap::filter(self : SortedMap[K, V], pred : (K, V) -> Bool) -> SortedMap[K, V]

#
SortedMap::floor

fn[K : Compare + Eq, V] SortedMap::floor(self : SortedMap[K, V], key : K) -> (K, V)?

#
SortedMap::from_array

fn[K : Compare + Eq, V] SortedMap::from_array(pairs : Array[(K, V)]) -> SortedMap[K, V]

#
SortedMap::from_sorted_entries

fn[K, V] SortedMap::from_sorted_entries(entries : Array[(K, V)]) -> SortedMap[K, V]

#
SortedMap::get

fn[K : Compare + Eq, V] SortedMap::get(self : SortedMap[K, V], key : K) -> V?

#
SortedMap::get_or_insert

fn[K : Compare + Eq, V] SortedMap::get_or_insert(self : SortedMap[K, V], key : K, default : V) -> V

#
SortedMap::get_or_insert_with

fn[K : Compare + Eq, V] SortedMap::get_or_insert_with(self : SortedMap[K, V], key : K, default_fn : () -> V) -> V

#
SortedMap::insert

fn[K : Compare + Eq, V] SortedMap::insert(self : SortedMap[K, V], key : K, value : V) -> V?

#
SortedMap::is_empty

fn[K, V] SortedMap::is_empty(self : SortedMap[K, V]) -> Bool

#
SortedMap::iter

fn[K, V] SortedMap::iter(self : SortedMap[K, V]) -> Iter[(K, V)]

#
SortedMap::keys

fn[K, V] SortedMap::keys(self : SortedMap[K, V]) -> Iter[K]

#
SortedMap::keys_array

fn[K, V] SortedMap::keys_array(self : SortedMap[K, V]) -> Array[K]

#
SortedMap::len

fn[K, V] SortedMap::len(self : SortedMap[K, V]) -> Int

#
SortedMap::lower_bound

fn[K : Compare + Eq, V] SortedMap::lower_bound(self : SortedMap[K, V], key : K) -> (K, V)?

#
SortedMap::map_values

fn[K, V, R] SortedMap::map_values(self : SortedMap[K, V], f : (V) -> R) -> SortedMap[K, R]

#
SortedMap::max_key

fn[K, V] SortedMap::max_key(self : SortedMap[K, V]) -> K?

#
SortedMap::merge

fn[K : Compare + Eq, V] SortedMap::merge(self : SortedMap[K, V], other : SortedMap[K, V], resolve : (V, V) -> V) -> SortedMap[K, V]

#
SortedMap::min_key

fn[K, V] SortedMap::min_key(self : SortedMap[K, V]) -> K?

#
SortedMap::new

fn[K, V] SortedMap::new() -> SortedMap[K, V]

#
SortedMap::range

fn[K : Compare + Eq, V] SortedMap::range(self : SortedMap[K, V], from : K, to : K) -> Array[(K, V)]

#
SortedMap::remove

fn[K : Compare + Eq, V] SortedMap::remove(self : SortedMap[K, V], key : K) -> V?

#
SortedMap::retain

fn[K, V] SortedMap::retain(self : SortedMap[K, V], pred : (K, V) -> Bool) -> Unit

#
SortedMap::to_array

fn[K, V] SortedMap::to_array(self : SortedMap[K, V]) -> Array[(K, V)]

#
SortedMap::update

fn[K : Compare + Eq, V] SortedMap::update(self : SortedMap[K, V], key : K, f : (V) -> V) -> Bool

#
SortedMap::upper_bound

fn[K : Compare + Eq, V] SortedMap::upper_bound(self : SortedMap[K, V], key : K) -> (K, V)?

#
SortedMap::values

fn[K, V] SortedMap::values(self : SortedMap[K, V]) -> Iter[V]

#
SortedMap::values_array

fn[K, V] SortedMap::values_array(self : SortedMap[K, V]) -> Array[V]

Source Files