Sign in

    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