Gankra

/home/users/1/abeinges/rust/src/libcollections/bit.rs:925:30: 925:35 error: variable does not need to be mutable, #[deny(unused_mut)] on by default
/home/users/1/abeinges/rust/src/libcollections/bit.rs:925 pub fn from_fn<F>(len: uint, mut f: F) -> Bitv where F: FnMut(uint) -> bool {
                                                                                       ^~~~~
error: aborting due to previous error

Fix that:

/home/users/1/abeinges/rust/src/libcollections/bit.rs:350:25: 350:26 error: cannot borrow immutable local variable `f` as mutable
/home/users/1/abeinges/rust/src/libcollections/bit.rs:350             bitv.set(i, f(i));

Gankra

use std::slice::BinarySearchResult;

pub fn binary_search<F>(targ: &[u32], mut f: F) -> BinarySearchResult
where F: FnMut(&u32) -> Ordering {
    let mut base : uint = 0;
    let mut lim : uint = targ.len();

    while lim != 0 {
        let ix = base + (lim >> 1);
        match f(&targ[ix]) {

Gankra

; ModuleID = 'lib.0.rs'
target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
target triple = "x86_64-unknown-linux-gnu"

%str_slice = type { i8*, i64 }
%"struct.test::Bencher[#8]" = type { i64, %"struct.std::time::duration::Duration[#1]", i64 }
%"struct.std::time::duration::Duration[#1]" = type { i64, i32 }
%"struct.core::fmt::Arguments[#2]" = type { { %str_slice*, i64 }, %"enum.core::option::Option<[\22&\5C'static [core::fmt::rt::v1::Argument]\22]>[#2]", { %"struct.core::fmt::ArgumentV1[#2]"*, i64 } }
%"enum.core::option::Option<[\22&\5C'static [core::fmt::rt::v1::Argument]\22]>[#2]" = type { { %"struct.core::fmt::rt::v1::Argument[#2]"*, i64 } }
%"struct.core::fmt::rt::v1::Argument[#2]" = type { %"enum.core::fmt::rt::v1::Position[#2]", %"struct.core::fmt::rt::v1::FormatSpec[#2]" }

Gankra

/*
    test elem_000001   ... bench:        42 ns/iter (+/- 28)
    test elem_000010   ... bench:        44 ns/iter (+/- 54)
    test elem_000100   ... bench:        54 ns/iter (+/- 9)
    test elem_001000   ... bench:       193 ns/iter (+/- 48)
    test elem_010000   ... bench:     14487 ns/iter (+/- 17706)
    test elem_100000   ... bench:    152159 ns/iter (+/- 46142)
    test iter_000001   ... bench:        42 ns/iter (+/- 14)
    test iter_000010   ... bench:        50 ns/iter (+/- 16)
    test iter_000100   ... bench:       169 ns/iter (+/- 30)

Gankra

/*
    test elem_000001   ... bench:        37 ns/iter (+/- 1)
    test elem_000010   ... bench:        44 ns/iter (+/- 2)
    test elem_000100   ... bench:        66 ns/iter (+/- 2)
    test elem_001000   ... bench:       332 ns/iter (+/- 5)
    test elem_010000   ... bench:     26077 ns/iter (+/- 386)
    test elem_100000   ... bench:    237744 ns/iter (+/- 15692)
    test iter_000001   ... bench:        42 ns/iter (+/- 0)
    test iter_000010   ... bench:        62 ns/iter (+/- 1)

Gankra

diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs
index f4b65aa..56f6182 100644
--- a/src/libcollections/bit.rs
+++ b/src/libcollections/bit.rs
@@ -925,7 +925,7 @@ impl Default for BitVec {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl FromIterator<bool> for BitVec {
     fn from_iter<I: IntoIterator<Item=bool>>(iter: I) -> BitVec {
-        let mut ret = Bitv::new();
+        let mut ret = BitVec::new();

Gankra

diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs
index b6d4289..7bb9f04 100644
--- a/src/test/run-pass/bitv-perf-test.rs
+++ b/src/test/run-pass/bitv-perf-test.rs
@@ -13,11 +13,11 @@
 #![feature(box_syntax)]
 
 extern crate collections;
-use std::collections::Bitv;
+use std::collections::BitVec;

Gankra

struct List<T> {
    head: Option<Box<Node<T>>>
}

struct Node<T> {
    elem: T,
    next: Option<Box<Node<T>>>,
}

impl<T> List<T> {

Gankra

enum-set::rustc --crate-type=lib -Ztime-passes src/lib.rs 
time: 0.003 	parsing
time: 0.001 	configuration 1
time: 0.000 	recursion limit
time: 0.000 	gated macro checking
time: 0.000 	crate injection
time: 0.006 	macro loading
time: 0.000 	plugin loading
time: 0.000 	plugin registration
time: 0.004 	expansion

Gankra

Equivalences

The following groups of types are legitimate to transmute between in repr(rust) (they have the same repr, which is equal to the C repr for structs).

• pointer equivalence:
  • &T
  • &mut T
  • *const T
  • *mut T