#[stable(feature = "rust1", since = "1.0.0")]
impl<T> Index<usize> for Vec<T> {
    type Output = T;

    #[inline]
    fn index(&self, index: usize) -> &T {
        // NB built-in indexing via `&[T]`
        &(**self)[index]
    }
}

fn when_all<T: Any, K: Error>(results: &[Result<T, K>]) -> Result<&[T], K>

Promise.all([async(), async2(), async3()]).then((async1, async2, async3) => ...).catch((error) => ....)

impl<S> Index<usize> for BitVector<S>
    where S: Sized + BitAnd<usize> + Not + Eq {
    type Output = bool;

    fn index(&self, index: usize) -> &bool {
        let data_index = index / (std::mem::size_of::<S>() * 8);
        let remainder = index % (std::mem::size_of::<S>() * 8);
        (self.data[data_index] & (1 << remainder) != 0)
    }
}

struct BitVector<S = usize>
    where S: Sized + BitAnd<usize> + Not + Eq {
    data: Vec<S>,
    capacity: usize
}

(self.data[data_index] & (1 << remainder) != 0)

fn bitand(self, rhs: RHS) -> Self::Output

fn main() {
  let size: usize = 5;
  let num: i32 = 0;

  println!("{}", size != num);
}

((self.data[data_index] & (1 << remainder)) as i32 != 0)

    impl<S> Index<usize> for BitVector<S>
        where S: Sized + BitAnd<S> + Shl<usize> + Not + Eq {
        type Output = bool;

        fn index(&self, index: usize) -> &bool {
            let data_index = index / (std::mem::size_of::<S>() * 8);
            let remainder = index % (std::mem::size_of::<S>() * 8);
            (self.data[data_index] & (((1 as S) << remainder) as S)) != 0
        }
    }

struct Circle {
    x: Option<f32>
}

impl Circle {
    fn take_ownership(self) {

    }
}

fn main() {
    let circle = Circle { x: Option::None };
    circle.take_ownership();

    println!("{:?}", circle.x);
}

struct Point {
    x: f32,
    y: f32,
    z: f32
}

struct Player<'a> {
    // Ouch!
    position: &'a mut Point
}

fn main() {
    let mut position = Point {
        x: 0.0,
        y: 0.0,
        z: 0.0
    };

    let player = Player {
        position: &mut position
    };
}

    struct Player {
        position: Point
    }

     struct Player<'a> {
        position: &'a Point
     }

mod tests {
    use super::*;

    fn test_with_capacity() {

struct Foo;

mod tests {
  fn test() {
    super::Foo
  }
}

trait Item {}

trait ItemContainer {
    fn has_item<T: Item>(&self, item: &T) -> bool;
}

struct Inventory<'a> {
    items: Vec<&'a Item>
}

impl <'a> ItemContainer for Inventory<'a> {
    fn has_item<T: Item>(&self, item: &T) -> bool {
        false
    }
}

#[derive(Debug)]
struct InventoryItem {}
impl Item for InventoryItem {}

fn main() {
    let item = InventoryItem {};
    {
        let container = Inventory {
            items: vec![]
        };
        assert!(!container.has_item(&item));

static TRUE: bool = true;
static FALSE: bool = false;

macro_rules! bool_ref {
    ($cond:expr) => ({
        if $cond { &TRUE } else { &FALSE }
    })
}

macro_rules! bool_ref {
    ($cond:expr) => (if $cond { &TRUE } else { &FALSE })
}

impl PartialEq for Item {
    fn eq(&self, other: &Item) -> bool {
        let Item(other_id) = *other;
        let Item(my_id) = *self;

        other_id == my_id
    }
}

mod inventory;

use inventory::Inventory;

fn main() {
    let inventory  = Inventory {};

}