apasel422 / eclectic Goto Github PK

pub trait EntryMap: Map {
    type Occupied<'a>: Occupied<'a = 'a, Key = Self::Key, Value = Self::Value>;
    type Vacant<'a>: Vacant<'a = 'a, Key = Self::Key, Value = Self::Value>;

    fn entry<'a>(&'a mut self, key: Self::Key)
        -> Entry<Self::Occupied<'a>, Self::Vacant<'a>>;
}

pub enum Entry<O, V>
where
    O: Occupied,
    V: Vacant<'a = O::'a, Key = O::Key, Value = O::Value>,
{
    Occupied(O),
    Vacant(V),
}

pub trait Occupied {
    lifetime 'a;
    type Key: Self::'a;
    type Value: Self::'a;

    fn into_mut(self) -> &Self::'a mut Self::Value;
    // ...
}

pub trait Vacant {
    lifetime 'a;
    type Key: Self::'a;
    type Value: Self::'a;

    fn insert(self, value: Self::Value) -> &Self::'a mut Self::Value;
    // ...
}

    extern crate eclectic;

    use eclectic::*;
    use std::hash::Hash;

    pub fn categorize<'a, D, B, F, O, M>(data: D, mut f: F) where
        D: IntoIterator + Sized,
        B: Default + Extend<D::Item> + 'static,
        F: FnMut(&D::Item) -> O,
        O: Hash + Eq,
        M: EntryMap<Key=O, Value=B> + Default,
    {
        let map = M::default();
        for x in data {
            match map.entry(f(&x)) {
                Entry::Vacant(v) => v.insert(B::default()),
                Entry::Occupied(o) => o.into_mut(),
            }.extend(Some(x));
        }
        map
    }

fn is_random_access(&self) -> bool;

struct Node<T: ?Sized> {
    left: Option<Box<Node<T>>>,
    right: Option<Box<Node<T>>>,
    item: T,
}

pub struct Heap<T: ?Sized> {
    root: Option<Box<Node<T>>>,
}