#root::data

Map root/data/Map.vi

struct Map[K, V](...);

impl

impl [K, V; Fork[K], Fork[V]]: Fork[Map[K, V]];
impl [K, V; Drop[K], Drop[V]]: Drop[Map[K, V]];
impl [K, V; Fork[K], Fork[V]]: Fork[Map[K, V]];
impl [K, V; Drop[K], Drop[V]]: Drop[Map[K, V]];
impl [K, V; Ord[K], Drop[K], Drop[V]]: Concat[Map[K, V], Map[K, V], Map[K, V]];
impl [K, V; Drop[K], Drop[V], Ord[K]]: Collect[Map[K, V], (K, V)];
impl [K, V; Ord[K], Show[K], Show[V]]: Show[Map[K, V]];

empty root/data/Map.vi:22

const empty[K, V]: Map[K, V];

from_list root/data/Map.vi:24

impl from_list[K, V; Ord[K], Drop[K], Drop[V]]: Cast[List[(K, V)], Map[K, V]];

clear root/data/Map.vi:30

fn clear[K, V; Ord[K], Drop[K], Drop[V]](self: &Map[K, V]);

len root/data/Map.vi:34

fn len[K, V](self: &Map[K, V]) -> N32;

insert root/data/Map.vi:38

fn insert[K, V; Ord[K], Drop[K]](self: &Map[K, V], key: K, value: V) -> Option[V];

has root/data/Map.vi:48

fn has[K, V; Ord[K]](self: &Map[K, V], key: &K) -> Bool;

at root/data/Map.vi:52

fn at[K, V; Ord[K]](self: &Map[K, V], key: &K) -> Option[&V];

get root/data/Map.vi:56

fn get[K, V; Ord[K], Fork[V]](self: &Map[K, V], key: &K) -> Option[V];

at_or_insert root/data/Map.vi:60

fn at_or_insert[K, V; Ord[K], Drop[K], Drop[V]](self: &Map[K, V], key: K, value: V) -> &V;

get_or_insert root/data/Map.vi:69

fn get_or_insert[K, V; Ord[K], Drop[K], Fork[V], Drop[V]](self: &Map[K, V], key: K, value: V) -> V;

at_le root/data/Map.vi:73

fn at_le[K, V; Ord[K]](self: &Map[K, V], key: &K) -> Option[&(K, V)];

get_le root/data/Map.vi:77

fn get_le[K, V; Ord[K], Fork[K], Fork[V]](self: &Map[K, V], key: &K) -> Option[(K, V)];

at_ge root/data/Map.vi:81

fn at_ge[K, V; Ord[K]](self: &Map[K, V], key: &K) -> Option[&(K, V)];

get_ge root/data/Map.vi:85

fn get_ge[K, V; Ord[K], Fork[K], Fork[V]](self: &Map[K, V], key: &K) -> Option[(K, V)];

remove root/data/Map.vi:89

fn remove[K, V; Ord[K], Drop[K]](self: &Map[K, V], key: &K) -> Option[V];

remove_min root/data/Map.vi:93

fn remove_min[K, V; Ord[K]](self: &Map[K, V]) -> Option[(K, V)];

remove_max root/data/Map.vi:97

fn remove_max[K, V; Ord[K]](self: &Map[K, V]) -> Option[(K, V)];

map_values root/data/Map.vi:101

fn map_values[K, V, U, F; Ord[K], Fork[F], Drop[F], Fn[F, (&K, V), U]](self: Map[K, V], f: F) -> Map[K, U];

iter_ref root/data/Map.vi:111

impl iter_ref[K, V; Ord[K]]: Cast[&Map[K, V], IterRef[K, V]];

IterRef root/data/Map.vi:117

struct IterRef[K, V](...);

iter root/data/Map.vi:130

impl iter[K, V; Ord[K]]: Cast[Map[K, V], Iter[K, V]];

Iter root/data/Map.vi:136

struct Iter[K, V](...);

keys root/data/Map.vi:146

fn keys[K, V; Ord[K]](self: &Map[K, V]) -> Map[IterRef[K, V], Key];

Key root/data/Map.vi:150

struct Key(...);

values root/data/Map.vi:160

fn values[K, V; Ord[K]](self: &Map[K, V]) -> Map[IterRef[K, V], Value];

Value root/data/Map.vi:164

struct Value(...);

to_list root/data/Map.vi:180

impl to_list[K, V; Ord[K]]: Cast[Map[K, V], List[(K, V)]];

balanced root/data/Map.vi:197

fn balanced[K, V; Ord[K]](self: &Map[K, V]) -> Bool;