modification of the container through another handle.
~~~
-let mut xs = [1, 2, 3];
+let mut xs = [1i, 2, 3];
{
let _it = xs.iter();
into a single value:
~~~
-let xs = [1, 9, 2, 3, 14, 12];
+let xs = [1i, 9, 2, 3, 14, 12];
let result = xs.iter().fold(0, |accumulator, item| accumulator - *item);
assert_eq!(result, -41);
~~~
Most adaptors return an adaptor object implementing the `Iterator` trait itself:
~~~
-let xs = [1, 9, 2, 3, 14, 12];
-let ys = [5, 2, 1, 8];
+let xs = [1i, 9, 2, 3, 14, 12];
+let ys = [5i, 2, 1, 8];
let sum = xs.iter().chain(ys.iter()).fold(0, |a, b| a + *b);
assert_eq!(sum, 57);
~~~
never call its underlying iterator again once `None` has been returned:
~~~
-let xs = [1,2,3,4,5];
-let mut calls = 0;
+let xs = [1i,2,3,4,5];
+let mut calls = 0i;
{
let it = xs.iter().scan((), |_, x| {
The function `range` (or `range_inclusive`) allows to simply iterate through a given range:
~~~
-for i in range(0, 5) {
+for i in range(0i, 5) {
print!("{} ", i) // prints "0 1 2 3 4"
}
-for i in std::iter::range_inclusive(0, 5) { // needs explicit import
+for i in std::iter::range_inclusive(0i, 5) { // needs explicit import
print!("{} ", i) // prints "0 1 2 3 4 5"
}
~~~
also advance the state of an iterator in a mutable location:
~~~
-let xs = [1, 2, 3, 4, 5];
+let xs = [1i, 2, 3, 4, 5];
let ys = ["foo", "bar", "baz", "foobar"];
// create an iterator yielding tuples of elements from both vectors
Iterators offer generic conversion to containers with the `collect` adaptor:
~~~
-let xs = [0, 1, 1, 2, 3, 5, 8];
+let xs = [0i, 1, 1, 2, 3, 5, 8];
let ys = xs.iter().rev().skip(1).map(|&x| x * 2).collect::<Vec<int>>();
assert_eq!(ys, vec![10, 6, 4, 2, 2, 0]);
~~~
returning another `DoubleEndedIterator` with `next` and `next_back` exchanged.
~~~
-let xs = [1, 2, 3, 4, 5, 6];
+let xs = [1i, 2, 3, 4, 5, 6];
let mut it = xs.iter();
println!("{}", it.next()); // prints `Some(1)`
println!("{}", it.next()); // prints `Some(2)`
`DoubleEndedIterator` implementations if the underlying iterators are.
~~~
-let xs = [1, 2, 3, 4];
-let ys = [5, 6, 7, 8];
+let xs = [1i, 2, 3, 4];
+let ys = [5i, 6, 7, 8];
let mut it = xs.iter().chain(ys.iter()).map(|&x| x * 2);
println!("{}", it.next()); // prints `Some(2)`
the trailing underscore is a workaround for issue #5898 and will be removed.
~~~
-let mut ys = [1, 2, 3, 4, 5];
+let mut ys = [1i, 2, 3, 4, 5];
ys.mut_iter().reverse_();
-assert!(ys == [5, 4, 3, 2, 1]);
+assert!(ys == [5i, 4, 3, 2, 1]);
~~~
## Random-access iterators
underlying iterators are.
~~~
-let xs = [1, 2, 3, 4, 5];
-let ys = [7, 9, 11];
+let xs = [1i, 2, 3, 4, 5];
+let ys = [7i, 9, 11];
let mut it = xs.iter().chain(ys.iter());
println!("{}", it.idx(0)); // prints `Some(1)`
println!("{}", it.idx(5)); // prints `Some(7)`
Named lifetime notation can also be used to control the flow of execution:
~~~
-'h: for i in range(0,10) {
+'h: for i in range(0u, 10) {
'g: loop {
if i % 2 == 0 { continue 'h; }
if i == 9 { break 'h; }
~~~rust
fn main() {
- let mut x = box 5;
+ let mut x = box 5i;
if *x < 10 {
let y = &x;
println!("Oh no: {}", y);
~~~rust{.ignore}
fn main() {
- let mut x = box 5;
+ let mut x = box 5i;
if *x < 10 {
let y = &x;
*x -= 1;
#[bench]
fn bench_xor_1000_ints(b: &mut Bencher) {
b.iter(|| {
- range(0, 1000).fold(0, |old, new| old ^ new);
+ range(0u, 1000).fold(0, |old, new| old ^ new);
});
}
~~~
# struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;
b.iter(|| {
// note lack of `;` (could also use an explicit `return`).
- range(0, 1000).fold(0, |old, new| old ^ new)
+ range(0u, 1000).fold(0, |old, new| old ^ new)
});
~~~
# fn main() {
# struct X; impl X { fn iter<T>(&self, _: || -> T) {} } let b = X;
b.iter(|| {
- test::black_box(range(0, 1000).fold(0, |old, new| old ^ new));
+ test::black_box(range(0u, 1000).fold(0, |old, new| old ^ new));
});
# }
~~~
```
fn main() {
- let numbers = vec![1,2,3];
+ let numbers = vec![1i, 2i, 3i];
let (tx, rx) = channel();
tx.send(numbers);
```ignore
fn main() {
- let numbers = vec![1,2,3];
+ let numbers = vec![1i, 2i, 3i];
let (tx, rx) = channel();
tx.send(numbers);
```
fn main() {
- let numbers = vec![1,2,3];
+ let numbers = vec![1i, 2i, 3i];
- for num in range(0, 3) {
+ for num in range(0u, 3) {
let (tx, rx) = channel();
// Use `clone` to send a *copy* of the array
tx.send(numbers.clone());
use std::sync::Arc;
fn main() {
- let numbers = vec![1,2,3];
+ let numbers = vec![1i, 2i, 3i];
let numbers = Arc::new(numbers);
- for num in range(0, 3) {
+ for num in range(0u, 3) {
let (tx, rx) = channel();
tx.send(numbers.clone());
use std::sync::{Arc, Mutex};
fn main() {
- let numbers = vec![1,2,3];
+ let numbers = vec![1i, 2i, 3i];
let numbers_lock = Arc::new(Mutex::new(numbers));
- for num in range(0, 3) {
+ for num in range(0u, 3) {
let (tx, rx) = channel();
tx.send(numbers_lock.clone());
# fn foo<T>(_: T){}
fn main() {
- // Equivalent to 'std::iter::range_step(0, 10, 2);'
- range_step(0, 10, 2);
+ // Equivalent to 'std::iter::range_step(0u, 10u, 2u);'
+ range_step(0u, 10u, 2u);
- // Equivalent to 'foo(vec![std::option::Some(1.0), std::option::None]);'
- foo(vec![Some(1.0), None]);
+ // Equivalent to 'foo(vec![std::option::Some(1.0f64),
+ // std::option::None]);'
+ foo(vec![Some(1.0f64), None]);
}
~~~~
~~~~
# trait Shape { }
# impl Shape for int { }
-# let mycircle = 0;
+# let mycircle = 0i;
let myshape: Box<Shape> = box mycircle as Box<Shape>;
~~~~
An example of creating and calling a closure:
```rust
-let captured_var = 10;
+let captured_var = 10i;
let closure_no_args = || println!("captured_var={}", captured_var);
}
fn main() {
- print(box 10 as Box<Printable>);
+ print(box 10
i as Box<Printable>);
}
~~~~
~~~~
let hi = "hi";
-let mut count = 0;
+let mut count = 0i;
while count < 10 {
println!("count is {}", count);
~~~
// `{}` will print the "default format" of a type
-println!("{} is {}", "the answer", 43);
+println!("{} is {}", "the answer", 43i);
~~~
~~~~
example:
~~~~
-# let age = 23;
+# let age = 23i;
match age {
a @ 0..20 => println!("{} years old", a),
_ => println!("older than 21")
There is also a for-loop that can be used to iterate over a range of numbers:
~~~~
-for n in range(0, 5) {
+for n in range(0u, 5) {
println!("{}", n);
}
~~~~
Avoiding a move can be done with the library-defined `clone` method:
~~~~
-let x = box 5;
+let x = box 5i;
let y = x.clone(); // `y` is a newly allocated box
let z = x; // no new memory allocated, `x` can no longer be used
~~~~
}
}
-let xs = Cons(5, box Cons(10, box Nil));
-let ys = Cons(5, box Cons(10, box Nil));
+let xs = Cons(5i, box Cons(10i, box Nil));
+let ys = Cons(5i, box Cons(10i, box Nil));
// The methods below are part of the PartialEq trait,
// which we implemented on our linked list.
assert!(xs.eq(&ys));
~~~
// A fixed-size vector
-let numbers = [1, 2, 3];
+let numbers = [1i, 2, 3];
let more_numbers = numbers;
// The type of a fixed-size vector is written as `[Type, ..length]`
use std::string::String;
// A dynamically sized vector (unique vector)
-let mut numbers = vec![1, 2, 3];
+let mut numbers = vec![1i, 2, 3];
numbers.push(4);
numbers.push(5);
use std::rc::Rc;
// A fixed-size array allocated in a reference-counted box
-let x = Rc::new([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+let x = Rc::new([1i, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
let y = x.clone(); // a new owner
let z = x; // this moves `x` into `z`, rather than creating a new owner
-assert!(*z == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+assert!(*z == [1i, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
// the variable is mutable, but not the contents of the box
let mut a = Rc::new([10, 9, 8, 7, 6, 5, 4, 3, 2, 1]);
use std::gc::GC;
// A fixed-size array allocated in a garbage-collected box
-let x = box(GC) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+let x = box(GC) [1i, 2, 3, 4, 5, 6, 7, 8, 9, 10];
let y = x; // does not perform a move, unlike with `Rc`
let z = x;
-assert!(*z == [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+assert!(*z == [1i, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
~~~
With shared ownership, mutability cannot be inherited so the boxes are always immutable. However,
fn main() {
// The rational number '1/2':
- let one_half = ::num::rational::Ratio::new(1, 2);
+ let one_half = ::num::rational::Ratio::new(1i, 2);
}
~~~
fn main() {
farm::dog();
- let a_third = Ratio::new(1, 3);
+ let a_third = Ratio::new(1i, 3);
}
~~~
fn main() {
// `range` is imported by default
- for _ in range(0, 10) {}
+ for _ in range(0u, 10) {}
// Doesn't hinder you from importing it under a different name yourself
- for _ in iter_range(0, 10) {}
+ for _ in iter_range(0u, 10) {}
// Or from not using the automatic import.
- for _ in ::std::iter::range(0, 10) {}
+ for _ in ::std::iter::range(0u, 10) {}
}
~~~
/// let numbers = Vec::from_fn(100, |i| i as f32);
/// let shared_numbers = Arc::new(numbers);
///
-/// for _ in range(0, 10) {
+/// for _ in range(0u, 10) {
/// let child_numbers = shared_numbers.clone();
///
/// spawn(proc() {
#[test]
fn test_clone() {
- let x = Rc::new(RefCell::new(5));
+ let x = Rc::new(RefCell::new(5i));
let y = x.clone();
*x.borrow_mut() = 20;
assert_eq!(*y.borrow(), 20);
#[test]
fn test_simple() {
- let x = Rc::new(5);
+ let x = Rc::new(5i);
assert_eq!(*x, 5);
}
#[test]
fn test_simple_clone() {
- let x = Rc::new(5);
+ let x = Rc::new(5i);
let y = x.clone();
assert_eq!(*x, 5);
assert_eq!(*y, 5);
#[test]
fn test_destructor() {
- let x = Rc::new(box 5);
+ let x = Rc::new(box 5i);
assert_eq!(**x, 5);
}
#[test]
fn test_live() {
- let x = Rc::new(5);
+ let x = Rc::new(5i);
let y = x.downgrade();
assert!(y.upgrade().is_some());
}
#[test]
fn test_dead() {
- let x = Rc::new(5);
+ let x = Rc::new(5i);
let y = x.downgrade();
drop(x);
assert!(y.upgrade().is_none());
fn gc_inside() {
// see issue #11532
use std::gc::GC;
- let a = Rc::new(RefCell::new(box(GC) 1));
+ let a = Rc::new(RefCell::new(box(GC) 1i));
assert!(a.try_borrow_mut().is_some());
}
#[test]
pub fn test_copy() {
let arena = TypedArena::new();
- for _ in range(0, 100000) {
+ for _ in range(0u, 100000) {
arena.alloc(Point {
x: 1,
y: 2,
#[test]
pub fn test_noncopy() {
let arena = TypedArena::new();
- for _ in range(0, 100000) {
+ for _ in range(0u, 100000) {
arena.alloc(Noncopy {
string: "hello world".to_string(),
array: vec!( 1, 2, 3, 4, 5 ),
impl fmt::Show for Bitv {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
for bit in self.iter() {
- try!(write!(fmt, "{}", if bit { 1 } else { 0 }));
+ try!(write!(fmt, "{}", if bit { 1u } else { 0u }));
}
Ok(())
}
//Tests the functionality of the insert methods (which are unfinished).
#[test]
fn insert_test_one() {
- let b = BTree::new(1, "abc".to_string(), 2);
- let is_insert = b.insert(2, "xyz".to_string());
+ let b = BTree::new(1i, "abc".to_string(), 2);
+ let is_insert = b.insert(2i, "xyz".to_string());
//println!("{}", is_insert.clone().to_str());
assert!(is_insert.root.is_leaf());
}
#[test]
fn insert_test_two() {
- let leaf_elt_1 = LeafElt::new(1, "aaa".to_string());
- let leaf_elt_2 = LeafElt::new(2, "bbb".to_string());
- let leaf_elt_3 = LeafElt::new(3, "ccc".to_string());
+ let leaf_elt_1 = LeafElt::new(1i, "aaa".to_string());
+ let leaf_elt_2 = LeafElt::new(2i, "bbb".to_string());
+ let leaf_elt_3 = LeafElt::new(3i, "ccc".to_string());
let n = Node::new_leaf(vec!(leaf_elt_1, leaf_elt_2, leaf_elt_3));
let b = BTree::new_with_node_len(n, 3, 2);
//println!("{}", b.clone().insert(4, "ddd".to_string()).to_str());
#[test]
fn insert_test_three() {
- let leaf_elt_1 = LeafElt::new(1, "aaa".to_string());
- let leaf_elt_2 = LeafElt::new(2, "bbb".to_string());
- let leaf_elt_3 = LeafElt::new(3, "ccc".to_string());
- let leaf_elt_4 = LeafElt::new(4, "ddd".to_string());
+ let leaf_elt_1 = LeafElt::new(1i, "aaa".to_string());
+ let leaf_elt_2 = LeafElt::new(2i, "bbb".to_string());
+ let leaf_elt_3 = LeafElt::new(3i, "ccc".to_string());
+ let leaf_elt_4 = LeafElt::new(4i, "ddd".to_string());
let n = Node::new_leaf(vec!(leaf_elt_1, leaf_elt_2, leaf_elt_3, leaf_elt_4));
let b = BTree::new_with_node_len(n, 3, 2);
//println!("{}", b.clone().insert(5, "eee".to_string()).to_str());
#[test]
fn insert_test_four() {
- let leaf_elt_1 = LeafElt::new(1, "aaa".to_string());
- let leaf_elt_2 = LeafElt::new(2, "bbb".to_string());
- let leaf_elt_3 = LeafElt::new(3, "ccc".to_string());
- let leaf_elt_4 = LeafElt::new(4, "ddd".to_string());
+ let leaf_elt_1 = LeafElt::new(1i, "aaa".to_string());
+ let leaf_elt_2 = LeafElt::new(2i, "bbb".to_string());
+ let leaf_elt_3 = LeafElt::new(3i, "ccc".to_string());
+ let leaf_elt_4 = LeafElt::new(4i, "ddd".to_string());
let n = Node::new_leaf(vec!(leaf_elt_1, leaf_elt_2, leaf_elt_3, leaf_elt_4));
let mut b = BTree::new_with_node_len(n, 3, 2);
b = b.clone().insert(5, "eee".to_string());
#[test]
fn bsearch_test_one() {
- let b = BTree::new(1, "abc".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2u);
assert_eq!(Some(1), b.root.bsearch_node(2));
}
#[test]
fn bsearch_test_two() {
- let b = BTree::new(1, "abc".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2u);
assert_eq!(Some(0), b.root.bsearch_node(0));
}
#[test]
fn bsearch_test_three() {
- let leaf_elt_1 = LeafElt::new(1, "aaa".to_string());
- let leaf_elt_2 = LeafElt::new(2, "bbb".to_string());
- let leaf_elt_3 = LeafElt::new(4, "ccc".to_string());
- let leaf_elt_4 = LeafElt::new(5, "ddd".to_string());
+ let leaf_elt_1 = LeafElt::new(1i, "aaa".to_string());
+ let leaf_elt_2 = LeafElt::new(2i, "bbb".to_string());
+ let leaf_elt_3 = LeafElt::new(4i, "ccc".to_string());
+ let leaf_elt_4 = LeafElt::new(5i, "ddd".to_string());
let n = Node::new_leaf(vec!(leaf_elt_1, leaf_elt_2, leaf_elt_3, leaf_elt_4));
let b = BTree::new_with_node_len(n, 3, 2);
assert_eq!(Some(2), b.root.bsearch_node(3));
#[test]
fn bsearch_test_four() {
- let leaf_elt_1 = LeafElt::new(1, "aaa".to_string());
- let leaf_elt_2 = LeafElt::new(2, "bbb".to_string());
- let leaf_elt_3 = LeafElt::new(4, "ccc".to_string());
- let leaf_elt_4 = LeafElt::new(5, "ddd".to_string());
+ let leaf_elt_1 = LeafElt::new(1i, "aaa".to_string());
+ let leaf_elt_2 = LeafElt::new(2i, "bbb".to_string());
+ let leaf_elt_3 = LeafElt::new(4i, "ccc".to_string());
+ let leaf_elt_4 = LeafElt::new(5i, "ddd".to_string());
let n = Node::new_leaf(vec!(leaf_elt_1, leaf_elt_2, leaf_elt_3, leaf_elt_4));
let b = BTree::new_with_node_len(n, 3, 2);
assert_eq!(Some(4), b.root.bsearch_node(800));
//Tests the functionality of the get method.
#[test]
fn get_test() {
- let b = BTree::new(1, "abc".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2);
let val = b.get(1);
assert_eq!(val, Some("abc".to_string()));
}
//Tests the BTree's clone() method.
#[test]
fn btree_clone_test() {
- let b = BTree::new(1, "abc".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2);
let b2 = b.clone();
assert!(b.root == b2.root)
}
//Tests the BTree's cmp() method when one node is "less than" another.
#[test]
fn btree_cmp_test_less() {
- let b = BTree::new(1, "abc".to_string(), 2);
- let b2 = BTree::new(2, "bcd".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2);
+ let b2 = BTree::new(2i, "bcd".to_string(), 2);
assert!(&b.cmp(&b2) == &Less)
}
//Tests the BTree's cmp() method when two nodes are equal.
#[test]
fn btree_cmp_test_eq() {
- let b = BTree::new(1, "abc".to_string(), 2);
- let b2 = BTree::new(1, "bcd".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2);
+ let b2 = BTree::new(1i, "bcd".to_string(), 2);
assert!(&b.cmp(&b2) == &Equal)
}
//Tests the BTree's cmp() method when one node is "greater than" another.
#[test]
fn btree_cmp_test_greater() {
- let b = BTree::new(1, "abc".to_string(), 2);
- let b2 = BTree::new(2, "bcd".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2);
+ let b2 = BTree::new(2i, "bcd".to_string(), 2);
assert!(&b2.cmp(&b) == &Greater)
}
//Tests the BTree's to_str() method.
#[test]
fn btree_tostr_test() {
- let b = BTree::new(1, "abc".to_string(), 2);
+ let b = BTree::new(1i, "abc".to_string(), 2);
assert_eq!(b.to_str(), "Key: 1, value: abc;".to_string())
}
assert_eq!(m.pop_front(), Some(box 1));
let mut n = DList::new();
- n.push_front(2);
+ n.push_front(2i);
n.push_front(3);
{
assert_eq!(n.front().unwrap(), &3);
#[cfg(test)]
fn generate_test() -> DList<int> {
- list_from(&[0,1,2,3,4,5,6])
+ list_from(&[0i,1,2,3,4,5,6])
}
#[cfg(test)]
{
let mut m = DList::new();
let mut n = DList::new();
- n.push_back(2);
+ n.push_back(2i);
m.append(n);
assert_eq!(m.len(), 1);
assert_eq!(m.pop_back(), Some(2));
{
let mut m = DList::new();
let n = DList::new();
- m.push_back(2);
+ m.push_back(2i);
m.append(n);
assert_eq!(m.len(), 1);
assert_eq!(m.pop_back(), Some(2));
check_links(&m);
}
- let v = vec![1,2,3,4,5];
- let u = vec![9,8,1,2,3,4,5];
+ let v = vec![1i,2,3,4,5];
+ let u = vec![9i,8,1,2,3,4,5];
let mut m = list_from(v.as_slice());
m.append(list_from(u.as_slice()));
check_links(&m);
{
let mut m = DList::new();
let mut n = DList::new();
- n.push_back(2);
+ n.push_back(2i);
m.prepend(n);
assert_eq!(m.len(), 1);
assert_eq!(m.pop_back(), Some(2));
check_links(&m);
}
- let v = vec![1,2,3,4,5];
- let u = vec![9,8,1,2,3,4,5];
+ let v = vec![1i,2,3,4,5];
+ let u = vec![9i,8,1,2,3,4,5];
let mut m = list_from(v.as_slice());
m.prepend(list_from(u.as_slice()));
check_links(&m);
n.rotate_forward(); check_links(&n);
assert_eq!(n.len(), 0);
- let v = vec![1,2,3,4,5];
+ let v = vec![1i,2,3,4,5];
let mut m = list_from(v.as_slice());
m.rotate_backward(); check_links(&m);
m.rotate_forward(); check_links(&m);
m.rotate_backward(); check_links(&m);
m.push_front(9); check_links(&m);
m.rotate_forward(); check_links(&m);
- assert_eq!(vec![3,9,5,1,2], m.move_iter().collect());
+ assert_eq!(vec![3i,9,5,1,2], m.move_iter().collect());
}
#[test]
}
let mut n = DList::new();
assert_eq!(n.iter().next(), None);
- n.push_front(4);
+ n.push_front(4i);
let mut it = n.iter();
assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(it.next().unwrap(), &4);
#[test]
fn test_iterator_clone() {
let mut n = DList::new();
- n.push_back(2);
+ n.push_back(2i);
n.push_back(3);
n.push_back(4);
let mut it = n.iter();
fn test_iterator_double_end() {
let mut n = DList::new();
assert_eq!(n.iter().next(), None);
- n.push_front(4);
+ n.push_front(4i);
n.push_front(5);
n.push_front(6);
let mut it = n.iter();
}
let mut n = DList::new();
assert_eq!(n.iter().rev().next(), None);
- n.push_front(4);
+ n.push_front(4i);
let mut it = n.iter().rev();
assert_eq!(it.size_hint(), (1, Some(1)));
assert_eq!(it.next().unwrap(), &4);
assert_eq!(len, 0);
let mut n = DList::new();
assert!(n.mut_iter().next().is_none());
- n.push_front(4);
+ n.push_front(4i);
n.push_back(5);
let mut it = n.mut_iter();
assert_eq!(it.size_hint(), (2, Some(2)));
fn test_iterator_mut_double_end() {
let mut n = DList::new();
assert!(n.mut_iter().next_back().is_none());
- n.push_front(4);
+ n.push_front(4i);
n.push_front(5);
n.push_front(6);
let mut it = n.mut_iter();
#[test]
fn test_insert_prev() {
- let mut m = list_from(&[0,2,4,6,8]);
+ let mut m = list_from(&[0i,2,4,6,8]);
let len = m.len();
{
let mut it = m.mut_iter();
#[test]
fn test_merge() {
- let mut m = list_from([0, 1, 3, 5, 6, 7, 2]);
- let n = list_from([-1, 0, 0, 7, 7, 9]);
+ let mut m = list_from([0i, 1, 3, 5, 6, 7, 2]);
+ let n = list_from([-1i, 0, 0, 7, 7, 9]);
let len = m.len() + n.len();
m.merge(n, |a, b| a <= b);
assert_eq!(m.len(), len);
#[test]
fn test_insert_ordered() {
let mut n = DList::new();
- n.insert_ordered(1);
+ n.insert_ordered(1i);
assert_eq!(n.len(), 1);
assert_eq!(n.pop_front(), Some(1));
let mut m = DList::new();
- m.push_back(2);
+ m.push_back(2i);
m.push_back(4);
m.insert_ordered(3);
check_links(&m);
}
let mut n = DList::new();
assert!(n.mut_iter().rev().next().is_none());
- n.push_front(4);
+ n.push_front(4i);
let mut it = n.mut_iter().rev();
assert!(it.next().is_some());
assert!(it.next().is_none());
#[test]
fn test_send() {
- let n = list_from([1,2,3]);
+ let n = list_from([1i,2,3]);
spawn(proc() {
check_links(&n);
assert_eq!(&[&1,&2,&3], n.iter().collect::<Vec<&int>>().as_slice());
m.push_back(1);
assert!(n == m);
- let n = list_from([2,3,4]);
- let m = list_from([1,2,3]);
+ let n = list_from([2i,3,4]);
+ let m = list_from([1i,2,3]);
assert!(n != m);
}
#[test]
fn test_ord() {
let n: DList<int> = list_from([]);
- let m = list_from([1,2,3]);
+ let m = list_from([1i,2,3]);
assert!(n < m);
assert!(m > n);
assert!(n <= n);
#[test]
fn test_ord_nan() {
- let nan = 0.0/0.0;
+ let nan = 0.0f64/0.0;
let n = list_from([nan]);
let m = list_from([nan]);
assert!(!(n < m));
assert!(!(n >= m));
let n = list_from([nan]);
- let one = list_from([1.0]);
+ let one = list_from([1.0f64]);
assert!(!(n < one));
assert!(!(n > one));
assert!(!(n <= one));
assert!(!(n >= one));
- let u = list_from([1.0,2.0,nan]);
- let v = list_from([1.0,2.0,3.0]);
+ let u = list_from([1.0f64,2.0,nan]);
+ let v = list_from([1.0f64,2.0,3.0]);
assert!(!(u < v));
assert!(!(u > v));
assert!(!(u <= v));
assert!(!(u >= v));
- let s = list_from([1.0,2.0,4.0,2.0]);
- let t = list_from([1.0,2.0,3.0,2.0]);
+ let s = list_from([1.0f64,2.0,4.0,2.0]);
+ let t = list_from([1.0f64,2.0,3.0,2.0]);
assert!(!(s < t));
assert!(s > one);
assert!(!(s <= one));
#[test]
fn test_fuzz() {
- for _ in range(0, 25) {
+ for _ in range(0u, 25) {
fuzz_test(3);
fuzz_test(16);
fuzz_test(189);
#[test]
fn test_show() {
- let list: DList<int> = range(0, 10).collect();
+ let list: DList<int> = range(0i, 10).collect();
assert!(list.to_str().as_slice() == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
let list: DList<&str> = vec!["just", "one", "test", "more"].iter()
#[bench]
fn bench_collect_into(b: &mut test::Bencher) {
- let v = &[0, ..64];
+ let v = &[0i, ..64];
b.iter(|| {
let _: DList<int> = v.iter().map(|x| *x).collect();
})
#[bench]
fn bench_rotate_forward(b: &mut test::Bencher) {
let mut m: DList<int> = DList::new();
- m.push_front(0);
+ m.push_front(0i);
m.push_front(1);
b.iter(|| {
m.rotate_forward();
#[bench]
fn bench_rotate_backward(b: &mut test::Bencher) {
let mut m: DList<int> = DList::new();
- m.push_front(0);
+ m.push_front(0i);
m.push_front(1);
b.iter(|| {
m.rotate_backward();
#[bench]
fn bench_iter(b: &mut test::Bencher) {
- let v = &[0, ..128];
+ let v = &[0i, ..128];
let m: DList<int> = v.iter().map(|&x|x).collect();
b.iter(|| {
assert!(m.iter().count() == 128);
}
#[bench]
fn bench_iter_mut(b: &mut test::Bencher) {
- let v = &[0, ..128];
+ let v = &[0i, ..128];
let mut m: DList<int> = v.iter().map(|&x|x).collect();
b.iter(|| {
assert!(m.mut_iter().count() == 128);
}
#[bench]
fn bench_iter_rev(b: &mut test::Bencher) {
- let v = &[0, ..128];
+ let v = &[0i, ..128];
let m: DList<int> = v.iter().map(|&x|x).collect();
b.iter(|| {
assert!(m.iter().rev().count() == 128);
}
#[bench]
fn bench_iter_mut_rev(b: &mut test::Bencher) {
- let v = &[0, ..128];
+ let v = &[0i, ..128];
let mut m: DList<int> = v.iter().map(|&x|x).collect();
b.iter(|| {
assert!(m.mut_iter().rev().count() == 128);
#[test]
fn test_iterator() {
- let data = vec!(5, 9, 3);
- let iterout = [9, 5, 3];
+ let data = vec!(5i, 9, 3);
+ let iterout = [9i, 5, 3];
let pq = PriorityQueue::from_vec(data);
let mut i = 0;
for el in pq.iter() {
#[test]
fn test_push() {
- let mut heap = PriorityQueue::from_vec(vec!(2, 4, 9));
+ let mut heap = PriorityQueue::from_vec(vec!(2i, 4, 9));
assert_eq!(heap.len(), 3);
assert!(*heap.top().unwrap() == 9);
heap.push(11);
#[test]
fn test_push_unique() {
- let mut heap = PriorityQueue::from_vec(vec!(box 2, box 4, box 9));
+ let mut heap = PriorityQueue::from_vec(vec!(box 2i, box 4, box 9));
assert_eq!(heap.len(), 3);
assert!(*heap.top().unwrap() == box 9);
heap.push(box 11);
#[test]
fn test_push_pop() {
- let mut heap = PriorityQueue::from_vec(vec!(5, 5, 2, 1, 3));
+ let mut heap = PriorityQueue::from_vec(vec!(5i, 5, 2, 1, 3));
assert_eq!(heap.len(), 5);
assert_eq!(heap.push_pop(6), 6);
assert_eq!(heap.len(), 5);
#[test]
fn test_replace() {
- let mut heap = PriorityQueue::from_vec(vec!(5, 5, 2, 1, 3));
+ let mut heap = PriorityQueue::from_vec(vec!(5i, 5, 2, 1, 3));
assert_eq!(heap.len(), 5);
assert_eq!(heap.replace(6).unwrap(), 5);
assert_eq!(heap.len(), 5);
#[test]
fn test_to_vec() {
check_to_vec(vec!());
- check_to_vec(vec!(5));
- check_to_vec(vec!(3, 2));
- check_to_vec(vec!(2, 3));
- check_to_vec(vec!(5, 1, 2));
- check_to_vec(vec!(1, 100, 2, 3));
- check_to_vec(vec!(1, 3, 5, 7, 9, 2, 4, 6, 8, 0));
- check_to_vec(vec!(2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1));
- check_to_vec(vec!(9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0));
- check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
- check_to_vec(vec!(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));
- check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2));
- check_to_vec(vec!(5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1));
+ check_to_vec(vec!(5i));
+ check_to_vec(vec!(3i, 2));
+ check_to_vec(vec!(2i, 3));
+ check_to_vec(vec!(5i, 1, 2));
+ check_to_vec(vec!(1i, 100, 2, 3));
+ check_to_vec(vec!(1i, 3, 5, 7, 9, 2, 4, 6, 8, 0));
+ check_to_vec(vec!(2i, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1));
+ check_to_vec(vec!(9i, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0));
+ check_to_vec(vec!(0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10));
+ check_to_vec(vec!(10i, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0));
+ check_to_vec(vec!(0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2));
+ check_to_vec(vec!(5i, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1));
}
#[test]
fn test_simple() {
let mut d = RingBuf::new();
assert_eq!(d.len(), 0u);
- d.push_front(17);
- d.push_front(42);
+ d.push_front(17i);
+ d.push_front(42i);
d.push_back(137);
assert_eq!(d.len(), 3u);
d.push_back(137);
fn bench_grow(b: &mut test::Bencher) {
let mut deq = RingBuf::new();
b.iter(|| {
- for _ in range(0, 65) {
+ for _ in range(0i, 65) {
deq.push_front(1);
}
})
#[test]
fn test_swap() {
- let mut d: RingBuf<int> = range(0, 5).collect();
+ let mut d: RingBuf<int> = range(0i, 5).collect();
d.pop_front();
d.swap(0, 3);
assert_eq!(d.iter().map(|&x|x).collect::<Vec<int>>(), vec!(4, 2, 3, 1));
assert_eq!(d.iter().next(), None);
assert_eq!(d.iter().size_hint(), (0, Some(0)));
- for i in range(0, 5) {
+ for i in range(0i, 5) {
d.push_back(i);
}
assert_eq!(d.iter().collect::<Vec<&int>>().as_slice(), &[&0,&1,&2,&3,&4]);
- for i in range(6, 9) {
+ for i in range(6i, 9) {
d.push_front(i);
}
assert_eq!(d.iter().collect::<Vec<&int>>().as_slice(), &[&8,&7,&6,&0,&1,&2,&3,&4]);
let mut d = RingBuf::new();
assert_eq!(d.iter().rev().next(), None);
- for i in range(0, 5) {
+ for i in range(0i, 5) {
d.push_back(i);
}
assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0]);
- for i in range(6, 9) {
+ for i in range(6i, 9) {
d.push_front(i);
}
assert_eq!(d.iter().rev().collect::<Vec<&int>>().as_slice(), &[&4,&3,&2,&1,&0,&6,&7,&8]);
let mut d = RingBuf::with_capacity(3);
assert!(d.mut_iter().rev().next().is_none());
- d.push_back(1);
+ d.push_back(1i);
d.push_back(2);
d.push_back(3);
assert_eq!(d.pop_front(), Some(1));
#[test]
fn test_from_iter() {
use std::iter;
- let v = vec!(1,2,3,4,5,6,7);
+ let v = vec!(1i,2,3,4,5,6,7);
let deq: RingBuf<int> = v.iter().map(|&x| x).collect();
let u: Vec<int> = deq.iter().map(|&x| x).collect();
assert_eq!(u, v);
#[test]
fn test_clone() {
let mut d = RingBuf::new();
- d.push_front(17);
+ d.push_front(17i);
d.push_front(42);
d.push_back(137);
d.push_back(137);
fn test_eq() {
let mut d = RingBuf::new();
assert!(d == RingBuf::with_capacity(0));
- d.push_front(137);
+ d.push_front(137i);
d.push_front(17);
d.push_front(42);
d.push_back(137);
#[test]
fn test_show() {
- let ringbuf: RingBuf<int> = range(0, 10).collect();
+ let ringbuf: RingBuf<int> = range(0i, 10).collect();
assert!(format!("{}", ringbuf).as_slice() == "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter()
type of the vector is `int`, the element type of the iterator is `&int`.
```rust
-let numbers = [0, 1, 2];
+let numbers = [0i, 1i, 2i];
for &x in numbers.iter() {
println!("{} is a number!", x);
}
/// # Example
///
/// ```rust
- /// let mut v = [-5, 4, 1, -3, 2];
+ /// let mut v = [-5i, 4, 1, -3, 2];
///
/// v.sort();
- /// assert!(v == [-5, -3, 1, 2, 4]);
+ /// assert!(v == [-5i, -3, 1, 2, 4]);
/// ```
fn sort(self);
/// # Example
///
/// ```rust
- /// let v = &mut [0, 1, 2];
+ /// let v = &mut [0i, 1, 2];
/// v.next_permutation();
- /// assert_eq!(v, &mut [0, 2, 1]);
+ /// assert_eq!(v, &mut [0i, 2, 1]);
/// v.next_permutation();
- /// assert_eq!(v, &mut [1, 0, 2]);
+ /// assert_eq!(v, &mut [1i, 0, 2]);
/// ```
fn next_permutation(self) -> bool;
/// # Example
///
/// ```rust
- /// let v = &mut [1, 0, 2];
+ /// let v = &mut [1i, 0, 2];
/// v.prev_permutation();
- /// assert_eq!(v, &mut [0, 2, 1]);
+ /// assert_eq!(v, &mut [0i, 2, 1]);
/// v.prev_permutation();
- /// assert_eq!(v, &mut [0, 1, 2]);
+ /// assert_eq!(v, &mut [0i, 1, 2]);
/// ```
fn prev_permutation(self) -> bool;
}
#[test]
fn test_get() {
- let mut a = vec![11];
+ let mut a = vec![11i];
assert_eq!(a.as_slice().get(1), None);
- a = vec![11, 12];
+ a = vec![11i, 12];
assert_eq!(a.as_slice().get(1).unwrap(), &12);
- a = vec![11, 12, 13];
+ a = vec![11i, 12, 13];
assert_eq!(a.as_slice().get(1).unwrap(), &12);
}
fn test_head() {
let mut a = vec![];
assert_eq!(a.as_slice().head(), None);
- a = vec![11];
+ a = vec![11i];
assert_eq!(a.as_slice().head().unwrap(), &11);
- a = vec![11, 12];
+ a = vec![11i, 12];
assert_eq!(a.as_slice().head().unwrap(), &11);
}
#[test]
fn test_tail() {
- let mut a = vec![11];
+ let mut a = vec![11i];
assert_eq!(a.tail(), &[]);
- a = vec![11, 12];
+ a = vec![11i, 12];
assert_eq!(a.tail(), &[12]);
}
#[test]
fn test_tailn() {
- let mut a = vec![11, 12, 13];
+ let mut a = vec![11i, 12, 13];
assert_eq!(a.tailn(0), &[11, 12, 13]);
- a = vec![11, 12, 13];
+ a = vec![11i, 12, 13];
assert_eq!(a.tailn(2), &[13]);
}
#[test]
fn test_init() {
- let mut a = vec![11];
+ let mut a = vec![11i];
assert_eq!(a.init(), &[]);
- a = vec![11, 12];
+ a = vec![11i, 12];
assert_eq!(a.init(), &[11]);
}
#[test]
fn test_initn() {
- let mut a = vec![11, 12, 13];
+ let mut a = vec![11i, 12, 13];
assert_eq!(a.as_slice().initn(0), &[11, 12, 13]);
- a = vec![11, 12, 13];
+ a = vec![11i, 12, 13];
assert_eq!(a.as_slice().initn(2), &[11]);
}
fn test_last() {
let mut a = vec![];
assert_eq!(a.as_slice().last(), None);
- a = vec![11];
+ a = vec![11i];
assert_eq!(a.as_slice().last().unwrap(), &11);
- a = vec![11, 12];
+ a = vec![11i, 12];
assert_eq!(a.as_slice().last().unwrap(), &12);
}
#[test]
fn test_slice() {
// Test fixed length vector.
- let vec_fixed = [1, 2, 3, 4];
+ let vec_fixed = [1i, 2, 3, 4];
let v_a = vec_fixed.slice(1u, vec_fixed.len()).to_owned();
assert_eq!(v_a.len(), 3u);
let v_a = v_a.as_slice();
assert_eq!(v_a[2], 4);
// Test on stack.
- let vec_stack = &[1, 2, 3];
+ let vec_stack = &[1i, 2, 3];
let v_b = vec_stack.slice(1u, 3u).to_owned();
assert_eq!(v_b.len(), 2u);
let v_b = v_b.as_slice();
assert_eq!(v_b[1], 3);
// Test `Box<[T]>`
- let vec_unique = vec![1, 2, 3, 4, 5, 6];
+ let vec_unique = vec![1i, 2, 3, 4, 5, 6];
let v_d = vec_unique.slice(1u, 6u).to_owned();
assert_eq!(v_d.len(), 5u);
let v_d = v_d.as_slice();
#[test]
fn test_slice_from() {
- let vec = &[1, 2, 3, 4];
+ let vec = &[1i, 2, 3, 4];
assert_eq!(vec.slice_from(0), vec);
assert_eq!(vec.slice_from(2), &[3, 4]);
assert_eq!(vec.slice_from(4), &[]);
#[test]
fn test_slice_to() {
- let vec = &[1, 2, 3, 4];
+ let vec = &[1i, 2, 3, 4];
assert_eq!(vec.slice_to(4), vec);
assert_eq!(vec.slice_to(2), &[1, 2]);
assert_eq!(vec.slice_to(0), &[]);
#[test]
fn test_pop() {
- let mut v = vec![5];
+ let mut v = vec![5i];
let e = v.pop();
assert_eq!(v.len(), 0);
assert_eq!(e, Some(5));
#[test]
fn test_swap_remove() {
- let mut v = vec![1, 2, 3, 4, 5];
+ let mut v = vec![1i, 2, 3, 4, 5];
let mut e = v.swap_remove(0);
assert_eq!(e, Some(1));
- assert_eq!(v, vec![5, 2, 3, 4]);
+ assert_eq!(v, vec![5i, 2, 3, 4]);
e = v.swap_remove(3);
assert_eq!(e, Some(4));
- assert_eq!(v, vec![5, 2, 3]);
+ assert_eq!(v, vec![5i, 2, 3]);
e = v.swap_remove(3);
assert_eq!(e, None);
- assert_eq!(v, vec![5, 2, 3]);
+ assert_eq!(v, vec![5i, 2, 3]);
}
#[test]
fn test_push() {
// Test on-stack push().
let mut v = vec![];
- v.push(1);
+ v.push(1i);
assert_eq!(v.len(), 1u);
assert_eq!(v.as_slice()[0], 1);
// Test on-heap push().
- v.push(2);
+ v.push(2i);
assert_eq!(v.len(), 2u);
assert_eq!(v.as_slice()[0], 1);
assert_eq!(v.as_slice()[1], 2);
fn test_grow() {
// Test on-stack grow().
let mut v = vec![];
- v.grow(2u, &1);
+ v.grow(2u, &1i);
{
let v = v.as_slice();
assert_eq!(v.len(), 2u);
}
// Test on-heap grow().
- v.grow(3u, &2);
+ v.grow(3u, &2i);
{
let v = v.as_slice();
assert_eq!(v.len(), 5u);
#[test]
fn test_grow_set() {
- let mut v = vec![1, 2, 3];
+ let mut v = vec![1i, 2, 3];
v.grow_set(4u, &4, 5);
let v = v.as_slice();
assert_eq!(v.len(), 5u);
#[test]
fn test_truncate() {
- let mut v = vec![box 6,box 5,box 4];
+ let mut v = vec![box 6i,box 5,box 4];
v.truncate(1);
let v = v.as_slice();
assert_eq!(v.len(), 1);
#[test]
fn test_clear() {
- let mut v = vec![box 6,box 5,box 4];
+ let mut v = vec![box 6i,box 5,box 4];
v.clear();
assert_eq!(v.len(), 0);
// If the unsafe block didn't drop things properly, we blow up here.
assert_eq!(v, b);
}
case(vec![], vec![]);
- case(vec![1], vec![1]);
- case(vec![1,1], vec![1]);
- case(vec![1,2,3], vec![1,2,3]);
- case(vec![1,1,2,3], vec![1,2,3]);
- case(vec![1,2,2,3], vec![1,2,3]);
- case(vec![1,2,3,3], vec![1,2,3]);
- case(vec![1,1,2,2,2,3,3], vec![1,2,3]);
+ case(vec![1u], vec![1]);
+ case(vec![1u,1], vec![1]);
+ case(vec![1u,2,3], vec![1,2,3]);
+ case(vec![1u,1,2,3], vec![1,2,3]);
+ case(vec![1u,2,2,3], vec![1,2,3]);
+ case(vec![1u,2,3,3], vec![1,2,3]);
+ case(vec![1u,1,2,2,2,3,3], vec![1,2,3]);
}
#[test]
fn test_dedup_unique() {
- let mut v0 = vec![box 1, box 1, box 2, box 3];
+ let mut v0 = vec![box 1i, box 1, box 2, box 3];
v0.dedup();
- let mut v1 = vec![box 1, box 2, box 2, box 3];
+ let mut v1 = vec![box 1i, box 2, box 2, box 3];
v1.dedup();
- let mut v2 = vec![box 1, box 2, box 3, box 3];
+ let mut v2 = vec![box 1i, box 2, box 3, box 3];
v2.dedup();
/*
* If the boxed pointers were leaked or otherwise misused, valgrind
#[test]
fn test_dedup_shared() {
- let mut v0 = vec![box 1, box 1, box 2, box 3];
+ let mut v0 = vec![box 1i, box 1, box 2, box 3];
v0.dedup();
- let mut v1 = vec![box 1, box 2, box 2, box 3];
+ let mut v1 = vec![box 1i, box 2, box 2, box 3];
v1.dedup();
- let mut v2 = vec![box 1, box 2, box 3, box 3];
+ let mut v2 = vec![box 1i, box 2, box 3, box 3];
v2.dedup();
/*
* If the pointers were leaked or otherwise misused, valgrind and/or
#[test]
fn test_retain() {
- let mut v = vec![1, 2, 3, 4, 5];
+ let mut v = vec![1u, 2, 3, 4, 5];
v.retain(is_odd);
- assert_eq!(v, vec![1, 3, 5]);
+ assert_eq!(v, vec![1u, 3, 5]);
}
#[test]
fn test_element_swaps() {
- let mut v = [1, 2, 3];
+ let mut v = [1i, 2, 3];
for (i, (a, b)) in ElementSwaps::new(v.len()).enumerate() {
v.swap(a, b);
match i {
assert_eq!(it.next(), None);
}
{
- let v = [1, 2, 3];
+ let v = [1i, 2, 3];
let mut it = v.permutations();
let (min_size, max_opt) = it.size_hint();
assert_eq!(min_size, 3*2);
#[test]
fn test_lexicographic_permutations() {
- let v : &mut[int] = &mut[1, 2, 3, 4, 5];
+ let v : &mut[int] = &mut[1i, 2, 3, 4, 5];
assert!(v.prev_permutation() == false);
assert!(v.next_permutation());
assert_eq!(v, &mut[1, 2, 3, 5, 4]);
assert!(v.next_permutation());
assert_eq!(v, &mut[1, 2, 4, 5, 3]);
- let v : &mut[int] = &mut[1, 0, 0, 0];
+ let v : &mut[int] = &mut[1i, 0, 0, 0];
assert!(v.next_permutation() == false);
assert!(v.prev_permutation());
assert_eq!(v, &mut[0, 1, 0, 0]);
assert!(empty.prev_permutation() == false);
assert_eq!(empty, &mut[]);
- let one_elem : &mut[int] = &mut[4];
+ let one_elem : &mut[int] = &mut[4i];
assert!(one_elem.prev_permutation() == false);
assert_eq!(one_elem, &mut[4]);
assert!(one_elem.next_permutation() == false);
assert_eq!(one_elem, &mut[4]);
- let two_elem : &mut[int] = &mut[1, 2];
+ let two_elem : &mut[int] = &mut[1i, 2];
assert!(two_elem.prev_permutation() == false);
assert_eq!(two_elem, &mut[1, 2]);
assert!(two_elem.next_permutation());
#[test]
fn test_position_elem() {
- assert!([].position_elem(&1).is_none());
+ assert!([].position_elem(&1i).is_none());
- let v1 = vec![1, 2, 3, 3, 2, 5];
+ let v1 = vec![1i, 2, 3, 3, 2, 5];
assert_eq!(v1.as_slice().position_elem(&1), Some(0u));
assert_eq!(v1.as_slice().position_elem(&2), Some(1u));
assert_eq!(v1.as_slice().position_elem(&5), Some(5u));
#[test]
fn test_bsearch_elem() {
- assert_eq!([1,2,3,4,5].bsearch_elem(&5), Some(4));
- assert_eq!([1,2,3,4,5].bsearch_elem(&4), Some(3));
- assert_eq!([1,2,3,4,5].bsearch_elem(&3), Some(2));
- assert_eq!([1,2,3,4,5].bsearch_elem(&2), Some(1));
- assert_eq!([1,2,3,4,5].bsearch_elem(&1), Some(0));
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&5), Some(4));
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&4), Some(3));
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&3), Some(2));
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&2), Some(1));
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&1), Some(0));
- assert_eq!([2,4,6,8,10].bsearch_elem(&1), None);
- assert_eq!([2,4,6,8,10].bsearch_elem(&5), None);
- assert_eq!([2,4,6,8,10].bsearch_elem(&4), Some(1));
- assert_eq!([2,4,6,8,10].bsearch_elem(&10), Some(4));
+ assert_eq!([2i,4,6,8,10].bsearch_elem(&1), None);
+ assert_eq!([2i,4,6,8,10].bsearch_elem(&5), None);
+ assert_eq!([2i,4,6,8,10].bsearch_elem(&4), Some(1));
+ assert_eq!([2i,4,6,8,10].bsearch_elem(&10), Some(4));
- assert_eq!([2,4,6,8].bsearch_elem(&1), None);
- assert_eq!([2,4,6,8].bsearch_elem(&5), None);
- assert_eq!([2,4,6,8].bsearch_elem(&4), Some(1));
- assert_eq!([2,4,6,8].bsearch_elem(&8), Some(3));
+ assert_eq!([2i,4,6,8].bsearch_elem(&1), None);
+ assert_eq!([2i,4,6,8].bsearch_elem(&5), None);
+ assert_eq!([2i,4,6,8].bsearch_elem(&4), Some(1));
+ assert_eq!([2i,4,6,8].bsearch_elem(&8), Some(3));
- assert_eq!([2,4,6].bsearch_elem(&1), None);
- assert_eq!([2,4,6].bsearch_elem(&5), None);
- assert_eq!([2,4,6].bsearch_elem(&4), Some(1));
- assert_eq!([2,4,6].bsearch_elem(&6), Some(2));
+ assert_eq!([2i,4,6].bsearch_elem(&1), None);
+ assert_eq!([2i,4,6].bsearch_elem(&5), None);
+ assert_eq!([2i,4,6].bsearch_elem(&4), Some(1));
+ assert_eq!([2i,4,6].bsearch_elem(&6), Some(2));
- assert_eq!([2,4].bsearch_elem(&1), None);
- assert_eq!([2,4].bsearch_elem(&5), None);
- assert_eq!([2,4].bsearch_elem(&2), Some(0));
- assert_eq!([2,4].bsearch_elem(&4), Some(1));
+ assert_eq!([2i,4].bsearch_elem(&1), None);
+ assert_eq!([2i,4].bsearch_elem(&5), None);
+ assert_eq!([2i,4].bsearch_elem(&2), Some(0));
+ assert_eq!([2i,4].bsearch_elem(&4), Some(1));
- assert_eq!([2].bsearch_elem(&1), None);
- assert_eq!([2].bsearch_elem(&5), None);
- assert_eq!([2].bsearch_elem(&2), Some(0));
+ assert_eq!([2i].bsearch_elem(&1), None);
+ assert_eq!([2i].bsearch_elem(&5), None);
+ assert_eq!([2i].bsearch_elem(&2), Some(0));
- assert_eq!([].bsearch_elem(&1), None);
- assert_eq!([].bsearch_elem(&5), None);
+ assert_eq!([].bsearch_elem(&1i), None);
+ assert_eq!([].bsearch_elem(&5i), None);
- assert!([1,1,1,1,1].bsearch_elem(&1) != None);
- assert!([1,1,1,1,2].bsearch_elem(&1) != None);
- assert!([1,1,1,2,2].bsearch_elem(&1) != None);
- assert!([1,1,2,2,2].bsearch_elem(&1) != None);
- assert_eq!([1,2,2,2,2].bsearch_elem(&1), Some(0));
+ assert!([1i,1,1,1,1].bsearch_elem(&1) != None);
+ assert!([1i,1,1,1,2].bsearch_elem(&1) != None);
+ assert!([1i,1,1,2,2].bsearch_elem(&1) != None);
+ assert!([1i,1,2,2,2].bsearch_elem(&1) != None);
+ assert_eq!([1i,2,2,2,2].bsearch_elem(&1), Some(0));
- assert_eq!([1,2,3,4,5].bsearch_elem(&6), None);
- assert_eq!([1,2,3,4,5].bsearch_elem(&0), None);
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&6), None);
+ assert_eq!([1i,2,3,4,5].bsearch_elem(&0), None);
}
#[test]
fn test_reverse() {
- let mut v: Vec<int> = vec![10, 20];
+ let mut v: Vec<int> = vec![10i, 20];
assert_eq!(*v.get(0), 10);
assert_eq!(*v.get(1), 20);
v.reverse();
#[test]
fn test_sort() {
for len in range(4u, 25) {
- for _ in range(0, 100) {
+ for _ in range(0i, 100) {
let mut v = task_rng().gen_iter::<uint>().take(len)
.collect::<Vec<uint>>();
let mut v1 = v.clone();
#[test]
fn test_sort_stability() {
- for len in range(4, 25) {
- for _ in range(0 , 10) {
- let mut counts = [0, .. 10];
+ for len in range(4i, 25) {
+ for _ in range(0u, 10) {
+ let mut counts = [0i, .. 10];
// create a vector like [(6, 1), (5, 1), (6, 2), ...],
// where the first item of each tuple is random, but
#[test]
fn test_partition() {
assert_eq!((vec![]).partition(|x: &int| *x < 3), (vec![], vec![]));
- assert_eq!((vec![1, 2, 3]).partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!((vec![1, 2, 3]).partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!((vec![1, 2, 3]).partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+ assert_eq!((vec![1i, 2, 3]).partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!((vec![1i, 2, 3]).partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!((vec![1i, 2, 3]).partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
}
#[test]
fn test_partitioned() {
assert_eq!(([]).partitioned(|x: &int| *x < 3), (vec![], vec![]));
- assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!(([1, 2, 3]).partitioned(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+ assert_eq!(([1i, 2, 3]).partitioned(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!(([1i, 2, 3]).partitioned(|x: &int| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!(([1i, 2, 3]).partitioned(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
}
#[test]
fn test_concat() {
let v: [Vec<int>, ..0] = [];
assert_eq!(v.concat_vec(), vec![]);
- assert_eq!([vec![1], vec![2,3]].concat_vec(), vec![1, 2, 3]);
+ assert_eq!([vec![1i], vec![2i,3i]].concat_vec(), vec![1, 2, 3]);
- assert_eq!([&[1], &[2,3]].concat_vec(), vec![1, 2, 3]);
+ assert_eq!([&[1i], &[2i,3i]].concat_vec(), vec![1, 2, 3]);
}
#[test]
fn test_connect() {
let v: [Vec<int>, ..0] = [];
assert_eq!(v.connect_vec(&0), vec![]);
- assert_eq!([vec![1], vec![2, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
- assert_eq!([vec![1], vec![2], vec![3]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
+ assert_eq!([vec![1i], vec![2i, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
+ assert_eq!([vec![1i], vec![2i], vec![3i]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
- assert_eq!([&[1], &[2, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
- assert_eq!([&[1], &[2], &[3]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
+ assert_eq!([&[1i], &[2i, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
+ assert_eq!([&[1i], &[2i], &[3]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
}
#[test]
fn test_shift() {
- let mut x = vec![1, 2, 3];
+ let mut x = vec![1i, 2, 3];
assert_eq!(x.shift(), Some(1));
- assert_eq!(&x, &vec![2, 3]);
+ assert_eq!(&x, &vec![2i, 3]);
assert_eq!(x.shift(), Some(2));
assert_eq!(x.shift(), Some(3));
assert_eq!(x.shift(), None);
#[test]
fn test_unshift() {
- let mut x = vec![1, 2, 3];
+ let mut x = vec![1i, 2, 3];
x.unshift(0);
assert_eq!(x, vec![0, 1, 2, 3]);
}
#[test]
fn test_insert() {
- let mut a = vec![1, 2, 4];
+ let mut a = vec![1i, 2, 4];
a.insert(2, 3);
assert_eq!(a, vec![1, 2, 3, 4]);
- let mut a = vec![1, 2, 3];
+ let mut a = vec![1i, 2, 3];
a.insert(0, 0);
assert_eq!(a, vec![0, 1, 2, 3]);
- let mut a = vec![1, 2, 3];
+ let mut a = vec![1i, 2, 3];
a.insert(3, 4);
assert_eq!(a, vec![1, 2, 3, 4]);
let mut a = vec![];
- a.insert(0, 1);
+ a.insert(0, 1i);
assert_eq!(a, vec![1]);
}
#[test]
#[should_fail]
fn test_insert_oob() {
- let mut a = vec![1, 2, 3];
+ let mut a = vec![1i, 2, 3];
a.insert(4, 5);
}
#[test]
fn test_remove() {
- let mut a = vec![1,2,3,4];
+ let mut a = vec![1i,2,3,4];
assert_eq!(a.remove(2), Some(3));
- assert_eq!(a, vec![1,2,4]);
+ assert_eq!(a, vec![1i,2,4]);
assert_eq!(a.remove(2), Some(4));
- assert_eq!(a, vec![1,2]);
+ assert_eq!(a, vec![1i,2]);
assert_eq!(a.remove(2), None);
- assert_eq!(a, vec![1,2]);
+ assert_eq!(a, vec![1i,2]);
assert_eq!(a.remove(0), Some(1));
- assert_eq!(a, vec![2]);
+ assert_eq!(a, vec![2i]);
assert_eq!(a.remove(0), Some(2));
assert_eq!(a, vec![]);
#[test]
fn test_slice_2() {
- let v = vec![1, 2, 3, 4, 5];
+ let v = vec![1i, 2, 3, 4, 5];
let v = v.slice(1u, 3u);
assert_eq!(v.len(), 2u);
assert_eq!(v[0], 2);
fn test_from_fn_fail() {
Vec::from_fn(100, |v| {
if v == 50 { fail!() }
- box 0
+ box 0i
});
}
if i == 50 {
fail!()
}
- (box 0, Rc::new(0))
+ (box 0i, Rc::new(0i))
})
}
#[test]
#[should_fail]
fn test_permute_fail() {
- let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)),
- (box 0, Rc::new(0)), (box 0, Rc::new(0))];
+ let v = [(box 0i, Rc::new(0i)), (box 0i, Rc::new(0i)),
+ (box 0i, Rc::new(0i)), (box 0i, Rc::new(0i))];
let mut i = 0;
for _ in v.permutations() {
if i == 2 {
#[should_fail]
fn test_copy_memory_oob() {
unsafe {
- let mut a = [1, 2, 3, 4];
- let b = [1, 2, 3, 4, 5];
+ let mut a = [1i, 2, 3, 4];
+ let b = [1i, 2, 3, 4, 5];
a.copy_memory(b);
}
}
#[test]
fn test_total_ord() {
- [1, 2, 3, 4].cmp(& &[1, 2, 3]) == Greater;
- [1, 2, 3].cmp(& &[1, 2, 3, 4]) == Less;
- [1, 2, 3, 4].cmp(& &[1, 2, 3, 4]) == Equal;
- [1, 2, 3, 4, 5, 5, 5, 5].cmp(& &[1, 2, 3, 4, 5, 6]) == Less;
- [2, 2].cmp(& &[1, 2, 3, 4]) == Greater;
+ [1i, 2, 3, 4].cmp(& &[1, 2, 3]) == Greater;
+ [1i, 2, 3].cmp(& &[1, 2, 3, 4]) == Less;
+ [1i, 2, 3, 4].cmp(& &[1, 2, 3, 4]) == Equal;
+ [1i, 2, 3, 4, 5, 5, 5, 5].cmp(& &[1, 2, 3, 4, 5, 6]) == Less;
+ [2i, 2].cmp(& &[1, 2, 3, 4]) == Greater;
}
#[test]
fn test_iterator() {
- let xs = [1, 2, 5, 10, 11];
+ let xs = [1i, 2, 5, 10, 11];
let mut it = xs.iter();
assert_eq!(it.size_hint(), (5, Some(5)));
assert_eq!(it.next().unwrap(), &1);
#[test]
fn test_random_access_iterator() {
- let xs = [1, 2, 5, 10, 11];
+ let xs = [1i, 2, 5, 10, 11];
let mut it = xs.iter();
assert_eq!(it.indexable(), 5);
#[test]
fn test_iter_size_hints() {
- let mut xs = [1, 2, 5, 10, 11];
+ let mut xs = [1i, 2, 5, 10, 11];
assert_eq!(xs.iter().size_hint(), (5, Some(5)));
assert_eq!(xs.mut_iter().size_hint(), (5, Some(5)));
}
#[test]
fn test_iter_clone() {
- let xs = [1, 2, 5];
+ let xs = [1i, 2, 5];
let mut it = xs.iter();
it.next();
let mut jt = it.clone();
#[test]
fn test_mut_iterator() {
- let mut xs = [1, 2, 3, 4, 5];
+ let mut xs = [1i, 2, 3, 4, 5];
for x in xs.mut_iter() {
*x += 1;
}
#[test]
fn test_rev_iterator() {
- let xs = [1, 2, 5, 10, 11];
+ let xs = [1i, 2, 5, 10, 11];
let ys = [11, 10, 5, 2, 1];
let mut i = 0;
for &x in xs.iter().rev() {
#[test]
fn test_move_from() {
- let mut a = [1,2,3,4,5];
- let b = vec![6,7,8];
+ let mut a = [1i,2,3,4,5];
+ let b = vec![6i,7,8];
assert_eq!(a.move_from(b, 0, 3), 3);
- assert!(a == [6,7,8,4,5]);
- let mut a = [7,2,8,1];
- let b = vec![3,1,4,1,5,9];
+ assert!(a == [6i,7,8,4,5]);
+ let mut a = [7i,2,8,1];
+ let b = vec![3i,1,4,1,5,9];
assert_eq!(a.move_from(b, 0, 6), 4);
- assert!(a == [3,1,4,1]);
- let mut a = [1,2,3,4];
- let b = vec![5,6,7,8,9,0];
+ assert!(a == [3i,1,4,1]);
+ let mut a = [1i,2,3,4];
+ let b = vec![5i,6,7,8,9,0];
assert_eq!(a.move_from(b, 2, 3), 1);
- assert!(a == [7,2,3,4]);
- let mut a = [1,2,3,4,5];
- let b = vec![5,6,7,8,9,0];
+ assert!(a == [7i,2,3,4]);
+ let mut a = [1i,2,3,4,5];
+ let b = vec![5i,6,7,8,9,0];
assert_eq!(a.mut_slice(2,4).move_from(b,1,6), 2);
- assert!(a == [1,2,6,7,5]);
+ assert!(a == [1i,2,6,7,5]);
}
#[test]
fn test_copy_from() {
- let mut a = [1,2,3,4,5];
- let b = [6,7,8];
+ let mut a = [1i,2,3,4,5];
+ let b = [6i,7,8];
assert_eq!(a.copy_from(b), 3);
- assert!(a == [6,7,8,4,5]);
- let mut c = [7,2,8,1];
- let d = [3,1,4,1,5,9];
+ assert!(a == [6i,7,8,4,5]);
+ let mut c = [7i,2,8,1];
+ let d = [3i,1,4,1,5,9];
assert_eq!(c.copy_from(d), 4);
- assert!(c == [3,1,4,1]);
+ assert!(c == [3i,1,4,1]);
}
#[test]
fn test_reverse_part() {
- let mut values = [1,2,3,4,5];
+ let mut values = [1i,2,3,4,5];
values.mut_slice(1, 4).reverse();
assert!(values == [1,4,3,2,5]);
}
)
let empty: Vec<int> = vec![];
test_show_vec!(empty, "[]".to_string());
- test_show_vec!(vec![1], "[1]".to_string());
- test_show_vec!(vec![1, 2, 3], "[1, 2, 3]".to_string());
+ test_show_vec!(vec![1i], "[1]".to_string());
+ test_show_vec!(vec![1i, 2, 3], "[1, 2, 3]".to_string());
test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
"[[], [1], [1, 1]]".to_string());
let empty_mut: &mut [int] = &mut[];
test_show_vec!(empty_mut, "[]".to_string());
- test_show_vec!(&mut[1], "[1]".to_string());
- test_show_vec!(&mut[1, 2, 3], "[1, 2, 3]".to_string());
+ test_show_vec!(&mut[1i], "[1]".to_string());
+ test_show_vec!(&mut[1i, 2, 3], "[1, 2, 3]".to_string());
test_show_vec!(&mut[&mut[], &mut[1u], &mut[1u, 1u]],
"[[], [1], [1, 1]]".to_string());
}
fn test_iter_zero_sized() {
let mut v = vec![Foo, Foo, Foo];
assert_eq!(v.len(), 3);
- let mut cnt = 0;
+ let mut cnt = 0u;
for f in v.iter() {
assert!(*f == Foo);
#[test]
fn test_shrink_to_fit() {
let mut xs = vec![0, 1, 2, 3];
- for i in range(4, 100) {
+ for i in range(4i, 100) {
xs.push(i)
}
assert_eq!(xs.capacity(), 128);
xs.shrink_to_fit();
assert_eq!(xs.capacity(), 100);
- assert_eq!(xs, range(0, 100).collect::<Vec<_>>());
+ assert_eq!(xs, range(0i, 100i).collect::<Vec<_>>());
}
#[test]
#[test]
fn test_mut_splitator() {
- let mut xs = [0,1,0,2,3,0,0,4,5,0];
+ let mut xs = [0i,1,0,2,3,0,0,4,5,0];
assert_eq!(xs.mut_split(|x| *x == 0).count(), 6);
for slice in xs.mut_split(|x| *x == 0) {
slice.reverse();
}
assert!(xs == [0,1,0,3,2,0,0,5,4,0]);
- let mut xs = [0,1,0,2,3,0,0,4,5,0,6,7];
+ let mut xs = [0i,1,0,2,3,0,0,4,5,0,6,7];
for slice in xs.mut_split(|x| *x == 0).take(5) {
slice.reverse();
}
#[test]
fn test_mut_splitator_rev() {
- let mut xs = [1,2,0,3,4,0,0,5,6,0];
+ let mut xs = [1i,2,0,3,4,0,0,5,6,0];
for slice in xs.mut_split(|x| *x == 0).rev().take(4) {
slice.reverse();
}
#[test]
fn test_get_mut() {
- let mut v = [0,1,2];
+ let mut v = [0i,1,2];
assert_eq!(v.get_mut(3), None);
v.get_mut(1).map(|e| *e = 7);
assert_eq!(v[1], 7);
#[test]
#[should_fail]
fn test_mut_chunks_0() {
- let mut v = [1, 2, 3, 4];
+ let mut v = [1i, 2, 3, 4];
let _it = v.mut_chunks(0);
}
#[test]
fn test_mut_last() {
- let mut x = [1, 2, 3, 4, 5];
+ let mut x = [1i, 2, 3, 4, 5];
let h = x.mut_last();
assert_eq!(*h.unwrap(), 5);
#[bench]
fn mut_iterator(b: &mut Bencher) {
- let mut v = Vec::from_elem(100, 0);
+ let mut v = Vec::from_elem(100, 0i);
b.iter(|| {
- let mut i = 0;
+ let mut i = 0i;
for x in v.mut_iter() {
*x = i;
i += 1;
#[bench]
fn concat(b: &mut Bencher) {
- let xss: Vec<Vec<uint>> = Vec::from_fn(100, |i| range(0, i).collect());
+ let xss: Vec<Vec<uint>> =
+ Vec::from_fn(100, |i| range(0u, i).collect());
b.iter(|| {
xss.as_slice().concat_vec()
});
#[bench]
fn connect(b: &mut Bencher) {
- let xss: Vec<Vec<uint>> = Vec::from_fn(100, |i| range(0, i).collect());
+ let xss: Vec<Vec<uint>> =
+ Vec::from_fn(100, |i| range(0u, i).collect());
b.iter(|| {
xss.as_slice().connect_vec(&0)
});
let mut rng = weak_rng();
b.iter(|| {
let mut v = Vec::from_elem(30, (0u, 0u));
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
let l = v.len();
v.insert(rng.gen::<uint>() % (l + 1),
(1, 1));
let mut rng = weak_rng();
b.iter(|| {
let mut v = Vec::from_elem(130, (0u, 0u));
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
let l = v.len();
v.remove(rng.gen::<uint>() % l);
}
#[test]
fn test_find_mut() {
let mut m = SmallIntMap::new();
- assert!(m.insert(1, 12));
+ assert!(m.insert(1, 12i));
assert!(m.insert(2, 8));
assert!(m.insert(5, 14));
let new = 100;
let mut map = SmallIntMap::new();
assert_eq!(map.len(), 0);
assert!(map.is_empty());
- assert!(map.insert(5, 20));
+ assert!(map.insert(5, 20i));
assert_eq!(map.len(), 1);
assert!(!map.is_empty());
assert!(map.insert(11, 12));
#[test]
fn test_clear() {
let mut map = SmallIntMap::new();
- assert!(map.insert(5, 20));
+ assert!(map.insert(5, 20i));
assert!(map.insert(11, 12));
assert!(map.insert(14, 22));
map.clear();
#[test]
fn test_swap() {
let mut m = SmallIntMap::new();
- assert_eq!(m.swap(1, 2), None);
- assert_eq!(m.swap(1, 3), Some(2));
- assert_eq!(m.swap(1, 4), Some(3));
+ assert_eq!(m.swap(1, 2i), None);
+ assert_eq!(m.swap(1, 3i), Some(2));
+ assert_eq!(m.swap(1, 4i), Some(3));
}
#[test]
fn test_pop() {
let mut m = SmallIntMap::new();
- m.insert(1, 2);
+ m.insert(1, 2i);
assert_eq!(m.pop(&1), Some(2));
assert_eq!(m.pop(&1), None);
}
fn test_iterator() {
let mut m = SmallIntMap::new();
- assert!(m.insert(0, 1));
+ assert!(m.insert(0, 1i));
assert!(m.insert(1, 2));
assert!(m.insert(3, 5));
assert!(m.insert(6, 10));
fn test_iterator_size_hints() {
let mut m = SmallIntMap::new();
- assert!(m.insert(0, 1));
+ assert!(m.insert(0, 1i));
assert!(m.insert(1, 2));
assert!(m.insert(3, 5));
assert!(m.insert(6, 10));
fn test_mut_iterator() {
let mut m = SmallIntMap::new();
- assert!(m.insert(0, 1));
+ assert!(m.insert(0, 1i));
assert!(m.insert(1, 2));
assert!(m.insert(3, 5));
assert!(m.insert(6, 10));
fn test_rev_iterator() {
let mut m = SmallIntMap::new();
- assert!(m.insert(0, 1));
+ assert!(m.insert(0, 1i));
assert!(m.insert(1, 2));
assert!(m.insert(3, 5));
assert!(m.insert(6, 10));
fn test_mut_rev_iterator() {
let mut m = SmallIntMap::new();
- assert!(m.insert(0, 1));
+ assert!(m.insert(0, 1i));
assert!(m.insert(1, 2));
assert!(m.insert(3, 5));
assert!(m.insert(6, 10));
#[test]
fn test_move_iter() {
let mut m = SmallIntMap::new();
- m.insert(1, box 2);
+ m.insert(1, box 2i);
let mut called = false;
for (k, v) in m.move_iter() {
assert!(!called);
called = true;
assert_eq!(k, 1);
- assert_eq!(v, box 2);
+ assert_eq!(v, box 2i);
}
assert!(called);
- m.insert(2, box 1);
+ m.insert(2, box 1i);
}
#[test]
let mut map = SmallIntMap::new();
let empty = SmallIntMap::<int>::new();
- map.insert(1, 2);
- map.insert(3, 4);
+ map.insert(1, 2i);
+ map.insert(3, 4i);
let map_str = map.to_str();
let map_str = map_str.as_slice();
#[test]
fn find_not_found() {
let mut m = TreeMap::new();
- assert!(m.insert(1, 2));
- assert!(m.insert(5, 3));
- assert!(m.insert(9, 3));
+ assert!(m.insert(1i, 2i));
+ assert!(m.insert(5i, 3i));
+ assert!(m.insert(9i, 3i));
assert_eq!(m.find(&2), None);
}
#[test]
fn test_find_mut() {
let mut m = TreeMap::new();
- assert!(m.insert(1, 12));
+ assert!(m.insert(1i, 12i));
assert!(m.insert(2, 8));
assert!(m.insert(5, 14));
let new = 100;
#[test]
fn insert_replace() {
let mut m = TreeMap::new();
- assert!(m.insert(5, 2));
+ assert!(m.insert(5i, 2i));
assert!(m.insert(2, 9));
assert!(!m.insert(2, 11));
assert_eq!(m.find(&2).unwrap(), &11);
fn test_clear() {
let mut m = TreeMap::new();
m.clear();
- assert!(m.insert(5, 11));
+ assert!(m.insert(5i, 11i));
assert!(m.insert(12, -3));
assert!(m.insert(19, 2));
m.clear();
let mut rng: rand::IsaacRng = rand::SeedableRng::from_seed(&[42]);
- for _ in range(0, 3) {
- for _ in range(0, 90) {
+ for _ in range(0u, 3) {
+ for _ in range(0u, 90) {
let k = rng.gen();
let v = rng.gen();
if !ctrl.iter().any(|x| x == &(k, v)) {
}
}
- for _ in range(0, 30) {
+ for _ in range(0u, 30) {
let r = rng.gen_range(0, ctrl.len());
let (key, _) = ctrl.remove(r).unwrap();
assert!(map.remove(&key));
#[test]
fn test_len() {
let mut m = TreeMap::new();
- assert!(m.insert(3, 6));
+ assert!(m.insert(3i, 6i));
assert_eq!(m.len(), 1);
assert!(m.insert(0, 0));
assert_eq!(m.len(), 2);
fn test_iterator() {
let mut m = TreeMap::new();
- assert!(m.insert(3, 6));
+ assert!(m.insert(3i, 6i));
assert!(m.insert(0, 0));
assert!(m.insert(4, 8));
assert!(m.insert(2, 4));
#[test]
fn test_interval_iteration() {
let mut m = TreeMap::new();
- for i in range(1, 100) {
+ for i in range(1i, 100i) {
assert!(m.insert(i * 2, i * 4));
}
- for i in range(1, 198) {
+ for i in range(1i, 198i) {
let mut lb_it = m.lower_bound(&i);
let (&k, &v) = lb_it.next().unwrap();
let lb = i + i % 2;
fn test_rev_iter() {
let mut m = TreeMap::new();
- assert!(m.insert(3, 6));
+ assert!(m.insert(3i, 6i));
assert!(m.insert(0, 0));
assert!(m.insert(4, 8));
assert!(m.insert(2, 4));
fn test_mut_interval_iter() {
let mut m_lower = TreeMap::new();
let mut m_upper = TreeMap::new();
- for i in range(1, 100) {
+ for i in range(1i, 100i) {
assert!(m_lower.insert(i * 2, i * 4));
assert!(m_upper.insert(i * 2, i * 4));
}
- for i in range(1, 199) {
+ for i in range(1i, 199) {
let mut lb_it = m_lower.mut_lower_bound(&i);
let (&k, v) = lb_it.next().unwrap();
let lb = i + i % 2;
assert_eq!(lb, k);
*v -= k;
}
- for i in range(0, 198) {
+ for i in range(0i, 198) {
let mut ub_it = m_upper.mut_upper_bound(&i);
let (&k, v) = ub_it.next().unwrap();
let ub = i + 2 - i % 2;
let mut b = TreeMap::new();
assert!(a == b);
- assert!(a.insert(0, 5));
+ assert!(a.insert(0i, 5i));
assert!(a != b);
assert!(b.insert(0, 4));
assert!(a != b);
let mut b = TreeMap::new();
assert!(!(a < b) && !(b < a));
- assert!(b.insert(0, 5));
+ assert!(b.insert(0i, 5i));
assert!(a < b);
assert!(a.insert(0, 7));
assert!(!(a < b) && b < a);
let mut b = TreeMap::new();
assert!(a <= b && a >= b);
- assert!(a.insert(1, 1));
+ assert!(a.insert(1i, 1i));
assert!(a > b && a >= b);
assert!(b < a && b <= a);
assert!(b.insert(2, 2));
#[test]
fn test_lazy_iterator() {
let mut m = TreeMap::new();
- let (x1, y1) = (2, 5);
+ let (x1, y1) = (2i, 5i);
let (x2, y2) = (9, 12);
let (x3, y3) = (20, -3);
let (x4, y4) = (29, 5);
#[test]
fn test_from_iter() {
- let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let map: TreeMap<int, int> = xs.iter().map(|&x| x).collect();
fn test_clear() {
let mut s = TreeSet::new();
s.clear();
- assert!(s.insert(5));
+ assert!(s.insert(5i));
assert!(s.insert(12));
assert!(s.insert(19));
s.clear();
let mut ys = TreeSet::new();
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
- assert!(xs.insert(5));
- assert!(ys.insert(11));
+ assert!(xs.insert(5i));
+ assert!(ys.insert(11i));
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
assert!(xs.insert(7));
#[test]
fn test_subset_and_superset() {
let mut a = TreeSet::new();
- assert!(a.insert(0));
+ assert!(a.insert(0i));
assert!(a.insert(5));
assert!(a.insert(11));
assert!(a.insert(7));
let mut b = TreeSet::new();
- assert!(b.insert(0));
+ assert!(b.insert(0i));
assert!(b.insert(7));
assert!(b.insert(19));
assert!(b.insert(250));
fn test_iterator() {
let mut m = TreeSet::new();
- assert!(m.insert(3));
+ assert!(m.insert(3i));
assert!(m.insert(0));
assert!(m.insert(4));
assert!(m.insert(2));
fn test_rev_iter() {
let mut m = TreeSet::new();
- assert!(m.insert(3));
+ assert!(m.insert(3i));
assert!(m.insert(0));
assert!(m.insert(4));
assert!(m.insert(2));
#[test]
fn test_move_iter() {
- let s: TreeSet<int> = range(0, 5).collect();
+ let s: TreeSet<int> = range(0i, 5).collect();
let mut n = 0;
for x in s.move_iter() {
#[test]
fn test_move_iter_size_hint() {
- let s: TreeSet<int> = vec!(0, 1).move_iter().collect();
+ let s: TreeSet<int> = vec!(0i, 1).move_iter().collect();
let mut it = s.move_iter();
fn test_clone_eq() {
let mut m = TreeSet::new();
- m.insert(1);
+ m.insert(1i);
m.insert(2);
assert!(m.clone() == m);
#[test]
fn test_swap() {
let mut m = TreeMap::new();
- assert_eq!(m.swap(1, 2), None);
- assert_eq!(m.swap(1, 3), Some(2));
- assert_eq!(m.swap(1, 4), Some(3));
+ assert_eq!(m.swap(1u, 2i), None);
+ assert_eq!(m.swap(1u, 3i), Some(2));
+ assert_eq!(m.swap(1u, 4i), Some(3));
}
#[test]
fn test_pop() {
let mut m = TreeMap::new();
- m.insert(1, 2);
+ m.insert(1u, 2i);
assert_eq!(m.pop(&1), Some(2));
assert_eq!(m.pop(&1), None);
}
#[test]
fn test_from_iter() {
- let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9];
let set: TreeSet<int> = xs.iter().map(|&x| x).collect();
#[test]
fn test_find_mut() {
let mut m = TrieMap::new();
- assert!(m.insert(1, 12));
- assert!(m.insert(2, 8));
- assert!(m.insert(5, 14));
+ assert!(m.insert(1u, 12i));
+ assert!(m.insert(2u, 8i));
+ assert!(m.insert(5u, 14i));
let new = 100;
match m.find_mut(&5) {
None => fail!(), Some(x) => *x = new
fn test_find_mut_missing() {
let mut m = TrieMap::new();
assert!(m.find_mut(&0).is_none());
- assert!(m.insert(1, 12));
+ assert!(m.insert(1u, 12i));
assert!(m.find_mut(&0).is_none());
assert!(m.insert(2, 8));
assert!(m.find_mut(&0).is_none());
#[test]
fn test_swap() {
let mut m = TrieMap::new();
- assert_eq!(m.swap(1, 2), None);
- assert_eq!(m.swap(1, 3), Some(2));
- assert_eq!(m.swap(1, 4), Some(3));
+ assert_eq!(m.swap(1u, 2i), None);
+ assert_eq!(m.swap(1u, 3i), Some(2));
+ assert_eq!(m.swap(1u, 4i), Some(3));
}
#[test]
fn test_pop() {
let mut m = TrieMap::new();
- m.insert(1, 2);
+ m.insert(1u, 2i);
assert_eq!(m.pop(&1), Some(2));
assert_eq!(m.pop(&1), None);
}
fn bench_iter_small(b: &mut Bencher) {
let mut m = TrieMap::<uint>::new();
let mut rng = weak_rng();
- for _ in range(0, 20) {
+ for _ in range(0u, 20) {
m.insert(rng.gen(), rng.gen());
}
fn bench_iter_large(b: &mut Bencher) {
let mut m = TrieMap::<uint>::new();
let mut rng = weak_rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
m.insert(rng.gen(), rng.gen());
}
fn bench_lower_bound(b: &mut Bencher) {
let mut m = TrieMap::<uint>::new();
let mut rng = weak_rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
m.insert(rng.gen(), rng.gen());
}
b.iter(|| {
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
m.lower_bound(rng.gen());
}
});
fn bench_upper_bound(b: &mut Bencher) {
let mut m = TrieMap::<uint>::new();
let mut rng = weak_rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
m.insert(rng.gen(), rng.gen());
}
b.iter(|| {
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
m.upper_bound(rng.gen());
}
});
let mut rng = weak_rng();
b.iter(|| {
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
m.insert(rng.gen(), [1, .. 10]);
}
})
let mut rng = weak_rng();
b.iter(|| {
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
// only have the last few bits set.
m.insert(rng.gen::<uint>() & 0xff_ff, [1, .. 10]);
}
let mut rng = weak_rng();
b.iter(|| {
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
m.insert(rng.gen(), ());
}
})
let mut rng = weak_rng();
b.iter(|| {
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
// only have the last few bits set.
m.insert(rng.gen::<uint>() & 0xff_ff, ());
}
/// ```rust
/// # use std::vec::Vec;
/// let mut vec = Vec::new();
-/// vec.push(1);
-/// vec.push(2);
+/// vec.push(1i);
+/// vec.push(2i);
///
/// assert_eq!(vec.len(), 2);
/// assert_eq!(vec.get(0), &1);
/// The `vec!` macro is provided to make initialization more convenient:
///
/// ```rust
-/// let mut vec = vec!(1, 2, 3);
+/// let mut vec = vec!(1i, 2i, 3i);
/// vec.push(4);
/// assert_eq!(vec, vec!(1, 2, 3, 4));
/// ```
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3, 4);
+ /// let vec = vec!(1i, 2i, 3i, 4i);
/// let (even, odd) = vec.partition(|&n| n % 2 == 0);
/// assert_eq!(even, vec!(2, 4));
/// assert_eq!(odd, vec!(1, 3));
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2);
- /// let vec = vec.append([3, 4]);
+ /// let vec = vec!(1i, 2i);
+ /// let vec = vec.append([3i, 4i]);
/// assert_eq!(vec, vec!(1, 2, 3, 4));
/// ```
#[inline]
///
/// ```rust
/// # use std::vec::Vec;
- /// let slice = [1, 2, 3];
+ /// let slice = [1i, 2, 3];
/// let vec = Vec::from_slice(slice);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1);
- /// vec.push_all([2, 3, 4]);
+ /// let mut vec = vec!(1i);
+ /// vec.push_all([2i, 3, 4]);
/// assert_eq!(vec, vec!(1, 2, 3, 4));
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3, 4);
+ /// let vec = vec!(1i, 2, 3, 4);
/// let (even, odd) = vec.partitioned(|&n| n % 2 == 0);
- /// assert_eq!(even, vec!(2, 4));
- /// assert_eq!(odd, vec!(1, 3));
+ /// assert_eq!(even, vec!(2i, 4));
+ /// assert_eq!(odd, vec!(1i, 3));
/// ```
pub fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
let mut lefts = Vec::new();
///
/// ```rust
/// # use std::vec::Vec;
- /// let mut vec: Vec<int> = vec!(1);
+ /// let mut vec: Vec<int> = vec!(1i);
/// vec.reserve_additional(10);
/// assert!(vec.capacity() >= 11);
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// vec.reserve(10);
/// assert!(vec.capacity() >= 10);
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// vec.shrink_to_fit();
/// ```
pub fn shrink_to_fit(&mut self) {
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// assert_eq!(vec.pop(), Some(3));
/// assert_eq!(vec, vec!(1, 2));
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2);
+ /// let mut vec = vec!(1i, 2);
/// vec.push(3);
/// assert_eq!(vec, vec!(1, 2, 3));
/// ```
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2);
+ /// let vec = vec!(1i, 2);
/// let vec = vec.append_one(3);
/// assert_eq!(vec, vec!(1, 2, 3));
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3, 4);
+ /// let mut vec = vec!(1i, 2, 3, 4);
/// vec.truncate(2);
/// assert_eq!(vec, vec!(1, 2));
/// ```
/// ```rust
/// fn foo(slice: &mut [int]) {}
///
- /// let mut vec = vec!(1, 2);
+ /// let mut vec = vec!(1i, 2);
/// foo(vec.as_mut_slice());
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// assert!(vec.get(1) == &2);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// *vec.get_mut(1) = 4;
- /// assert_eq!(vec, vec!(1, 4, 3));
+ /// assert_eq!(vec, vec!(1i, 4, 3));
/// ```
#[inline]
pub fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut T {
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// for num in vec.iter() {
/// println!("{}", *num);
/// }
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// for num in vec.mut_iter() {
/// *num = 0;
/// }
/// ```rust
/// let mut v = vec!(5i, 4, 1, 3, 2);
/// v.sort_by(|a, b| a.cmp(b));
- /// assert_eq!(v, vec!(1, 2, 3, 4, 5));
+ /// assert_eq!(v, vec!(1i, 2, 3, 4, 5));
///
/// // reverse sorting
/// v.sort_by(|a, b| b.cmp(a));
- /// assert_eq!(v, vec!(5, 4, 3, 2, 1));
+ /// assert_eq!(v, vec!(5i, 4, 3, 2, 1));
/// ```
#[inline]
pub fn sort_by(&mut self, compare: |&T, &T| -> Ordering) {
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3, 4);
+ /// let vec = vec!(1i, 2, 3, 4);
/// assert!(vec.slice(0, 2) == [1, 2]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// assert!(vec.tail() == [2, 3]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3, 4);
+ /// let vec = vec!(1i, 2, 3, 4);
/// assert!(vec.tailn(2) == [3, 4]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// assert!(vec.last() == Some(&3));
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// *vec.mut_last().unwrap() = 4;
- /// assert_eq!(vec, vec!(1, 2, 4));
+ /// assert_eq!(vec, vec!(1i, 2, 4));
/// ```
#[inline]
pub fn mut_last<'a>(&'a mut self) -> Option<&'a mut T> {
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// vec.unshift(4);
/// assert_eq!(vec, vec!(4, 1, 2, 3));
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// assert!(vec.shift() == Some(1));
/// assert_eq!(vec, vec!(2, 3));
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3);
+ /// let mut vec = vec!(1i, 2, 3);
/// vec.insert(1, 4);
/// assert_eq!(vec, vec!(1, 4, 2, 3));
/// ```
/// # Example
///
/// ```rust
- /// let mut v = vec!(1, 2, 3);
+ /// let mut v = vec!(1i, 2, 3);
/// assert_eq!(v.remove(1), Some(2));
/// assert_eq!(v, vec!(1, 3));
///
/// # Example
///
/// ```rust
- /// let mut vec = vec!(box 1);
+ /// let mut vec = vec!(box 1i);
/// vec.push_all_move(vec!(box 2, box 3, box 4));
/// assert_eq!(vec, vec!(box 1, box 2, box 3, box 4));
/// ```
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3, 4);
+ /// let mut vec = vec!(1i, 2, 3, 4);
/// assert!(vec.mut_slice(0, 2) == [1, 2]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3, 4);
+ /// let mut vec = vec!(1i, 2, 3, 4);
/// assert!(vec.mut_slice_from(2) == [3, 4]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3, 4);
+ /// let mut vec = vec!(1i, 2, 3, 4);
/// assert!(vec.mut_slice_to(2) == [1, 2]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 3, 4, 5, 6);
+ /// let mut vec = vec!(1i, 2, 3, 4, 5, 6);
///
/// // scoped to restrict the lifetime of the borrows
/// {
/// # Example
///
/// ```rust
- /// let mut v = vec!(1, 2, 3);
+ /// let mut v = vec!(1i, 2, 3);
/// v.reverse();
- /// assert_eq!(v, vec!(3, 2, 1));
+ /// assert_eq!(v, vec!(3i, 2, 1));
/// ```
#[inline]
pub fn reverse(&mut self) {
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// assert!(vec.slice_from(1) == [2, 3]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// assert!(vec.slice_to(2) == [1, 2]);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let vec = vec!(1, 2, 3);
+ /// let vec = vec!(1i, 2, 3);
/// assert!(vec.contains(&1));
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut vec = vec!(1, 2, 2, 3, 2);
+ /// let mut vec = vec!(1i, 2, 2, 3, 2);
/// vec.dedup();
- /// assert_eq!(vec, vec!(1, 2, 3, 2));
+ /// assert_eq!(vec, vec!(1i, 2, 3, 2));
/// ```
pub fn dedup(&mut self) {
unsafe {
/// ```rust
/// fn foo(slice: &[int]) {}
///
- /// let vec = vec!(1, 2);
+ /// let vec = vec!(1i, 2);
/// foo(vec.as_slice());
/// ```
#[inline]
v.reserve_additional(2);
assert!(v.capacity() >= 2);
- for i in range(0, 16) {
+ for i in range(0i, 16) {
v.push(i);
}
let mut v = Vec::new();
let mut w = Vec::new();
- v.extend(range(0, 3));
- for i in range(0, 3) { w.push(i) }
+ v.extend(range(0i, 3));
+ for i in range(0i, 3) { w.push(i) }
assert_eq!(v, w);
- v.extend(range(3, 10));
- for i in range(3, 10) { w.push(i) }
+ v.extend(range(3i, 10));
+ for i in range(3i, 10) { w.push(i) }
assert_eq!(v, w);
}
#[test]
fn test_clone() {
let v: Vec<int> = vec!();
- let w = vec!(1, 2, 3);
+ let w = vec!(1i, 2, 3);
assert_eq!(v, v.clone());
#[test]
fn test_clone_from() {
let mut v = vec!();
- let three = vec!(box 1, box 2, box 3);
- let two = vec!(box 4, box 5);
+ let three = vec!(box 1i, box 2, box 3);
+ let two = vec!(box 4i, box 5);
// zero, long
v.clone_from(&three);
assert_eq!(v, three);
#[test]
fn test_partition() {
assert_eq!(vec![].partition(|x: &int| *x < 3), (vec![], vec![]));
- assert_eq!(vec![1, 2, 3].partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!(vec![1, 2, 3].partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!(vec![1, 2, 3].partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+ assert_eq!(vec![1i, 2, 3].partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!(vec![1i, 2, 3].partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!(vec![1i, 2, 3].partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
}
#[test]
fn test_partitioned() {
assert_eq!(vec![].partitioned(|x: &int| *x < 3), (vec![], vec![]))
- assert_eq!(vec![1, 2, 3].partitioned(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
- assert_eq!(vec![1, 2, 3].partitioned(|x: &int| *x < 2), (vec![1], vec![2, 3]));
- assert_eq!(vec![1, 2, 3].partitioned(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+ assert_eq!(vec![1i, 2, 3].partitioned(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
+ assert_eq!(vec![1i, 2, 3].partitioned(|x: &int| *x < 2), (vec![1], vec![2, 3]));
+ assert_eq!(vec![1i, 2, 3].partitioned(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
}
#[test]
fn test_zip_unzip() {
- let z1 = vec![(1, 4), (2, 5), (3, 6)];
+ let z1 = vec![(1i, 4i), (2, 5), (3, 6)];
let (left, right) = unzip(z1.iter().map(|&x| x));
fn test_unsafe_ptrs() {
unsafe {
// Test on-stack copy-from-buf.
- let a = [1, 2, 3];
+ let a = [1i, 2, 3];
let ptr = a.as_ptr();
let b = raw::from_buf(ptr, 3u);
assert_eq!(b, vec![1, 2, 3]);
// Test on-heap copy-from-buf.
- let c = vec![1, 2, 3, 4, 5];
+ let c = vec![1i, 2, 3, 4, 5];
let ptr = c.as_ptr();
let d = raw::from_buf(ptr, 5u);
assert_eq!(d, vec![1, 2, 3, 4, 5]);
#[bench]
fn bench_from_slice_5(b: &mut Bencher) {
b.iter(|| {
- let v: Vec<int> = Vec::from_slice([1, 2, 3, 4, 5]);
+ let v: Vec<int> = Vec::from_slice([1i, 2, 3, 4, 5]);
assert!(v.as_slice() == [1, 2, 3, 4, 5]);
})
}
#[bench]
fn bench_as_ref(b: &mut Bencher) {
b.iter(|| {
- let mut x = 0; let mut y = &mut x as &mut Any;
+ let mut x = 0i;
+ let mut y = &mut x as &mut Any;
test::black_box(&mut y);
test::black_box(y.as_ref::<int>() == Some(&0));
});
#[test]
fn smoketest_cell() {
- let x = Cell::new(10);
+ let x = Cell::new(10i);
assert!(x == Cell::new(10));
assert!(x.get() == 10);
x.set(20);
assert!(x == Cell::new(20));
assert!(x.get() == 20);
- let y = Cell::new((30, 40));
+ let y = Cell::new((30i, 40i));
assert!(y == Cell::new((30, 40)));
assert!(y.get() == (30, 40));
}
_ => { f('U'); 8 }
};
for offset in range_step::<i32>(4 * (pad - 1), -1, -4) {
+ let offset = offset as uint;
unsafe {
match ((c as i32) >> offset) & 0xf {
i @ 0 .. 9 => { f(transmute('0' as i32 + i)); }
#[test]
fn test_clone_from() {
- let a = box 5;
- let mut b = box 10;
+ let a = box 5i;
+ let mut b = box 10i;
realclone_from(&mut b, &a);
assert_eq!(*b, 5);
}
#[test]
fn test_success() {
- let mut i = 0;
+ let mut i = 0i;
try_finally(
&mut i, (),
|i, ()| {
#[test]
#[should_fail]
fn test_fail() {
- let mut i = 0;
+ let mut i = 0i;
try_finally(
&mut i, (),
|i, ()| {
///
/// ~~~
/// use std::fmt::radix;
-/// assert_eq!(format!("{}", radix(55, 36)), "1j".to_string());
+/// assert_eq!(format!("{}", radix(55i, 36)), "1j".to_string());
/// ~~~
pub fn radix<T>(x: T, base: u8) -> RadixFmt<T, Radix> {
RadixFmt(x, Radix::new(base))
assert!(format!("{:o}", 1u64).as_slice() == "1");
// Test a larger number
- assert!(format!("{:t}", 55).as_slice() == "110111");
- assert!(format!("{:o}", 55).as_slice() == "67");
- assert!(format!("{:d}", 55).as_slice() == "55");
- assert!(format!("{:x}", 55).as_slice() == "37");
- assert!(format!("{:X}", 55).as_slice() == "37");
+ assert!(format!("{:t}", 55i).as_slice() == "110111");
+ assert!(format!("{:o}", 55i).as_slice() == "67");
+ assert!(format!("{:d}", 55i).as_slice() == "55");
+ assert!(format!("{:x}", 55i).as_slice() == "37");
+ assert!(format!("{:X}", 55i).as_slice() == "37");
}
#[test]
#[test]
fn test_format_int_flags() {
- assert!(format!("{:3d}", 1).as_slice() == " 1");
- assert!(format!("{:>3d}", 1).as_slice() == " 1");
- assert!(format!("{:>+3d}", 1).as_slice() == " +1");
- assert!(format!("{:<3d}", 1).as_slice() == "1 ");
- assert!(format!("{:#d}", 1).as_slice() == "1");
- assert!(format!("{:#x}", 10).as_slice() == "0xa");
- assert!(format!("{:#X}", 10).as_slice() == "0xA");
- assert!(format!("{:#5x}", 10).as_slice() == " 0xa");
- assert!(format!("{:#o}", 10).as_slice() == "0o12");
- assert!(format!("{:08x}", 10).as_slice() == "0000000a");
- assert!(format!("{:8x}", 10).as_slice() == " a");
- assert!(format!("{:<8x}", 10).as_slice() == "a ");
- assert!(format!("{:>8x}", 10).as_slice() == " a");
- assert!(format!("{:#08x}", 10).as_slice() == "0x00000a");
- assert!(format!("{:08d}", -10).as_slice() == "-0000010");
+ assert!(format!("{:3d}", 1i).as_slice() == " 1");
+ assert!(format!("{:>3d}", 1i).as_slice() == " 1");
+ assert!(format!("{:>+3d}", 1i).as_slice() == " +1");
+ assert!(format!("{:<3d}", 1i).as_slice() == "1 ");
+ assert!(format!("{:#d}", 1i).as_slice() == "1");
+ assert!(format!("{:#x}", 10i).as_slice() == "0xa");
+ assert!(format!("{:#X}", 10i).as_slice() == "0xA");
+ assert!(format!("{:#5x}", 10i).as_slice() == " 0xa");
+ assert!(format!("{:#o}", 10i).as_slice() == "0o12");
+ assert!(format!("{:08x}", 10i).as_slice() == "0000000a");
+ assert!(format!("{:8x}", 10i).as_slice() == " a");
+ assert!(format!("{:<8x}", 10i).as_slice() == "a ");
+ assert!(format!("{:>8x}", 10i).as_slice() == " a");
+ assert!(format!("{:#08x}", 10i).as_slice() == "0x00000a");
+ assert!(format!("{:08d}", -10i).as_slice() == "-0000010");
assert!(format!("{:x}", -1u8).as_slice() == "ff");
assert!(format!("{:X}", -1u8).as_slice() == "FF");
assert!(format!("{:t}", -1u8).as_slice() == "11111111");
#[test]
fn test_format_int_sign_padding() {
- assert!(format!("{:+5d}", 1).as_slice() == " +1");
- assert!(format!("{:+5d}", -1).as_slice() == " -1");
- assert!(format!("{:05d}", 1).as_slice() == "00001");
- assert!(format!("{:05d}", -1).as_slice() == "-0001");
- assert!(format!("{:+05d}", 1).as_slice() == "+0001");
- assert!(format!("{:+05d}", -1).as_slice() == "-0001");
+ assert!(format!("{:+5d}", 1i).as_slice() == " +1");
+ assert!(format!("{:+5d}", -1i).as_slice() == " -1");
+ assert!(format!("{:05d}", 1i).as_slice() == "00001");
+ assert!(format!("{:05d}", -1i).as_slice() == "-0001");
+ assert!(format!("{:+05d}", 1i).as_slice() == "+0001");
+ assert!(format!("{:+05d}", -1i).as_slice() == "-0001");
}
#[test]
#[test]
fn test_format_radix() {
- assert!(format!("{:04}", radix(3, 2)).as_slice() == "0011");
- assert!(format!("{}", radix(55, 36)).as_slice() == "1j");
+ assert!(format!("{:04}", radix(3i, 2)).as_slice() == "0011");
+ assert!(format!("{}", radix(55i, 36)).as_slice() == "1j");
}
#[test]
translated to the `loop` below.
```rust
-let values = vec![1, 2, 3];
+let values = vec![1i, 2, 3];
// "Syntactical sugar" taking advantage of an iterator
for &x in values.iter() {
/// # Example
///
/// ```rust
- /// let a = [0];
- /// let b = [1];
+ /// let a = [0i];
+ /// let b = [1i];
/// let mut it = a.iter().chain(b.iter());
/// assert_eq!(it.next().unwrap(), &0);
/// assert_eq!(it.next().unwrap(), &1);
/// # Example
///
/// ```rust
- /// let a = [0];
- /// let b = [1];
+ /// let a = [0i];
+ /// let b = [1i];
/// let mut it = a.iter().zip(b.iter());
/// assert_eq!(it.next().unwrap(), (&0, &1));
/// assert!(it.next().is_none());
/// # Example
///
/// ```rust
- /// let a = [1, 2];
+ /// let a = [1i, 2];
/// let mut it = a.iter().map(|&x| 2 * x);
/// assert_eq!(it.next().unwrap(), 2);
/// assert_eq!(it.next().unwrap(), 4);
/// # Example
///
/// ```rust
- /// let a = [1, 2];
+ /// let a = [1i, 2];
/// let mut it = a.iter().filter(|&x| *x > 1);
/// assert_eq!(it.next().unwrap(), &2);
/// assert!(it.next().is_none());
/// # Example
///
/// ```rust
- /// let a = [1, 2];
+ /// let a = [1i, 2];
/// let mut it = a.iter().filter_map(|&x| if x > 1 {Some(2 * x)} else {None});
/// assert_eq!(it.next().unwrap(), 4);
/// assert!(it.next().is_none());
/// # Example
///
/// ```rust
- /// let a = [100, 200];
+ /// let a = [100i, 200];
/// let mut it = a.iter().enumerate();
/// assert_eq!(it.next().unwrap(), (0, &100));
/// assert_eq!(it.next().unwrap(), (1, &200));
/// # Example
///
/// ```rust
- /// let xs = [100, 200, 300];
+ /// let xs = [100i, 200, 300];
/// let mut it = xs.iter().map(|x| *x).peekable();
/// assert_eq!(it.peek().unwrap(), &100);
/// assert_eq!(it.next().unwrap(), 100);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 2, 1];
+ /// let a = [1i, 2, 3, 2, 1];
/// let mut it = a.iter().skip_while(|&a| *a < 3);
/// assert_eq!(it.next().unwrap(), &3);
/// assert_eq!(it.next().unwrap(), &2);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 2, 1];
+ /// let a = [1i, 2, 3, 2, 1];
/// let mut it = a.iter().take_while(|&a| *a < 3);
/// assert_eq!(it.next().unwrap(), &1);
/// assert_eq!(it.next().unwrap(), &2);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter().skip(3);
/// assert_eq!(it.next().unwrap(), &4);
/// assert_eq!(it.next().unwrap(), &5);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter().take(3);
/// assert_eq!(it.next().unwrap(), &1);
/// assert_eq!(it.next().unwrap(), &2);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter().scan(1, |fac, &x| {
/// *fac = *fac * x;
/// Some(*fac)
/// }
/// sum
/// }
- /// let x = vec![1,2,3,7,8,9];
+ /// let x = vec![1i,2,3,7,8,9];
/// assert_eq!(process(x.move_iter()), 1006);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let mut xs = range(0, 10);
+ /// let mut xs = range(0u, 10);
/// // sum the first five values
/// let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
/// assert!(partial_sum == 10);
/// # Example
///
/// ```rust
- /// range(0, 5).advance(|x| {print!("{} ", x); true});
+ /// range(0u, 5).advance(|x| {print!("{} ", x); true});
/// ```
#[inline]
fn advance(&mut self, f: |A| -> bool) -> bool {
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let b: Vec<int> = a.iter().map(|&x| x).collect();
/// assert!(a.as_slice() == b.as_slice());
/// ```
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter();
/// assert!(it.nth(2).unwrap() == &3);
/// assert!(it.nth(2) == None);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// assert!(a.iter().last().unwrap() == &5);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// assert!(a.iter().fold(0, |a, &b| a + b) == 15);
/// ```
#[inline]
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter();
/// assert!(it.count() == 5);
/// assert!(it.count() == 0);
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// assert!(a.iter().all(|x| *x > 0));
/// assert!(!a.iter().all(|x| *x > 2));
/// ```
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter();
/// assert!(it.any(|x| *x == 3));
/// assert!(!it.any(|x| *x == 3));
/// ```rust
/// use std::iter::AdditiveIterator;
///
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// let mut it = a.iter().map(|&x| x);
/// assert!(it.sum() == 15);
/// ```
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// assert!(a.iter().max().unwrap() == &5);
/// ```
fn max(&mut self) -> Option<A>;
/// # Example
///
/// ```rust
- /// let a = [1, 2, 3, 4, 5];
+ /// let a = [1i, 2, 3, 4, 5];
/// assert!(a.iter().min().unwrap() == &1);
/// ```
fn min(&mut self) -> Option<A>;
/// let r: MinMaxResult<int> = NoElements;
/// assert_eq!(r.into_option(), None)
///
- /// let r = OneElement(1);
+ /// let r = OneElement(1i);
/// assert_eq!(r.into_option(), Some((1,1)));
///
- /// let r = MinMax(1,2);
+ /// let r = MinMax(1i,2i);
/// assert_eq!(r.into_option(), Some((1,2)));
/// ```
pub fn into_option(self) -> Option<(T,T)> {
/// ```rust
/// use std::iter::{CloneableIterator, count};
///
- /// let a = count(1,1).take(1);
+ /// let a = count(1i,1i).take(1);
/// let mut cy = a.cycle();
/// assert_eq!(cy.next(), Some(1));
/// assert_eq!(cy.next(), Some(1));
use slice::ImmutableVector;
let empty: [int, ..0] = [];
- let xs = [1,2,3];
- let ys = [1,2,0];
+ let xs = [1i,2,3];
+ let ys = [1i,2,0];
assert!(!lt(xs.iter(), ys.iter()));
assert!(!le(xs.iter(), ys.iter()));
assert!(!ge(empty.iter(), xs.iter()));
// Sequence with NaN
- let u = [1.0, 2.0];
- let v = [0.0/0.0, 3.0];
+ let u = [1.0f64, 2.0];
+ let v = [0.0f64/0.0, 3.0];
assert!(!lt(u.iter(), v.iter()));
assert!(!le(u.iter(), v.iter()));
assert!(!gt(u.iter(), v.iter()));
assert!(!ge(u.iter(), v.iter()));
- let a = [0.0/0.0];
- let b = [1.0];
- let c = [2.0];
+ let a = [0.0f64/0.0];
+ let b = [1.0f64];
+ let c = [2.0f64];
assert!(lt(a.iter(), b.iter()) == (a[0] < b[0]));
assert!(le(a.iter(), b.iter()) == (a[0] <= b[0]));
#[test]
fn test_counter_from_iter() {
- let it = count(0, 5).take(10);
+ let it = count(0i, 5).take(10);
let xs: Vec<int> = FromIterator::from_iter(it);
assert!(xs == vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
}
#[test]
fn test_iterator_nth() {
- let v = &[0, 1, 2, 3, 4];
+ let v = &[0i, 1, 2, 3, 4];
for i in range(0u, v.len()) {
assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
}
#[test]
fn test_iterator_last() {
- let v = &[0, 1, 2, 3, 4];
+ let v = &[0i, 1, 2, 3, 4];
assert_eq!(v.iter().last().unwrap(), &4);
assert_eq!(v.slice(0, 1).iter().last().unwrap(), &0);
}
#[test]
fn test_iterator_len() {
- let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().count(), 4);
assert_eq!(v.slice(0, 10).iter().count(), 10);
assert_eq!(v.slice(0, 0).iter().count(), 0);
#[test]
fn test_iterator_sum() {
- let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().map(|&x| x).sum(), 6);
assert_eq!(v.iter().map(|&x| x).sum(), 55);
assert_eq!(v.slice(0, 0).iter().map(|&x| x).sum(), 0);
#[test]
fn test_iterator_product() {
- let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().map(|&x| x).product(), 0);
assert_eq!(v.slice(1, 5).iter().map(|&x| x).product(), 24);
assert_eq!(v.slice(0, 0).iter().map(|&x| x).product(), 1);
#[test]
fn test_iterator_max() {
- let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().map(|&x| x).max(), Some(3));
assert_eq!(v.iter().map(|&x| x).max(), Some(10));
assert_eq!(v.slice(0, 0).iter().map(|&x| x).max(), None);
#[test]
fn test_iterator_min() {
- let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+ let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
assert_eq!(v.slice(0, 4).iter().map(|&x| x).min(), Some(0));
assert_eq!(v.iter().map(|&x| x).min(), Some(0));
assert_eq!(v.slice(0, 0).iter().map(|&x| x).min(), None);
#[test]
fn test_iterator_size_hint() {
- let c = count(0, 1);
- let v = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
- let v2 = &[10, 11, 12];
+ let c = count(0i, 1);
+ let v = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+ let v2 = &[10i, 11, 12];
let vi = v.iter();
assert_eq!(c.size_hint(), (uint::MAX, None));
#[test]
fn test_collect() {
- let a = vec![1, 2, 3, 4, 5];
+ let a = vec![1i, 2, 3, 4, 5];
let b: Vec<int> = a.iter().map(|&x| x).collect();
assert!(a == b);
}
#[test]
fn test_all() {
- let v: Box<&[int]> = box &[1, 2, 3, 4, 5];
+ let v: Box<&[int]> = box &[1i, 2, 3, 4, 5];
assert!(v.iter().all(|&x| x < 10));
assert!(!v.iter().all(|&x| x % 2 == 0));
assert!(!v.iter().all(|&x| x > 100));
#[test]
fn test_any() {
- let v: Box<&[int]> = box &[1, 2, 3, 4, 5];
+ let v: Box<&[int]> = box &[1i, 2, 3, 4, 5];
assert!(v.iter().any(|&x| x < 10));
assert!(v.iter().any(|&x| x % 2 == 0));
assert!(!v.iter().any(|&x| x > 100));
#[test]
fn test_find() {
- let v: &[int] = &[1, 3, 9, 27, 103, 14, 11];
+ let v: &[int] = &[1i, 3, 9, 27, 103, 14, 11];
assert_eq!(*v.iter().find(|x| *x & 1 == 0).unwrap(), 14);
assert_eq!(*v.iter().find(|x| *x % 3 == 0).unwrap(), 3);
assert!(v.iter().find(|x| *x % 12 == 0).is_none());
#[test]
fn test_position() {
- let v = &[1, 3, 9, 27, 103, 14, 11];
+ let v = &[1i, 3, 9, 27, 103, 14, 11];
assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
assert!(v.iter().position(|x| *x % 12 == 0).is_none());
#[test]
fn test_count() {
- let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
+ let xs = &[1i, 2, 2, 1, 5, 9, 0, 2];
assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3);
assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1);
assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0);
#[test]
fn test_max_by() {
- let xs: &[int] = &[-3, 0, 1, 5, -10];
+ let xs: &[int] = &[-3i, 0, 1, 5, -10];
assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
}
#[test]
fn test_min_by() {
- let xs: &[int] = &[-3, 0, 1, 5, -10];
+ let xs: &[int] = &[-3i, 0, 1, 5, -10];
assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
}
#[test]
fn test_by_ref() {
- let mut xs = range(0, 10);
+ let mut xs = range(0i, 10);
// sum the first five values
let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
assert_eq!(partial_sum, 10);
#[test]
fn test_rev() {
- let xs = [2, 4, 6, 8, 10, 12, 14, 16];
+ let xs = [2i, 4, 6, 8, 10, 12, 14, 16];
let mut it = xs.iter();
it.next();
it.next();
#[test]
fn test_double_ended_map() {
- let xs = [1, 2, 3, 4, 5, 6];
+ let xs = [1i, 2, 3, 4, 5, 6];
let mut it = xs.iter().map(|&x| x * -1);
assert_eq!(it.next(), Some(-1));
assert_eq!(it.next(), Some(-2));
#[test]
fn test_double_ended_enumerate() {
- let xs = [1, 2, 3, 4, 5, 6];
+ let xs = [1i, 2, 3, 4, 5, 6];
let mut it = xs.iter().map(|&x| x).enumerate();
assert_eq!(it.next(), Some((0, 1)));
assert_eq!(it.next(), Some((1, 2)));
#[test]
fn test_double_ended_zip() {
- let xs = [1, 2, 3, 4, 5, 6];
- let ys = [1, 2, 3, 7];
+ let xs = [1i, 2, 3, 4, 5, 6];
+ let ys = [1i, 2, 3, 7];
let a = xs.iter().map(|&x| x);
let b = ys.iter().map(|&x| x);
let mut it = a.zip(b);
#[test]
fn test_double_ended_filter() {
- let xs = [1, 2, 3, 4, 5, 6];
+ let xs = [1i, 2, 3, 4, 5, 6];
let mut it = xs.iter().filter(|&x| *x & 1 == 0);
assert_eq!(it.next_back().unwrap(), &6);
assert_eq!(it.next_back().unwrap(), &4);
#[test]
fn test_double_ended_filter_map() {
- let xs = [1, 2, 3, 4, 5, 6];
+ let xs = [1i, 2, 3, 4, 5, 6];
let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
assert_eq!(it.next_back().unwrap(), 12);
assert_eq!(it.next_back().unwrap(), 8);
#[test]
fn test_double_ended_chain() {
- let xs = [1, 2, 3, 4, 5];
- let ys = [7, 9, 11];
+ let xs = [1i, 2, 3, 4, 5];
+ let ys = [7i, 9, 11];
let mut it = xs.iter().chain(ys.iter()).rev();
assert_eq!(it.next().unwrap(), &11)
assert_eq!(it.next().unwrap(), &9)
fn test_rposition() {
fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
- let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
+ let v = [(0i, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
assert_eq!(v.iter().rposition(f), Some(3u));
assert!(v.iter().rposition(g).is_none());
#[test]
#[should_fail]
fn test_rposition_fail() {
- let v = [(box 0, box(GC) 0), (box 0, box(GC) 0),
- (box 0, box(GC) 0), (box 0, box(GC) 0)];
- let mut i = 0;
+ let v = [(box 0i, box(GC) 0i), (box 0i, box(GC) 0i),
+ (box 0i, box(GC) 0i), (box 0i, box(GC) 0i)];
+ let mut i = 0i;
v.iter().rposition(|_elt| {
if i == 2 {
fail!()
{
let mut b = a.clone();
assert_eq!(len, b.indexable());
- let mut n = 0;
+ let mut n = 0u;
for (i, elt) in a.enumerate() {
assert!(Some(elt) == b.idx(i));
n += 1;
#[test]
fn test_double_ended_flat_map() {
let u = [0u,1];
- let v = [5,6,7,8];
+ let v = [5u,6,7,8];
let mut it = u.iter().flat_map(|x| v.slice(*x, v.len()).iter());
assert_eq!(it.next_back().unwrap(), &8);
assert_eq!(it.next().unwrap(), &5);
#[test]
fn test_random_access_chain() {
- let xs = [1, 2, 3, 4, 5];
- let ys = [7, 9, 11];
+ let xs = [1i, 2, 3, 4, 5];
+ let ys = [7i, 9, 11];
let mut it = xs.iter().chain(ys.iter());
assert_eq!(it.idx(0).unwrap(), &1);
assert_eq!(it.idx(5).unwrap(), &7);
#[test]
fn test_random_access_enumerate() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
check_randacc_iter(xs.iter().enumerate(), xs.len());
}
#[test]
fn test_random_access_rev() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
check_randacc_iter(xs.iter().rev(), xs.len());
let mut it = xs.iter().rev();
it.next();
#[test]
fn test_random_access_zip() {
- let xs = [1, 2, 3, 4, 5];
- let ys = [7, 9, 11];
+ let xs = [1i, 2, 3, 4, 5];
+ let ys = [7i, 9, 11];
check_randacc_iter(xs.iter().zip(ys.iter()), cmp::min(xs.len(), ys.len()));
}
#[test]
fn test_random_access_take() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
let empty: &[int] = [];
check_randacc_iter(xs.iter().take(3), 3);
check_randacc_iter(xs.iter().take(20), xs.len());
#[test]
fn test_random_access_skip() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
let empty: &[int] = [];
check_randacc_iter(xs.iter().skip(2), xs.len() - 2);
check_randacc_iter(empty.iter().skip(2), 0);
#[test]
fn test_random_access_inspect() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
// test .map and .inspect that don't implement Clone
let mut it = xs.iter().inspect(|_| {});
#[test]
fn test_random_access_map() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
let mut it = xs.iter().map(|x| *x);
assert_eq!(xs.len(), it.indexable());
#[test]
fn test_random_access_cycle() {
- let xs = [1, 2, 3, 4, 5];
+ let xs = [1i, 2, 3, 4, 5];
let empty: &[int] = [];
check_randacc_iter(xs.iter().cycle().take(27), 27);
check_randacc_iter(empty.iter().cycle(), 0);
assert!(range(-10i, -1).collect::<Vec<int>>() ==
vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
assert!(range(0i, 5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
- assert_eq!(range(200, -5).count(), 0);
- assert_eq!(range(200, -5).rev().count(), 0);
- assert_eq!(range(200, 200).count(), 0);
- assert_eq!(range(200, 200).rev().count(), 0);
+ assert_eq!(range(200i, -5).count(), 0);
+ assert_eq!(range(200i, -5).rev().count(), 0);
+ assert_eq!(range(200i, 200).count(), 0);
+ assert_eq!(range(200i, 200).rev().count(), 0);
assert_eq!(range(0i, 100).size_hint(), (100, Some(100)));
// this test is only meaningful when sizeof uint < sizeof u64
vec![0i, 1, 2, 3, 4, 5]);
assert!(range_inclusive(0i, 5).rev().collect::<Vec<int>>() ==
vec![5i, 4, 3, 2, 1, 0]);
- assert_eq!(range_inclusive(200, -5).count(), 0);
- assert_eq!(range_inclusive(200, -5).rev().count(), 0);
- assert!(range_inclusive(200, 200).collect::<Vec<int>>() == vec![200]);
- assert!(range_inclusive(200, 200).rev().collect::<Vec<int>>() == vec![200]);
+ assert_eq!(range_inclusive(200i, -5).count(), 0);
+ assert_eq!(range_inclusive(200i, -5).rev().count(), 0);
+ assert!(range_inclusive(200i, 200).collect::<Vec<int>>() == vec![200]);
+ assert!(range_inclusive(200i, 200).rev().collect::<Vec<int>>() == vec![200]);
}
#[test]
vec![20, 14, 8, 2]);
assert!(range_step(200u8, 255, 50).collect::<Vec<u8>>() ==
vec![200u8, 250]);
- assert!(range_step(200, -5, 1).collect::<Vec<int>>() == vec![]);
- assert!(range_step(200, 200, 1).collect::<Vec<int>>() == vec![]);
+ assert!(range_step(200i, -5, 1).collect::<Vec<int>>() == vec![]);
+ assert!(range_step(200i, 200, 1).collect::<Vec<int>>() == vec![]);
}
#[test]
vec![20, 14, 8, 2]);
assert!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() ==
vec![200u8, 250]);
- assert!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>() ==
+ assert!(range_step_inclusive(200i, -5, 1).collect::<Vec<int>>() ==
vec![]);
- assert!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>() ==
+ assert!(range_step_inclusive(200i, 200, 1).collect::<Vec<int>>() ==
vec![200]);
}
#[test]
fn test_reverse() {
- let mut ys = [1, 2, 3, 4, 5];
+ let mut ys = [1i, 2, 3, 4, 5];
ys.mut_iter().reverse_();
assert!(ys == [5, 4, 3, 2, 1]);
}
#[test]
fn test_peekable_is_empty() {
- let a = [1];
+ let a = [1i];
let mut it = a.iter().peekable();
assert!( !it.is_empty() );
it.next();
let r: MinMaxResult<int> = NoElements;
assert_eq!(r.into_option(), None)
- let r = OneElement(1);
+ let r = OneElement(1i);
assert_eq!(r.into_option(), Some((1,1)));
- let r = MinMax(1,2);
+ let r = MinMax(1i,2);
assert_eq!(r.into_option(), Some((1,2)));
}
}
/// ```
/// use std::cell::RefCell;
///
-/// let x = RefCell::new(1);
+/// let x = RefCell::new(1i);
///
/// let mut mutable_borrow = x.borrow_mut();
/// *mutable_borrow = 1;
#[test]
fn test_swap() {
- let mut x = 31337;
- let mut y = 42;
+ let mut x = 31337i;
+ let mut y = 42i;
swap(&mut x, &mut y);
assert_eq!(x, 42);
assert_eq!(y, 31337);
trait Foo {}
impl Foo for int {}
- let a = box 100 as Box<Foo>;
+ let a = box 100i as Box<Foo>;
unsafe {
let x: raw::TraitObject = transmute(a);
assert!(*(x.data as *int) == 100);
/// ```rust
/// use std::num;
///
-/// assert_eq!(num::pow(2, 4), 16);
+/// assert_eq!(num::pow(2i, 4), 16);
/// ```
#[inline]
pub fn pow<T: One + Mul<T, T>>(mut base: T, mut exp: uint) -> T {
/// ```
/// use std::num;
///
-/// let twenty: f32 = num::cast(0x14).unwrap();
+/// let twenty: f32 = num::cast(0x14i).unwrap();
/// assert_eq!(twenty, 20f32);
/// ```
///
/// Helper function for testing numeric operations
#[cfg(test)]
pub fn test_num<T:Num + NumCast + ::std::fmt::Show>(ten: T, two: T) {
- assert_eq!(ten.add(&two), cast(12).unwrap());
- assert_eq!(ten.sub(&two), cast(8).unwrap());
- assert_eq!(ten.mul(&two), cast(20).unwrap());
- assert_eq!(ten.div(&two), cast(5).unwrap());
- assert_eq!(ten.rem(&two), cast(0).unwrap());
+ assert_eq!(ten.add(&two), cast(12i).unwrap());
+ assert_eq!(ten.sub(&two), cast(8i).unwrap());
+ assert_eq!(ten.mul(&two), cast(20i).unwrap());
+ assert_eq!(ten.div(&two), cast(5i).unwrap());
+ assert_eq!(ten.rem(&two), cast(0i).unwrap());
assert_eq!(ten.add(&two), ten + two);
assert_eq!(ten.sub(&two), ten - two);
macro_rules! shl_impl(
($($t:ty)*) => ($(
- #[cfg(not(test))]
+ #[cfg(stage0)]
impl Shl<$t, $t> for $t {
#[inline]
fn shl(&self, other: &$t) -> $t { (*self) << (*other) }
}
+ #[cfg(not(stage0), not(test))]
+ impl Shl<$t, $t> for $t {
+ #[inline]
+ fn shl(&self, other: &$t) -> $t {
+ (*self) << (*other as uint)
+ }
+ }
)*)
)
macro_rules! shr_impl(
($($t:ty)*) => ($(
- #[cfg(not(test))]
+ #[cfg(stage0, not(test))]
impl Shr<$t, $t> for $t {
#[inline]
fn shr(&self, other: &$t) -> $t { (*self) >> (*other) }
}
+ #[cfg(not(stage0), not(test))]
+ impl Shr<$t, $t> for $t {
+ #[inline]
+ fn shr(&self, other: &$t) -> $t { (*self) >> (*other as uint) }
+ }
)*)
)
/// let good_year = from_str(good_year_from_input).unwrap_or_default();
/// let bad_year = from_str(bad_year_from_input).unwrap_or_default();
///
- /// assert_eq!(1909, good_year);
- /// assert_eq!(0, bad_year);
+ /// assert_eq!(1909i, good_year);
+ /// assert_eq!(0i, bad_year);
/// ```
#[inline]
pub fn unwrap_or_default(self) -> T {
t.clone()
}
- let i = Rc::new(RefCell::new(0));
+ let i = Rc::new(RefCell::new(0i));
{
let x = r(realclone(&i));
let opt = Some(x);
#[test]
fn test_option_dance() {
let x = Some(());
- let mut y = Some(5);
+ let mut y = Some(5i);
let mut y2 = 0;
for _x in x.iter() {
y2 = y.take_unwrap();
#[test]
fn test_and() {
- let x: Option<int> = Some(1);
- assert_eq!(x.and(Some(2)), Some(2));
+ let x: Option<int> = Some(1i);
+ assert_eq!(x.and(Some(2i)), Some(2));
assert_eq!(x.and(None::<int>), None);
let x: Option<int> = None;
- assert_eq!(x.and(Some(2)), None);
+ assert_eq!(x.and(Some(2i)), None);
assert_eq!(x.and(None::<int>), None);
}
#[test]
fn test_option_while_some() {
- let mut i = 0;
+ let mut i = 0i;
Some(10).while_some(|j| {
i += 1;
if j > 0 {
#[test]
fn test_unwrap() {
- assert_eq!(Some(1).unwrap(), 1);
+ assert_eq!(Some(1i).unwrap(), 1);
let s = Some("hello".to_string()).unwrap();
assert_eq!(s.as_slice(), "hello");
}
#[test]
fn test_filtered() {
- let some_stuff = Some(42);
+ let some_stuff = Some(42i);
let modified_stuff = some_stuff.filtered(|&x| {x < 10});
assert_eq!(some_stuff.unwrap(), 42);
assert!(modified_stuff.is_none());
#[test]
fn test_iter() {
- let val = 5;
+ let val = 5i;
let x = Some(val);
let mut it = x.iter();
#[test]
fn test_mut_iter() {
- let val = 5;
- let new_val = 11;
+ let val = 5i;
+ let new_val = 11i;
let mut x = Some(val);
{
#[test]
fn test_ord() {
- let small = Some(1.0);
- let big = Some(5.0);
- let nan = Some(0.0/0.0);
+ let small = Some(1.0f64);
+ let big = Some(5.0f64);
+ let nan = Some(0.0f64/0.0);
assert!(!(nan < big));
assert!(!(nan > big));
assert!(small < big);
#[test]
fn test_collect() {
- let v: Option<Vec<int>> = collect(range(0, 0)
- .map(|_| Some(0)));
+ let v: Option<Vec<int>> = collect(range(0i, 0)
+ .map(|_| Some(0i)));
assert!(v == Some(vec![]));
- let v: Option<Vec<int>> = collect(range(0, 3)
+ let v: Option<Vec<int>> = collect(range(0i, 3)
.map(|x| Some(x)));
assert!(v == Some(vec![0, 1, 2]));
- let v: Option<Vec<int>> = collect(range(0, 3)
+ let v: Option<Vec<int>> = collect(range(0i, 3)
.map(|x| if x > 1 { None } else { Some(x) }));
assert!(v == None);
#[test]
fn test_ptr_addition() {
unsafe {
- let xs = Vec::from_elem(16, 5);
+ let xs = Vec::from_elem(16, 5i);
let mut ptr = xs.as_ptr();
let end = ptr.offset(16);
m_ptr = m_ptr.offset(1);
}
- assert!(xs_mut == Vec::from_elem(16, 10));
+ assert!(xs_mut == Vec::from_elem(16, 10i));
}
}
];
let arr_ptr = arr.as_ptr();
- let mut ctr = 0;
- let mut iteration_count = 0;
+ let mut ctr = 0u;
+ let mut iteration_count = 0u;
array_each(arr_ptr, |e| {
let actual = str::raw::from_c_str(e);
let expected = expected_arr[ctr].with_ref(|buf| {
#[test]
pub fn test_and() {
- assert_eq!(op1().and(Ok(667)).unwrap(), 667);
+ assert_eq!(op1().and(Ok(667i)).unwrap(), 667);
assert_eq!(op1().and(Err::<(), &'static str>("bad")).unwrap_err(),
"bad");
- assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface");
+ assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface");
assert_eq!(op2().and(Err::<(),&'static str>("bad")).unwrap_err(),
"sadface");
}
#[test]
fn test_collect() {
- let v: Result<Vec<int>, ()> = collect(range(0, 0).map(|_| Ok::<int, ()>(0)));
+ let v: Result<Vec<int>, ()> = collect(range(0i, 0).map(|_| Ok::<int, ()>(0)));
assert!(v == Ok(vec![]));
- let v: Result<Vec<int>, ()> = collect(range(0, 3).map(|x| Ok::<int, ()>(x)));
+ let v: Result<Vec<int>, ()> = collect(range(0i, 3).map(|x| Ok::<int, ()>(x)));
assert!(v == Ok(vec![0, 1, 2]));
- let v: Result<Vec<int>, int> = collect(range(0, 3)
+ let v: Result<Vec<int>, int> = collect(range(0i, 3)
.map(|x| if x > 1 { Err(x) } else { Ok(x) }));
assert!(v == Err(2));
// test that it does not take more elements than it needs
- let mut functions = [|| Ok(()), || Err(1), || fail!()];
+ let mut functions = [|| Ok(()), || Err(1i), || fail!()];
let v: Result<Vec<()>, int> = collect(functions.mut_iter().map(|f| (*f)()));
assert!(v == Err(1));
#[test]
fn test_fold() {
- assert_eq!(fold_(range(0, 0)
+ assert_eq!(fold_(range(0i, 0)
.map(|_| Ok::<(), ()>(()))),
Ok(()));
- assert_eq!(fold(range(0, 3)
+ assert_eq!(fold(range(0i, 3)
.map(|x| Ok::<int, ()>(x)),
0, |a, b| a + b),
Ok(3));
- assert_eq!(fold_(range(0, 3)
+ assert_eq!(fold_(range(0i, 3)
.map(|x| if x > 1 { Err(x) } else { Ok(()) })),
Err(2));
// test that it does not take more elements than it needs
- let mut functions = [|| Ok(()), || Err(1), || fail!()];
+ let mut functions = [|| Ok(()), || Err(1i), || fail!()];
assert_eq!(fold_(functions.mut_iter()
.map(|f| (*f)())),
#[test]
pub fn test_unwrap_or() {
- let ok: Result<int, &'static str> = Ok(100);
+ let ok: Result<int, &'static str> = Ok(100i);
let ok_err: Result<int, &'static str> = Err("Err");
assert_eq!(ok.unwrap_or(50), 100);
pub fn test_unwrap_or_else() {
fn handler(msg: &'static str) -> int {
if msg == "I got this." {
- 50
+ 50i
} else {
fail!("BadBad")
}
pub fn test_unwrap_or_else_failure() {
fn handler(msg: &'static str) -> int {
if msg == "I got this." {
- 50
+ 50i
} else {
fail!("BadBad")
}
* `[3,4]`):
*
* ```rust
- * let v = &[1,2,3,4];
+ * let v = &[1i, 2, 3, 4];
* for win in v.windows(2) {
* println!("{}", win);
* }
* `[3,4]`, `[5]`):
*
* ```rust
- * let v = &[1,2,3,4,5];
+ * let v = &[1i, 2, 3, 4, 5];
* for win in v.chunks(2) {
* println!("{}", win);
* }
/// # Example
///
/// ```rust
- /// let mut v = [1, 2, 3, 4, 5, 6];
+ /// let mut v = [1i, 2, 3, 4, 5, 6];
///
/// // scoped to restrict the lifetime of the borrows
/// {
/// let (left, right) = v.mut_split_at(0);
/// assert!(left == &mut []);
- /// assert!(right == &mut [1, 2, 3, 4, 5, 6]);
+ /// assert!(right == &mut [1i, 2, 3, 4, 5, 6]);
/// }
///
/// {
/// let (left, right) = v.mut_split_at(2);
- /// assert!(left == &mut [1, 2]);
- /// assert!(right == &mut [3, 4, 5, 6]);
+ /// assert!(left == &mut [1i, 2]);
+ /// assert!(right == &mut [3i, 4, 5, 6]);
/// }
///
/// {
/// let (left, right) = v.mut_split_at(6);
- /// assert!(left == &mut [1, 2, 3, 4, 5, 6]);
+ /// assert!(left == &mut [1i, 2, 3, 4, 5, 6]);
/// assert!(right == &mut []);
/// }
/// ```
/// # Example
///
/// ```rust
- /// let mut v = [1, 2, 3];
+ /// let mut v = [1i, 2, 3];
/// v.reverse();
- /// assert!(v == [3, 2, 1]);
+ /// assert!(v == [3i, 2, 1]);
/// ```
fn reverse(self);
/// ```rust
/// use std::slice::MutableCloneableVector;
///
- /// let mut dst = [0, 0, 0];
- /// let src = [1, 2];
+ /// let mut dst = [0i, 0, 0];
+ /// let src = [1i, 2];
///
/// assert!(dst.copy_from(src) == 2);
/// assert!(dst == [1, 2, 0]);
///
- /// let src2 = [3, 4, 5, 6];
+ /// let src2 = [3i, 4, 5, 6];
/// assert!(dst.copy_from(src2) == 3);
- /// assert!(dst == [3, 4, 5]);
+ /// assert!(dst == [3i, 4, 5]);
/// ```
fn copy_from(self, &[T]) -> uint;
}
period = period2;
}
- let byteset = needle.iter().fold(0, |a, &b| (1 << (b & 0x3f)) | a);
+ let byteset = needle.iter()
+ .fold(0, |a, &b| (1 << ((b & 0x3f) as uint)) | a);
if needle.slice_to(critPos) == needle.slice_from(needle.len() - critPos) {
TwoWaySearcher {
}
// Quickly skip by large portions unrelated to our substring
- if (self.byteset >> (haystack[self.position + needle.len() - 1] & 0x3f)) & 1 == 0 {
+ if (self.byteset >>
+ ((haystack[self.position + needle.len() - 1] & 0x3f)
+ as uint)) & 1 == 0 {
self.position += needle.len();
continue 'search;
}
//! Using methods:
//!
//! ```
-//! let pair = ("pi", 3.14);
+//! let pair = ("pi", 3.14f64);
//! assert_eq!(pair.val0(), "pi");
-//! assert_eq!(pair.val1(), 3.14);
+//! assert_eq!(pair.val1(), 3.14f64);
//! ```
//!
//! Using traits implemented for tuples:
//! ```
//! use std::default::Default;
//!
-//! let a = (1, 2);
-//! let b = (3, 4);
+//! let a = (1i, 2i);
+//! let b = (3i, 4i);
//! assert!(a != b);
//!
//! let c = b.clone();
#[test]
fn test_clone() {
- let a = (1, "2");
+ let a = (1i, "2");
let b = a.clone();
assert_eq!(a, b);
}
fn test_tuple_cmp() {
let (small, big) = ((1u, 2u, 3u), (3u, 2u, 1u));
- let nan = 0.0/0.0;
+ let nan = 0.0f64/0.0;
// PartialEq
assert_eq!(small, small);
assert!(big >= small);
assert!(big >= big);
- assert!(!((1.0, 2.0) < (nan, 3.0)));
- assert!(!((1.0, 2.0) <= (nan, 3.0)));
- assert!(!((1.0, 2.0) > (nan, 3.0)));
- assert!(!((1.0, 2.0) >= (nan, 3.0)));
- assert!(((1.0, 2.0) < (2.0, nan)));
- assert!(!((2.0, 2.0) < (2.0, nan)));
+ assert!(!((1.0f64, 2.0f64) < (nan, 3.0)));
+ assert!(!((1.0f64, 2.0f64) <= (nan, 3.0)));
+ assert!(!((1.0f64, 2.0f64) > (nan, 3.0)));
+ assert!(!((1.0f64, 2.0f64) >= (nan, 3.0)));
+ assert!(((1.0f64, 2.0f64) < (2.0, nan)));
+ assert!(!((2.0f64, 2.0f64) < (2.0, nan)));
// Ord
assert!(small.cmp(&small) == Equal);
#[test]
fn test_show() {
- let s = format!("{}", (1,));
+ let s = format!("{}", (1i,));
assert_eq!(s.as_slice(), "(1,)");
- let s = format!("{}", (1, true));
+ let s = format!("{}", (1i, true));
assert_eq!(s.as_slice(), "(1, true)");
- let s = format!("{}", (1, "hi", true));
+ let s = format!("{}", (1i, "hi", true));
assert_eq!(s.as_slice(), "(1, hi, true)");
}
}
fn test_flate_round_trip() {
let mut r = rand::task_rng();
let mut words = vec!();
- for _ in range(0, 20) {
+ for _ in range(0u, 20) {
let range = r.gen_range(1u, 10);
let v = r.gen_iter::<u8>().take(range).collect::<Vec<u8>>();
words.push(v);
}
- for _ in range(0, 20) {
+ for _ in range(0u, 20) {
let mut input = vec![];
- for _ in range(0, 2000) {
+ for _ in range(0u, 2000) {
input.push_all(r.choose(words.as_slice()).unwrap().as_slice());
}
debug!("de/inflate of {} bytes of random word-sequences",
fn test_range_pattern() {
let pat = Pattern::new("a[0-9]b");
- for i in range(0, 10) {
+ for i in range(0u, 10) {
assert!(pat.matches(format!("a{}b", i).as_slice()));
}
assert!(!pat.matches("a_b"));
let pat = Pattern::new("a[!0-9]b");
- for i in range(0, 10) {
+ for i in range(0u, 10) {
assert!(!pat.matches(format!("a{}b", i).as_slice()));
}
assert!(pat.matches("a_b"));
event_loop_factory: basic::event_loop,
});
- for _ in range(0, 20) {
+ for _ in range(0u, 20) {
pool.spawn(TaskOpts::new(), proc() {
let (tx, rx) = channel();
spawn(proc() {
fn multithreading() {
run(proc() {
let mut rxs = vec![];
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
let (tx, rx) = channel();
spawn(proc() {
tx.send(());
fn single_threaded_yield() {
use std::task::deschedule;
run(proc() {
- for _ in range(0, 5) { deschedule(); }
+ for _ in range(0u, 5) { deschedule(); }
});
}
// Testing that a task in one scheduler can block in foreign code
// without affecting other schedulers
- for _ in range(0, 20) {
+ for _ in range(0u, 20) {
let mut pool = pool();
let (start_tx, start_rx) = channel();
let (fin_tx, fin_rx) = channel();
fn yield_test() {
let (tx, rx) = channel();
spawn_opts(TaskOpts::new(), proc() {
- for _ in range(0, 10) { task::deschedule(); }
+ for _ in range(0u, 10) { task::deschedule(); }
tx.send(());
});
rx.recv();
error!("this is printed by default");
if log_enabled!(log::INFO) {
- let x = 3 * 4; // expensive computation
+ let x = 3i * 4i; // expensive computation
info!("the answer was: {}", x);
}
}
/// # fn main() {
/// log!(log::DEBUG, "this is a debug message");
/// log!(log::WARN, "this is a warning {}", "message");
-/// log!(6, "this is a custom logging level: {level}", level=6);
+/// log!(6, "this is a custom logging level: {level}", level=6u);
/// # }
/// ```
#[macro_export]
/// #[phase(plugin, link)] extern crate log;
///
/// # fn main() {
-/// # let error = 3;
+/// # let error = 3u;
/// error!("the build has failed with error code: {}", error);
/// # }
/// ```
/// #[phase(plugin, link)] extern crate log;
///
/// # fn main() {
-/// # let code = 3;
+/// # let code = 3u;
/// warn!("you may like to know that a process exited with: {}", code);
/// # }
/// ```
/// #[phase(plugin, link)] extern crate log;
///
/// # fn main() {
-/// # let ret = 3;
+/// # let ret = 3i;
/// info!("this function is about to return: {}", ret);
/// # }
/// ```
/// #[phase(plugin, link)] extern crate log;
///
/// # fn main() {
-/// debug!("x = {x}, y = {y}", x=10, y=20);
+/// debug!("x = {x}, y = {y}", x=10i, y=20i);
/// # }
/// ```
#[macro_export]
}
pub fn fd_set(set: &mut fd_set, fd: i32) {
- set.fds_bits[(fd / 32) as uint] |= 1 << (fd % 32);
+ set.fds_bits[(fd / 32) as uint] |= 1 << ((fd % 32) as uint);
}
}
fn yield_test() {
let (tx, rx) = channel();
spawn(proc() {
- for _ in range(0, 10) { task::deschedule(); }
+ for _ in range(0u, 10) { task::deschedule(); }
tx.send(());
});
rx.recv();
fn test_rand_range() {
let mut rng = task_rng();
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).unwrap(),
&FromPrimitive::from_uint(237).unwrap()),
FromPrimitive::from_uint(236).unwrap());
let l = FromPrimitive::from_uint(403469000 + 2352).unwrap();
let u = FromPrimitive::from_uint(403469000 + 3513).unwrap();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let n: BigUint = rng.gen_biguint_below(&u);
assert!(n < u);
fn test_rand_range() {
let mut rng = task_rng();
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
assert_eq!(rng.gen_bigint_range(&FromPrimitive::from_uint(236).unwrap(),
&FromPrimitive::from_uint(237).unwrap()),
FromPrimitive::from_uint(236).unwrap());
fn check(l: BigInt, u: BigInt) {
let mut rng = task_rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let n: BigInt = rng.gen_bigint_range(&l, &u);
assert!(n >= l);
assert!(n < u);
let n = { let one : BigUint = One::one(); one << 1000 };
b.iter(|| {
let mut m = n.clone();
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
m = m >> 1;
}
})
// check our constants are what Ratio::new etc. would make.
assert_eq!(_0, Zero::zero());
assert_eq!(_1, One::one());
- assert_eq!(_2, Ratio::from_integer(2));
- assert_eq!(_1_2, Ratio::new(1,2));
- assert_eq!(_3_2, Ratio::new(3,2));
- assert_eq!(_neg1_2, Ratio::new(-1,2));
+ assert_eq!(_2, Ratio::from_integer(2i));
+ assert_eq!(_1_2, Ratio::new(1i,2i));
+ assert_eq!(_3_2, Ratio::new(3i,2i));
+ assert_eq!(_neg1_2, Ratio::new(-1i,2i));
}
#[test]
#[test]
#[should_fail]
fn test_new_zero() {
- let _a = Ratio::new(1,0);
+ let _a = Ratio::new(1i,0);
}
}
test(_1, _1_2, _1_2);
- test(_1_2, _3_2, Ratio::new(3,4));
- test(_1_2, _neg1_2, Ratio::new(-1, 4));
+ test(_1_2, _3_2, Ratio::new(3i,4i));
+ test(_1_2, _neg1_2, Ratio::new(-1i, 4i));
}
#[test]
test16(_2, "2/1".to_string());
test16(_neg1_2, "-1/2".to_string());
test16(_neg1_2 / _2, "-1/4".to_string());
- test16(Ratio::new(13,15), "d/f".to_string());
+ test16(Ratio::new(13i,15i), "d/f".to_string());
test16(_1_2*_1_2*_1_2*_1_2, "1/10".to_string());
}
test(2f64.powf(100.), ("1267650600228229401496703205376", "1"));
test(-2f64.powf(100.), ("-1267650600228229401496703205376", "1"));
test(684729.48391f64, ("367611342500051", "536870912"));
- test(-8573.5918555, ("-4713381968463931", "549755813888"));
+ test(-8573.5918555f64, ("-4713381968463931", "549755813888"));
test(1.0 / 2f64.powf(100.), ("1", "1267650600228229401496703205376"));
}
fn test_exp() {
let mut exp = Exp::new(10.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
assert!(exp.sample(&mut rng) >= 0.0);
assert!(exp.ind_sample(&mut rng) >= 0.0);
}
fn test_chi_squared_one() {
let mut chi = ChiSquared::new(1.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
chi.sample(&mut rng);
chi.ind_sample(&mut rng);
}
fn test_chi_squared_small() {
let mut chi = ChiSquared::new(0.5);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
chi.sample(&mut rng);
chi.ind_sample(&mut rng);
}
fn test_chi_squared_large() {
let mut chi = ChiSquared::new(30.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
chi.sample(&mut rng);
chi.ind_sample(&mut rng);
}
fn test_f() {
let mut f = FisherF::new(2.0, 32.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
f.sample(&mut rng);
f.ind_sample(&mut rng);
}
fn test_t() {
let mut t = StudentT::new(11.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
t.sample(&mut rng);
t.ind_sample(&mut rng);
}
/// Weighted { weight: 1, item: 'c' });
/// let wc = WeightedChoice::new(items.as_mut_slice());
/// let mut rng = rand::task_rng();
-/// for _ in range(0, 16) {
+/// for _ in range(0u, 16) {
/// // on average prints 'a' 4 times, 'b' 8 and 'c' twice.
/// println!("{}", wc.ind_sample(&mut rng));
/// }
}}
);
- t!(vec!(Weighted { weight: 1, item: 10}), [10]);
+ t!(vec!(Weighted { weight: 1, item: 10i}), [10]);
// skip some
- t!(vec!(Weighted { weight: 0, item: 20},
- Weighted { weight: 2, item: 21},
- Weighted { weight: 0, item: 22},
- Weighted { weight: 1, item: 23}),
+ t!(vec!(Weighted { weight: 0, item: 20i},
+ Weighted { weight: 2, item: 21i},
+ Weighted { weight: 0, item: 22i},
+ Weighted { weight: 1, item: 23i}),
[21,21, 23]);
// different weights
- t!(vec!(Weighted { weight: 4, item: 30},
- Weighted { weight: 3, item: 31}),
+ t!(vec!(Weighted { weight: 4, item: 30i},
+ Weighted { weight: 3, item: 31i}),
[30,30,30,30, 31,31,31]);
// check that we're binary searching
// correctly with some vectors of odd
// length.
- t!(vec!(Weighted { weight: 1, item: 40},
- Weighted { weight: 1, item: 41},
- Weighted { weight: 1, item: 42},
- Weighted { weight: 1, item: 43},
- Weighted { weight: 1, item: 44}),
+ t!(vec!(Weighted { weight: 1, item: 40i},
+ Weighted { weight: 1, item: 41i},
+ Weighted { weight: 1, item: 42i},
+ Weighted { weight: 1, item: 43i},
+ Weighted { weight: 1, item: 44i}),
[40, 41, 42, 43, 44]);
- t!(vec!(Weighted { weight: 1, item: 50},
- Weighted { weight: 1, item: 51},
- Weighted { weight: 1, item: 52},
- Weighted { weight: 1, item: 53},
- Weighted { weight: 1, item: 54},
- Weighted { weight: 1, item: 55},
- Weighted { weight: 1, item: 56}),
+ t!(vec!(Weighted { weight: 1, item: 50i},
+ Weighted { weight: 1, item: 51i},
+ Weighted { weight: 1, item: 52i},
+ Weighted { weight: 1, item: 53i},
+ Weighted { weight: 1, item: 54i},
+ Weighted { weight: 1, item: 55i},
+ Weighted { weight: 1, item: 56i}),
[50, 51, 52, 53, 54, 55, 56]);
}
}
#[test] #[should_fail]
fn test_weighted_choice_zero_weight() {
- WeightedChoice::new(&mut [Weighted { weight: 0, item: 0},
- Weighted { weight: 0, item: 1}]);
+ WeightedChoice::new(&mut [Weighted { weight: 0, item: 0i},
+ Weighted { weight: 0, item: 1i}]);
}
#[test] #[should_fail]
fn test_weighted_choice_weight_overflows() {
let x = (-1) as uint / 2; // x + x + 2 is the overflow
- WeightedChoice::new(&mut [Weighted { weight: x, item: 0 },
- Weighted { weight: 1, item: 1 },
- Weighted { weight: x, item: 2 },
- Weighted { weight: 1, item: 3 }]);
+ WeightedChoice::new(&mut [Weighted { weight: x, item: 0i },
+ Weighted { weight: 1, item: 1i },
+ Weighted { weight: x, item: 2i },
+ Weighted { weight: 1, item: 3i }]);
}
}
fn test_normal() {
let mut norm = Normal::new(10.0, 10.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
norm.sample(&mut rng);
norm.ind_sample(&mut rng);
}
fn test_log_normal() {
let mut lnorm = LogNormal::new(10.0, 10.0);
let mut rng = ::test::rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
lnorm.sample(&mut rng);
lnorm.ind_sample(&mut rng);
}
/// let between = Range::new(10u, 10000u);
/// let mut rng = rand::task_rng();
/// let mut sum = 0;
-/// for _ in range(0, 1000) {
+/// for _ in range(0u, 1000) {
/// sum += between.ind_sample(&mut rng);
/// }
/// println!("{}", sum);
#[should_fail]
#[test]
fn test_range_bad_limits_equal() {
- Range::new(10, 10);
+ Range::new(10i, 10i);
}
#[should_fail]
#[test]
fn test_range_bad_limits_flipped() {
- Range::new(10, 5);
+ Range::new(10i, 5i);
}
#[test]
(Bounded::min_value(), Bounded::max_value())];
for &(low, high) in v.iter() {
let mut sampler: Range<$ty> = Range::new(low, high);
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let v = sampler.sample(&mut rng);
assert!(low <= v && v < high);
let v = sampler.ind_sample(&mut rng);
(-1e35, 1e35)];
for &(low, high) in v.iter() {
let mut sampler: Range<$ty> = Range::new(low, high);
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let v = sampler.sample(&mut rng);
assert!(low <= v && v < high);
let v = sampler.ind_sample(&mut rng);
use {Rng, SeedableRng, Rand};
static RAND_SIZE_LEN: u32 = 8;
-static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN;
+static RAND_SIZE: u32 = 1 << (RAND_SIZE_LEN as uint);
+static RAND_SIZE_UINT: uint = 1 << (RAND_SIZE_LEN as uint);
/// A random number generator that uses the ISAAC algorithm[1].
///
/// generator*](http://www.burtleburtle.net/bob/rand/isaacafa.html)
pub struct IsaacRng {
cnt: u32,
- rsl: [u32, .. RAND_SIZE],
- mem: [u32, .. RAND_SIZE],
+ rsl: [u32, ..RAND_SIZE_UINT],
+ mem: [u32, ..RAND_SIZE_UINT],
a: u32,
b: u32,
c: u32
}
static EMPTY: IsaacRng = IsaacRng {
cnt: 0,
- rsl: [0, .. RAND_SIZE],
- mem: [0, .. RAND_SIZE],
+ rsl: [0, ..RAND_SIZE_UINT],
+ mem: [0, ..RAND_SIZE_UINT],
a: 0, b: 0, c: 0
};
}}
);
- for _ in range(0, 4) { mix!(); }
+ for _ in range(0u, 4) {
+ mix!();
+ }
if use_rsl {
macro_rules! memloop (
/// Refills the output buffer (`self.rsl`)
#[inline]
+ #[allow(unsigned_negate)]
fn isaac(&mut self) {
self.c += 1;
// abbreviations
let mut a = self.a;
let mut b = self.b + self.c;
- static MIDPOINT: uint = RAND_SIZE as uint / 2;
+ static MIDPOINT: uint = (RAND_SIZE / 2) as uint;
macro_rules! ind (($x:expr) => {
- self.mem[(($x >> 2) & (RAND_SIZE - 1)) as uint]
+ self.mem[(($x >> 2) as uint & ((RAND_SIZE - 1) as uint))]
});
- macro_rules! rngstep(
+ macro_rules! rngstepp(
($j:expr, $shift:expr) => {{
let base = $j;
- let mix = if $shift < 0 {
- a >> -$shift as uint
- } else {
- a << $shift as uint
- };
+ let mix = a << $shift as uint;
let x = self.mem[base + mr_offset];
a = (a ^ mix) + self.mem[base + m2_offset];
let y = ind!(x) + a + b;
self.mem[base + mr_offset] = y;
- b = ind!(y >> RAND_SIZE_LEN) + x;
+ b = ind!(y >> RAND_SIZE_LEN as uint) + x;
+ self.rsl[base + mr_offset] = b;
+ }}
+ );
+ macro_rules! rngstepn(
+ ($j:expr, $shift:expr) => {{
+ let base = $j;
+ let mix = a >> $shift as uint;
+
+ let x = self.mem[base + mr_offset];
+ a = (a ^ mix) + self.mem[base + m2_offset];
+ let y = ind!(x) + a + b;
+ self.mem[base + mr_offset] = y;
+
+ b = ind!(y >> RAND_SIZE_LEN as uint) + x;
self.rsl[base + mr_offset] = b;
}}
);
let r = [(0, MIDPOINT), (MIDPOINT, 0)];
for &(mr_offset, m2_offset) in r.iter() {
for i in range_step(0u, MIDPOINT, 4) {
- rngstep!(i + 0, 13);
- rngstep!(i + 1, -6);
- rngstep!(i + 2, 2);
- rngstep!(i + 3, -16);
+ rngstepp!(i + 0, 13);
+ rngstepn!(i + 1, 6);
+ rngstepp!(i + 2, 2);
+ rngstepn!(i + 3, 16);
}
}
}}
);
- for _ in range(0, 4) { mix!(); }
+ for _ in range(0u, 4) {
+ mix!();
+ }
+
if use_rsl {
macro_rules! memloop (
($arr:expr) => {{
*self.mem.unsafe_ref(($x as uint >> 3) & (RAND_SIZE_64 - 1))
}
);
- macro_rules! rngstep(
+ macro_rules! rngstepp(
+ ($j:expr, $shift:expr) => {{
+ let base = base + $j;
+ let mix = a ^ (a << $shift as uint);
+ let mix = if $j == 0 {!mix} else {mix};
+
+ unsafe {
+ let x = *self.mem.unsafe_ref(base + mr_offset);
+ a = mix + *self.mem.unsafe_ref(base + m2_offset);
+ let y = ind!(x) + a + b;
+ self.mem.unsafe_set(base + mr_offset, y);
+
+ b = ind!(y >> RAND_SIZE_64_LEN) + x;
+ self.rsl.unsafe_set(base + mr_offset, b);
+ }
+ }}
+ );
+ macro_rules! rngstepn(
($j:expr, $shift:expr) => {{
let base = base + $j;
- let mix = a ^ (if $shift < 0 {
- a >> -$shift as uint
- } else {
- a << $shift as uint
- });
+ let mix = a ^ (a >> $shift as uint);
let mix = if $j == 0 {!mix} else {mix};
unsafe {
for &(mr_offset, m2_offset) in MP_VEC.iter() {
for base in range(0, MIDPOINT / 4).map(|i| i * 4) {
- rngstep!(0, 21);
- rngstep!(1, -5);
- rngstep!(2, 12);
- rngstep!(3, -33);
+ rngstepp!(0, 21);
+ rngstepn!(1, 5);
+ rngstepp!(2, 12);
+ rngstepn!(3, 33);
}
}
let seed = &[12345, 67890, 54321, 9876];
let mut rb: IsaacRng = SeedableRng::from_seed(seed);
// skip forward to the 10000th number
- for _ in range(0, 10000) { rb.next_u32(); }
+ for _ in range(0u, 10000) { rb.next_u32(); }
let v = Vec::from_fn(10, |_| rb.next_u32());
assert_eq!(v,
let seed = &[12345, 67890, 54321, 9876];
let mut rb: Isaac64Rng = SeedableRng::from_seed(seed);
// skip forward to the 10000th number
- for _ in range(0, 10000) { rb.next_u64(); }
+ for _ in range(0u, 10000) { rb.next_u64(); }
let v = Vec::from_fn(10, |_| rb.next_u64());
assert_eq!(v,
/// let mut rng = task_rng();
/// let n: uint = rng.gen_range(0u, 10);
/// println!("{}", n);
- /// let m: f64 = rng.gen_range(-40.0, 1.3e5);
+ /// let m: f64 = rng.gen_range(-40.0f64, 1.3e5f64);
/// println!("{}", m);
/// ```
fn gen_range<T: PartialOrd + SampleRange>(&mut self, low: T, high: T) -> T {
/// ```
/// use std::rand::{task_rng, Rng};
///
- /// let choices = [1, 2, 4, 8, 16, 32];
+ /// let choices = [1i, 2, 4, 8, 16, 32];
/// let mut rng = task_rng();
/// println!("{}", rng.choose(choices));
/// assert_eq!(rng.choose(choices.slice_to(0)), None);
/// use std::rand::{task_rng, Rng};
///
/// let mut rng = task_rng();
- /// let mut y = [1,2,3];
+ /// let mut y = [1i, 2, 3];
/// rng.shuffle(y);
/// println!("{}", y.as_slice());
/// rng.shuffle(y);
// this is unlikely to catch an incorrect implementation that
// generates exactly 0 or 1, but it keeps it sane.
let mut rng = task_rng();
- for _ in range(0, 1_000) {
+ for _ in range(0u, 1_000) {
// strict inequalities
let Open01(f) = rng.gen::<Open01<f64>>();
assert!(0.0 < f && f < 1.0);
#[test]
fn rand_closed() {
let mut rng = task_rng();
- for _ in range(0, 1_000) {
+ for _ in range(0u, 1_000) {
// strict inequalities
let Closed01(f) = rng.gen::<Closed01<f64>>();
assert!(0.0 <= f && f <= 1.0);
let mut rs = ReseedingRng::new(Counter {i:0}, 400, ReseedWithDefault);
let mut i = 0;
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
assert_eq!(rs.next_u32(), i % 100);
i += 1;
}
let hash = state.result();
return Svh {
- hash: range_step(0, 64, 4).map(|i| hex(hash >> i)).collect()
+ hash: range_step(0u, 64u, 4u).map(|i| hex(hash >> i)).collect()
};
fn hex(b: u64) -> char {
fn extract_one(&mut self, m: HashSet<Path>, flavor: &str,
slot: &mut Option<MetadataBlob>) -> Option<Path> {
let mut ret = None::<Path>;
- let mut error = 0;
+ let mut error = 0u;
if slot.is_some() {
// FIXME(#10786): for an optimization, we only read one of the
BiAnd | BiBitAnd => Ok(const_int(a & b)),
BiOr | BiBitOr => Ok(const_int(a | b)),
BiBitXor => Ok(const_int(a ^ b)),
- BiShl => Ok(const_int(a << b)),
- BiShr => Ok(const_int(a >> b)),
+ BiShl => Ok(const_int(a << b as uint)),
+ BiShr => Ok(const_int(a >> b as uint)),
BiEq => fromb(a == b),
BiLt => fromb(a < b),
BiLe => fromb(a <= b),
BiAnd | BiBitAnd => Ok(const_uint(a & b)),
BiOr | BiBitOr => Ok(const_uint(a | b)),
BiBitXor => Ok(const_uint(a ^ b)),
- BiShl => Ok(const_uint(a << b)),
- BiShr => Ok(const_uint(a >> b)),
+ BiShl => Ok(const_uint(a << b as uint)),
+ BiShr => Ok(const_uint(a >> b as uint)),
BiEq => fromb(a == b),
BiLt => fromb(a < b),
BiLe => fromb(a <= b),
// shifts can have any integral type as their rhs
(Ok(const_int(a)), Ok(const_uint(b))) => {
match op {
- BiShl => Ok(const_int(a << b)),
- BiShr => Ok(const_int(a >> b)),
+ BiShl => Ok(const_int(a << b as uint)),
+ BiShr => Ok(const_int(a >> b as uint)),
_ => Err("can't do this op on an int and uint".to_string())
}
}
(Ok(const_uint(a)), Ok(const_int(b))) => {
match op {
- BiShl => Ok(const_uint(a << b)),
- BiShr => Ok(const_uint(a >> b)),
+ BiShl => Ok(const_uint(a << b as uint)),
+ BiShr => Ok(const_uint(a >> b as uint)),
_ => Err("can't do this op on a uint and int".to_string())
}
}
fn bit_str(bit: uint) -> String {
let byte = bit >> 8;
- let lobits = 1 << (bit & 0xFF);
+ let lobits = 1u << (bit & 0xFF);
format!("[{}:{}-{:02x}]", bit, byte, lobits)
}
/// Resolves all imports for the crate. This method performs the fixed-
/// point iteration.
fn resolve_imports(&mut self) {
- let mut i = 0;
+ let mut i = 0u;
let mut prev_unresolved_imports = 0;
loop {
debug!("(resolving imports) iteration {}, {} imports left",
self.check_and_record(Variable,
span,
sub_span,
- svec!(id, name, qualname, value, typ, 0));
+ svec!(id, name, qualname, value, typ, 0u));
}
// formal parameters
self.check_and_record(Variable,
span,
sub_span,
- svec!(id, name, qualname, "", typ, 0));
+ svec!(id, name, qualname, "", typ, 0u));
}
// value is the initialising expression of the static if it is not mut, otherwise "".
self.check_and_record(Inheritance,
span,
sub_span,
- svec!(base_id.node, base_id.krate, deriv_id, 0));
+ svec!(base_id.node,
+ base_id.krate,
+ deriv_id,
+ 0u));
}
pub fn fn_call_str(&mut self,
self.record_with_span(ModRef,
span,
sub_span,
- svec!(0, 0, qualname, parent));
+ svec!(0u, 0u, qualname, parent));
}
pub fn typedef_str(&mut self,
self.record_with_span(TypeRef,
span,
sub_span,
- svec!(0, 0, qualname, 0));
+ svec!(0u, 0u, qualname, 0u));
}
// A slightly generic function for a reference to an item of any kind.
assert_eq!(val_ty(ptr), llty.ptr_to());
let bits = machine::llbitsize_of_real(bcx.ccx(), llty);
assert!(bits <= 64);
+ let bits = bits as uint;
let mask = (-1u64 >> (64 - bits)) as Disr;
if (max + 1) & mask == min & mask {
// i.e., if the range is everything. The lo==hi case would be
let null_variant_index = (1 - non_null_variant_index) as uint;
let null_variant_ident = self.variants.get(null_variant_index).name;
let null_variant_name = token::get_ident(null_variant_ident);
- let union_member_name = format!("RUST$ENCODED$ENUM${}${}", 0, null_variant_name);
+ let union_member_name = format!("RUST$ENCODED$ENUM${}${}",
+ 0u,
+ null_variant_name);
// Finally create the (singleton) list of descriptions of union
// members.
match debug_location {
KnownLocation { scope, line, .. } => {
- let col = 0; // Always set the column to zero like Clang and GCC
+ let col = 0u; // Always set the column to zero like Clang and GCC
debug!("setting debug location to {} {}", line, col);
let elements = [C_i32(cx, line as i32), C_i32(cx, col as i32), scope, ptr::null()];
unsafe {
expected.repr(fcx.ccx.tcx),
expr_ty.repr(fcx.ccx.tcx));
let expected = if ty::type_needs_infer(expected) {
- resolve_type(fcx.infcx(), expected,
+ resolve_type(fcx.infcx(),
+ None,
+ expected,
try_resolve_tvar_shallow).unwrap_or(expected)
} else { expected };
match fcx.mk_assignty(expr, expr_ty, expected) {
upvar_borrow_map: RefCell<ty::UpvarBorrowMap>,
}
+/// When type-checking an expression, we propagate downward
+/// whatever type hint we are able in the form of an `Expectation`.
+enum Expectation {
+ /// We know nothing about what type this expression should have.
+ NoExpectation,
+
+ /// This expression should have the type given (or some subtype)
+ ExpectHasType(ty::t),
+
+ /// This expression will be cast to the `ty::t`
+ ExpectCastableToType(ty::t),
+}
+
#[deriving(Clone)]
pub struct FnStyleState {
pub def: ast::NodeId,
visit.visit_block(body, ());
}
- check_block_with_expected(&fcx, body, Some(ret_ty));
+ check_block_with_expected(&fcx, body, ExpectHasType(ret_ty));
// We unify the tail expr's type with the
// function result type, if there is a tail expr.
}
// AST fragment checking
-pub fn check_lit(fcx: &FnCtxt, lit: &ast::Lit) -> ty::t {
+fn check_lit(fcx: &FnCtxt,
+ lit: &ast::Lit,
+ expected: Expectation)
+ -> ty::t
+{
let tcx = fcx.ccx.tcx;
match lit.node {
ast::LitInt(_, t) => ty::mk_mach_int(t),
ast::LitUint(_, t) => ty::mk_mach_uint(t),
ast::LitIntUnsuffixed(_) => {
- // An unsuffixed integer literal could have any integral type,
- // so we create an integral type variable for it.
- ty::mk_int_var(tcx, fcx.infcx().next_int_var_id())
+ let opt_ty = expected.map_to_option(fcx, |sty| {
+ match *sty {
+ ty::ty_int(i) => Some(ty::mk_mach_int(i)),
+ ty::ty_uint(i) => Some(ty::mk_mach_uint(i)),
+ ty::ty_char => Some(ty::mk_mach_uint(ast::TyU8)),
+ ty::ty_ptr(..) => Some(ty::mk_mach_uint(ast::TyU)),
+ ty::ty_bare_fn(..) => Some(ty::mk_mach_uint(ast::TyU)),
+ _ => None
+ }
+ });
+ opt_ty.unwrap_or_else(
+ || ty::mk_int_var(tcx, fcx.infcx().next_int_var_id()))
}
ast::LitFloat(_, t) => ty::mk_mach_float(t),
ast::LitFloatUnsuffixed(_) => {
- // An unsuffixed floating point literal could have any floating point
- // type, so we create a floating point type variable for it.
- ty::mk_float_var(tcx, fcx.infcx().next_float_var_id())
+ let opt_ty = expected.map_to_option(fcx, |sty| {
+ match *sty {
+ ty::ty_float(i) => Some(ty::mk_mach_float(i)),
+ _ => None
+ }
+ });
+ opt_ty.unwrap_or_else(
+ || ty::mk_float_var(tcx, fcx.infcx().next_float_var_id()))
}
ast::LitNil => ty::mk_nil(),
ast::LitBool(_) => ty::mk_bool()
}
}
-pub fn check_expr_has_type(
- fcx: &FnCtxt, expr: &ast::Expr,
- expected: ty::t) {
- check_expr_with_unifier(fcx, expr, Some(expected), NoPreference, || {
- demand::suptype(fcx, expr.span, expected, fcx.expr_ty(expr));
- });
+pub fn check_expr_has_type(fcx: &FnCtxt,
+ expr: &ast::Expr,
+ expected: ty::t) {
+ check_expr_with_unifier(
+ fcx, expr, ExpectHasType(expected), NoPreference,
+ || demand::suptype(fcx, expr.span, expected, fcx.expr_ty(expr)));
}
-fn check_expr_coercable_to_type(fcx: &FnCtxt, expr: &ast::Expr, expected: ty::t) {
- check_expr_with_unifier(fcx, expr, Some(expected), NoPreference, || {
- demand::coerce(fcx, expr.span, expected, expr)
- });
+fn check_expr_coercable_to_type(fcx: &FnCtxt,
+ expr: &ast::Expr,
+ expected: ty::t) {
+ check_expr_with_unifier(
+ fcx, expr, ExpectHasType(expected), NoPreference,
+ || demand::coerce(fcx, expr.span, expected, expr));
}
fn check_expr_with_hint(fcx: &FnCtxt, expr: &ast::Expr, expected: ty::t) {
- check_expr_with_unifier(fcx, expr, Some(expected), NoPreference, || ())
+ check_expr_with_unifier(
+ fcx, expr, ExpectHasType(expected), NoPreference,
+ || ())
}
-fn check_expr_with_opt_hint(fcx: &FnCtxt, expr: &ast::Expr,
- expected: Option<ty::t>) {
- check_expr_with_unifier(fcx, expr, expected, NoPreference, || ())
+fn check_expr_with_expectation(fcx: &FnCtxt,
+ expr: &ast::Expr,
+ expected: Expectation) {
+ check_expr_with_unifier(
+ fcx, expr, expected, NoPreference,
+ || ())
}
-fn check_expr_with_opt_hint_and_lvalue_pref(fcx: &FnCtxt,
+fn check_expr_with_expectation_and_lvalue_pref(fcx: &FnCtxt,
expr: &ast::Expr,
- expected: Option<ty::t>,
- lvalue_pref: LvaluePreference) {
+ expected: Expectation,
+ lvalue_pref: LvaluePreference)
+{
check_expr_with_unifier(fcx, expr, expected, lvalue_pref, || ())
}
fn check_expr(fcx: &FnCtxt, expr: &ast::Expr) {
- check_expr_with_unifier(fcx, expr, None, NoPreference, || ())
+ check_expr_with_unifier(fcx, expr, NoExpectation, NoPreference, || ())
}
fn check_expr_with_lvalue_pref(fcx: &FnCtxt, expr: &ast::Expr,
lvalue_pref: LvaluePreference) {
- check_expr_with_unifier(fcx, expr, None, lvalue_pref, || ())
+ check_expr_with_unifier(fcx, expr, NoExpectation, lvalue_pref, || ())
}
/// `ty_bot`, so avoid that when err and bot need to be handled differently.
fn check_expr_with_unifier(fcx: &FnCtxt,
expr: &ast::Expr,
- expected: Option<ty::t>,
+ expected: Expectation,
lvalue_pref: LvaluePreference,
- unifier: ||) {
+ unifier: ||)
+{
debug!(">> typechecking");
// A generic function for doing all of the checking for call expressions
opt_else_expr: Option<Gc<ast::Expr>>,
id: ast::NodeId,
sp: Span,
- expected: Option<ty::t>) {
+ expected: Expectation) {
check_expr_has_type(fcx, cond_expr, ty::mk_bool());
let branches_ty = match opt_else_expr {
Some(ref else_expr) => {
+ // Disregard "castable to" expectations because they
+ // can lead us astray. Consider for example `if cond
+ // {22} else {c} as u8` -- if we propagate the
+ // "castable to u8" constraint to 22, it will pick the
+ // type 22u8, which is overly constrained (c might not
+ // be a u8). In effect, the problem is that the
+ // "castable to" expectation is not the tightest thing
+ // we can say, so we want to drop it in this case.
+ // The tightest thing we can say is "must unify with
+ // else branch". Note that in the case of a "has type"
+ // constraint, this limitation does not hold.
+ let expected = expected.only_has_type();
+
check_block_with_expected(fcx, then_blk, expected);
let then_ty = fcx.node_ty(then_blk.id);
- check_expr_with_opt_hint(fcx, &**else_expr, expected);
+ check_expr_with_expectation(fcx, &**else_expr, expected);
let else_ty = fcx.expr_ty(&**else_expr);
infer::common_supertype(fcx.infcx(),
infer::IfExpression(sp),
fcx.expr_ty(&*lhs));
if ty::type_is_integral(lhs_t) && ast_util::is_shift_binop(op) {
- // Shift is a special case: rhs can be any integral type
- check_expr(fcx, &*rhs);
- let rhs_t = fcx.expr_ty(&*rhs);
- require_integral(fcx, rhs.span, rhs_t);
+ // Shift is a special case: rhs must be uint, no matter what lhs is
+ check_expr_has_type(fcx, rhs, ty::mk_uint());
fcx.write_ty(expr.id, lhs_t);
return;
}
})
}
- // Resolves `expected` by a single level if it is a variable and passes it
- // through the `unpack` function. It there is no expected type or
- // resolution is not possible (e.g., no constraints yet present), just
- // returns `none`.
- fn unpack_expected<O>(
- fcx: &FnCtxt,
- expected: Option<ty::t>,
- unpack: |&ty::sty| -> Option<O>)
- -> Option<O> {
- match expected {
- Some(t) => {
- match resolve_type(fcx.infcx(), t, force_tvar) {
- Ok(t) => unpack(&ty::get(t).sty),
- _ => None
- }
- }
- _ => None
- }
- }
-
fn check_expr_fn(fcx: &FnCtxt,
expr: &ast::Expr,
store: ty::TraitStore,
decl: &ast::FnDecl,
body: ast::P<ast::Block>,
- expected: Option<ty::t>) {
+ expected: Expectation) {
let tcx = fcx.ccx.tcx;
// Find the expected input/output types (if any). Substitute
// fresh bound regions for any bound regions we find in the
// expected types so as to avoid capture.
- let expected_sty = unpack_expected(fcx,
- expected,
- |x| Some((*x).clone()));
+ let expected_sty = expected.map_to_option(fcx, |x| Some((*x).clone()));
let (expected_sig,
expected_onceness,
expected_bounds) = {
}
}
- ast::ExprLit(ref lit) => {
- let typ = check_lit(fcx, &**lit);
+ ast::ExprLit(lit) => {
+ let typ = check_lit(fcx, lit, expected);
fcx.write_ty(id, typ);
}
ast::ExprBinary(op, ref lhs, ref rhs) => {
}
}
ast::ExprUnary(unop, ref oprnd) => {
- let exp_inner = unpack_expected(fcx, expected, |sty| {
+ let expected = expected.only_has_type();
+ let expected_inner = expected.map(fcx, |sty| {
match unop {
ast::UnBox | ast::UnUniq => match *sty {
- ty::ty_box(ty) | ty::ty_uniq(ty) => Some(ty),
- _ => None
+ ty::ty_box(ty) | ty::ty_uniq(ty) => {
+ ExpectHasType(ty)
+ }
+ _ => {
+ NoExpectation
+ }
},
- ast::UnNot | ast::UnNeg => expected,
- ast::UnDeref => None
+ ast::UnNot | ast::UnNeg => {
+ expected
+ }
+ ast::UnDeref => {
+ NoExpectation
+ }
}
});
let lvalue_pref = match unop {
ast::UnDeref => lvalue_pref,
_ => NoPreference
};
- check_expr_with_opt_hint_and_lvalue_pref(fcx, &**oprnd, exp_inner, lvalue_pref);
+ check_expr_with_expectation_and_lvalue_pref(
+ fcx, &**oprnd, expected_inner, lvalue_pref);
let mut oprnd_t = fcx.expr_ty(&**oprnd);
if !ty::type_is_error(oprnd_t) && !ty::type_is_bot(oprnd_t) {
match unop {
fcx.write_ty(id, oprnd_t);
}
ast::ExprAddrOf(mutbl, ref oprnd) => {
- let hint = unpack_expected(
- fcx, expected,
- |sty| match *sty { ty::ty_rptr(_, ref mt) => Some(mt.ty),
- _ => None });
+ let expected = expected.only_has_type();
+ let hint = expected.map(fcx, |sty| {
+ match *sty { ty::ty_rptr(_, ref mt) => ExpectHasType(mt.ty),
+ _ => NoExpectation }
+ });
let lvalue_pref = match mutbl {
ast::MutMutable => PreferMutLvalue,
ast::MutImmutable => NoPreference
};
- check_expr_with_opt_hint_and_lvalue_pref(fcx, &**oprnd, hint, lvalue_pref);
+ check_expr_with_expectation_and_lvalue_pref(fcx,
+ &**oprnd,
+ hint,
+ lvalue_pref);
// Note: at this point, we cannot say what the best lifetime
// is to use for resulting pointer. We want to use the
}
fcx.write_bot(id);
}
- ast::ExprParen(ref a) => {
- check_expr_with_opt_hint_and_lvalue_pref(fcx, &**a, expected, lvalue_pref);
- fcx.write_ty(id, fcx.expr_ty(&**a));
+ ast::ExprParen(a) => {
+ check_expr_with_expectation_and_lvalue_pref(fcx, a, expected, lvalue_pref);
+ fcx.write_ty(id, fcx.expr_ty(a));
}
ast::ExprAssign(ref lhs, ref rhs) => {
check_expr_with_lvalue_pref(fcx, &**lhs, PreferMutLvalue);
fcx.write_bot(id);
}
}
- ast::ExprCast(ref e, ref t) => {
- check_expr(fcx, &**e);
- let t_1 = fcx.to_ty(&**t);
- let t_e = fcx.expr_ty(&**e);
-
- debug!("t_1={}", fcx.infcx().ty_to_str(t_1));
- debug!("t_e={}", fcx.infcx().ty_to_str(t_e));
-
- if ty::type_is_error(t_e) {
- fcx.write_error(id);
- }
- else if ty::type_is_bot(t_e) {
- fcx.write_bot(id);
- }
- else {
- match ty::get(t_1).sty {
- // This will be looked up later on
- _ if ty::type_is_trait(t_1) => {},
-
- _ => {
- let t_1 = structurally_resolved_type(fcx, e.span, t_1);
- let t_e = structurally_resolved_type(fcx, e.span, t_e);
-
- if ty::type_is_nil(t_e) {
- fcx.type_error_message(expr.span, |actual| {
- format!("cast from nil: `{}` as `{}`",
- actual,
- fcx.infcx().ty_to_str(t_1))
- }, t_e, None);
- } else if ty::type_is_nil(t_1) {
- fcx.type_error_message(expr.span, |actual| {
- format!("cast to nil: `{}` as `{}`",
- actual,
- fcx.infcx().ty_to_str(t_1))
- }, t_e, None);
- }
-
- let t_1_is_scalar = ty::type_is_scalar(t_1);
- let t_1_is_char = ty::type_is_char(t_1);
- let t_1_is_bare_fn = ty::type_is_bare_fn(t_1);
- let t_1_is_float = ty::type_is_floating_point(t_1);
-
- // casts to scalars other than `char` and `bare fn` are trivial
- let t_1_is_trivial = t_1_is_scalar && !t_1_is_char && !t_1_is_bare_fn;
- if ty::type_is_c_like_enum(fcx.tcx(), t_e) && t_1_is_trivial {
- if t_1_is_float {
- fcx.type_error_message(expr.span, |actual| {
- format!("illegal cast; cast through an \
- integer first: `{}` as `{}`",
- actual,
- fcx.infcx().ty_to_str(t_1))
- }, t_e, None);
- }
- // casts from C-like enums are allowed
- } else if t_1_is_char {
- let t_e = fcx.infcx().resolve_type_vars_if_possible(t_e);
- if ty::get(t_e).sty != ty::ty_uint(ast::TyU8) {
- fcx.type_error_message(expr.span, |actual| {
- format!("only `u8` can be cast as \
- `char`, not `{}`", actual)
- }, t_e, None);
- }
- } else if ty::get(t_1).sty == ty::ty_bool {
- fcx.tcx()
- .sess
- .span_err(expr.span,
- "cannot cast as `bool`, compare with \
- zero instead");
- } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) {
- fn is_vec(t: ty::t) -> bool {
- match ty::get(t).sty {
- ty::ty_vec(..) => true,
- ty::ty_ptr(ty::mt{ty: t, ..}) | ty::ty_rptr(_, ty::mt{ty: t, ..}) |
- ty::ty_box(t) | ty::ty_uniq(t) => match ty::get(t).sty {
- ty::ty_vec(_, None) => true,
- _ => false,
- },
- _ => false
- }
- }
- fn types_compatible(fcx: &FnCtxt, sp: Span,
- t1: ty::t, t2: ty::t) -> bool {
- if !is_vec(t1) {
- false
- } else {
- let el = ty::sequence_element_type(fcx.tcx(),
- t1);
- infer::mk_eqty(fcx.infcx(), false,
- infer::Misc(sp), el, t2).is_ok()
- }
- }
-
- // Due to the limitations of LLVM global constants,
- // region pointers end up pointing at copies of
- // vector elements instead of the original values.
- // To allow unsafe pointers to work correctly, we
- // need to special-case obtaining an unsafe pointer
- // from a region pointer to a vector.
-
- /* this cast is only allowed from &[T] to *T or
- &T to *T. */
- match (&ty::get(t_e).sty, &ty::get(t_1).sty) {
- (&ty::ty_rptr(_, ty::mt { ty: mt1, mutbl: ast::MutImmutable }),
- &ty::ty_ptr(ty::mt { ty: mt2, mutbl: ast::MutImmutable }))
- if types_compatible(fcx, e.span, mt1, mt2) => {
- /* this case is allowed */
- }
- _ => {
- demand::coerce(fcx, e.span, t_1, &**e);
- }
- }
- } else if !(ty::type_is_scalar(t_e) && t_1_is_trivial) {
- /*
- If more type combinations should be supported than are
- supported here, then file an enhancement issue and
- record the issue number in this comment.
- */
- fcx.type_error_message(expr.span, |actual| {
- format!("non-scalar cast: `{}` as `{}`",
- actual,
- fcx.infcx().ty_to_str(t_1))
- }, t_e, None);
- }
- }
- }
- fcx.write_ty(id, t_1);
- }
+ ast::ExprCast(expr_from, t) => {
+ let ty_to = fcx.to_ty(t);
+ debug!("ExprCast ty_to={}", fcx.infcx().ty_to_str(ty_to));
+ check_cast(fcx, expr_from, ty_to);
+ fcx.write_ty(id, ty_to);
}
ast::ExprVec(ref args) => {
let t: ty::t = fcx.infcx().next_ty_var();
fcx.write_ty(id, typ);
}
ast::ExprRepeat(ref element, ref count_expr) => {
- check_expr_with_hint(fcx, &**count_expr, ty::mk_uint());
+ check_expr_has_type(fcx, &**count_expr, ty::mk_uint());
let count = ty::eval_repeat_count(fcx, &**count_expr);
let t: ty::t = fcx.infcx().next_ty_var();
check_expr_has_type(fcx, &**element, t);
}
}
ast::ExprTup(ref elts) => {
- let flds = unpack_expected(fcx, expected, |sty| {
+ let expected = expected.only_has_type();
+ let flds = expected.map_to_option(fcx, |sty| {
match *sty {
ty::ty_tup(ref flds) => Some((*flds).clone()),
_ => None
let elt_ts = elts.iter().enumerate().map(|(i, e)| {
let opt_hint = match flds {
- Some(ref fs) if i < fs.len() => Some(*fs.get(i)),
- _ => None
+ Some(ref fs) if i < fs.len() => ExpectHasType(*fs.get(i)),
+ _ => NoExpectation
};
- check_expr_with_opt_hint(fcx, &**e, opt_hint);
- let t = fcx.expr_ty(&**e);
+ check_expr_with_expectation(fcx, *e, opt_hint);
+ let t = fcx.expr_ty(*e);
err_field = err_field || ty::type_is_error(t);
bot_field = bot_field || ty::type_is_bot(t);
t
syntax::print::pprust::expr_to_str(expr));
debug!("... {}, expected is {}",
ppaux::ty_to_str(tcx, fcx.expr_ty(expr)),
- match expected {
- Some(t) => ppaux::ty_to_str(tcx, t),
- _ => "empty".to_string()
- });
+ expected.repr(tcx))
unifier();
}
+impl Expectation {
+ fn only_has_type(self) -> Expectation {
+ match self {
+ NoExpectation | ExpectCastableToType(..) => NoExpectation,
+ ExpectHasType(t) => ExpectHasType(t)
+ }
+ }
+
+ // Resolves `expected` by a single level if it is a variable. If
+ // there is no expected type or resolution is not possible (e.g.,
+ // no constraints yet present), just returns `None`.
+ fn resolve(self, fcx: &FnCtxt) -> Expectation {
+ match self {
+ NoExpectation => {
+ NoExpectation
+ }
+ ExpectCastableToType(t) => {
+ ExpectCastableToType(
+ fcx.infcx().resolve_type_vars_if_possible(t))
+ }
+ ExpectHasType(t) => {
+ ExpectHasType(
+ fcx.infcx().resolve_type_vars_if_possible(t))
+ }
+ }
+ }
+
+ fn map(self, fcx: &FnCtxt, unpack: |&ty::sty| -> Expectation) -> Expectation {
+ match self.resolve(fcx) {
+ NoExpectation => NoExpectation,
+ ExpectCastableToType(t) | ExpectHasType(t) => unpack(&ty::get(t).sty),
+ }
+ }
+
+ fn map_to_option<O>(self,
+ fcx: &FnCtxt,
+ unpack: |&ty::sty| -> Option<O>)
+ -> Option<O>
+ {
+ match self.resolve(fcx) {
+ NoExpectation => None,
+ ExpectCastableToType(t) | ExpectHasType(t) => unpack(&ty::get(t).sty),
+ }
+ }
+}
+
+impl Repr for Expectation {
+ fn repr(&self, tcx: &ty::ctxt) -> String {
+ match *self {
+ NoExpectation => format!("NoExpectation"),
+ ExpectHasType(t) => format!("ExpectHasType({})",
+ t.repr(tcx)),
+ ExpectCastableToType(t) => format!("ExpectCastableToType({})",
+ t.repr(tcx)),
+ }
+ }
+}
+
+fn check_cast(fcx: &FnCtxt, expr_from: Gc<ast::Expr>, ty_to: ty::t) {
+ // Find the type of `expr_from`. Supply hints based on the type
+ // we are casting to, if appropriate.
+ let ty_to = structurally_resolved_type(fcx, expr_from.span, ty_to);
+ if ty::type_is_scalar(ty_to) {
+ // Supply the type as a hint so as to influence integer
+ // literals and other things that might care.
+ check_expr_with_hint(fcx, expr_from, ty_to)
+ } else {
+ check_expr(fcx, expr_from)
+ }
+ let ty_from = fcx.expr_ty(expr_from);
+
+ // Object creation is checked during the vtable phase.
+ if ty::type_is_trait(ty_to) {
+ check_expr(fcx, expr_from);
+ return;
+ }
+
+ let ty_from = fcx.infcx().resolve_type_vars_if_possible(ty_from);
+
+ if ty::type_is_nil(ty_from) {
+ fcx.type_error_message(expr_from.span, |actual| {
+ format!("cast from nil: `{}` as `{}`", actual,
+ fcx.infcx().ty_to_str(ty_to))
+ }, ty_from, None);
+ return;
+ }
+
+ if ty::type_is_nil(ty_to) {
+ fcx.type_error_message(expr_from.span, |actual| {
+ format!("cast to nil: `{}` as `{}`", actual,
+ fcx.infcx().ty_to_str(ty_to))
+ }, ty_from, None);
+ return;
+ }
+
+ let t_e = structurally_resolved_type(fcx, expr_from.span, ty_from);
+ let t_1 = structurally_resolved_type(fcx, expr_from.span, ty_to);
+
+ let to_is_scalar = ty::type_is_scalar(t_1);
+ let to_is_float = ty::type_is_floating_point(t_1);
+ let to_is_char = ty::type_is_char(t_1);
+ let to_is_bare_fn = ty::type_is_bare_fn(t_1);
+
+ // casts to scalars other than `char` and `bare fn` are trivial
+ let to_is_trivial = to_is_scalar &&
+ !to_is_char && !to_is_bare_fn;
+
+ if ty::type_is_c_like_enum(fcx.tcx(), t_e) && to_is_trivial {
+ if to_is_float {
+ fcx.type_error_message(expr_from.span, |actual| {
+ format!("illegal cast; cast through an integer first: `{}` \
+ as `{}`",
+ actual,
+ fcx.infcx().ty_to_str(t_1))
+ }, ty_from, None);
+ }
+ // casts from C-like enums are allowed
+ } else if to_is_char {
+ if ty::get(ty_from).sty != ty::ty_uint(ast::TyU8) {
+ fcx.type_error_message(expr_from.span, |actual| {
+ format!("only `u8` can be cast as `char`, not `{}`", actual)
+ }, ty_from, None);
+ }
+ } else if ty::type_is_bool(t_1) {
+ fcx.tcx().sess.span_err(expr_from.span,
+ "cannot cast as `bool`, compare with zero instead");
+ } else if ty::type_is_region_ptr(t_e) && ty::type_is_unsafe_ptr(t_1) {
+ fn is_vec(t: ty::t) -> bool {
+ match ty::get(t).sty {
+ ty::ty_vec(..) => true,
+ ty::ty_ptr(ty::mt{ty: t, ..}) |
+ ty::ty_rptr(_, ty::mt{ty: t, ..}) |
+ ty::ty_box(t) |
+ ty::ty_uniq(t) => match ty::get(t).sty {
+ ty::ty_vec(_, None) => true,
+ _ => false,
+ },
+ _ => false
+ }
+ }
+ fn types_compatible(fcx: &FnCtxt, sp: Span,
+ t1: ty::t, t2: ty::t) -> bool {
+ if !is_vec(t1) {
+ false
+ } else {
+ let el = ty::sequence_element_type(fcx.tcx(),
+ t1);
+ infer::mk_eqty(fcx.infcx(), false,
+ infer::Misc(sp), el, t2).is_ok()
+ }
+ }
+
+ // Due to the limitations of LLVM global constants,
+ // region pointers end up pointing at copies of
+ // vector elements instead of the original values.
+ // To allow unsafe pointers to work correctly, we
+ // need to special-case obtaining an unsafe pointer
+ // from a region pointer to a vector.
+
+ /* this cast is only allowed from &[T] to *T or
+ &T to *T. */
+ match (&ty::get(t_e).sty, &ty::get(t_1).sty) {
+ (&ty::ty_rptr(_, ty::mt { ty: mt1, mutbl: ast::MutImmutable }),
+ &ty::ty_ptr(ty::mt { ty: mt2, mutbl: ast::MutImmutable }))
+ if types_compatible(fcx, expr_from.span, mt1, mt2) => {
+ /* this case is allowed */
+ }
+ _ => {
+ demand::coerce(fcx, expr_from.span, ty_to, expr_from);
+ }
+ }
+ } else if !(ty::type_is_scalar(t_e) && to_is_trivial) {
+ // If more type combinations should be supported than are
+ // supported here, then file an enhancement issue and
+ // record the issue number in this comment.
+ fcx.type_error_message(expr_from.span, |actual| {
+ format!("non-scalar cast: `{}` as `{}`", actual,
+ fcx.infcx().ty_to_str(ty_to))
+ }, ty_from, None);
+ }
+}
+
pub fn require_uint(fcx: &FnCtxt, sp: Span, t: ty::t) {
if !type_is_uint(fcx, sp, t) {
fcx.type_error_message(sp, |actual| {
}
pub fn check_block_no_value(fcx: &FnCtxt, blk: &ast::Block) {
- check_block_with_expected(fcx, blk, Some(ty::mk_nil()));
+ check_block_with_expected(fcx, blk, ExpectHasType(ty::mk_nil()));
let blkty = fcx.node_ty(blk.id);
if ty::type_is_error(blkty) {
fcx.write_error(blk.id);
}
}
-pub fn check_block_with_expected(fcx: &FnCtxt,
- blk: &ast::Block,
- expected: Option<ty::t>) {
+fn check_block_with_expected(fcx: &FnCtxt,
+ blk: &ast::Block,
+ expected: Expectation) {
let prev = {
let mut fcx_ps = fcx.ps.borrow_mut();
let fn_style_state = fcx_ps.recurse(blk);
e.span,
"unreachable expression".to_string());
}
- check_expr_with_opt_hint(fcx, &*e, expected);
- let ety = fcx.expr_ty(&*e);
+ check_expr_with_expectation(fcx, e, expected);
+ let ety = fcx.expr_ty(e);
fcx.write_ty(blk.id, ety);
if any_err {
fcx.write_error(blk.id);
// Resolves `typ` by a single level if `typ` is a type variable. If no
// resolution is possible, then an error is reported.
pub fn structurally_resolved_type(fcx: &FnCtxt, sp: Span, tp: ty::t) -> ty::t {
- match infer::resolve_type(fcx.infcx(), tp, force_tvar) {
+ match infer::resolve_type(fcx.infcx(), Some(sp), tp, force_tvar) {
Ok(t_s) if !ty::type_is_ty_var(t_s) => t_s,
_ => {
fcx.type_error_message(sp, |_actual| {
* bigger than the let and the `*b` expression, so we will
* effectively resolve `<R0>` to be the block B.
*/
- match resolve_type(self.fcx.infcx(), unresolved_ty,
+ match resolve_type(self.fcx.infcx(), None, unresolved_ty,
resolve_and_force_all_but_regions) {
Ok(t) => t,
Err(_) => ty::mk_err()
is_early: bool)
-> Option<ty::t> {
let tcx = vcx.tcx();
- match resolve_type(vcx.infcx, ty, resolve_and_force_all_but_regions) {
+ match resolve_type(vcx.infcx, Some(span), ty, resolve_and_force_all_but_regions) {
Ok(new_type) => Some(new_type),
Err(e) if !is_early => {
tcx.sess.span_fatal(span,
return t;
}
- match resolve_type(self.infcx, t, resolve_all | force_all) {
+ match resolve_type(self.infcx, None, t, resolve_all | force_all) {
Ok(t) => t,
Err(e) => {
self.report_error(e);
-> Option<t> {
let resolved_type;
match resolve_type(inference_context,
+ Some(span),
original_type,
resolve_ivar) {
Ok(resulting_type) if !type_is_ty_var(resulting_type) => {
pub fn unpack_actual_value(&self, a: ty::t, f: |&ty::sty| -> CoerceResult)
-> CoerceResult {
- match resolve_type(self.get_ref().infcx, a, try_resolve_tvar_shallow) {
+ match resolve_type(self.get_ref().infcx, None,
+ a, try_resolve_tvar_shallow) {
Ok(t) => {
f(&ty::get(t).sty)
}
pub enum fixup_err {
unresolved_int_ty(IntVid),
+ unresolved_float_ty(FloatVid),
unresolved_ty(TyVid),
cyclic_ty(TyVid),
unresolved_region(RegionVid),
pub fn fixup_err_to_str(f: fixup_err) -> String {
match f {
unresolved_int_ty(_) => "unconstrained integral type".to_string(),
+ unresolved_float_ty(_) => {
+ "unconstrained floating point type".to_string()
+ }
unresolved_ty(_) => "unconstrained type".to_string(),
cyclic_ty(_) => "cyclic type of infinite size".to_string(),
unresolved_region(_) => "unconstrained region".to_string(),
// See comment on the type `resolve_state` below
pub fn resolve_type(cx: &InferCtxt,
+ span: Option<Span>,
a: ty::t,
modes: uint)
- -> fres<ty::t>
-{
- let mut resolver = resolver(cx, modes);
+ -> fres<ty::t> {
+ let mut resolver = resolver(cx, modes, span);
cx.commit_unconditionally(|| resolver.resolve_type_chk(a))
}
pub fn resolve_region(cx: &InferCtxt, r: ty::Region, modes: uint)
- -> fres<ty::Region>
-{
- let mut resolver = resolver(cx, modes);
+ -> fres<ty::Region> {
+ let mut resolver = resolver(cx, modes, None);
resolver.resolve_region_chk(r)
}
}
pub fn resolve_type_vars_if_possible(&self, typ: ty::t) -> ty::t {
- match resolve_type(self, typ, resolve_nested_tvar | resolve_ivar) {
- Ok(new_type) => new_type,
- Err(_) => typ
+ match resolve_type(self,
+ None,
+ typ, resolve_nested_tvar | resolve_ivar) {
+ Ok(new_type) => new_type,
+ Err(_) => typ
}
}
fn iterate_until_fixed_point(&self,
tag: &str,
body: |constraint: &Constraint| -> bool) {
- let mut iteration = 0;
+ let mut iteration = 0u;
let mut changed = true;
while changed {
changed = false;
use middle::typeck::infer::{Bounds, cyclic_ty, fixup_err, fres, InferCtxt};
use middle::typeck::infer::unresolved_ty;
use middle::typeck::infer::unify::Root;
-use util::common::{indent};
-use util::ppaux::{ty_to_str, Repr};
+use syntax::codemap::Span;
+use util::common::indent;
+use util::ppaux::{Repr, ty_to_str};
use syntax::ast;
modes: uint,
err: Option<fixup_err>,
v_seen: Vec<TyVid> ,
- type_depth: uint
+ type_depth: uint,
+ span: Option<Span>,
}
-pub fn resolver<'a>(infcx: &'a InferCtxt, modes: uint) -> ResolveState<'a> {
+pub fn resolver<'a>(infcx: &'a InferCtxt,
+ modes: uint,
+ span: Option<Span>)
+ -> ResolveState<'a>
+{
ResolveState {
infcx: infcx,
modes: modes,
err: None,
v_seen: Vec::new(),
- type_depth: 0
+ type_depth: 0,
+ span: span
}
}
(self.modes & mode) == mode
}
- pub fn resolve_type_chk(&mut self, typ: ty::t) -> fres<ty::t> {
+ pub fn resolve_type_chk(&mut self,
+ typ: ty::t)
+ -> fres<ty::t> {
self.err = None;
debug!("Resolving {} (modes={:x})",
}
}
- pub fn resolve_region_chk(&mut self, orig: ty::Region)
+ pub fn resolve_region_chk(&mut self,
+ orig: ty::Region)
-> fres<ty::Region> {
self.err = None;
let resolved = indent(|| self.resolve_region(orig) );
Some(UintType(t)) => ty::mk_mach_uint(t),
None => {
if self.should(force_ivar) {
- // As a last resort, default to int.
+ // As a last resort, default to int and emit an error.
let ty = ty::mk_int();
table.borrow_mut().set(
tcx, node.key, Root(Some(IntType(ast::TyI)), node.rank));
+
+ match self.span {
+ Some(sp) => {
+ self.infcx.tcx.sess.span_err(
+ sp,
+ "cannot determine the type of this integer; add \
+ a suffix to specify the type explicitly");
+ }
+ None => { }
+ }
ty
} else {
ty::mk_int_var(self.infcx.tcx, vid)
Some(t) => ty::mk_mach_float(t),
None => {
if self.should(force_fvar) {
- // As a last resort, default to f64.
+ // As a last resort, default to f64 and emit an error.
let ty = ty::mk_f64();
table.borrow_mut().set(
tcx, node.key, Root(Some(ast::TyF64), node.rank));
+
+ match self.span {
+ Some(sp) => {
+ self.infcx.tcx.sess.span_err(
+ sp,
+ "cannot determine the type of this number; add \
+ a suffix to specify the type explicitly");
+ }
+ None => { }
+ }
ty
} else {
ty::mk_float_var(self.infcx.tcx, vid)
ty_bot => "!".to_string(),
ty_bool => "bool".to_string(),
ty_char => "char".to_string(),
- ty_int(t) => ast_util::int_ty_to_str(t, None,
- ast_util::AutoSuffix).to_string(),
- ty_uint(t) => ast_util::uint_ty_to_str(t, None,
- ast_util::AutoSuffix).to_string(),
+ ty_int(t) => ast_util::int_ty_to_str(t, None).to_string(),
+ ty_uint(t) => ast_util::uint_ty_to_str(t, None).to_string(),
ty_float(t) => ast_util::float_ty_to_str(t).to_string(),
ty_box(typ) => format!("Gc<{}>", ty_to_str(cx, typ)),
ty_uniq(typ) => format!("Box<{}>", ty_to_str(cx, typ)),
pub type _Unwind_Word = libc::uintptr_t;
#[cfg(target_arch = "x86")]
-pub static unwinder_private_data_size: int = 5;
+pub static unwinder_private_data_size: uint = 5;
#[cfg(target_arch = "x86_64")]
-pub static unwinder_private_data_size: int = 2;
+pub static unwinder_private_data_size: uint = 2;
#[cfg(target_arch = "arm", not(target_os = "ios"))]
-pub static unwinder_private_data_size: int = 20;
+pub static unwinder_private_data_size: uint = 20;
#[cfg(target_arch = "arm", target_os = "ios")]
-pub static unwinder_private_data_size: int = 5;
+pub static unwinder_private_data_size: uint = 5;
#[cfg(target_arch = "mips")]
#[cfg(target_arch = "mipsel")]
-pub static unwinder_private_data_size: int = 2;
+pub static unwinder_private_data_size: uint = 2;
pub struct _Unwind_Exception {
pub exception_class: _Unwind_Exception_Class,
fn smoke() { Thread::start(proc (){}).join(); }
#[test]
- fn data() { assert_eq!(Thread::start(proc () { 1 }).join(), 1); }
+ fn data() { assert_eq!(Thread::start(proc () { 1i }).join(), 1); }
#[test]
fn detached() { Thread::spawn(proc () {}) }
#[test]
fn small_stacks() {
- assert_eq!(42, Thread::start_stack(0, proc () 42).join());
- assert_eq!(42, Thread::start_stack(1, proc () 42).join());
+ assert_eq!(42i, Thread::start_stack(0, proc () 42i).join());
+ assert_eq!(42i, Thread::start_stack(1, proc () 42i).join());
}
}
fn test_base64_random() {
use std::rand::{task_rng, random, Rng};
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let times = task_rng().gen_range(1u, 100);
let v = Vec::from_fn(times, |_| random::<u8>());
assert_eq!(v.as_slice()
// the most significant bit is set, the second most significant bit is set etc. we can
// replace up to three "and+branch" with a single table lookup which gives us a measured
// speedup of around 2x on x86_64.
- static SHIFT_MASK_TABLE: [(u32, u32), ..16] = [
+ static SHIFT_MASK_TABLE: [(uint, u32), ..16] = [
(0, 0x0), (0, 0x0fffffff),
(8, 0x1fffff), (8, 0x1fffff),
(16, 0x3fff), (16, 0x3fff), (16, 0x3fff), (16, 0x3fff),
#[test]
pub fn test_to_hex_all_bytes() {
- for i in range(0, 256) {
+ for i in range(0u, 256) {
assert_eq!([i as u8].to_hex(), format!("{:02x}", i as uint));
}
}
#[test]
pub fn test_from_hex_all_bytes() {
- for i in range(0, 256) {
+ for i in range(0u, 256) {
assert_eq!(format!("{:02x}", i as uint).as_slice()
.from_hex()
.unwrap()
assert_eq!(true.to_json(), Boolean(true));
assert_eq!(false.to_json(), Boolean(false));
assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
- assert_eq!((1, 2).to_json(), list2);
- assert_eq!((1, 2, 3).to_json(), list3);
- assert_eq!([1, 2].to_json(), list2);
- assert_eq!((&[1, 2, 3]).to_json(), list3);
- assert_eq!((vec![1, 2]).to_json(), list2);
- assert_eq!(vec!(1, 2, 3).to_json(), list3);
+ assert_eq!((1i, 2i).to_json(), list2);
+ assert_eq!((1i, 2i, 3i).to_json(), list3);
+ assert_eq!([1i, 2].to_json(), list2);
+ assert_eq!((&[1i, 2, 3]).to_json(), list3);
+ assert_eq!((vec![1i, 2]).to_json(), list2);
+ assert_eq!(vec!(1i, 2i, 3i).to_json(), list3);
let mut tree_map = TreeMap::new();
- tree_map.insert("a".to_string(), 1);
+ tree_map.insert("a".to_string(), 1i);
tree_map.insert("b".to_string(), 2);
assert_eq!(tree_map.to_json(), object);
let mut hash_map = HashMap::new();
- hash_map.insert("a".to_string(), 1);
+ hash_map.insert("a".to_string(), 1i);
hash_map.insert("b".to_string(), 2);
assert_eq!(hash_map.to_json(), object);
- assert_eq!(Some(15).to_json(), Number(15 as f64));
+ assert_eq!(Some(15i).to_json(), Number(15 as f64));
assert_eq!(None::<int>.to_json(), Null);
}
fn big_json() -> String {
let mut src = "[\n".to_string();
- for _ in range(0, 500) {
+ for _ in range(0i, 500) {
src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \
[1,2,3]},"#);
}
fn test_create_capacity_zero() {
let mut m = HashMap::with_capacity(0);
- assert!(m.insert(1, 1));
+ assert!(m.insert(1i, 1i));
assert!(m.contains_key(&1));
assert!(!m.contains_key(&0));
fn test_insert() {
let mut m = HashMap::new();
assert_eq!(m.len(), 0);
- assert!(m.insert(1, 2));
+ assert!(m.insert(1i, 2i));
assert_eq!(m.len(), 1);
- assert!(m.insert(2, 4));
+ assert!(m.insert(2i, 4i));
assert_eq!(m.len(), 2);
assert_eq!(*m.find(&1).unwrap(), 2);
assert_eq!(*m.find(&2).unwrap(), 4);
#[test]
fn test_drops() {
- drop_vector.replace(Some(RefCell::new(Vec::from_elem(200, 0))));
+ drop_vector.replace(Some(RefCell::new(Vec::from_elem(200, 0i))));
{
let mut m = HashMap::new();
// Try this a few times to make sure we never screw up the hashmap's
// internal state.
- for _ in range(0, 10) {
+ for _ in range(0i, 10) {
assert!(m.is_empty());
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
assert!(m.insert(i, i));
for j in range_inclusive(1, i) {
}
}
- for i in range_inclusive(1001, 2000) {
+ for i in range_inclusive(1001i, 2000) {
assert!(!m.contains_key(&i));
}
// remove forwards
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
assert!(m.remove(&i));
for j in range_inclusive(1, i) {
}
}
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
assert!(!m.contains_key(&i));
}
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
assert!(m.insert(i, i));
}
// remove backwards
- for i in range_step_inclusive(1000, 1, -1) {
+ for i in range_step_inclusive(1000i, 1, -1) {
assert!(m.remove(&i));
for j in range_inclusive(i, 1000) {
#[test]
fn test_find_mut() {
let mut m = HashMap::new();
- assert!(m.insert(1, 12));
- assert!(m.insert(2, 8));
- assert!(m.insert(5, 14));
+ assert!(m.insert(1i, 12i));
+ assert!(m.insert(2i, 8i));
+ assert!(m.insert(5i, 14i));
let new = 100;
match m.find_mut(&5) {
None => fail!(), Some(x) => *x = new
#[test]
fn test_insert_overwrite() {
let mut m = HashMap::new();
- assert!(m.insert(1, 2));
+ assert!(m.insert(1i, 2i));
assert_eq!(*m.find(&1).unwrap(), 2);
- assert!(!m.insert(1, 3));
+ assert!(!m.insert(1i, 3i));
assert_eq!(*m.find(&1).unwrap(), 3);
}
#[test]
fn test_insert_conflicts() {
let mut m = HashMap::with_capacity(4);
- assert!(m.insert(1, 2));
- assert!(m.insert(5, 3));
- assert!(m.insert(9, 4));
+ assert!(m.insert(1i, 2i));
+ assert!(m.insert(5i, 3i));
+ assert!(m.insert(9i, 4i));
assert_eq!(*m.find(&9).unwrap(), 4);
assert_eq!(*m.find(&5).unwrap(), 3);
assert_eq!(*m.find(&1).unwrap(), 2);
#[test]
fn test_conflict_remove() {
let mut m = HashMap::with_capacity(4);
- assert!(m.insert(1, 2));
+ assert!(m.insert(1i, 2i));
assert_eq!(*m.find(&1).unwrap(), 2);
assert!(m.insert(5, 3));
assert_eq!(*m.find(&1).unwrap(), 2);
#[test]
fn test_is_empty() {
let mut m = HashMap::with_capacity(4);
- assert!(m.insert(1, 2));
+ assert!(m.insert(1i, 2i));
assert!(!m.is_empty());
assert!(m.remove(&1));
assert!(m.is_empty());
#[test]
fn test_pop() {
let mut m = HashMap::new();
- m.insert(1, 2);
+ m.insert(1i, 2i);
assert_eq!(m.pop(&1), Some(2));
assert_eq!(m.pop(&1), None);
}
#[allow(experimental)]
fn test_pop_equiv() {
let mut m = HashMap::new();
- m.insert(1, 2);
+ m.insert(1i, 2i);
assert_eq!(m.pop_equiv(&KindaIntLike(1)), Some(2));
assert_eq!(m.pop_equiv(&KindaIntLike(1)), None);
}
#[test]
fn test_swap() {
let mut m = HashMap::new();
- assert_eq!(m.swap(1, 2), None);
- assert_eq!(m.swap(1, 3), Some(2));
- assert_eq!(m.swap(1, 4), Some(3));
+ assert_eq!(m.swap(1i, 2i), None);
+ assert_eq!(m.swap(1i, 3i), Some(2));
+ assert_eq!(m.swap(1i, 4i), Some(3));
}
#[test]
let hm = {
let mut hm = HashMap::new();
- hm.insert('a', 1);
- hm.insert('b', 2);
+ hm.insert('a', 1i);
+ hm.insert('b', 2i);
hm
};
#[test]
fn test_keys() {
- let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+ let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
let map = vec.move_iter().collect::<HashMap<int, char>>();
let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
assert_eq!(keys.len(), 3);
#[test]
fn test_values() {
- let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+ let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
let map = vec.move_iter().collect::<HashMap<int, char>>();
let values = map.values().map(|&v| v).collect::<Vec<char>>();
assert_eq!(values.len(), 3);
#[test]
fn test_find() {
let mut m = HashMap::new();
- assert!(m.find(&1).is_none());
- m.insert(1, 2);
+ assert!(m.find(&1i).is_none());
+ m.insert(1i, 2i);
match m.find(&1) {
None => fail!(),
Some(v) => assert_eq!(*v, 2)
#[test]
fn test_eq() {
let mut m1 = HashMap::new();
- m1.insert(1, 2);
- m1.insert(2, 3);
- m1.insert(3, 4);
+ m1.insert(1i, 2i);
+ m1.insert(2i, 3i);
+ m1.insert(3i, 4i);
let mut m2 = HashMap::new();
- m2.insert(1, 2);
- m2.insert(2, 3);
+ m2.insert(1i, 2i);
+ m2.insert(2i, 3i);
assert!(m1 != m2);
- m2.insert(3, 4);
+ m2.insert(3i, 4i);
assert_eq!(m1, m2);
}
let mut map: HashMap<int, int> = HashMap::new();
let empty: HashMap<int, int> = HashMap::new();
- map.insert(1, 2);
- map.insert(3, 4);
+ map.insert(1i, 2i);
+ map.insert(3i, 4i);
let map_str = format!("{}", map);
fn test_find_equiv() {
let mut m = HashMap::new();
- let (foo, bar, baz) = (1,2,3);
+ let (foo, bar, baz) = (1i,2i,3i);
m.insert("foo".to_string(), foo);
m.insert("bar".to_string(), bar);
m.insert("baz".to_string(), baz);
#[test]
fn test_from_iter() {
- let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
#[test]
fn test_size_hint() {
- let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
#[test]
fn test_mut_size_hint() {
- let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+ let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
let mut ys = HashSet::new();
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
- assert!(xs.insert(5));
- assert!(ys.insert(11));
+ assert!(xs.insert(5i));
+ assert!(ys.insert(11i));
assert!(xs.is_disjoint(&ys));
assert!(ys.is_disjoint(&xs));
assert!(xs.insert(7));
#[test]
fn test_subset_and_superset() {
let mut a = HashSet::new();
- assert!(a.insert(0));
+ assert!(a.insert(0i));
assert!(a.insert(5));
assert!(a.insert(11));
assert!(a.insert(7));
let mut b = HashSet::new();
- assert!(b.insert(0));
+ assert!(b.insert(0i));
assert!(b.insert(7));
assert!(b.insert(19));
assert!(b.insert(250));
let mut a = HashSet::new();
let mut b = HashSet::new();
- assert!(a.insert(11));
+ assert!(a.insert(11i));
assert!(a.insert(1));
assert!(a.insert(3));
assert!(a.insert(77));
assert!(a.insert(5));
assert!(a.insert(-5));
- assert!(b.insert(2));
+ assert!(b.insert(2i));
assert!(b.insert(11));
assert!(b.insert(77));
assert!(b.insert(-9));
let mut a = HashSet::new();
let mut b = HashSet::new();
- assert!(a.insert(1));
+ assert!(a.insert(1i));
assert!(a.insert(3));
assert!(a.insert(5));
assert!(a.insert(9));
assert!(a.insert(11));
- assert!(b.insert(3));
+ assert!(b.insert(3i));
assert!(b.insert(9));
let mut i = 0;
let mut a = HashSet::new();
let mut b = HashSet::new();
- assert!(a.insert(1));
+ assert!(a.insert(1i));
assert!(a.insert(3));
assert!(a.insert(5));
assert!(a.insert(9));
assert!(a.insert(11));
- assert!(b.insert(-2));
+ assert!(b.insert(-2i));
assert!(b.insert(3));
assert!(b.insert(9));
assert!(b.insert(14));
let mut a = HashSet::new();
let mut b = HashSet::new();
- assert!(a.insert(1));
+ assert!(a.insert(1i));
assert!(a.insert(3));
assert!(a.insert(5));
assert!(a.insert(9));
assert!(a.insert(19));
assert!(a.insert(24));
- assert!(b.insert(-2));
+ assert!(b.insert(-2i));
assert!(b.insert(1));
assert!(b.insert(5));
assert!(b.insert(9));
#[test]
fn test_from_iter() {
- let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+ let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9];
let set: HashSet<int> = xs.iter().map(|&x| x).collect();
// I'm keeping them around to prevent a regression.
let mut s1 = HashSet::new();
- s1.insert(1);
+ s1.insert(1i);
s1.insert(2);
s1.insert(3);
let mut s2 = HashSet::new();
- s2.insert(1);
+ s2.insert(1i);
s2.insert(2);
assert!(s1 != s2);
let mut set: HashSet<int> = HashSet::new();
let empty: HashSet<int> = HashSet::new();
- set.insert(1);
+ set.insert(1i);
set.insert(2);
let set_str = format!("{}", set);
b.iter(|| {
let mut m = HashMap::new();
- m.insert(0, 0);
+ m.insert(0i, 0i);
assert_eq!(m.len(), 1);
})
}
let mut m = HashMap::new();
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
m.insert(i, i);
}
let mut m = HashMap::new();
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
m.insert(i, i);
}
b.iter(|| {
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
m.contains_key(&i);
}
});
let mut m = HashMap::new();
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
m.insert(i, i);
}
b.iter(|| {
- for i in range_inclusive(1001, 2000) {
+ for i in range_inclusive(1001i, 2000) {
m.contains_key(&i);
}
});
let mut m = HashMap::new();
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
m.insert(i, i);
}
- let mut k = 1;
+ let mut k = 1i;
b.iter(|| {
m.pop(&k);
let mut m = HashMap::new();
- for i in range_inclusive(1, 1000) {
+ for i in range_inclusive(1i, 1000) {
m.insert(i, i);
}
- let mut k = 1;
+ let mut k = 1i;
b.iter(|| {
m.find(&(k + 400));
```rust
# extern crate debug;
# fn main() {
-format!("Hello"); // => "Hello"
-format!("Hello, {:s}!", "world"); // => "Hello, world!"
-format!("The number is {:d}", 1); // => "The number is 1"
-format!("{:?}", (3, 4)); // => "(3, 4)"
-format!("{value}", value=4); // => "4"
-format!("{} {}", 1, 2); // => "1 2"
+format!("Hello"); // => "Hello"
+format!("Hello, {:s}!", "world"); // => "Hello, world!"
+format!("The number is {:d}", 1i); // => "The number is 1"
+format!("{:?}", (3i, 4i)); // => "(3, 4)"
+format!("{value}", value=4i); // => "4"
+format!("{} {}", 1i, 2i); // => "1 2"
# }
```
iterator advances. This leads to behavior like this:
```rust
-format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
+format!("{1} {} {0} {}", 1i, 2i); // => "2 1 1 2"
```
The internal iterator over the argument has not been advanced by the time the
```rust
# extern crate debug;
# fn main() {
-format!("{argument}", argument = "test"); // => "test"
-format!("{name} {}", 1, name = 2); // => "2 1"
-format!("{a:s} {c:d} {b:?}", a="a", b=(), c=3); // => "a 3 ()"
+format!("{argument}", argument = "test"); // => "test"
+format!("{name} {}", 1i, name = 2i); // => "2 1"
+format!("{a:s} {c:d} {b:?}", a="a", b=(), c=3i); // => "a 3 ()"
# }
```
let mut n = n;
while i > 0u {
bytes.push((n & 255_u64) as u8);
- n >>= 8_u64;
+ n >>= 8;
i -= 1u;
}
f(bytes.as_slice())
let mut bytes = vec!();
let mut i = size;
while i > 0u {
- let shift = ((i - 1u) * 8u) as u64;
+ let shift = (i - 1u) * 8u;
bytes.push((n >> shift) as u8);
i -= 1u;
}
let dir = &tmpdir.join("di_readdir");
check!(mkdir(dir, io::UserRWX));
let prefix = "foo";
- for n in range(0,3) {
+ for n in range(0i,3) {
let f = dir.join(format!("{}.txt", n));
let mut w = check!(File::create(&f));
let msg_str = format!("{}{}", prefix, n.to_str());
fn bench_mem_writer(b: &mut Bencher) {
b.iter(|| {
let mut wr = MemWriter::new();
- for _i in range(0, 10) {
+ for _i in range(0u, 10) {
wr.write([5, .. 10]).unwrap();
}
assert_eq!(wr.unwrap().as_slice(), [5, .. 100].as_slice());
let buf = Vec::from_slice([5 as u8, ..100]);
{
let mut rdr = MemReader::new(buf);
- for _i in range(0, 10) {
+ for _i in range(0u, 10) {
let mut buf = [0 as u8, .. 10];
rdr.read(buf).unwrap();
assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
let mut buf = [0 as u8, ..100];
{
let mut wr = BufWriter::new(buf);
- for _i in range(0, 10) {
+ for _i in range(0u, 10) {
wr.write([5, .. 10]).unwrap();
}
}
let buf = [5 as u8, ..100];
{
let mut rdr = BufReader::new(buf);
- for _i in range(0, 10) {
+ for _i in range(0u, 10) {
let mut buf = [0 as u8, .. 10];
rdr.read(buf).unwrap();
assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
port).unwrap());
});
let _l = rx.recv();
- for i in range(0, 1001) {
+ for i in range(0i, 1001) {
match a.accept() {
Ok(..) => break,
Err(ref e) if e.kind == TimedOut => {}
assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
s.set_timeout(Some(20));
- for i in range(0, 1001) {
+ for i in range(0i, 1001) {
match s.write([0, .. 128 * 1024]) {
Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
Err(IoError { kind: TimedOut, .. }) => break,
assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
tx.send(());
- for _ in range(0, 100) {
+ for _ in range(0i, 100) {
assert!(s.write([0, ..128 * 1024]).is_ok());
}
})
let mut s = a.accept().unwrap();
s.set_write_timeout(Some(20));
- for i in range(0, 1001) {
+ for i in range(0i, 1001) {
match s.write([0, .. 128 * 1024]) {
Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
Err(IoError { kind: TimedOut, .. }) => break,
let _b = UdpSocket::bind(addr2).unwrap();
a.set_write_timeout(Some(1000));
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
match a.sendto([0, ..4*1024], addr2) {
Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
Err(IoError { kind: TimedOut, .. }) => break,
};
spawn(proc() {
- for _ in range(0, times) {
+ for _ in range(0u, times) {
let mut stream = UnixStream::connect(&path2);
match stream.write([100]) {
Ok(..) => {}
tx.send(UnixStream::connect(&addr2).unwrap());
});
let l = rx.recv();
- for i in range(0, 1001) {
+ for i in range(0u, 1001) {
match a.accept() {
Ok(..) => break,
Err(ref e) if e.kind == TimedOut => {}
assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
s.set_timeout(Some(20));
- for i in range(0, 1001) {
+ for i in range(0u, 1001) {
match s.write([0, .. 128 * 1024]) {
Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
Err(IoError { kind: TimedOut, .. }) => break,
assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
tx.send(());
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
assert!(s.write([0, ..128 * 1024]).is_ok());
}
})
let mut s = a.accept().unwrap();
s.set_write_timeout(Some(20));
- for i in range(0, 1001) {
+ for i in range(0u, 1001) {
match s.write([0, .. 128 * 1024]) {
Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
Err(IoError { kind: TimedOut, .. }) => break,
iotest!(fn test_zero() {
let mut p = sleeper();
p.signal_kill().unwrap();
- for _ in range(0, 20) {
+ for _ in range(0i, 20) {
if p.signal(0).is_err() {
assert!(!p.wait().unwrap().success());
return
/// let mut timer = Timer::new().unwrap();
/// let ten_milliseconds = timer.oneshot(10);
///
- /// for _ in range(0, 100) { /* do work */ }
+ /// for _ in range(0u, 100) { /* do work */ }
///
/// // blocks until 10 ms after the `oneshot` call
/// ten_milliseconds.recv();
/// let mut timer = Timer::new().unwrap();
/// let ten_milliseconds = timer.periodic(10);
///
- /// for _ in range(0, 100) { /* do work */ }
+ /// for _ in range(0u, 100) { /* do work */ }
///
/// // blocks until 10 ms after the `periodic` call
/// ten_milliseconds.recv();
///
- /// for _ in range(0, 100) { /* do work */ }
+ /// for _ in range(0u, 100) { /* do work */ }
///
/// // blocks until 20 ms after the `periodic` call (*not* 10ms after the
/// // previous `recv`)
/// # #![allow(unreachable_code)]
/// fail!();
/// fail!("this is a terrible mistake!");
-/// fail!(4); // fail with the value of 4 to be collected elsewhere
+/// fail!(4i); // fail with the value of 4 to be collected elsewhere
/// fail!("this is a {} {message}", "fancy", message = "message");
/// ```
#[macro_export]
/// // assert with a custom message
/// # let x = true;
/// assert!(x, "x wasn't true!");
-/// # let a = 3; let b = 27;
+/// # let a = 3i; let b = 27i;
/// assert!(a + b == 30, "a = {}, b = {}", a, b);
/// ```
#[macro_export]
/// # Example
///
/// ```
-/// let a = 3;
-/// let b = 1 + 2;
+/// let a = 3i;
+/// let b = 1i + 2i;
/// assert_eq!(a, b);
/// ```
#[macro_export]
/// // assert with a custom message
/// # let x = true;
/// debug_assert!(x, "x wasn't true!");
-/// # let a = 3; let b = 27;
+/// # let a = 3i; let b = 27i;
/// debug_assert!(a + b == 30, "a = {}, b = {}", a, b);
/// ```
#[macro_export]
/// # Example
///
/// ```
-/// let a = 3;
-/// let b = 1 + 2;
+/// let a = 3i;
+/// let b = 1i + 2i;
/// debug_assert_eq!(a, b);
/// ```
#[macro_export]
/// ```
/// format!("test");
/// format!("hello {}", "world!");
-/// format!("x = {}, y = {y}", 10, y = 30);
+/// format!("x = {}, y = {y}", 10i, y = 30i);
/// ```
#[macro_export]
macro_rules! format(
/// let (tx1, rx1) = channel();
/// let (tx2, rx2) = channel();
/// # fn long_running_task() {}
-/// # fn calculate_the_answer() -> int { 42 }
+/// # fn calculate_the_answer() -> int { 42i }
///
/// spawn(proc() { long_running_task(); tx1.send(()) });
/// spawn(proc() { tx2.send(calculate_the_answer()) });
/// # Example
///
/// ```
- /// let s = concat!("test", 10, 'b', true);
+ /// let s = concat!("test", 10i, 'b', true);
/// assert_eq!(s, "test10btrue");
/// ```
#[macro_export]
/// Helper function for testing numeric operations
#[cfg(test)]
pub fn test_num<T:Num + NumCast + Show>(ten: T, two: T) {
- assert_eq!(ten.add(&two), cast(12).unwrap());
- assert_eq!(ten.sub(&two), cast(8).unwrap());
- assert_eq!(ten.mul(&two), cast(20).unwrap());
- assert_eq!(ten.div(&two), cast(5).unwrap());
- assert_eq!(ten.rem(&two), cast(0).unwrap());
+ assert_eq!(ten.add(&two), cast(12i).unwrap());
+ assert_eq!(ten.sub(&two), cast(8i).unwrap());
+ assert_eq!(ten.mul(&two), cast(20i).unwrap());
+ assert_eq!(ten.div(&two), cast(5i).unwrap());
+ assert_eq!(ten.rem(&two), cast(0i).unwrap());
assert_eq!(ten.add(&two), ten + two);
assert_eq!(ten.sub(&two), ten - two);
assert_eq!(result, naive_pow($num, $exp));
}}
)
- assert_pow!((3, 0 ) => 1);
- assert_pow!((5, 1 ) => 5);
- assert_pow!((-4, 2 ) => 16);
- assert_pow!((0.5, 5 ) => 0.03125);
- assert_pow!((8, 3 ) => 512);
- assert_pow!((8.0, 5 ) => 32768.0);
- assert_pow!((8.5, 5 ) => 44370.53125);
- assert_pow!((2u64, 50) => 1125899906842624);
+ assert_pow!((3i, 0 ) => 1);
+ assert_pow!((5i, 1 ) => 5);
+ assert_pow!((-4i, 2 ) => 16);
+ assert_pow!((0.5f64, 5 ) => 0.03125);
+ assert_pow!((8i, 3 ) => 512);
+ assert_pow!((8.0f64, 5 ) => 32768.0);
+ assert_pow!((8.5f64, 5 ) => 44370.53125);
+ assert_pow!((2u64, 50) => 1125899906842624);
}
}
#[bench]
fn bench_pow_function(b: &mut Bencher) {
- let v = Vec::from_fn(1024, |n| n);
- b.iter(|| {v.iter().fold(0, |old, new| num::pow(old, *new));});
+ let v = Vec::from_fn(1024u, |n| n);
+ b.iter(|| {v.iter().fold(0u, |old, new| num::pow(old, *new));});
}
}
/// use std::rand::{task_rng, sample};
///
/// let mut rng = task_rng();
-/// let sample = sample(&mut rng, range(1, 100), 5);
+/// let sample = sample(&mut rng, range(1i, 100), 5);
/// println!("{}", sample);
/// ```
pub fn sample<T, I: Iterator<T>, R: Rng>(rng: &mut R,
#[test]
fn test_gen_range() {
let mut r = task_rng();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let a = r.gen_range(-3i, 42);
assert!(a >= -3 && a < 42);
- assert_eq!(r.gen_range(0, 1), 0);
- assert_eq!(r.gen_range(-12, -11), -12);
+ assert_eq!(r.gen_range(0i, 1), 0);
+ assert_eq!(r.gen_range(-12i, -11), -12);
}
- for _ in range(0, 1000) {
- let a = r.gen_range(10, 42);
+ for _ in range(0u, 1000) {
+ let a = r.gen_range(10i, 42);
assert!(a >= 10 && a < 42);
- assert_eq!(r.gen_range(0, 1), 0);
+ assert_eq!(r.gen_range(0i, 1), 0);
assert_eq!(r.gen_range(3_000_000u, 3_000_001), 3_000_000);
}
#[test]
fn test_choose() {
let mut r = task_rng();
- assert_eq!(r.choose([1, 1, 1]).map(|&x|x), Some(1));
+ assert_eq!(r.choose([1i, 1, 1]).map(|&x|x), Some(1));
let v: &[int] = &[];
assert_eq!(r.choose(v), None);
let mut r = task_rng();
let empty: &mut [int] = &mut [];
r.shuffle(empty);
- let mut one = [1];
+ let mut one = [1i];
r.shuffle(one);
assert_eq!(one.as_slice(), &[1]);
- let mut two = [1, 2];
+ let mut two = [1i, 2];
r.shuffle(two);
assert!(two == [1, 2] || two == [2, 1]);
- let mut x = [1, 1, 1];
+ let mut x = [1i, 1, 1];
r.shuffle(x);
assert_eq!(x.as_slice(), &[1, 1, 1]);
}
fn test_task_rng() {
let mut r = task_rng();
r.gen::<int>();
- let mut v = [1, 1, 1];
+ let mut v = [1i, 1, 1];
r.shuffle(v);
assert_eq!(v.as_slice(), &[1, 1, 1]);
assert_eq!(r.gen_range(0u, 1u), 0u);
#[test]
fn test_sample() {
- let min_val = 1;
- let max_val = 100;
+ let min_val = 1i;
+ let max_val = 100i;
let mut r = task_rng();
let vals = range(min_val, max_val).collect::<Vec<int>>();
fn test_os_rng_tasks() {
let mut txs = vec!();
- for _ in range(0, 20) {
+ for _ in range(0u, 20) {
let (tx, rx) = channel();
txs.push(tx);
task::spawn(proc() {
task::deschedule();
let mut v = [0u8, .. 1000];
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
r.next_u32();
task::deschedule();
r.next_u64();
let _c = Cleanup { handle: process, SymCleanup: SymCleanup };
// And now that we're done with all the setup, do the stack walking!
- let mut i = 0;
+ let mut i = 0i;
try!(write!(w, "stack backtrace:\n"));
while StackWalk64(image, process, thread, &mut frame, &mut context,
0 as *libc::c_void, 0 as *libc::c_void,
#[test]
fn test_get_ref_method() {
- let mut f = Future::from_value(22);
+ let mut f = Future::from_value(22i);
assert_eq!(*f.get_ref(), 22);
}
fn test_task_pool() {
let f: || -> proc(uint):Send -> uint = || { proc(i) i };
let mut pool = TaskPool::new(4, f);
- for _ in range(0, 8) {
+ for _ in range(0u, 8) {
pool.execute(proc(i) println!("Hello from thread {}!", *i));
}
}
fn test_vectors() {
let x: Vec<int> = vec![];
assert_eq!(x.to_str(), "[]".to_string());
- assert_eq!((vec![1]).to_str(), "[1]".to_string());
- assert_eq!((vec![1, 2, 3]).to_str(), "[1, 2, 3]".to_string());
- assert!((vec![vec![], vec![1], vec![1, 1]]).to_str() ==
+ assert_eq!((vec![1i]).to_str(), "[1]".to_string());
+ assert_eq!((vec![1i, 2, 3]).to_str(), "[1, 2, 3]".to_string());
+ assert!((vec![vec![], vec![1i], vec![1i, 1]]).to_str() ==
"[[], [1], [1, 1]]".to_string());
}
}
#[test]
fn option_swap() {
- let p = AtomicOption::new(box 1);
- let a = box 2;
+ let p = AtomicOption::new(box 1i);
+ let a = box 2i;
let b = p.swap(a, SeqCst);
#[test]
fn option_take() {
- let p = AtomicOption::new(box 1);
+ let p = AtomicOption::new(box 1i);
assert!(p.take(SeqCst) == Some(box 1));
assert!(p.take(SeqCst) == None);
- let p2 = box 2;
+ let p2 = box 2i;
p.swap(p2, SeqCst);
assert!(p.take(SeqCst) == Some(box 2));
#[test]
fn option_fill() {
- let p = AtomicOption::new(box 1);
- assert!(p.fill(box 2, SeqCst).is_some()); // should fail; shouldn't leak!
+ let p = AtomicOption::new(box 1i);
+ assert!(p.fill(box 2i, SeqCst).is_some()); // should fail; shouldn't leak!
assert!(p.take(SeqCst) == Some(box 1));
- assert!(p.fill(box 2, SeqCst).is_none()); // shouldn't fail
+ assert!(p.fill(box 2i, SeqCst).is_none()); // shouldn't fail
assert!(p.take(SeqCst) == Some(box 2));
}
}
//! // Create a simple streaming channel
//! let (tx, rx) = channel();
//! spawn(proc() {
-//! tx.send(10);
+//! tx.send(10i);
//! });
-//! assert_eq!(rx.recv(), 10);
+//! assert_eq!(rx.recv(), 10i);
//! ```
//!
//! Shared usage:
//! ```
//! // Create a shared channel which can be sent along from many tasks
//! let (tx, rx) = channel();
-//! for i in range(0, 10) {
+//! for i in range(0i, 10i) {
//! let tx = tx.clone();
//! spawn(proc() {
//! tx.send(i);
//! })
//! }
//!
-//! for _ in range(0, 10) {
+//! for _ in range(0i, 10i) {
//! let j = rx.recv();
//! assert!(0 <= j && j < 10);
//! }
//! Synchronous channels:
//!
//! ```
-//! let (tx, rx) = sync_channel(0);
+//! let (tx, rx) = sync_channel::<int>(0);
//! spawn(proc() {
//! // This will wait for the parent task to start receiving
//! tx.send(53);
/// let (tx, rx) = sync_channel(1);
///
/// // this returns immediately
-/// tx.send(1);
+/// tx.send(1i);
///
/// spawn(proc() {
/// // this will block until the previous message has been received
-/// tx.send(2);
+/// tx.send(2i);
/// });
///
-/// assert_eq!(rx.recv(), 1);
-/// assert_eq!(rx.recv(), 2);
+/// assert_eq!(rx.recv(), 1i);
+/// assert_eq!(rx.recv(), 2i);
/// ```
pub fn sync_channel<T: Send>(bound: uint) -> (SyncSender<T>, Receiver<T>) {
let a = Arc::new(Unsafe::new(sync::Packet::new(bound)));
/// let (tx, rx) = channel();
///
/// // This send is always successful
- /// assert_eq!(tx.send_opt(1), Ok(()));
+ /// assert_eq!(tx.send_opt(1i), Ok(()));
///
/// // This send will fail because the receiver is gone
/// drop(rx);
- /// assert_eq!(tx.send_opt(1), Err(1));
+ /// assert_eq!(tx.send_opt(1i), Err(1));
/// ```
pub fn send_opt(&self, t: T) -> Result<(), T> {
// In order to prevent starvation of other tasks in situations where
}
test!(fn smoke() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
tx.send(1);
assert_eq!(rx.recv(), 1);
})
test!(fn drop_full() {
let (tx, _rx) = channel();
- tx.send(box 1);
+ tx.send(box 1i);
})
test!(fn drop_full_shared() {
let (tx, _rx) = channel();
drop(tx.clone());
drop(tx.clone());
- tx.send(box 1);
+ tx.send(box 1i);
})
test!(fn smoke_shared() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
tx.send(1);
assert_eq!(rx.recv(), 1);
let tx = tx.clone();
})
test!(fn smoke_threads() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
spawn(proc() {
tx.send(1);
});
})
test!(fn smoke_port_gone() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
drop(rx);
tx.send(1);
} #[should_fail])
test!(fn smoke_shared_port_gone() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
drop(rx);
tx.send(1);
} #[should_fail])
test!(fn smoke_shared_port_gone2() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
drop(rx);
let tx2 = tx.clone();
drop(tx);
} #[should_fail])
test!(fn port_gone_concurrent() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
spawn(proc() {
rx.recv();
});
} #[should_fail])
test!(fn port_gone_concurrent_shared() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
let tx2 = tx.clone();
spawn(proc() {
rx.recv();
} #[should_fail])
test!(fn chan_gone_concurrent() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
spawn(proc() {
tx.send(1);
tx.send(1);
} #[should_fail])
test!(fn stress() {
- let (tx, rx) = channel();
+ let (tx, rx) = channel::<int>();
spawn(proc() {
- for _ in range(0, 10000) { tx.send(1); }
+ for _ in range(0u, 10000) { tx.send(1i); }
});
- for _ in range(0, 10000) {
+ for _ in range(0u, 10000) {
assert_eq!(rx.recv(), 1);
}
})
let tx4 = tx3.clone();
spawn(proc() {
tx1.send(());
- for _ in range(0, 40) {
+ for _ in range(0i, 40) {
assert_eq!(rx2.recv(), 1);
}
tx3.send(());
});
rx1.recv();
native::task::spawn(proc() {
- for _ in range(0, 40) {
+ for _ in range(0i, 40) {
tx2.send(1);
}
tx4.send(());
let (tx, rx) = channel::<int>();
let (dtx, drx) = channel();
native::task::spawn(proc() {
- for _ in range(0, 40) {
+ for _ in range(0i, 40) {
assert_eq!(rx.recv(), 1);
}
dtx.send(());
});
- for _ in range(0, 40) {
+ for _ in range(0u, 40) {
tx.send(1);
}
drx.recv();
for _ in range(0, stress_factor()) {
let (tx, rx) = channel();
spawn(proc() {
- tx.send(box 10);
+ tx.send(box 10i);
});
spawn(proc() {
- assert!(rx.recv() == box 10);
+ assert!(rx.recv() == box 10i);
});
}
})
test!(fn recv_a_lot() {
// Regression test that we don't run out of stack in scheduler context
let (tx, rx) = channel();
- for _ in range(0, 10000) { tx.send(()); }
- for _ in range(0, 10000) { rx.recv(); }
+ for _ in range(0i, 10000) { tx.send(()); }
+ for _ in range(0i, 10000) { rx.recv(); }
})
test!(fn shared_chan_stress() {
tx2.send(());
});
// make sure the other task has gone to sleep
- for _ in range(0, 5000) { task::deschedule(); }
+ for _ in range(0u, 5000) { task::deschedule(); }
// upgrade to a shared chan and send a message
let t = tx.clone();
let (tx, rx) = channel();
let t = Thread::start(proc() {
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
tx.send(());
}
});
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
rx.recv();
}
t.join();
}
cdone.send(());
});
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
tx.send(());
}
t.join();
}
test!(fn smoke() {
- let (tx, rx) = sync_channel(1);
+ let (tx, rx) = sync_channel::<int>(1);
tx.send(1);
assert_eq!(rx.recv(), 1);
})
test!(fn drop_full() {
let (tx, _rx) = sync_channel(1);
- tx.send(box 1);
+ tx.send(box 1i);
})
test!(fn smoke_shared() {
- let (tx, rx) = sync_channel(1);
+ let (tx, rx) = sync_channel::<int>(1);
tx.send(1);
assert_eq!(rx.recv(), 1);
let tx = tx.clone();
})
test!(fn smoke_threads() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() {
tx.send(1);
});
})
test!(fn smoke_port_gone() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
drop(rx);
tx.send(1);
} #[should_fail])
test!(fn smoke_shared_port_gone2() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
drop(rx);
let tx2 = tx.clone();
drop(tx);
} #[should_fail])
test!(fn port_gone_concurrent() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() {
rx.recv();
});
} #[should_fail])
test!(fn port_gone_concurrent_shared() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
let tx2 = tx.clone();
spawn(proc() {
rx.recv();
} #[should_fail])
test!(fn chan_gone_concurrent() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() {
tx.send(1);
tx.send(1);
} #[should_fail])
test!(fn stress() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() {
- for _ in range(0, 10000) { tx.send(1); }
+ for _ in range(0u, 10000) { tx.send(1); }
});
- for _ in range(0, 10000) {
+ for _ in range(0u, 10000) {
assert_eq!(rx.recv(), 1);
}
})
test!(fn oneshot_multi_thread_send_recv_stress() {
for _ in range(0, stress_factor()) {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<Box<int>>(0);
spawn(proc() {
- tx.send(box 10);
+ tx.send(box 10i);
});
spawn(proc() {
- assert!(rx.recv() == box 10);
+ assert!(rx.recv() == box 10i);
});
}
})
test!(fn stream_send_recv_stress() {
for _ in range(0, stress_factor()) {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<Box<int>>(0);
send(tx, 0);
recv(rx, 0);
test!(fn recv_a_lot() {
// Regression test that we don't run out of stack in scheduler context
let (tx, rx) = sync_channel(10000);
- for _ in range(0, 10000) { tx.send(()); }
- for _ in range(0, 10000) { rx.recv(); }
+ for _ in range(0u, 10000) { tx.send(()); }
+ for _ in range(0u, 10000) { rx.recv(); }
})
test!(fn shared_chan_stress() {
// This bug used to end up in a livelock inside of the Receiver destructor
// because the internal state of the Shared packet was corrupted
test!(fn destroy_upgraded_shared_port_when_sender_still_active() {
- let (tx, rx) = sync_channel(0);
- let (tx2, rx2) = sync_channel(0);
+ let (tx, rx) = sync_channel::<()>(0);
+ let (tx2, rx2) = sync_channel::<()>(0);
spawn(proc() {
rx.recv(); // wait on a oneshot
drop(rx); // destroy a shared
tx2.send(());
});
// make sure the other task has gone to sleep
- for _ in range(0, 5000) { task::deschedule(); }
+ for _ in range(0u, 5000) { task::deschedule(); }
// upgrade to a shared chan and send a message
let t = tx.clone();
test!(fn try_recvs_off_the_runtime() {
use std::rt::thread::Thread;
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<()>(0);
let (cdone, pdone) = channel();
let t = Thread::start(proc() {
let mut hits = 0;
}
cdone.send(());
});
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
tx.send(());
}
t.join();
})
test!(fn send_opt1() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() { rx.recv(); });
assert_eq!(tx.send_opt(1), Ok(()));
})
test!(fn send_opt2() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() { drop(rx); });
assert_eq!(tx.send_opt(1), Err(1));
})
test!(fn send_opt3() {
- let (tx, rx) = sync_channel(1);
+ let (tx, rx) = sync_channel::<int>(1);
assert_eq!(tx.send_opt(1), Ok(()));
spawn(proc() { drop(rx); });
assert_eq!(tx.send_opt(1), Err(1));
})
test!(fn send_opt4() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
let tx2 = tx.clone();
let (done, donerx) = channel();
let done2 = done.clone();
})
test!(fn try_send1() {
- let (tx, _rx) = sync_channel(0);
+ let (tx, _rx) = sync_channel::<int>(0);
assert_eq!(tx.try_send(1), Err(Full(1)));
})
test!(fn try_send2() {
- let (tx, _rx) = sync_channel(1);
+ let (tx, _rx) = sync_channel::<int>(1);
assert_eq!(tx.try_send(1), Ok(()));
assert_eq!(tx.try_send(1), Err(Full(1)));
})
test!(fn try_send3() {
- let (tx, rx) = sync_channel(1);
+ let (tx, rx) = sync_channel::<int>(1);
assert_eq!(tx.try_send(1), Ok(()));
drop(rx);
assert_eq!(tx.try_send(1), Err(RecvDisconnected(1)));
})
test!(fn try_send4() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() {
- for _ in range(0, 1000) { task::deschedule(); }
+ for _ in range(0u, 1000) { task::deschedule(); }
assert_eq!(tx.try_send(1), Ok(()));
});
assert_eq!(rx.recv(), 1);
//! let (tx1, rx1) = channel();
//! let (tx2, rx2) = channel();
//!
-//! tx1.send(1);
-//! tx2.send(2);
+//! tx1.send(1i);
+//! tx2.send(2i);
//!
//! select! {
//! val = rx1.recv() => {
-//! assert_eq!(val, 1);
+//! assert_eq!(val, 1i);
//! },
//! val = rx2.recv() => {
-//! assert_eq!(val, 2);
+//! assert_eq!(val, 2i);
//! }
//! }
//! ```
let (tx3, rx3) = channel::<int>();
spawn(proc() {
- for _ in range(0, 20) { task::deschedule(); }
+ for _ in range(0u, 20) { task::deschedule(); }
tx1.send(1);
rx3.recv();
- for _ in range(0, 20) { task::deschedule(); }
+ for _ in range(0u, 20) { task::deschedule(); }
});
select! (
let (tx3, rx3) = channel::<()>();
spawn(proc() {
- for _ in range(0, 20) { task::deschedule(); }
+ for _ in range(0u, 20) { task::deschedule(); }
tx1.send(1);
tx2.send(2);
rx3.recv();
tx3.send(());
});
- for _ in range(0, 1000) { task::deschedule(); }
+ for _ in range(0u, 1000) { task::deschedule(); }
drop(tx1.clone());
tx2.send(());
rx3.recv();
tx2.send(());
});
- for _ in range(0, 100) { task::deschedule() }
+ for _ in range(0u, 100) { task::deschedule() }
tx1.send(());
rx2.recv();
})
tx2.send(());
});
- for _ in range(0, 100) { task::deschedule() }
+ for _ in range(0u, 100) { task::deschedule() }
tx1.send(());
rx2.recv();
})
tx2.send(());
});
- for _ in range(0, 100) { task::deschedule() }
+ for _ in range(0u, 100) { task::deschedule() }
tx1.send(());
rx2.recv();
})
test!(fn sync1() {
- let (tx, rx) = sync_channel(1);
+ let (tx, rx) = sync_channel::<int>(1);
tx.send(1);
select! {
n = rx.recv() => { assert_eq!(n, 1); }
})
test!(fn sync2() {
- let (tx, rx) = sync_channel(0);
+ let (tx, rx) = sync_channel::<int>(0);
spawn(proc() {
- for _ in range(0, 100) { task::deschedule() }
+ for _ in range(0u, 100) { task::deschedule() }
tx.send(1);
});
select! {
})
test!(fn sync3() {
- let (tx1, rx1) = sync_channel(0);
- let (tx2, rx2) = channel();
+ let (tx1, rx1) = sync_channel::<int>(0);
+ let (tx2, rx2): (Sender<int>, Receiver<int>) = channel();
spawn(proc() { tx1.send(1); });
spawn(proc() { tx2.send(2); });
select! {
// size.
//
// The size in question is 1 << MIN_BITS
-static MIN_BITS: int = 7;
+static MIN_BITS: uint = 7;
struct Deque<T> {
bottom: AtomicInt,
/// LLVM is probably pretty good at doing this already.
struct Buffer<T> {
storage: *T,
- log_size: int,
+ log_size: uint,
}
impl<T: Send> BufferPool<T> {
Stealer { deque: b, noshare: marker::NoShare })
}
- fn alloc(&self, bits: int) -> Box<Buffer<T>> {
+ fn alloc(&mut self, bits: uint) -> Box<Buffer<T>> {
unsafe {
let mut pool = self.pool.lock();
match pool.iter().position(|x| x.size() >= (1 << bits)) {
// personally going to heavily comment what's going on here.
impl<T: Send> Deque<T> {
- fn new(pool: BufferPool<T>) -> Deque<T> {
+ fn new(mut pool: BufferPool<T>) -> Deque<T> {
let buf = pool.alloc(MIN_BITS);
Deque {
bottom: AtomicInt::new(0),
}
#[inline]
-fn buffer_alloc_size<T>(log_size: int) -> uint {
+fn buffer_alloc_size<T>(log_size: uint) -> uint {
(1 << log_size) * size_of::<T>()
}
impl<T: Send> Buffer<T> {
- unsafe fn new(log_size: int) -> Buffer<T> {
+ unsafe fn new(log_size: uint) -> Buffer<T> {
let size = buffer_alloc_size::<T>(log_size);
let buffer = allocate(size, min_align_of::<T>());
Buffer {
// Again, unsafe because this has incredibly dubious ownership violations.
// It is assumed that this buffer is immediately dropped.
unsafe fn resize(&self, b: int, t: int, delta: int) -> Buffer<T> {
- let buf = Buffer::new(self.log_size + delta);
+ // NB: not entirely obvious, but thanks to 2's complement,
+ // casting delta to uint and then adding gives the desired
+ // effect.
+ let buf = Buffer::new(self.log_size + delta as uint);
for i in range(t, b) {
buf.put(i, self.get(i));
}
let (w, s) = pool.deque();
assert_eq!(w.pop(), None);
assert_eq!(s.steal(), Empty);
- w.push(1);
+ w.push(1i);
assert_eq!(w.pop(), Some(1));
w.push(1);
assert_eq!(s.steal(), Data(1));
let mut rng = rand::task_rng();
let mut expected = 0;
while expected < AMT {
- if rng.gen_range(0, 3) == 2 {
+ if rng.gen_range(0i, 3) == 2 {
match w.pop() {
None => {}
Some(2) => unsafe { HITS.fetch_add(1, SeqCst); },
let mut myhit = false;
'outer: loop {
for _ in range(0, rng.gen_range(0, AMT)) {
- if !myhit && rng.gen_range(0, 3) == 2 {
+ if !myhit && rng.gen_range(0i, 3) == 2 {
match w.pop() {
None => {}
Some((1, 2)) => myhit = true,
/// ```
/// use sync::{RWLock, Arc};
///
-/// let lock1 = Arc::new(RWLock::new(1));
+/// let lock1 = Arc::new(RWLock::new(1i));
/// let lock2 = lock1.clone();
///
/// spawn(proc() {
/// use sync::{Arc, Barrier};
///
/// let barrier = Arc::new(Barrier::new(10));
-/// for _ in range(0, 10) {
+/// for _ in range(0u, 10) {
/// let c = barrier.clone();
/// // The same messages will be printed together.
/// // You will NOT see any interleaving.
#[test] #[should_fail]
fn test_mutex_arc_poison() {
- let arc = Arc::new(Mutex::new(1));
+ let arc = Arc::new(Mutex::new(1i));
let arc2 = arc.clone();
let _ = task::try(proc() {
let lock = arc2.lock();
fn test_mutex_arc_nested() {
// Tests nested mutexes and access
// to underlying data.
- let arc = Arc::new(Mutex::new(1));
+ let arc = Arc::new(Mutex::new(1i));
let arc2 = Arc::new(Mutex::new(arc));
task::spawn(proc() {
let lock = arc2.lock();
#[test] #[should_fail]
fn test_rw_arc_poison_wr() {
- let arc = Arc::new(RWLock::new(1));
+ let arc = Arc::new(RWLock::new(1i));
let arc2 = arc.clone();
let _ = task::try(proc() {
let lock = arc2.write();
}
#[test] #[should_fail]
fn test_rw_arc_poison_ww() {
- let arc = Arc::new(RWLock::new(1));
+ let arc = Arc::new(RWLock::new(1i));
let arc2 = arc.clone();
let _ = task::try(proc() {
let lock = arc2.write();
}
#[test]
fn test_rw_arc_no_poison_rr() {
- let arc = Arc::new(RWLock::new(1));
+ let arc = Arc::new(RWLock::new(1i));
let arc2 = arc.clone();
let _ = task::try(proc() {
let lock = arc2.read();
}
#[test]
fn test_rw_arc_no_poison_rw() {
- let arc = Arc::new(RWLock::new(1));
+ let arc = Arc::new(RWLock::new(1i));
let arc2 = arc.clone();
let _ = task::try(proc() {
let lock = arc2.read();
}
#[test]
fn test_rw_arc_no_poison_dr() {
- let arc = Arc::new(RWLock::new(1));
+ let arc = Arc::new(RWLock::new(1i));
let arc2 = arc.clone();
let _ = task::try(proc() {
let lock = arc2.write().downgrade();
#[test]
fn test_rw_arc() {
- let arc = Arc::new(RWLock::new(0));
+ let arc = Arc::new(RWLock::new(0i));
let arc2 = arc.clone();
let (tx, rx) = channel();
task::spawn(proc() {
let mut lock = arc2.write();
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
let tmp = *lock;
*lock = -1;
task::deschedule();
// Readers try to catch the writer in the act
let mut children = Vec::new();
- for _ in range(0, 5) {
+ for _ in range(0u, 5) {
let arc3 = arc.clone();
children.push(try_future(proc() {
let lock = arc3.read();
// (4) tells writer and all other readers to contend as it downgrades.
// (5) Writer attempts to set state back to 42, while downgraded task
// and all reader tasks assert that it's 31337.
- let arc = Arc::new(RWLock::new(0));
+ let arc = Arc::new(RWLock::new(0i));
// Reader tasks
let mut reader_convos = Vec::new();
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
let ((tx1, rx1), (tx2, rx2)) = (channel(), channel());
reader_convos.push((tx1, rx2));
let arcn = arc.clone();
let lock = lock.downgrade();
// if writer mistakenly got in, make sure it mutates state
// before we assert on it
- for _ in range(0, 5) { task::deschedule(); }
+ for _ in range(0u, 5) { task::deschedule(); }
// make sure writer didn't get in.
assert!(*lock);
}
// deschedules in the intuitively-right locations made it even less
// likely, and I wasn't sure why :( . This is a mediocre "next best"
// option.
- for _ in range(0, 8) {
+ for _ in range(0u, 8) {
test_rw_write_cond_downgrade_read_race_helper();
}
}
let barrier = Arc::new(Barrier::new(10));
let (tx, rx) = channel();
- for _ in range(0, 9) {
+ for _ in range(0u, 9) {
let c = barrier.clone();
let tx = tx.clone();
spawn(proc() {
barrier.wait();
// Now, the barrier is cleared and we should get data.
- for _ in range(0, 9) {
+ for _ in range(0u, 9) {
rx.recv();
}
}
#[test]
fn smoke_once() {
static mut o: Once = ONCE_INIT;
- let mut a = 0;
+ let mut a = 0i;
unsafe { o.doit(|| a += 1); }
assert_eq!(a, 1);
unsafe { o.doit(|| a += 1); }
static mut run: bool = false;
let (tx, rx) = channel();
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
let tx = tx.clone();
spawn(proc() {
- for _ in range(0, 4) { task::deschedule() }
+ for _ in range(0u, 4) { task::deschedule() }
unsafe {
o.doit(|| {
assert!(!run);
assert!(run);
}
- for _ in range(0, 10) {
+ for _ in range(0u, 10) {
rx.recv();
}
}
});
// Uncomment if you wish to test for sem races. Not
// valgrind-friendly.
- /* for _ in range(0, 1000) { task::deschedule(); } */
+ /* for _ in range(0u, 1000) { task::deschedule(); } */
// Need to wait outside the exclusive.
if waiter_nobe.is_some() {
let _ = waiter_nobe.unwrap().recv();
let s2 = s.clone();
task::spawn(proc() {
let _g = s2.access();
- for _ in range(0, 5) { task::deschedule(); }
+ for _ in range(0u, 5) { task::deschedule(); }
});
let _g = s.access();
- for _ in range(0, 5) { task::deschedule(); }
+ for _ in range(0u, 5) { task::deschedule(); }
}
#[test]
fn test_sem_as_cvar() {
s2.acquire();
tx.send(());
});
- for _ in range(0, 5) { task::deschedule(); }
+ for _ in range(0u, 5) { task::deschedule(); }
s.release();
let _ = rx.recv();
let s = Arc::new(Semaphore::new(0));
let s2 = s.clone();
task::spawn(proc() {
- for _ in range(0, 5) { task::deschedule(); }
+ for _ in range(0u, 5) { task::deschedule(); }
s2.release();
let _ = rx.recv();
});
tx.send(());
});
rx.recv(); // wait for child to come alive
- for _ in range(0, 5) { task::deschedule(); } // let the child contend
+ for _ in range(0u, 5) { task::deschedule(); } // let the child contend
}
rx.recv(); // wait for child to be done
}
}
fn access_shared(sharedstate: *mut int, m: &Arc<Mutex>, n: uint) {
- for _ in range(0, n) {
+ for _ in range(0u, n) {
let _g = m.lock();
let oldval = unsafe { *sharedstate };
task::deschedule();
let m = Arc::new(Mutex::new());
let mut rxs = Vec::new();
- for _ in range(0, num_waiters) {
+ for _ in range(0u, num_waiters) {
let mi = m.clone();
let (tx, rx) = channel();
rxs.push(rx);
fn access_shared(sharedstate: &mut int, x: &Arc<RWLock>,
mode: RWLockMode, n: uint) {
- for _ in range(0, n) {
+ for _ in range(0u, n) {
lock_rwlock_in_mode(x, mode, || {
let oldval = *sharedstate;
task::deschedule();
let x = Arc::new(RWLock::new());
let mut rxs = Vec::new();
- for _ in range(0, num_waiters) {
+ for _ in range(0u, num_waiters) {
let xi = x.clone();
let (tx, rx) = channel();
rxs.push(rx);
#[test]
fn smoke() {
let q = Queue::new(0);
- q.push(1);
+ q.push(1i);
q.push(2);
assert_eq!(q.pop(), Some(1));
assert_eq!(q.pop(), Some(2));
#[test]
fn smoke_bound() {
let q = Queue::new(1);
- q.push(1);
+ q.push(1i);
q.push(2);
assert_eq!(q.pop(), Some(1));
assert_eq!(q.pop(), Some(2));
let b = a.clone();
let (tx, rx) = channel();
native::task::spawn(proc() {
- for _ in range(0, 100000) {
+ for _ in range(0u, 100000) {
loop {
match b.pop() {
Some(1) => break,
}
tx.send(());
});
- for _ in range(0, 100000) {
+ for _ in range(0i, 100000) {
a.push(1);
}
rx.recv();
impl Architecture {
fn bit(&self) -> u32 {
- 1 << (*self as u32)
+ 1 << (*self as uint)
}
}
assert_eq!(i, abi_data.abi.index());
}
- let bits = 1 << (X86 as u32);
- let bits = bits | 1 << (X86_64 as u32);
+ let bits = 1 << (X86 as uint);
+ let bits = bits | 1 << (X86_64 as uint);
assert_eq!(IntelBits, bits);
- let bits = 1 << (Arm as u32);
+ let bits = 1 << (Arm as uint);
assert_eq!(ArmBits, bits);
}
impl fmt::Show for IntTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}",
- ast_util::int_ty_to_str(*self, None, ast_util::AutoSuffix))
+ write!(f, "{}", ast_util::int_ty_to_str(*self, None))
}
}
impl fmt::Show for UintTy {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(f, "{}",
- ast_util::uint_ty_to_str(*self, None, ast_util::AutoSuffix))
+ write!(f, "{}", ast_util::uint_ty_to_str(*self, None))
}
}
return match e.node { ExprPath(_) => true, _ => false };
}
-pub enum SuffixMode {
- ForceSuffix,
- AutoSuffix,
-}
-
// Get a string representation of a signed int type, with its value.
// We want to avoid "45int" and "-3int" in favor of "45" and "-3"
-pub fn int_ty_to_str(t: IntTy, val: Option<i64>, mode: SuffixMode) -> String {
+pub fn int_ty_to_str(t: IntTy, val: Option<i64>) -> String {
let s = match t {
- TyI if val.is_some() => match mode {
- AutoSuffix => "",
- ForceSuffix => "i",
- },
+ TyI if val.is_some() => "i",
TyI => "int",
TyI8 => "i8",
TyI16 => "i16",
// Get a string representation of an unsigned int type, with its value.
// We want to avoid "42uint" in favor of "42u"
-pub fn uint_ty_to_str(t: UintTy, val: Option<u64>, mode: SuffixMode) -> String {
+pub fn uint_ty_to_str(t: UintTy, val: Option<u64>) -> String {
let s = match t {
- TyU if val.is_some() => match mode {
- AutoSuffix => "",
- ForceSuffix => "u",
- },
+ TyU if val.is_some() => "u",
TyU => "uint",
TyU8 => "u8",
TyU16 => "u16",
res.push_char('\'');
res
}
- LIT_INT(i, t) => ast_util::int_ty_to_str(t, Some(i),
- ast_util::ForceSuffix),
- LIT_UINT(u, t) => ast_util::uint_ty_to_str(t, Some(u),
- ast_util::ForceSuffix),
+ LIT_INT(i, t) => ast_util::int_ty_to_str(t, Some(i)),
+ LIT_UINT(u, t) => ast_util::uint_ty_to_str(t, Some(u)),
LIT_INT_UNSUFFIXED(i) => { (i as u64).to_str() }
LIT_FLOAT(s, t) => {
let mut body = String::from_str(get_ident(s).get());
let n: uint = 3 * linewidth;
debug!("mk_printer {}", linewidth);
let token: Vec<Token> = Vec::from_elem(n, Eof);
- let size: Vec<int> = Vec::from_elem(n, 0);
+ let size: Vec<int> = Vec::from_elem(n, 0i);
let scan_stack: Vec<uint> = Vec::from_elem(n, 0u);
Printer {
out: out,
}
ast::LitInt(i, t) => {
word(&mut self.s,
- ast_util::int_ty_to_str(t, Some(i),
- ast_util::AutoSuffix).as_slice())
+ ast_util::int_ty_to_str(t, Some(i)).as_slice())
}
ast::LitUint(u, t) => {
word(&mut self.s,
- ast_util::uint_ty_to_str(t, Some(u),
- ast_util::ForceSuffix).as_slice())
+ ast_util::uint_ty_to_str(t, Some(u)).as_slice())
}
ast::LitIntUnsuffixed(i) => {
word(&mut self.s, format!("{}", i).as_slice())
#[test]
fn test_push_get() {
let mut v = SmallVector::zero();
- v.push(1);
+ v.push(1i);
assert_eq!(1, v.len());
assert_eq!(&1, v.get(0));
v.push(2);
#[test]
fn test_from_iter() {
- let v: SmallVector<int> = (vec!(1, 2, 3)).move_iter().collect();
+ let v: SmallVector<int> = (vec!(1i, 2, 3)).move_iter().collect();
assert_eq!(3, v.len());
assert_eq!(&1, v.get(0));
assert_eq!(&2, v.get(1));
let v: Vec<int> = v.move_iter().collect();
assert_eq!(Vec::new(), v);
- let v = SmallVector::one(1);
- assert_eq!(vec!(1), v.move_iter().collect());
+ let v = SmallVector::one(1i);
+ assert_eq!(vec!(1i), v.move_iter().collect());
- let v = SmallVector::many(vec!(1, 2, 3));
- assert_eq!(vec!(1, 2, 3), v.move_iter().collect());
+ let v = SmallVector::many(vec!(1i, 2i, 3i));
+ assert_eq!(vec!(1i, 2i, 3i), v.move_iter().collect());
}
#[test]
#[test]
fn test_expect_one_one() {
- assert_eq!(1, SmallVector::one(1).expect_one(""));
- assert_eq!(1, SmallVector::many(vec!(1)).expect_one(""));
+ assert_eq!(1i, SmallVector::one(1i).expect_one(""));
+ assert_eq!(1i, SmallVector::many(vec!(1i)).expect_one(""));
}
}
'c' => if stack.len() > 0 {
match stack.pop().unwrap() {
// if c is 0, use 0200 (128) for ncurses compatibility
- Number(c) => output.push(if c == 0 { 128 } else { c } as u8),
+ Number(c) => {
+ output.push(if c == 0 {
+ 128u8
+ } else {
+ c as u8
+ })
+ }
_ => return Err("a non-char was used with %c".to_string())
}
} else { return Err("stack is empty".to_string()) },
let magic = try!(file.read_le_u16());
if magic != 0x011A {
return Err(format!("invalid magic number: expected {:x} but found {:x}",
- 0x011A, magic as uint));
+ 0x011Au, magic as uint));
}
let names_bytes = try!(file.read_le_i16()) as int;
}
pub fn write_metric_diff(&mut self, diff: &MetricDiff) -> io::IoResult<()> {
- let mut noise = 0;
- let mut improved = 0;
- let mut regressed = 0;
- let mut added = 0;
- let mut removed = 0;
+ let mut noise = 0u;
+ let mut improved = 0u;
+ let mut regressed = 0u;
+ let mut added = 0u;
+ let mut removed = 0u;
for (k, v) in diff.iter() {
match *v {
assert_eq!(out, expected);
}
- t(&Summary::new([-2.0, -1.0]),
+ t(&Summary::new([-2.0f64, -1.0f64]),
"-2 |[------******#*****---]| -1".to_string());
- t(&Summary::new([0.0, 2.0]),
+ t(&Summary::new([0.0f64, 2.0f64]),
"0 |[-------*****#*******---]| 2".to_string());
- t(&Summary::new([-2.0, 0.0]),
+ t(&Summary::new([-2.0f64, 0.0f64]),
"-2 |[------******#******---]| 0".to_string());
}
#[test]
fn test_sum_f64s() {
- assert_eq!([0.5, 3.2321, 1.5678].sum(), 5.2999);
+ assert_eq!([0.5f64, 3.2321f64, 1.5678f64].sum(), 5.2999);
}
#[test]
fn test_sum_f64_between_ints_that_sum_to_0() {
- assert_eq!([1e30, 1.2, -1e30].sum(), 1.2);
+ assert_eq!([1e30f64, 1.2f64, -1e30f64].sum(), 1.2);
}
}
#[bench]
pub fn sum_three_items(b: &mut Bencher) {
b.iter(|| {
- [1e20, 1.5, -1e20].sum();
+ [1e20f64, 1.5f64, -1e20f64].sum();
})
}
#[bench]
pub fn sum_many_f64(b: &mut Bencher) {
- let nums = [-1e30, 1e60, 1e30, 1.0, -1e60];
+ let nums = [-1e30f64, 1e60, 1e30, 1.0, -1e60];
let v = Vec::from_fn(500, |i| nums[i%5]);
b.iter(|| {
}
pub fn foo() {
- let a = &1 as &inner::Trait;
+ let a = &1i as &inner::Trait;
a.f();
}
use std::gc::{Gc, GC};
#[macro_export]
-macro_rules! exported_macro (() => (2))
+macro_rules! exported_macro (() => (2i))
-macro_rules! unexported_macro (() => (3))
+macro_rules! unexported_macro (() => (3i))
#[plugin_registrar]
pub fn plugin_registrar(reg: &mut Registry) {
}
fn shift_push() {
- let mut v1 = Vec::from_elem(30000, 1);
+ let mut v1 = Vec::from_elem(30000, 1i);
let mut v2 = Vec::new();
while v1.len() > 0 {
let mut path = Path::new(env!("CFG_SRC_DIR"));
path.push("src/test/bench/shootout-k-nucleotide.data");
- for _ in range(0, 3) {
+ for _ in range(0u, 3) {
let mut reader = BufferedReader::new(File::open(&path).unwrap());
for _line in reader.lines() {
}
let mut pixels = [0f32, ..256*256];
let n2d = Noise2DContext::new();
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
for y in range(0u, 256) {
for x in range(0u, 256) {
let v = n2d.get(x as f32 * 0.1, y as f32 * 0.1);
let mut messages = range_step(min_depth, max_depth + 1, 2).map(|depth| {
use std::num::pow;
- let iterations = pow(2, (max_depth - depth + min_depth) as uint);
+ let iterations = pow(2i, (max_depth - depth + min_depth) as uint);
Future::spawn(proc() {
let mut chk = 0;
for i in range(1, iterations + 1) {
to_rendezvous: Sender<CreatureInfo>,
to_rendezvous_log: Sender<String>
) {
- let mut creatures_met = 0;
+ let mut creatures_met = 0i32;
let mut evil_clones_met = 0;
let mut rendezvous = from_rendezvous.iter();
let mut perm = Vec::from_fn(n, |e| ((n + e - i) % n + 1) as i32);
let mut tperm = perm.clone();
let mut count = Vec::from_elem(n, 0u);
- let mut perm_count = 0;
+ let mut perm_count = 0i;
let mut checksum = 0;
for countdown in range(1, fact(n - 1) + 1).rev() {
if x < 0 || x > 4 {return None;}
let y = y + dy;
if y < 0 || y > 9 {return None;}
- m |= 1 << (y * 5 + x);
+ m |= 1 << (y * 5 + x) as uint;
}
Some(m)
}
// (i/5, i%5).
fn make_masks() -> Vec<Vec<Vec<u64> > > {
let pieces = vec!(
- vec!((0,0),(0,1),(0,2),(0,3),(1,3)),
- vec!((0,0),(0,2),(0,3),(1,0),(1,1)),
- vec!((0,0),(0,1),(0,2),(1,2),(2,1)),
- vec!((0,0),(0,1),(0,2),(1,1),(2,1)),
- vec!((0,0),(0,2),(1,0),(1,1),(2,1)),
- vec!((0,0),(0,1),(0,2),(1,1),(1,2)),
- vec!((0,0),(0,1),(1,1),(1,2),(2,1)),
- vec!((0,0),(0,1),(0,2),(1,0),(1,2)),
- vec!((0,0),(0,1),(0,2),(1,2),(1,3)),
- vec!((0,0),(0,1),(0,2),(0,3),(1,2)));
+ vec!((0i,0i),(0,1),(0,2),(0,3),(1,3)),
+ vec!((0i,0i),(0,2),(0,3),(1,0),(1,1)),
+ vec!((0i,0i),(0,1),(0,2),(1,2),(2,1)),
+ vec!((0i,0i),(0,1),(0,2),(1,1),(2,1)),
+ vec!((0i,0i),(0,2),(1,0),(1,1),(2,1)),
+ vec!((0i,0i),(0,1),(0,2),(1,1),(1,2)),
+ vec!((0i,0i),(0,1),(1,1),(1,2),(2,1)),
+ vec!((0i,0i),(0,1),(0,2),(1,0),(1,2)),
+ vec!((0i,0i),(0,1),(0,2),(1,2),(1,3)),
+ vec!((0i,0i),(0,1),(0,2),(0,3),(1,2)));
// To break the central symetry of the problem, every
// transformation must be taken except for one piece (piece 3
.map(|(id, p)| transform(p, id != 3))
.collect();
- range(0, 50).map(|yx| {
+ range(0i, 50).map(|yx| {
transforms.iter().enumerate().map(|(id, t)| {
t.iter().filter_map(|p| mask(yx / 5, yx % 5, id, p)).collect()
}).collect()
// Gets the identifier of a mask.
fn get_id(m: u64) -> u8 {
for id in range(0u8, 10) {
- if m & (1 << (id + 50)) != 0 {return id;}
+ if m & (1 << (id + 50) as uint) != 0 {return id;}
}
fail!("{:016x} does not have a valid identifier", m);
}
}
fn stress_task(id: int) {
- let mut i = 0;
+ let mut i = 0i;
loop {
- let n = 15;
+ let n = 15i;
assert_eq!(fib(n), fib(n));
i += 1;
println!("{}: Completed {} iterations", id, i);
let num_trials = 10;
for n in range(1, max + 1) {
- for _ in range(0, num_trials) {
+ for _ in range(0u, num_trials) {
let start = time::precise_time_ns();
let fibn = fib(n);
let stop = time::precise_time_ns();
} else {
FromStr::from_str(args[1].as_slice()).unwrap()
};
- let u = Arc::new(RWLock::new(Vec::from_elem(n, 1.)));
- let v = Arc::new(RWLock::new(Vec::from_elem(n, 1.)));
- let tmp = Arc::new(RWLock::new(Vec::from_elem(n, 1.)));
- for _ in range(0, 10) {
+ let u = Arc::new(RWLock::new(Vec::from_elem(n, 1f64)));
+ let v = Arc::new(RWLock::new(Vec::from_elem(n, 1f64)));
+ let tmp = Arc::new(RWLock::new(Vec::from_elem(n, 1f64)));
+ for _ in range(0u8, 10) {
mult_AtAv(u.clone(), v.clone(), tmp.clone());
mult_AtAv(v.clone(), u.clone(), tmp.clone());
}
}
fn main() {
- for _ in range(1, 100_000) {
+ for _ in range(1u32, 100_000) {
spawn(proc() {})
}
}
impl Colors {
fn new(start_color: u8) -> Colors {
// Sets bits 9..start_color
- let tails = !0u16 << start_color;
+ let tails = !0u16 << start_color as uint;
return Colors(HEADS & tails);
}
fn remove(&mut self, color: u8) {
if color != 0u8 {
let Colors(val) = *self;
- let mask = !(1u16 << color);
+ let mask = !(1u16 << color as uint);
*self = Colors(val & mask);
}
}
}
fn main() {
- let i = 8;
+ let i = 8i;
let f = coerce(|| println!("{:?}", i) );
f();
}
let mut v = box 3;
let mut x = &mut v;
- for _ in range(0, 3) {
+ for _ in range(0i, 3) {
borrow(v); //~ ERROR cannot borrow
}
*x = box 5;
None => {
// It is ok to reassign x here, because there is in
// fact no outstanding loan of x!
- x = Some(0);
+ x = Some(0i);
}
Some(ref _i) => {
- x = Some(1); //~ ERROR cannot assign
+ x = Some(1i); //~ ERROR cannot assign
}
}
x.clone(); // just to prevent liveness warnings
}
fn box_imm() {
- let v = box 3;
+ let v = box 3i;
let _w = &v;
task::spawn(proc() {
println!("v={}", *v);
}
fn box_imm_explicit() {
- let v = box 3;
+ let v = box 3i;
let _w = &v;
task::spawn(proc() {
println!("v={}", *v);
use std::gc::GC;
fn testfn(cond: bool) {
- let mut x = box(GC) 3;
- let mut y = box(GC) 4;
+ let mut x = box(GC) 3i;
+ let mut y = box(GC) 4i;
// borrow x and y
let r_x = &*x;
println!("*r = {}, exp = {}", *r, exp);
assert_eq!(*r, exp);
- x = box(GC) 5; //~ERROR cannot assign to `x` because it is borrowed
- y = box(GC) 6; //~ERROR cannot assign to `y` because it is borrowed
+ x = box(GC) 5i; //~ERROR cannot assign to `x` because it is borrowed
+ y = box(GC) 6i; //~ERROR cannot assign to `y` because it is borrowed
println!("*r = {}, exp = {}", *r, exp);
assert_eq!(*r, exp);
- assert_eq!(x, box(GC) 5);
- assert_eq!(y, box(GC) 6);
+ assert_eq!(x, box(GC) 5i);
+ assert_eq!(y, box(GC) 6i);
}
pub fn main() {
fn test(cond: bool) {
let v;
while cond {
- v = 3;
+ v = 3i;
break;
}
println!("{}", v); //~ ERROR use of possibly uninitialized variable: `v`
+++ /dev/null
-// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-fn main() {
- let foo = ['h' as u8, 'i' as u8, 0 as u8];
- let bar = &foo as *u8; //~ ERROR mismatched types
-}
// if n > m, it's a type mismatch error.
// n < m
- let &x = &(&1 as &T);
- let &x = &&(&1 as &T);
- let &&x = &&(&1 as &T);
+ let &x = &(&1i as &T);
+ let &x = &&(&1i as &T);
+ let &&x = &&(&1i as &T);
// n == m
- let &x = &1 as &T; //~ ERROR cannot be dereferenced
- let &&x = &(&1 as &T); //~ ERROR cannot be dereferenced
- let box x = box 1 as Box<T>; //~ ERROR cannot be dereferenced
+ let &x = &1i as &T; //~ ERROR cannot be dereferenced
+ let &&x = &(&1i as &T); //~ ERROR cannot be dereferenced
+ let box x = box 1i as Box<T>; //~ ERROR cannot be dereferenced
// n > m
- let &&x = &1 as &T; //~ ERROR found an `&`-pointer pattern
- let &&&x = &(&1 as &T); //~ ERROR found an `&`-pointer pattern
- let box box x = box 1 as Box<T>; //~ ERROR found a box pattern
+ let &&x = &1i as &T; //~ ERROR found an `&`-pointer pattern
+ let &&&x = &(&1i as &T); //~ ERROR found an `&`-pointer pattern
+ let box box x = box 1i as Box<T>; //~ ERROR found a box pattern
}
}
fn main() {
- let v = &5;
+ let v = &5i;
println!("{}", f(v)());
}
fn bar(int_param: int) {}
fn main() {
- let foo: [u8, ..4] = [1u8, ..4u8];
+ let foo: [u8, ..4] = [1u8, ..4u];
bar(foo);
//~^ ERROR mismatched types: expected `int` but found `[u8, .. 4]`
// (expected int but found vector)
// ~Repeat<&'blk int> where blk is the lifetime of the block below.
let y = {
- let tmp0 = 3;
+ let tmp0 = 3i;
let tmp1 = &tmp0; //~ ERROR `tmp0` does not live long enough
repeater(tmp1)
};
}
pub fn foo() {
- let a = &1 as &inner::Trait;
+ let a = &1i as &inner::Trait;
a.f();
}
// Tests that a function with a ! annotation always actually fails
// error-pattern: some control paths may return
-fn bad_bang(i: uint) -> ! { println!("{}", 3); }
+fn bad_bang(i: uint) -> ! { println!("{}", 3i); }
fn main() { bad_bang(5u); }
extern crate debug;
fn main() {
- let x = box 5;
+ let x = box 5i;
let y = x;
println!("{:?}", *x); //~ ERROR use of partially moved value: `*x`
y.clone();
//~^ NOTE maybe a missing `()` to call it? If not, try an anonymous
// Ensure the span is useful
- let ys = &[1,2,3,4,5,6,7];
+ let ys = &[1i,2,3,4,5,6,7];
let a = ys.iter()
.map(|x| x)
.filter(|&&x| x == 1)
use std::task;
fn main() {
- let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ let v = vec!(1i, 2, 3, 4, 5, 6, 7, 8, 9, 10);
let arc_v = Arc::new(v);
task::spawn(proc() {
use std::task;
fn main() {
- let v = vec!(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
+ let v = vec!(1i, 2, 3, 4, 5, 6, 7, 8, 9, 10);
let arc_v = Arc::new(v);
task::spawn(proc() {
// Check that non constant exprs fail for vector repeat syntax
fn main() {
- fn bar(n: int) {
+ fn bar(n: uint) {
let _x = [0, ..n]; //~ ERROR expected constant integer for repeat count but found variable
}
}
use std::gc::GC;
fn testfn(cond: bool) {
- let mut x = box(GC) 3;
- let mut y = box(GC) 4;
+ let mut x = box(GC) 3i;
+ let mut y = box(GC) 4i;
let mut a = &*x;
- let mut exp = 3;
+ let mut exp = 3i;
if cond {
a = &*y;
exp = 4;
}
- x = box(GC) 5; //~ERROR cannot assign to `x` because it is borrowed
- y = box(GC) 6; //~ERROR cannot assign to `y` because it is borrowed
+ x = box(GC) 5i; //~ERROR cannot assign to `x` because it is borrowed
+ y = box(GC) 6i; //~ERROR cannot assign to `y` because it is borrowed
assert_eq!(*a, exp);
- assert_eq!(x, box(GC) 5);
- assert_eq!(y, box(GC) 6);
+ assert_eq!(x, box(GC) 5i);
+ assert_eq!(y, box(GC) 6i);
}
pub fn main() {}
fn wants_static_fn(_x: ||: 'static) {}
fn main() {
- let i = 3;
+ let i = 3i;
wants_static_fn(|| { //~ ERROR cannot infer
println!("i={}", i);
})
let mut x;
if cond {
- x = &3; //~ ERROR borrowed value does not live long enough
- assert_eq!(*x, 3);
+ x = &3i; //~ ERROR borrowed value does not live long enough
+ assert_eq!(*x, 3i);
}
}
fn main() {
10i.dup::<int>(); //~ ERROR does not take type parameters
10i.blah::<int, int>(); //~ ERROR incorrect number of type parameters
- (box 10 as Box<bar>).dup(); //~ ERROR contains a self-type
+ (box 10i as Box<bar>).dup(); //~ ERROR contains a self-type
}
fn main() {
let x: Box<Tr+ Share>;
- box() 1 as Box<Tr+ Share>;
+ box() 1i as Box<Tr+ Share>;
}
// error-pattern:assertion failed: `(left == right) && (right == left)` (left: `14`, right: `15`)
fn main() {
- assert_eq!(14,15);
+ assert_eq!(14i,15i);
}
// error-pattern:failed at 'test-assert-fmt 42 rust'
fn main() {
- assert!(false, "test-assert-fmt {} {}", 42, "rust");
+ assert!(false, "test-assert-fmt {} {}", 42i, "rust");
}
fn main() {
- fail!(box 413 as Box<::std::any::Any+Send>);
+ fail!(box 413i as Box<::std::any::Any+Send>);
}
// error-pattern:failed at 'test-fail-fmt 42 rust'
fn main() {
- fail!("test-fail-fmt {} {}", 42, "rust");
+ fail!("test-fail-fmt {} {}", 42i, "rust");
}
}
fn main() {
- let y = box 0;
+ let y = box 0i;
let x: Gc<proc():Send> = box(GC) (proc() {
println!("{:?}", y.clone());
});
}
fn main() {
- let x = box(GC) box box 0;
+ let x = box(GC) box box 0i;
failfn();
println!("{:?}", x);
}
}
fn main() {
- let x = box(GC) box 0;
+ let x = box(GC) box 0i;
failfn();
println!("{:?}", x);
}
}
fn main() {
- let x = box(GC) vec!(0, 1, 2, 3, 4, 5);
+ let x = box(GC) vec!(0i, 1, 2, 3, 4, 5);
failfn();
println!("{:?}", x);
}
let mut rng = task_rng();
// a subset of the XID_start unicode table (ensuring that the
// compiler doesn't fail with an "unrecognised token" error)
- let (lo, hi): (u32, u32) = match rng.gen_range(1, 4 + 1) {
+ let (lo, hi): (u32, u32) = match rng.gen_range(1u32, 4u32 + 1) {
1 => (0x41, 0x5a),
2 => (0xf8, 0x1ba),
3 => (0x1401, 0x166c),
.write_str("mod unicode_input_multiple_files_chars;");
}
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
{
let randoms = tmpdir.join("unicode_input_multiple_files_chars.rs");
let mut w = File::create(&randoms).unwrap();
- for _ in range(0, 30) {
+ for _ in range(0u, 30) {
let _ = w.write_char(random_char());
}
}
let mut rng = task_rng();
// a subset of the XID_start unicode table (ensuring that the
// compiler doesn't fail with an "unrecognised token" error)
- let (lo, hi): (u32, u32) = match rng.gen_range(1, 4 + 1) {
+ let (lo, hi): (u32, u32) = match rng.gen_range(1u32, 4u32 + 1) {
1 => (0x41, 0x5a),
2 => (0xf8, 0x1ba),
3 => (0x1401, 0x166c),
let tmpdir = Path::new(args.get(2).as_slice());
let main_file = tmpdir.join("span_main.rs");
- for _ in range(0, 100) {
+ for _ in range(0u, 100) {
let n = task_rng().gen_range(3u, 20);
{
pub fn main() {
let a = hexfloat!("0x1.999999999999ap-4");
- assert_eq!(a, 0.1);
+ assert_eq!(a, 0.1f64);
let b = hexfloat!("-0x1.fffp-4", f32);
assert_eq!(b, -0.12498474_f32);
let c = hexfloat!("0x.12345p5", f64);
assert_eq!(i32_a * i32_a * i32_a, 1000);
assert_eq!(i32_a * i32_a * i32_a * i32_a, 10000);
assert_eq!(i32_a * i32_a / i32_a * i32_a, 100);
- assert_eq!(i32_a * (i32_a - 1) << 2 + i32_a, 368640);
+ assert_eq!(i32_a * (i32_a - 1) << (2 + i32_a as uint), 368640);
let i32_b: int = 0x10101010;
assert_eq!(i32_b + 1 - 1, i32_b);
assert_eq!(i32_b << 1, i32_b << 1);
struct Point { x : int }
pub fn main() {
- assert_eq!(14,14);
+ assert_eq!(14i,14i);
assert_eq!("abc".to_string(),"abc".to_string());
assert_eq!(box Point{x:34},box Point{x:34});
assert_eq!(&Point{x:34},&Point{x:34});
pub fn main() {
println!("{:?}", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
- println!("{:?}", f(5, 6).a);
+ println!("{:?}", f(5i, 6i).a);
}
// except according to those terms.
pub fn main() {
- let mut sum = 0;
+ let mut sum = 0i;
let xs = vec!(1, 2, 3, 4, 5);
for x in xs.iter() {
sum += *x;
}
pub fn main() {
- let mut v = vec!(1);
+ let mut v = vec!(1i);
v.push_val(2);
v.push_val(3);
assert_eq!(v, vec!(1, 2, 3));
assert!(!out.status.success());
let s = str::from_utf8(out.error.as_slice()).unwrap();
let mut i = 0;
- for _ in range(0, 2) {
+ for _ in range(0i, 2) {
i += s.slice_from(i + 10).find_str("stack backtrace").unwrap() + 10;
}
assert!(s.slice_from(i + 10).find_str("stack backtrace").is_none(),
assert_eq!(-2147483648i32 - 1i32, 2147483647i32);
assert_eq!(-9223372036854775808i64 - 1i64, 9223372036854775807i64);
- assert_eq!(-9223372036854775808 - 1, 9223372036854775807);
+ assert_eq!(-9223372036854775808i - 1, 9223372036854775807);
}
// Check that issue #954 stays fixed
pub fn main() {
- match -1 { -1 => {}, _ => fail!("wat") }
- assert_eq!(1-1, 0);
+ match -1i { -1 => {}, _ => fail!("wat") }
+ assert_eq!(1i-1, 0i);
}
}
fn test_box() {
- assert_eq!(box(GC) 10, box(GC) 10);
+ assert_eq!(box(GC) 10i, box(GC) 10i);
}
fn test_ptr() {
unsafe {
- let p1: *u8 = ::std::mem::transmute(0);
- let p2: *u8 = ::std::mem::transmute(0);
- let p3: *u8 = ::std::mem::transmute(1);
+ let p1: *u8 = ::std::mem::transmute(0u);
+ let p2: *u8 = ::std::mem::transmute(0u);
+ let p3: *u8 = ::std::mem::transmute(1u);
assert_eq!(p1, p2);
assert!(p1 != p3);
}
pub fn main() {
- for _ in range(0, 10000) { bitv_test(); }
+ for _ in range(0i, 10000) { bitv_test(); }
}
println!("{}", b);
assert_eq!(b, 1);
assert_eq!(a, 2);
- assert_eq!(!0xf0 & 0xff, 0xf);
- assert_eq!(0xf0 | 0xf, 0xff);
- assert_eq!(0xf << 4, 0xf0);
- assert_eq!(0xf0 >> 4, 0xf);
- assert_eq!(-16 >> 2, -4);
- assert_eq!(0b1010_1010 | 0b0101_0101, 0xff);
+ assert_eq!(!0xf0i & 0xff, 0xf);
+ assert_eq!(0xf0i | 0xf, 0xff);
+ assert_eq!(0xfi << 4, 0xf0);
+ assert_eq!(0xf0i >> 4, 0xf);
+ assert_eq!(-16i >> 2, -4);
+ assert_eq!(0b1010_1010i | 0b0101_0101, 0xff);
}
pub fn main() {
let num = 12;
- assert_eq!(if (true) { 12 } else { 12 } - num, 0);
- assert_eq!(12 - if (true) { 12 } else { 12 }, 0);
- if (true) { 12; } {-num};
- if (true) { 12; }; {-num};
- if (true) { 12; };;; -num;
+ assert_eq!(if (true) { 12i } else { 12 } - num, 0);
+ assert_eq!(12i - if (true) { 12i } else { 12 }, 0);
+ if (true) { 12i; } {-num};
+ if (true) { 12i; }; {-num};
+ if (true) { 12i; };;; -num;
}
fn iter_vec<T>(v: Vec<T> , f: |&T|) { for x in v.iter() { f(x); } }
pub fn main() {
- let v = vec!(1, 2, 3, 4, 5, 6, 7);
- let mut odds = 0;
+ let v = vec!(1i, 2, 3, 4, 5, 6, 7);
+ let mut odds = 0i;
iter_vec(v, |i| {
if *i % 2 == 1 {
odds += 1;
fn iter_vec<T>(v: Vec<T> , f: |&T|) { for x in v.iter() { f(x); } }
pub fn main() {
- let v = vec!(1, 2, 3, 4, 5);
+ let v = vec!(1i, 2, 3, 4, 5);
let mut sum = 0;
iter_vec(v.clone(), |i| {
iter_vec(v.clone(), |j| {
// except according to those terms.
pub fn main() {
- let x = [22];
+ let x = [22i];
let y = &x[0];
assert_eq!(*y, 22);
}
}
pub fn main() {
- let mut data = [1, 2, 3];
+ let mut data = [1i, 2, 3];
{
let slice = MutSlice { data: data };
slice.data[0] += 4;
None => {
// It is ok to reassign x here, because there is in
// fact no outstanding loan of x!
- x = Some(0);
+ x = Some(0i);
}
Some(_) => { }
}
#![feature(managed_boxes)]
pub fn main() {
- let (&x, &y) = (&3, &'a');
+ let (&x, &y) = (&3i, &'a');
assert_eq!(x, 3);
assert_eq!(y, 'a');
}
}
pub fn main() {
- assert_eq!(foo(&3), 3);
+ assert_eq!(foo(&3i), 3i);
assert_eq!(foo(&'a'), 'a');
}
use std::gc::GC;
pub fn main() {
- assert!((box(GC) 1 < box(GC) 3));
+ assert!((box(GC) 1i < box(GC) 3i));
assert!((box(GC) box(GC) "hello ".to_string() >
box(GC) box(GC) "hello".to_string()));
assert!((box(GC) box(GC) box(GC) "hello".to_string() !=
// except according to those terms.
fn main() {
- let box x = box 3;
- match box 3 {
+ let box x = box 3i;
+ match box 3i {
box y => {
assert!(x == y);
println!("{} {}", x, y);
// except according to those terms.
pub fn main() {
- let mut i = 0;
+ let mut i = 0i;
while i < 20 { i += 1; if i == 10 { break; } }
assert_eq!(i, 10);
loop { i += 1; if i == 20 { break; } }
assert_eq!(i, 20);
- let xs = [1, 2, 3, 4, 5, 6];
+ let xs = [1i, 2, 3, 4, 5, 6];
for x in xs.iter() {
if *x == 3 { break; } assert!((*x <= 3));
}
i += 1; if i % 2 == 0 { continue; } assert!((i % 2 != 0));
if i >= 10 { break; }
}
- let ys = vec!(1, 2, 3, 4, 5, 6);
+ let ys = vec!(1i, 2, 3, 4, 5, 6);
for x in ys.iter() {
if *x % 2 == 0 { continue; }
assert!((*x % 2 != 0));
pub fn main() {
- assert_eq!(3.hi(), "hello: 3".to_string());
- assert_eq!(Some(Some(3)).hi(),
+ assert_eq!(3i.hi(), "hello: 3".to_string());
+ assert_eq!(Some(Some(3i)).hi(),
"something!something!hello: 3".to_string());
assert_eq!(None::<int>.hi(), "hello - none".to_string());
assert_eq!(Some(None::<int>).hi(), "something!hello - none".to_string());
- assert_eq!(Some(3).hi(), "something!hello: 3".to_string());
+ assert_eq!(Some(3i).hi(), "something!hello: 3".to_string());
}
pub fn main() {
let (tx, rx) = channel();
- foo(31337, tx);
- assert!(rx.recv() == 31337);
+ foo(31337i, tx);
+ assert!(rx.recv() == 31337i);
}
}
pub fn main() {
- let (tx, rx) = channel();
- foo(X(31337), tx);
- assert!(rx.recv() == X(31337));
+ let (tx, rx): (Sender<X<int>>, Receiver<X<int>>) = channel();
+ foo(X(31337i), tx);
+ assert!(rx.recv() == X(31337i));
}
}
pub fn main() {
- let (tx, rx) = channel();
- foo(31337, tx);
- assert!(rx.recv() == 31337);
+ let (tx, rx): (Sender<int>, Receiver<int>) = channel();
+ foo(31337i, tx);
+ assert!(rx.recv() == 31337i);
}
assert_eq!(b'\xF0', 240u8);
assert_eq!(FOO, 240u8);
- assert_eq!([42, ..b'\t'].as_slice(), &[42, 42, 42, 42, 42, 42, 42, 42, 42]);
-
match 42 {
b'*' => {},
_ => fail!()
pub fn main() {
//let bt0 = sys::rusti::frame_address(1u32);
//println!("%?", bt0);
- cci_iter_lib::iter([1, 2, 3], |i| {
+ cci_iter_lib::iter([1i, 2, 3], |i| {
println!("{}", *i);
//assert!(bt0 == sys::rusti::frame_address(2u32));
})
pub fn main() {
let f = {|i| i};
- assert_eq!(f(2), 2);
- assert_eq!(f(5), 5);
+ assert_eq!(f(2i), 2i);
+ assert_eq!(f(5i), 5i);
}
}
pub fn main() {
- let x: int = 2 + 2;
+ let x: int = 2i + 2;
println!("{}", x);
println!("hello, world");
- println!("{}", 10);
+ println!("{}", 10i);
}
pub fn main() {
- static FOO: int = 2;
- let _v = [0, ..FOO*3*2/2];
+ static FOO: uint = 2;
+ let _v = [0i, ..FOO*3*2/2];
}
static BAR: int = 3;
pub fn main() {
- let x: int = 3;
+ let x: int = 3i;
let y = match x {
- FOO => 1,
- BAR => 2,
- _ => 3
+ FOO => 1i,
+ BAR => 2i,
+ _ => 3i
};
assert_eq!(y, 2);
}
use std::gc::GC;
pub fn main() {
- let x = box(GC) Cell::new(5);
- x.set(1000);
+ let x = box(GC) Cell::new(5i);
+ x.set(1000i);
println!("{:?}", x.get());
}
use std::rc::Rc;
fn main() {
- let x = Rc::new([1, 2, 3, 4]);
+ let x = Rc::new([1i, 2, 3, 4]);
assert!(*x == [1, 2, 3, 4]);
}
pub fn main() {
let e0 = E0;
- let e11 = E1(1);
- let e12 = E1(2);
- let e21 = E2(1, 1);
- let e22 = E2(1, 2);
+ let e11 = E1(1i);
+ let e12 = E1(2i);
+ let e21 = E2(1i, 1i);
+ let e22 = E2(1i, 2i);
// in order for both PartialOrd and Ord
let es = [e0, e11, e12, e21, e22];
pub fn main() {
- let (es11, es12, es21, es22) = (ES1 {x: 1}, ES1 {x: 2}, ES2 {x: 1, y: 1}, ES2 {x: 1, y: 2});
+ let (es11, es12, es21, es22) = (ES1 {
+ x: 1i
+ }, ES1 {
+ x: 2i
+ }, ES2 {
+ x: 1i,
+ y: 1i
+ }, ES2 {
+ x: 1i,
+ y: 2i
+ });
// in order for both PartialOrd and Ord
let ess = [es11, es12, es21, es22];
}
pub fn main() {
- let s1 = S {x: 1, y: 1};
- let s2 = S {x: 1, y: 2};
+ let s1 = S {x: 1i, y: 1i};
+ let s2 = S {x: 1i, y: 2i};
// in order for both PartialOrd and Ord
let ss = [s1, s2];
pub fn main() {
- let ts1 = TS(1, 1);
- let ts2 = TS(1, 2);
+ let ts1 = TS(1i, 1i);
+ let ts2 = TS(1i, 2i);
// in order for both PartialOrd and Ord
let tss = [ts1, ts2];
pub fn main() {
// check there's no segfaults
- for _ in range(0, 20) {
+ for _ in range(0i, 20) {
rand::random::<A>();
rand::random::<B>();
rand::random::<C>();
}
pub fn main() {
- let a = Foo { x: 1, y: 2.0, z: 3 };
- let b = Foo { x: 1, y: 2.0, z: 3 };
+ let a = Foo { x: 1, y: 2.0f64, z: 3 };
+ let b = Foo { x: 1, y: 2.0f64, z: 3 };
assert_eq!(a, b);
assert!(!(a != b));
assert!(a.eq(&b));
struct A { a: int }
pub fn main() {
- let _x: Option<f64> = foo_func(0);
+ let _x: Option<f64> = foo_func(0i);
}
pub fn main() {
// Basic usage
- t!(to_str(1.2345678e-5, 10u, true, s::SignNeg, s::DigMax(6), s::ExpDec, false),
+ t!(to_str(1.2345678e-5f64, 10u, true, s::SignNeg, s::DigMax(6), s::ExpDec, false),
"1.234568e-5")
// Hexadecimal output
- t!(to_str(7.281738281250e+01, 16u, true, s::SignAll, s::DigMax(6), s::ExpBin, false),
+ t!(to_str(7.281738281250e+01f64, 16u, true, s::SignAll, s::DigMax(6), s::ExpBin, false),
"+1.2345p+6")
- t!(to_str(-1.777768135071e-02, 16u, true, s::SignAll, s::DigMax(6), s::ExpBin, false),
+ t!(to_str(-1.777768135071e-02f64, 16u, true, s::SignAll, s::DigMax(6), s::ExpBin, false),
"-1.2345p-6")
// Some denormals
- t!(to_str(4.9406564584124654e-324, 10u, true, s::SignNeg, s::DigMax(6), s::ExpBin, false),
+ t!(to_str(4.9406564584124654e-324f64, 10u, true, s::SignNeg, s::DigMax(6), s::ExpBin, false),
"1p-1074")
- t!(to_str(2.2250738585072009e-308, 10u, true, s::SignNeg, s::DigMax(6), s::ExpBin, false),
+ t!(to_str(2.2250738585072009e-308f64, 10u, true, s::SignNeg, s::DigMax(6), s::ExpBin, false),
"1p-1022")
}
fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); }
fn test_filled_with_stuff() {
- let rs = { let mut a = 0; while a < 10 { a += 1; } a };
+ let rs = { let mut a = 0i; while a < 10 { a += 1; } a };
assert_eq!(rs, 10);
}
fn test_generic() {
fn f<T>(t: T) -> T { t }
- assert_eq!(f(10), 10);
+ assert_eq!(f(10i), 10);
}
fn test_alt() {
// Tests for if as expressions returning boxed types
fn test_box() {
- let rs = if true { box(GC) 100 } else { box(GC) 101 };
+ let rs = if true { box(GC) 100i } else { box(GC) 101i };
assert_eq!(*rs, 100);
}
fn test_if_fail() { let x = if false { fail!() } else { 10 }; assert!((x == 10)); }
fn test_else_fail() {
- let x = if true { 10 } else { fail!() };
- assert_eq!(x, 10);
+ let x = if true { 10i } else { fail!() };
+ assert_eq!(x, 10i);
}
fn test_elseif_fail() {
- let x = if false { 0 } else if false { fail!() } else { 10 };
- assert_eq!(x, 10);
+ let x = if false { 0 } else if false { fail!() } else { 10i };
+ assert_eq!(x, 10i);
}
pub fn main() { test_if_fail(); test_else_fail(); test_elseif_fail(); }
// Tests for if as expressions returning boxed types
fn test_box() {
- let rs = if true { box 100 } else { box 101 };
- assert_eq!(*rs, 100);
+ let rs = if true { box 100i } else { box 101i };
+ assert_eq!(*rs, 100i);
}
pub fn main() { test_box(); }
// Tests for match as expressions resulting in boxed types
fn test_box() {
- let res = match true { true => { box(GC) 100 } _ => fail!("wat") };
- assert_eq!(*res, 100);
+ let res = match true { true => { box(GC) 100i } _ => fail!("wat") };
+ assert_eq!(*res, 100i);
}
fn test_str() {
}
fn test_box() {
- let r = match true { true => { vec!(10) } false => { fail!() } };
- assert_eq!(*r.get(0), 10);
+ let r = match true { true => { vec!(10i) } false => { fail!() } };
+ assert_eq!(*r.get(0), 10i);
}
pub fn main() { test_simple(); test_box(); }
// Tests for match as expressions resulting in boxed types
fn test_box() {
- let res = match true { true => { box 100 }, _ => fail!() };
- assert_eq!(*res, 100);
+ let res = match true { true => { box 100i }, _ => fail!() };
+ assert_eq!(*res, 100i);
}
pub fn main() { test_box(); }
pub fn main() {
println!("{}", match red {
- red => { 1 }
- green => { 2 }
- blue => { 3 }
+ red => { 1i }
+ green => { 2i }
+ blue => { 3i }
});
}
// except according to those terms.
pub fn main() {
- let arr = [1,2,3];
+ let arr = [1i,2i,3i];
let arr2 = arr;
- assert_eq!(arr[1], 2);
- assert_eq!(arr2[2], 3);
+ assert_eq!(arr[1], 2i);
+ assert_eq!(arr2[2], 3i);
}
extern crate debug;
pub fn main() {
- let pi = 3.1415927;
+ let pi = 3.1415927f64;
println!("{:?}", -pi * (pi + 2.0 / pi) - pi * 5.0);
if pi == 5.0 || pi < 10.0 || pi <= 2.0 || pi != 22.0 / 7.0 || pi >= 10.0
|| pi > 1.0 {
pub fn main() {
- let a = 1.5e6;
- let b = 1.5E6;
- let c = 1e6;
- let d = 1E6;
+ let a = 1.5e6f64;
+ let b = 1.5E6f64;
+ let c = 1e6f64;
+ let d = 1E6f64;
let e = 3.0f32;
let f = 5.9f64;
let g = 1e6f32;
let h = 1.0e7f64;
let i = 1.0E7f64;
- let j = 3.1e+9;
- let k = 3.2e-10;
+ let j = 3.1e+9f64;
+ let k = 3.2e-10f64;
assert_eq!(a, b);
assert!((c < b));
assert_eq!(c, d);
pub fn main() {
let mut h = HashMap::new();
- let kvs = [(1, 10), (2, 20), (3, 30)];
+ let kvs = [(1i, 10i), (2i, 20i), (3i, 30i)];
for &(k,v) in kvs.iter() {
h.insert(k,v);
}
pub fn main() {
let mut h = HashMap::new();
- let kvs = [(1, 10), (2, 20), (3, 30)];
+ let kvs = [(1i, 10i), (2i, 20i), (3i, 30i)];
for &(k,v) in kvs.iter() {
h.insert(k,v);
}
- let mut x = 0;
- let mut y = 0;
+ let mut x = 0i;
+ let mut y = 0i;
for (&k,&v) in h.iter() {
x += k;
y += v;
// except according to those terms.
pub fn main() {
- let x = [1,..100];
- let mut y = 0;
+ let x = [1i,..100];
+ let mut y = 0i;
for (n,i) in x.iter().enumerate() {
if n < 10 {
continue;
fn id<T:Send>(t: T) -> T { return t; }
pub fn main() {
- let expected = box 100;
+ let expected = box 100i;
let actual = id::<Box<int>>(expected.clone());
println!("{:?}", *actual);
assert_eq!(*expected, *actual);
fn f<T>(x: Gc<T>) -> Gc<T> { return x; }
-pub fn main() { let x = f(box(GC) 3); println!("{:?}", *x); }
+pub fn main() { let x = f(box(GC) 3i); println!("{:?}", *x); }
fn f<T>(x: Box<T>) -> Box<T> { return x; }
-pub fn main() { let x = f(box 3); println!("{:?}", *x); }
+pub fn main() { let x = f(box 3i); println!("{:?}", *x); }
}
pub fn main() {
- assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), vec!(2,3,4));
+ assert_eq!(vec_utils::map_(&vec!(1i,2i,3i), |&x| x+1), vec!(2i,3i,4i));
}
fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
pub fn main() {
- println!("{:?}", get_third((1, 2, 3)));
- assert_eq!(get_third((1, 2, 3)), 3);
+ println!("{:?}", get_third((1i, 2i, 3i)));
+ assert_eq!(get_third((1i, 2i, 3i)), 3);
assert_eq!(get_third((5u8, 6u8, 7u8)), 7u8);
}
struct Pair { x: int, y: int }
pub fn main() {
- let a =
+ let a: int =
match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
assert_eq!(a, 2);
- let b =
+ let b: int =
match (Pair {x: 10, y: 20}) {
x if x.x < 5 && x.y < 5 => { 1 }
Pair {x: x, y: y} if x == 10 && y == 20 => { 2 }
macro_rules! run_once {
($e: expr) => {
// ditto
- 'x: for _ in range(0, 1) { $e }
+ 'x: for _ in range(0i, 1) { $e }
}
}
pub fn main() {
let mut i = 0i;
- let j = {
+ let j: int = {
'x: loop {
// this 'x should refer to the outer loop, lexically
loop_x!(break 'x);
};
assert_eq!(j, 1i);
- let k = {
- 'x: for _ in range(0, 1) {
+ let k: int = {
+ 'x: for _ in range(0i, 1) {
// ditto
loop_x!(break 'x);
i += 1;
};
assert_eq!(k, 1i);
- let n = {
- 'x: for _ in range(0, 1) {
+ let n: int = {
+ 'x: for _ in range(0i, 1) {
// ditto
run_once!(continue 'x);
i += 1;
macro_rules! run_once {
($e: expr) => {
// ditto
- 'x: for _ in range(0, 1) { $e }
+ 'x: for _ in range(0i, 1) { $e }
}
}
pub fn main() {
- 'x: for _ in range(0, 1) {
+ 'x: for _ in range(0i, 1) {
// this 'x should refer to the outer loop, lexically
loop_x!(break 'x);
fail!("break doesn't act hygienically inside for loop");
fail!("break doesn't act hygienically inside infinite loop");
}
- 'x: for _ in range(0, 1) {
+ 'x: for _ in range(0i, 1) {
// ditto
run_once!(continue 'x);
fail!("continue doesn't act hygienically inside for loop");
pub fn main() {
// Make sure there's a poly formatter that takes anything
- t!(format!("{:?}", 1), "1");
+ t!(format!("{:?}", 1i), "1");
t!(format!("{:?}", A), "A");
t!(format!("{:?}", ()), "()");
- t!(format!("{:?}", box(GC) (box 1, "foo")), "box(GC) (box 1, \"foo\")");
+ t!(format!("{:?}", box(GC) (box 1i, "foo")), "box(GC) (box 1, \"foo\")");
// Various edge cases without formats
t!(format!(""), "");
// At least exercise all the formats
t!(format!("{:b}", true), "true");
t!(format!("{:c}", '☃'), "☃");
- t!(format!("{:d}", 10), "10");
- t!(format!("{:i}", 10), "10");
+ t!(format!("{:d}", 10i), "10");
+ t!(format!("{:i}", 10i), "10");
t!(format!("{:u}", 10u), "10");
t!(format!("{:o}", 10u), "12");
t!(format!("{:x}", 10u), "a");
t!(format!("{:d}", A), "aloha");
t!(format!("{:d}", B), "adios");
t!(format!("foo {:s} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
- t!(format!("{1} {0}", 0, 1), "1 0");
- t!(format!("{foo} {bar}", foo=0, bar=1), "0 1");
- t!(format!("{foo} {1} {bar} {0}", 0, 1, foo=2, bar=3), "2 1 3 0");
+ t!(format!("{1} {0}", 0i, 1i), "1 0");
+ t!(format!("{foo} {bar}", foo=0i, bar=1i), "0 1");
+ t!(format!("{foo} {1} {bar} {0}", 0i, 1i, foo=2i, bar=3i), "2 1 3 0");
t!(format!("{} {0}", "a"), "a a");
- t!(format!("{foo_bar}", foo_bar=1), "1");
- t!(format!("{:d}", 5 + 5), "10");
+ t!(format!("{foo_bar}", foo_bar=1i), "1");
+ t!(format!("{:d}", 5i + 5i), "10");
// Formatting strings and their arguments
t!(format!("{:s}", "a"), "a");
test_order();
// make sure that format! doesn't move out of local variables
- let a = box 3;
+ let a = box 3i;
format!("{:?}", a);
format!("{:?}", a);
// io::Writer instance.
fn test_write() {
let mut buf = MemWriter::new();
- write!(&mut buf as &mut io::Writer, "{}", 3);
+ write!(&mut buf as &mut io::Writer, "{}", 3i);
{
let w = &mut buf as &mut io::Writer;
- write!(w, "{foo}", foo=4);
+ write!(w, "{foo}", foo=4i);
write!(w, "{:s}", "hello");
writeln!(w, "{}", "line");
writeln!(w, "{foo}", foo="bar");
let mut buf = MemWriter::new();
{
let w = &mut buf as &mut io::Writer;
- format_args!(|args| { write!(w, "{}", args); }, "{}", 1);
+ format_args!(|args| { write!(w, "{}", args); }, "{}", 1i);
format_args!(|args| { write!(w, "{}", args); }, "test");
- format_args!(|args| { write!(w, "{}", args); }, "{test}", test=3);
+ format_args!(|args| { write!(w, "{}", args); }, "{test}", test=3i);
}
let s = str::from_utf8(buf.unwrap().as_slice()).unwrap().to_string();
t!(s, "1test3");
pub fn main() {
assert_eq!(size_of::<u8>(), 1);
- let (mut x, mut y) = (1, 2);
+ let (mut x, mut y) = (1i, 2i);
swap(&mut x, &mut y);
assert_eq!(x, 2);
assert_eq!(y, 1);
// except according to those terms.
pub fn main() {
- let a = 0xBEEF;
- let b = 0o755;
- let c = 0b10101;
- let d = -0xBEEF;
- let e = -0o755;
- let f = -0b10101;
+ let a = 0xBEEFi;
+ let b = 0o755i;
+ let c = 0b10101i;
+ let d = -0xBEEFi;
+ let e = -0o755i;
+ let f = -0b10101i;
assert_eq!(a, 48879);
assert_eq!(b, 493);
pub fn main() {
unsafe {
- let mut x = box 1;
+ let mut x = box 1i;
assert_eq!(rusti::atomic_load(&*x), 1);
*x = 5;
pub fn main() {
unsafe {
- let x = box 1;
+ let x = box 1i;
let mut y = rusti::init();
let mut z: *uint = transmute(&x);
rusti::move_val_init(&mut y, x);
let args = os::args();
let args = args.as_slice();
if args.len() > 1 && args[1].as_slice() == "child" {
- for _ in range(0, 1000) {
+ for _ in range(0i, 1000i) {
println!("hello?");
}
- for _ in range(0, 1000) {
+ for _ in range(0i, 1000i) {
println!("hello?");
}
return;
extern crate foo = "issue-11225-1";
pub fn main() {
- foo::foo(1);
+ foo::foo(1i);
}
extern crate foo = "issue-11225-2";
pub fn main() {
- foo::foo(1);
+ foo::foo(1i);
}
// except according to those terms.
pub fn main() {
- let x = 1;
- let y = 2;
+ let x = 1i;
+ let y = 2i;
- assert_eq!(3, match (x, y) {
+ assert_eq!(3i, match (x, y) {
(1, 1) => 1,
(2, 2) => 2,
(1..2, 2) => 3,
});
// nested tuple
- assert_eq!(3, match ((x, y),) {
+ assert_eq!(3i, match ((x, y),) {
((1, 1),) => 1,
((2, 2),) => 2,
((1..2, 2),) => 3,
}
fn lit_shadow_range() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
1 if false => 1,
1..2 => 2,
_ => 3
});
- let x = 0;
- assert_eq!(2, match x+1 {
+ let x = 0i;
+ assert_eq!(2i, match x+1 {
0 => 0,
1 if false => 1,
1..2 => 2,
_ => 3
});
- assert_eq!(2, match val() {
+ assert_eq!(2i, match val() {
1 if false => 1,
1..2 => 2,
_ => 3
});
- assert_eq!(2, match CONST {
+ assert_eq!(2i, match CONST {
0 => 0,
1 if false => 1,
1..2 => 2,
});
// value is out of the range of second arm, should match wildcard pattern
- assert_eq!(3, match 3 {
+ assert_eq!(3i, match 3 {
1 if false => 1,
1..2 => 2,
_ => 3
}
fn range_shadow_lit() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
1..2 if false => 1,
1 => 2,
_ => 3
});
- let x = 0;
- assert_eq!(2, match x+1 {
+ let x = 0i;
+ assert_eq!(2i, match x+1 {
0 => 0,
1..2 if false => 1,
1 => 2,
_ => 3
});
- assert_eq!(2, match val() {
+ assert_eq!(2i, match val() {
1..2 if false => 1,
1 => 2,
_ => 3
});
- assert_eq!(2, match CONST {
+ assert_eq!(2i, match CONST {
0 => 0,
1..2 if false => 1,
1 => 2,
});
// ditto
- assert_eq!(3, match 3 {
+ assert_eq!(3i, match 3 {
1..2 if false => 1,
1 => 2,
_ => 3
}
fn range_shadow_range() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
0..2 if false => 1,
1..3 => 2,
_ => 3,
});
- let x = 0;
- assert_eq!(2, match x+1 {
+ let x = 0i;
+ assert_eq!(2i, match x+1 {
100 => 0,
0..2 if false => 1,
1..3 => 2,
_ => 3,
});
- assert_eq!(2, match val() {
+ assert_eq!(2i, match val() {
0..2 if false => 1,
1..3 => 2,
_ => 3,
});
- assert_eq!(2, match CONST {
+ assert_eq!(2i, match CONST {
100 => 0,
0..2 if false => 1,
1..3 => 2,
});
// ditto
- assert_eq!(3, match 5 {
+ assert_eq!(3i, match 5 {
0..2 if false => 1,
1..3 => 2,
_ => 3,
}
fn multi_pats_shadow_lit() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
100 => 0,
0 | 1..10 if false => 1,
1 => 2,
}
fn multi_pats_shadow_range() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
100 => 0,
0 | 1..10 if false => 1,
1..3 => 2,
}
fn lit_shadow_multi_pats() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
100 => 0,
1 if false => 1,
0 | 1..10 => 2,
}
fn range_shadow_multi_pats() {
- assert_eq!(2, match 1 {
+ assert_eq!(2i, match 1 {
100 => 0,
1..3 if false => 1,
0 | 1..10 => 2,
// which is a rare combination of vector patterns, multiple wild-card
// patterns and guard functions.
let r = match [Bar(0, false)].as_slice() {
- [Bar(_, pred)] if pred => 1,
- [Bar(_, pred)] if !pred => 2,
- _ => 0,
+ [Bar(_, pred)] if pred => 1i,
+ [Bar(_, pred)] if !pred => 2i,
+ _ => 0i,
};
assert_eq!(2, r);
}
let (tx, rx) = channel();
spawn(proc() { helper(rx) });
let (snd, rcv) = channel();
- for _ in range(1, 100000) {
+ for _ in range(1i, 100000i) {
snd.send(1);
let (tx2, rx2) = channel();
tx.send(tx2);
fn main() {
let r = match (FooNullary, 'a') {
- (FooUint(..), 'a'..'z') => 1,
- (FooNullary, 'x') => 2,
+ (FooUint(..), 'a'..'z') => 1i,
+ (FooNullary, 'x') => 2i,
_ => 0
};
assert_eq!(r, 0);
let r = match (FooUint(0), 'a') {
- (FooUint(1), 'a'..'z') => 1,
- (FooUint(..), 'x') => 2,
- (FooNullary, 'a') => 3,
+ (FooUint(1), 'a'..'z') => 1i,
+ (FooUint(..), 'x') => 2i,
+ (FooNullary, 'a') => 3i,
_ => 0
};
assert_eq!(r, 0);
let r = match ('a', FooUint(0)) {
- ('a'..'z', FooUint(1)) => 1,
- ('x', FooUint(..)) => 2,
- ('a', FooNullary) => 3,
+ ('a'..'z', FooUint(1)) => 1i,
+ ('x', FooUint(..)) => 2i,
+ ('a', FooNullary) => 3i,
_ => 0
};
assert_eq!(r, 0);
let r = match ('a', 'a') {
- ('a'..'z', 'b') => 1,
- ('x', 'a'..'z') => 2,
+ ('a'..'z', 'b') => 1i,
+ ('x', 'a'..'z') => 2i,
_ => 0
};
assert_eq!(r, 0);
let r = match ('a', 'a') {
- ('a'..'z', 'b') => 1,
- ('x', 'a'..'z') => 2,
- ('a', 'a') => 3,
+ ('a'..'z', 'b') => 1i,
+ ('x', 'a'..'z') => 2i,
+ ('a', 'a') => 3i,
_ => 0
};
assert_eq!(r, 3);
fn main() {
let x = match A(3) {
- A(..) => 1
+ A(..) => 1i
};
assert_eq!(x, 1);
let x = match A(4) {
- A(1) => 1,
- A(..) => 2
+ A(1) => 1i,
+ A(..) => 2i
};
assert_eq!(x, 2);
// There's no particularly good reason to support this, but it's currently allowed,
// and this makes sure it doesn't ICE or break LLVM.
let x = match B {
- B(..) => 3
+ B(..) => 3i
};
assert_eq!(x, 3);
}
fn main() {
let x = match Foo(42) {
- Foo(..) => 1,
+ Foo(..) => 1i,
_ if true => 0,
Bar(..) => fail!("Oh dear")
};
assert_eq!(x, 1);
let x = match Foo(42) {
- _ if true => 0,
+ _ if true => 0i,
Foo(..) => 1,
Bar(..) => fail!("Oh dear")
};
// except according to those terms.
fn main() {
- let mut x = &[1, 2, 3, 4];
+ let mut x = &[1i, 2, 3, 4];
let mut result = vec!();
loop {
extern crate debug;
pub fn main() {
- let mut x = 0;
+ let mut x = 0i;
'foo: loop {
'bar: loop {
}
pub fn main() {
- let z = box 22;
+ let z = box 22i;
a_val(z.clone(), z.clone());
}
// except according to those terms.
pub fn main() {
- let x = 1;
- let y = 1;
+ let x = 1i;
+ let y = 1i;
assert_eq!(&x, &y);
}
// except according to those terms.
pub fn main() {
- let mut x = 0;
- for _ in range(0, 4096) { x += 1; }
+ let mut x = 0i;
+ for _ in range(0i, 4096) { x += 1; }
assert_eq!(x, 4096);
println!("x = {}", x);
}
// except according to those terms.
pub fn main() {
- let mut x = box 3;
+ let mut x = box 3i;
x = x;
assert_eq!(*x, 3);
}
pub fn main() {
let mut table = HashMap::new();
- table.insert("one".to_string(), 1);
- table.insert("two".to_string(), 2);
+ table.insert("one".to_string(), 1i);
+ table.insert("two".to_string(), 2i);
assert!(check_strs(table.to_str().as_slice(), "{one: 1, two: 2}") ||
check_strs(table.to_str().as_slice(), "{two: 2, one: 1}"));
}
// Usage with failing inference
pub fn main() {
- let a = Vec2 { x: 3.0, y: 4.0 };
+ let a = Vec2 { x: 3.0f64, y: 4.0f64 };
// the following compiles and works properly
- let v1: Vec2 = a * 3.0;
+ let v1: Vec2 = a * 3.0f64;
println!("{} {}", v1.x, v1.y);
// the following compiles but v2 will not be Vec2 yet and
// using it later will cause an error that the type of v2
// must be known
- let v2 = a * 3.0;
+ let v2 = a * 3.0f64;
println!("{} {}", v2.x, v2.y); // error regarding v2's type
}
// except according to those terms.
pub fn main() {
- let mut count = 0;
- for _ in range(0, 999_999) { count += 1; }
+ let mut count = 0i;
+ for _ in range(0i, 999_999) { count += 1; }
assert_eq!(count, 999_999);
println!("{}", count);
}
}
pub fn main() {
- let inner = 5;
+ let inner = 5i;
let outer = Outer::new(&inner as &Inner);
outer.inner.print();
}
}
fn main() {
- assert_eq!(foo([1, 2, 3]), (1, 3, 6));
+ assert_eq!(foo([1i, 2i, 3i]), (1i, 3i, 6i));
let [a, b, c, d] = bar("foo", "bar");
assert_eq!(a, "foo");
assert_eq!(a, "baz");
assert!(xs == ["foo", "foo"]);
assert_eq!(d, "baz");
-}
\ No newline at end of file
+}
// except according to those terms.
fn main() {
- let x = match Some(1) {
- ref _y @ Some(_) => 1,
- None => 2,
+ let x = match Some(1i) {
+ ref _y @ Some(_) => 1i,
+ None => 2i,
};
assert_eq!(x, 1);
}
let ints = integers();
let threes = periodical(3);
let fives = periodical(5);
- for _ in range(1, 100) {
+ for _ in range(1i, 100i) {
match (ints.recv(), threes.recv(), fives.recv()) {
(_, true, true) => println!("FizzBuzz"),
(_, true, false) => println!("Fizz"),
impl X for int {}
pub struct Z<'a>(Enum<&'a X>);
- fn foo() { let x = 42; let z = Z(A(&x as &X)); let _ = z; }
+ fn foo() { let x = 42i; let z = Z(A(&x as &X)); let _ = z; }
}
mod b {
}
fn bar() {
- let x = 42;
+ let x = 42i;
let _y = Y { x: Some(&x as &X) };
}
}
pub trait X { fn f(&self); }
impl X for int { fn f(&self) {} }
pub struct Z<'a>(Option<&'a X>);
- fn main() { let x = 42; let z = Z(Some(&x as &X)); let _ = z; }
+ fn main() { let x = 42i; let z = Z(Some(&x as &X)); let _ = z; }
}
pub fn main() {}
use issue2378b::{two_maybes};
pub fn main() {
- let x = two_maybes{a: just(3), b: just(5)};
+ let x = two_maybes{a: just(3i), b: just(5i)};
assert_eq!(x[0u], (3, 5));
}
}
pub fn main() {
- let x = 3;
+ let x = 3i;
let y = repeater(box x);
assert_eq!(x, y.get());
}
}
}
- 'bar: for _ in range(0, 100) {
+ 'bar: for _ in range(0i, 100i) {
loop {
break 'bar;
}
struct A { a: Box<int> }
fn foo() -> ||: 'static -> int {
- let k = box 22;
+ let k = box 22i;
let _u = A {a: k.clone()};
let result: ||: 'static -> int = || 22;
result
pub fn main() {
fn invoke(f: ||) { f(); }
- let k = box 22;
+ let k = box 22i;
let _u = A {a: k.clone()};
invoke(|| println!("{:?}", k.clone()) )
}
#![feature(macro_rules)]
// shouldn't affect evaluation of $ex:
-macro_rules! bad_macro (($ex:expr) => ({let _x = 9; $ex}))
+macro_rules! bad_macro (($ex:expr) => ({let _x = 9i; $ex}))
pub fn main() {
- let _x = 8;
- assert_eq!(bad_macro!(_x),8)
+ let _x = 8i;
+ assert_eq!(bad_macro!(_x),8i)
}
extern crate debug;
pub fn main() {
- let x = vec!(1, 2, 3);
- let mut y = 0;
+ let x = vec!(1i, 2i, 3i);
+ let mut y = 0i;
for i in x.iter() { println!("{:?}", *i); y += *i; }
println!("{:?}", y);
assert_eq!(y, 6);
fn test() {
let v;
loop {
- v = 3;
+ v = 3i;
break;
}
println!("{}", v);
}
pub fn main() {
- println!("{}", 1);
- println!("{}", 2.0);
+ println!("{}", 1i);
+ println!("{}", 2.0f64);
println!("{:?}", Three);
- println!("{:?}", vec!(4));
+ println!("{:?}", vec!(4i));
}
// except according to those terms.
pub fn main() {
- let x = vec!(10, 20, 30);
- let mut sum = 0;
+ let x = vec!(10i, 20i, 30i);
+ let mut sum = 0i;
for x in x.iter() { sum += *x; }
assert_eq!(sum, 60);
}
extern crate macro_crate_def_only;
pub fn main() {
- assert_eq!(5, make_a_5!());
+ assert_eq!(5i, make_a_5!());
}
extern crate macro_export_inner_module;
pub fn main() {
- assert_eq!(1, foo!());
+ assert_eq!(1i, foo!());
}
}
pub fn main() {
- assert_eq!(1, f(Some('x')));
- assert_eq!(2, f(Some('y')));
- assert_eq!(3, f(None));
+ assert_eq!(1u, f(Some('x')));
+ assert_eq!(2u, f(Some('y')));
+ assert_eq!(3u, f(None));
- assert_eq!(1, match Some('x') {
- Some(char_x!()) => 1,
- _ => 2,
+ assert_eq!(1i, match Some('x') {
+ Some(char_x!()) => 1i,
+ _ => 2i,
});
- assert_eq!(1, match Some('x') {
- some!(char_x!()) => 1,
- _ => 2,
+ assert_eq!(1i, match Some('x') {
+ some!(char_x!()) => 1i,
+ _ => 2i,
});
- assert_eq!(1, match Some('x') {
- indirect!() => 1,
- _ => 2,
+ assert_eq!(1i, match Some('x') {
+ indirect!() => 1i,
+ _ => 2i,
});
- assert_eq!(3, {
- let ident_pat!(x) = 2;
- x+1
+ assert_eq!(3i, {
+ let ident_pat!(x) = 2i;
+ x+1i
});
}
)
);
- mylet!(y, 8*2);
- assert_eq!(y, 16);
+ mylet!(y, 8i*2);
+ assert_eq!(y, 16i);
myfn!(mult, (a,b), { a*b } );
assert_eq!(mult(2, add(4,4)), 16);
macro_rules! actually_an_expr_macro (
- () => ( 16 )
+ () => ( 16i )
)
- assert_eq!({ actually_an_expr_macro!() }, 16);
+ assert_eq!({ actually_an_expr_macro!() }, 16i);
}
#![feature(macro_rules)]
#[cfg(foo)]
-macro_rules! foo( () => (1) )
+macro_rules! foo( () => (1i) )
#[cfg(not(foo))]
-macro_rules! foo( () => (2) )
+macro_rules! foo( () => (2i) )
pub fn main() {
- assert_eq!(foo!(), 1);
+ assert_eq!(foo!(), 1i);
}
#![feature(macro_rules)]
#[cfg(foo)]
-macro_rules! foo( () => (1) )
+macro_rules! foo( () => (1i) )
#[cfg(not(foo))]
-macro_rules! foo( () => (2) )
+macro_rules! foo( () => (2i) )
pub fn main() {
- assert_eq!(foo!(), 2);
+ assert_eq!(foo!(), 2i);
}
}
fn test2() {
- match (1, 2, 3) {
+ match (1i, 2i, 3i) {
(1, a, b) | (2, b, a) => {
assert_eq!(a, 2);
assert_eq!(b, 3);
}
fn test3() {
- match (1, 2, 3) {
+ match (1i, 2i, 3i) {
(1, ref a, ref b) | (2, ref b, ref a) => {
assert_eq!(*a, 2);
assert_eq!(*b, 3);
}
fn test4() {
- match (1, 2, 3) {
+ match (1i, 2i, 3i) {
(1, a, b) | (2, b, a) if a == 2 => {
assert_eq!(a, 2);
assert_eq!(b, 3);
}
fn test5() {
- match (1, 2, 3) {
+ match (1i, 2i, 3i) {
(1, ref a, ref b) | (2, ref b, ref a) if *a == 2 => {
assert_eq!(*a, 2);
assert_eq!(*b, 3);
// except according to those terms.
pub fn main() {
- let mut v = Some(22);
+ let mut v = Some(22i);
match v {
None => {}
Some(ref mut p) => { *p += 1; }
_ => fail!()
}
- let x = match "a" { "a" => 1, "b" => 2, _ => fail!() };
+ let x = match "a" { "a" => 1i, "b" => 2i, _ => fail!() };
assert_eq!(x, 1);
match "a" { "a" => { } "b" => { }, _ => fail!() }
extern crate debug;
pub fn main() {
- match box 100 {
+ match box 100i {
box x => {
println!("{:?}", x);
assert_eq!(x, 100);
pub fn main() {
- match vec!(1, 2, 3) {
+ match vec!(1i, 2i, 3i) {
x => {
assert_eq!(x.len(), 3);
assert_eq!(*x.get(0), 1);
// begin failing.
mod m {
- pub fn f() -> Vec<int> { Vec::from_elem(1u, 0) }
+ pub fn f() -> Vec<int> { Vec::from_elem(1u, 0i) }
}
pub fn main() { let _x = m::f(); }
}
pub fn main() {
- let foo = F { a: 1 };
+ let foo = F { a: 1i };
foo.serialize(1i);
- let bar = F { a: F {a: 1 } };
+ let bar = F { a: F {a: 1i } };
bar.serialize(2i);
}
}
pub fn main() {
- f(3);
+ f(3i);
}
impl Foo for X {}
pub fn main() {
- let (a, mut b) = (23, 4);
+ let (a, mut b) = (23i, 4i);
assert_eq!(a, 23);
assert_eq!(b, 4);
b = a + b;
Baz(f32, u8)
}
- let (x, mut y) = (32, Foo(21));
+ let (x, mut y) = (32i, Foo(21));
match x {
mut z @ 32 => {
// except according to those terms.
fn test1() {
- let mut ints = [0, ..32];
+ let mut ints = [0i, ..32];
ints[0] += 1;
assert_eq!(ints[0], 1);
}
fn test2() {
- let mut ints = [0, ..32];
+ let mut ints = [0i, ..32];
for i in ints.mut_iter() { *i += 22; }
for i in ints.iter() { assert!(*i == 22); }
}
match Some::<int>(5) {
Some::<int>(_x) => {
let mut bar;
- match None::<int> { None::<int> => { bar = 5; } _ => { baz(); } }
+ match None::<int> { None::<int> => { bar = 5i; } _ => { baz(); } }
println!("{:?}", bar);
}
None::<int> => { println!("hello"); }
}
pub fn main() {
- let mv = myvec(vec!(1, 2, 3));
+ let mv = myvec(vec!(1i, 2, 3));
let mv_clone = mv.clone();
let mv_clone = myvec_deref(mv_clone);
assert_eq!(*mv_clone.get(1), 2);
let bar = "bar".to_string();
let mut list = AssociationList {pairs: Vec::new()};
- list.push(foo.clone(), 22);
- list.push(bar.clone(), 44);
+ list.push(foo.clone(), 22i);
+ list.push(bar.clone(), 44i);
assert!(list[foo] == 22)
assert!(list[bar] == 44)
}
pub fn main() {
- let a = &[1, 2, 3];
+ let a = &[1i, 2i, 3i];
assert_eq!(DerefArray {inner: a}[1], 2);
}
}
pub fn main() {
- let nested = DerefWrapper {x: true, y: DerefWrapper {x: 0, y: 1}};
+ let nested = DerefWrapper {x: true, y: DerefWrapper {x: 0i, y: 1i}};
// Use the first field that you can find.
assert_eq!(nested.x, true);
// Also go through multiple levels of indirection.
assert_eq!(Rc::new(nested).x, true);
- let nested_priv = priv_test::DerefWrapperHideX::new(true, DerefWrapper {x: 0, y: 1});
+ let nested_priv = priv_test::DerefWrapperHideX::new(true, DerefWrapper {x: 0i, y: 1i});
// FIXME(eddyb) #12808 should skip private fields.
// assert_eq!(nested_priv.x, 0);
assert_eq!((*nested_priv).x, 0);
extern crate overloaded_autoderef_xc;
fn main() {
- assert!(overloaded_autoderef_xc::check(5, 5));
+ assert!(overloaded_autoderef_xc::check(5i, 5i));
}
assert_eq!(point.x, 2);
assert_eq!(point.y, 4);
- let i = Rc::new(RefCell::new(2));
+ let i = Rc::new(RefCell::new(2i));
let i_value = *i.borrow();
*i.borrow_mut() = 5;
assert_eq!((i_value, *i.borrow()), (2, 5));
p.borrow_mut().y += 3;
assert_eq!(*p.borrow(), Point {x: 3, y: 5});
- let v = Rc::new(RefCell::new([1, 2, 3]));
+ let v = Rc::new(RefCell::new([1i, 2, 3]));
v.borrow_mut()[0] = 3;
v.borrow_mut()[1] += 3;
assert_eq!((v.borrow()[0], v.borrow()[1], v.borrow()[2]), (3, 5, 3));
}
pub fn main() {
- let mut n = DerefCounter::new(0);
+ let mut n = DerefCounter::new(0i);
let mut v = DerefCounter::new(Vec::new());
let _ = *n; // Immutable deref + copy a POD.
assert_eq!(n.counts(), (2, 1)); assert_eq!(v.counts(), (1, 1));
let mut v2 = Vec::new();
- v2.push(1);
+ v2.push(1i);
*n = 5; *v = v2; // Mutable deref + assignment.
assert_eq!(n.counts(), (2, 2)); assert_eq!(v.counts(), (1, 2));
}
pub fn main() {
- assert_eq!(*Rc::new(5), 5);
- assert_eq!(***Rc::new(box box 5), 5);
+ assert_eq!(*Rc::new(5i), 5);
+ assert_eq!(***Rc::new(box box 5i), 5);
assert_eq!(*Rc::new(Point {x: 2, y: 4}), Point {x: 2, y: 4});
- let i = Rc::new(RefCell::new(2));
+ let i = Rc::new(RefCell::new(2i));
let i_value = *(*i).borrow();
*(*i).borrow_mut() = 5;
assert_eq!((i_value, *(*i).borrow()), (2, 5));
(*(*p).borrow_mut()).y += 3;
assert_eq!(*(*p).borrow(), Point {x: 3, y: 5});
- let v = Rc::new(RefCell::new(vec!(1, 2, 3)));
+ let v = Rc::new(RefCell::new(vec!(1i, 2, 3)));
*(*(*v).borrow_mut()).get_mut(0) = 3;
*(*(*v).borrow_mut()).get_mut(1) += 3;
assert_eq!((*(*(*v).borrow()).get(0),
is_static::<proc():'static>();
- let a = 3;
+ let a = 3i;
bar::<proc()>(proc() {
let b = &a;
println!("{}", *b);
use reexported_static_methods::Bort;
pub fn main() {
- assert_eq!(42, Foo::foo());
- assert_eq!(84, Baz::bar());
- assert!(Boz::boz(1));
+ assert_eq!(42i, Foo::foo());
+ assert_eq!(84i, Baz::bar());
+ assert!(Boz::boz(1i));
assert_eq!("bort()".to_string(), Bort::bort());
}
}
pub fn main() {
- let mut i = 3;
+ let mut i = 3i;
assert_eq!(i, 3);
{
let cl = || i += 1;
}
impl<'t> MakerTrait<'t> for Box<Trait<'t>> {
- fn mk() -> Box<Trait<'t>> { box() (4,5) as Box<Trait> }
+ fn mk() -> Box<Trait<'t>> { box() (4i,5i) as Box<Trait> }
}
enum List<'l> {
}
pub fn main() {
- let t = (2,3);
+ let t = (2i,3i);
let o = &t as &Trait;
let s1 = Struct1 { f: o };
let s2 = Struct2 { f: o };
}
pub fn main() {
- let b1 = Box { t: &3 };
- assert_eq!(add(b1, b1), 6);
+ let b1 = Box { t: &3i };
+ assert_eq!(add(b1, b1), 6i);
}
}
pub fn main() {
- let b1 = Box { t: &3 };
- assert_eq!(add(b1, b1), 6);
+ let b1 = Box { t: &3i };
+ assert_eq!(add(b1, b1), 6i);
}
fn borrow<'r, T>(x: &'r T) -> &'r T {x}
pub fn main() {
- let x = box(GC) 3;
+ let x = box(GC) 3i;
loop {
let y = borrow(x);
assert_eq!(*x, *y);
}
pub fn main() {
- let mut x = Some(23);
+ let mut x = Some(23i);
{
let y = get(&x);
assert_eq!(*y, 23);
}
- x = Some(24);
+ x = Some(24i);
{
let y = get(&x);
pub fn main() {
let x = [ [true], ..512 ];
- let y = [ 0, ..1 ];
+ let y = [ 0i, ..1 ];
println!("{:?}", x);
println!("{:?}", y);
assert!(("hello".to_string() < "hellr".to_string()));
assert!(("hello ".to_string() > "hello".to_string()));
assert!(("hello".to_string() != "there".to_string()));
- assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3)));
- assert!((vec!(1, 2, 3) < vec!(1, 2, 3, 4)));
- assert!((vec!(1, 2, 4, 4) > vec!(1, 2, 3, 4)));
- assert!((vec!(1, 2, 3, 4) < vec!(1, 2, 4, 4)));
- assert!((vec!(1, 2, 3) <= vec!(1, 2, 3)));
- assert!((vec!(1, 2, 3) <= vec!(1, 2, 3, 3)));
- assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3)));
- assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3));
- assert!((vec!(1, 2, 3) != vec!(1, 1, 3)));
+ assert!((vec!(1i, 2, 3, 4) > vec!(1, 2, 3)));
+ assert!((vec!(1i, 2, 3) < vec!(1, 2, 3, 4)));
+ assert!((vec!(1i, 2, 4, 4) > vec!(1, 2, 3, 4)));
+ assert!((vec!(1i, 2, 3, 4) < vec!(1, 2, 4, 4)));
+ assert!((vec!(1i, 2, 3) <= vec!(1, 2, 3)));
+ assert!((vec!(1i, 2, 3) <= vec!(1, 2, 3, 3)));
+ assert!((vec!(1i, 2, 3, 4) > vec!(1, 2, 3)));
+ assert_eq!(vec!(1i, 2, 3), vec!(1, 2, 3));
+ assert!((vec!(1i, 2, 3) != vec!(1, 1, 3)));
}
}
fn test_misc() {
- assert_eq!(1 << 1i8 << 1u8 << 1i16 << 1u8 << 1u64, 32);
+ assert_eq!(1i << 1 << 1 << 1 << 1 << 1, 32);
}
fn test_expr() {
let v10 = 10 as uint;
let v4 = 4 as u8;
let v2 = 2 as u8;
- assert_eq!(v10 >> v2, v2 as uint);
- assert_eq!(v10 << v4, 160 as uint);
+ assert_eq!(v10 >> v2 as uint, v2 as uint);
+ assert_eq!(v10 << v4 as uint, 160 as uint);
let v10 = 10 as u8;
let v4 = 4 as uint;
let v2 = 2 as uint;
- assert_eq!(v10 >> v2, v2 as u8);
- assert_eq!(v10 << v4, 160 as u8);
+ assert_eq!(v10 >> v2 as uint, v2 as u8);
+ assert_eq!(v10 << v4 as uint, 160 as u8);
let v10 = 10 as int;
let v4 = 4 as i8;
let v2 = 2 as i8;
- assert_eq!(v10 >> v2, v2 as int);
- assert_eq!(v10 << v4, 160 as int);
+ assert_eq!(v10 >> v2 as uint, v2 as int);
+ assert_eq!(v10 << v4 as uint, 160 as int);
let v10 = 10 as i8;
let v4 = 4 as int;
let v2 = 2 as int;
- assert_eq!(v10 >> v2, v2 as i8);
- assert_eq!(v10 << v4, 160 as i8);
+ assert_eq!(v10 >> v2 as uint, v2 as i8);
+ assert_eq!(v10 << v4 as uint, 160 as i8);
let v10 = 10 as uint;
let v4 = 4 as int;
let v2 = 2 as int;
- assert_eq!(v10 >> v2, v2 as uint);
- assert_eq!(v10 << v4, 160 as uint);
+ assert_eq!(v10 >> v2 as uint, v2 as uint);
+ assert_eq!(v10 << v4 as uint, 160 as uint);
}
fn test_const() {
- static r1_1: uint = 10u >> 2u8;
- static r2_1: uint = 10u << 4u8;
+ static r1_1: uint = 10u >> 2u;
+ static r2_1: uint = 10u << 4u;
assert_eq!(r1_1, 2 as uint);
assert_eq!(r2_1, 160 as uint);
assert_eq!(r1_2, 2 as u8);
assert_eq!(r2_2, 160 as u8);
- static r1_3: int = 10 >> 2i8;
- static r2_3: int = 10 << 4i8;
+ static r1_3: int = 10 >> 2u;
+ static r2_3: int = 10 << 4u;
assert_eq!(r1_3, 2 as int);
assert_eq!(r2_3, 160 as int);
- static r1_4: i8 = 10i8 >> 2;
- static r2_4: i8 = 10i8 << 4;
+ static r1_4: i8 = 10i8 >> 2u;
+ static r2_4: i8 = 10i8 << 4u;
assert_eq!(r1_4, 2 as i8);
assert_eq!(r2_4, 160 as i8);
- static r1_5: uint = 10u >> 2i8;
- static r2_5: uint = 10u << 4i8;
+ static r1_5: uint = 10u >> 2u;
+ static r2_5: uint = 10u << 4u;
assert_eq!(r1_5, 2 as uint);
assert_eq!(r2_5, 160 as uint);
}
-pub fn main() { let mut n; n = 1; println!("{}", n); }
+pub fn main() { let mut n; n = 1i; println!("{}", n); }
assert_eq!(10u.plus(), 30);
assert_eq!(("hi".to_string()).plus(), 200);
- assert_eq!((vec!(1)).length_().str(), "1".to_string());
- let vect = vec!(3, 4).map_(|a| *a + 4);
+ assert_eq!((vec!(1i)).length_().str(), "1".to_string());
+ let vect = vec!(3i, 4).map_(|a| *a + 4);
assert_eq!(*vect.get(0), 7);
- let vect = (vec!(3, 4)).map_::<uint>(|a| *a as uint + 4u);
+ let vect = (vec!(3i, 4)).map_::<uint>(|a| *a as uint + 4u);
assert_eq!(*vect.get(0), 7u);
let mut x = 0u;
10u.multi(|_n| x += 2u );
pub fn main() {
let foo = Foo {
- bar: 0,
- baz: 1
+ bar: 0i,
+ baz: 1i
};
let foo_ = foo.clone();
}
pub fn main() {
- let a = (1, 2, 3);
- let b = (1, 2, 3);
+ let a = (1i, 2i, 3i);
+ let b = (1i, 2i, 3i);
assert_eq!(a, b);
assert!((a != (1, 2, 4)));
assert!((a < (1, 2, 4)));
assert!((a <= (1, 2, 4)));
- assert!(((1, 2, 4) > a));
- assert!(((1, 2, 4) >= a));
+ assert!(((1i, 2i, 4i) > a));
+ assert!(((1i, 2i, 4i) >= a));
let x = large;
let y = small;
assert!((x != y));
impl<S: Clone + Add<S, S>> Movable<S> for Point<S> {}
pub fn main() {
- let mut p = Point{ x: 1, y: 2};
+ let mut p = Point{ x: 1i, y: 2i};
p.translate(3);
assert_eq!(p.X(), 4);
}
rx1.recv();
let mut v = Vec::new();
- for _ in range(0, 10000) {
+ for _ in range(0u, 10000) {
match TcpStream::connect_timeout(addr, 100) {
Ok(e) => v.push(e),
Err(ref e) if e.kind == io::TimedOut => return,
let addr = rx.recv();
let (tx, rx) = channel();
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
let tx = tx.clone();
TaskBuilder::new().stack_size(64 * 1024).spawn(proc() {
let host = addr.ip.to_str();
// Wait for all clients to exit, but don't wait for the server to exit. The
// server just runs infinitely.
drop(tx);
- for _ in range(0, 1000) {
+ for _ in range(0u, 1000) {
rx.recv();
}
unsafe { libc::exit(0) }
impl<T> Foo for Bar<T> { }
pub fn main() {
- let a = Bar { x: 1 };
+ let a = Bar { x: 1u };
let b = &a as &Foo;
}
pub fn main() {
let t1 = Tree(box(GC) RefCell::new(TreeR{left: None,
right: None,
- val: box 1 as Box<to_str+Send>}));
+ val: box 1i as Box<to_str+Send>}));
let t2 = Tree(box(GC) RefCell::new(TreeR{left: Some(t1),
right: Some(t1),
- val: box 2 as Box<to_str+Send>}));
+ val: box 2i as Box<to_str+Send>}));
let expected =
"[2, some([1, none, none]), some([1, none, none])]".to_string();
assert!(t2.to_str_() == expected);
}
pub fn main () {
- assert_eq!(f(0, 1, 2), (1, 2));
- assert_eq!(f(0u, 1, 2), (1, 2));
+ assert_eq!(f(0i, 1i, 2i), (1, 2));
+ assert_eq!(f(0u, 1i, 2i), (1, 2));
}
}
pub fn main () {
- assert_eq!(f(0, 2), 2);
+ assert_eq!(f(0i, 2i), 2);
}
}
pub fn main () {
- assert_eq!(f(0, 1, 2), (1, 2));
- assert_eq!(f(0, 1u8, 2u8), (1u8, 2u8));
+ assert_eq!(f(0i, 1i, 2i), (1, 2));
+ assert_eq!(f(0i, 1u8, 2u8), (1u8, 2u8));
}
}
pub fn main () {
- f(0);
+ f(0i);
}
pub fn main() {
// Some tests of random things
- f(0);
+ f(0i);
- assert_eq!(A::lurr(&0, &1), 21);
+ assert_eq!(A::lurr(&0i, &1i), 21);
let a = stuff::thing { x: 0 };
let b = stuff::thing { x: 1 };
assert_eq!(a.h(), 11);
assert_eq!(c.h(), 11);
- assert_eq!(0i.thing(3.14, 1), (3.14, 1));
- assert_eq!(B::staticthing(&0i, 3.14, 1), (3.14, 1));
+ assert_eq!(0i.thing(3.14f64, 1i), (3.14f64, 1i));
+ assert_eq!(B::staticthing(&0i, 3.14f64, 1i), (3.14f64, 1i));
assert_eq!(B::<f64>::staticthing::<int>(&0i, 3.14, 1), (3.14, 1));
- assert_eq!(g(0i, 3.14, 1), (3.14, 1));
- assert_eq!(g(false, 3.14, 1), (3.14, 1));
+ assert_eq!(g(0i, 3.14f64, 1i), (3.14f64, 1i));
+ assert_eq!(g(false, 3.14f64, 1i), (3.14, 1));
let obj = box 0i as Box<A>;
assert_eq!(obj.h(), 11);
// Trying out a real one
- assert!(12.test_neq(&10));
- assert!(!10.test_neq(&10));
+ assert!(12i.test_neq(&10i));
+ assert!(!10i.test_neq(&10i));
assert!(a.test_neq(&b));
assert!(!a.test_neq(&a));
- assert!(neq(&12, &10));
- assert!(!neq(&10, &10));
+ assert!(neq(&12i, &10i));
+ assert!(!neq(&10i, &10i));
assert!(neq(&a, &b));
assert!(!neq(&a, &a));
}
}
pub fn main() {
- assert_eq!(foo(vec!(1)), vec!("hi".to_string()));
+ assert_eq!(foo(vec!(1i)), vec!("hi".to_string()));
assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), vec!("4".to_string(), "5".to_string()));
assert_eq!(bar::<String, Vec<String> >(vec!("x".to_string(), "y".to_string())),
vec!("x".to_string(), "y".to_string()));
pub trait FloatExt: NumExt {}
-fn greater_than_one<T:NumExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() }
-fn greater_than_one_float<T:FloatExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() }
+fn greater_than_one<T:NumExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() }
+fn greater_than_one_float<T:FloatExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() }
pub fn main() {}
pub trait NumExt: Num + NumCast { }
fn greater_than_one<T:NumExt>(n: &T) -> bool {
- n.gt(&NumCast::from(1).unwrap())
+ n.gt(&NumCast::from(1i).unwrap())
}
pub fn main() {}
pub trait NumExt: Num + NumCast + PartialOrd { }
fn greater_than_one<T:NumExt>(n: &T) -> bool {
- *n > NumCast::from(1).unwrap()
+ *n > NumCast::from(1i).unwrap()
}
pub fn main() {}
impl NumExt for f32 {}
fn num_eq_one<T:NumExt>(n: T) {
- println!("{}", n == NumCast::from(1).unwrap())
+ println!("{}", n == NumCast::from(1i).unwrap())
}
pub fn main() {
impl NumExt for int {}
fn num_eq_one<T:NumExt>() -> T {
- NumCast::from(1).unwrap()
+ NumCast::from(1i).unwrap()
}
pub fn main() {
}
pub fn main() {
- f(&0)
+ f(&0i)
}
pub fn main() {
assert!(1.to_string() == "1".to_string());
- assert!((vec!(2, 3, 4)).to_string() == "[2, 3, 4]".to_string());
+ assert!((vec!(2i, 3, 4)).to_string() == "[2, 3, 4]".to_string());
fn indirect<T:to_str>(x: T) -> String {
format!("{}!", x.to_string())
}
- assert!(indirect(vec!(10, 20)) == "[10, 20]!".to_string());
+ assert!(indirect(vec!(10i, 20)) == "[10, 20]!".to_string());
fn indirect2<T:to_str>(x: T) -> String {
indirect(x)
}
- assert!(indirect2(vec!(1)) == "[1]!".to_string());
+ assert!(indirect2(vec!(1i)) == "[1]!".to_string());
}
pub fn main() {
let (tx, rx) = channel();
- tx.send(42);
+ tx.send(42i);
let r = rx.recv();
println!("{:?}", r);
}
// except according to those terms.
pub fn main() {
- let mut i = box 1;
+ let mut i = box 1i;
// Should be a copy
let mut j;
j = i.clone();
#![allow(dead_assignment)]
pub fn main() {
- let i = box 1;
- let mut j = box 2;
+ let i = box 1i;
+ let mut j = box 2i;
// Should drop the previous value of j
j = i;
assert_eq!(*j, 1);
}
pub fn main() {
- let t = f(box 100);
- assert_eq!(t, box 100);
- let t = f(box box(GC) vec!(100));
- assert_eq!(t, box box(GC) vec!(100));
+ let t = f(box 100i);
+ assert_eq!(t, box 100i);
+ let t = f(box box(GC) vec!(100i));
+ assert_eq!(t, box box(GC) vec!(100i));
}
pub fn main() {
let mut i;
- i = box 1;
+ i = box 1i;
assert_eq!(*i, 1);
}
pub fn main() {
- let i = box vec!(100);
- assert_eq!(*i.get(0), 100);
+ let i = box vec!(100i);
+ assert_eq!(*i.get(0), 100i);
}
// except according to those terms.
pub fn main() {
- let i = box 100;
- assert!(i == box 100);
- assert!(i < box 101);
- assert!(i <= box 100);
- assert!(i > box 99);
- assert!(i >= box 99);
+ let i = box 100i;
+ assert!(i == box 100i);
+ assert!(i < box 101i);
+ assert!(i <= box 100i);
+ assert!(i > box 99i);
+ assert!(i >= box 99i);
}
// except according to those terms.
pub fn main() {
- let mut i = box 1;
+ let mut i = box 1i;
// Should be a copy
let mut j = i.clone();
- *i = 2;
- *j = 3;
- assert_eq!(*i, 2);
- assert_eq!(*j, 3);
+ *i = 2i;
+ *j = 3i;
+ assert_eq!(*i, 2i);
+ assert_eq!(*j, 3i);
}
// except according to those terms.
pub fn main() {
- let i = box 1;
+ let i = box 1i;
let j = i;
assert_eq!(*j, 1);
}
// except according to those terms.
pub fn main() {
- let i = box 100;
+ let i = box 100i;
let j = i;
assert_eq!(*j, 100);
}
// except according to those terms.
pub fn main() {
- let i = box 100;
+ let i = box 100i;
assert_eq!(*i, 100);
}
// option. This file may not be copied, modified, or distributed
// except according to those terms.
-
fn f(i: Box<int>) {
assert_eq!(*i, 100);
}
pub fn main() {
- let i = box 100;
+ let i = box 100i;
f(i);
}
pub fn main() {
- let mut a = vec!(box 10);
+ let mut a = vec!(box 10i);
let b = a.clone();
assert_eq!(**a.get(0), 10);
// except according to those terms.
pub fn main() {
- let vect = vec!(box 100);
+ let vect = vec!(box 100i);
assert!(*vect.get(0) == box 100);
}
assert!(i != j);
}
- let i = box 100;
- let j = box 100;
+ let i = box 100i;
+ let j = box 100i;
f(i, j);
- let i = box 100;
- let j = box 101;
+ let i = box 100i;
+ let j = box 101i;
g(i, j);
}
assert!(i != j);
}
- let i = box 100;
- let j = box 100;
+ let i = box 100i;
+ let j = box 100i;
f(i, j);
- let i = box 100;
- let j = box 101;
+ let i = box 100i;
+ let j = box 101i;
g(i, j);
}
assert!(i != j);
}
- let i = box 100;
- let j = box 100;
+ let i = box 100i;
+ let j = box 100i;
f(i, j);
- let i = box 100;
- let j = box 101;
+ let i = box 100i;
+ let j = box 101i;
g(i, j);
}
extern crate debug;
pub fn main() {
- let i = box 100;
+ let i = box 100i;
println!("{:?}", i);
}
#![allow(unused_variable)]
pub fn main() {
- let i = box 100;
- let j = box 200;
+ let i = box 100i;
+ let j = box 200i;
let j = i;
assert_eq!(*j, 100);
}
pub fn main() {
let mut i;
- i = box 100;
+ i = box 100i;
assert_eq!(*i, 100);
}
// except according to those terms.
pub fn main() {
- let i = box 100;
+ let i = box 100i;
let mut j;
j = i;
assert_eq!(*j, 100);
// except according to those terms.
pub fn main() {
- let mut i = box 0;
+ let mut i = box 0i;
*i = 1;
assert_eq!(*i, 1);
}
pub fn main() {
let (tx, rx) = channel();
- tx.send(box 100);
+ tx.send(box 100i);
let v = rx.recv();
- assert_eq!(v, box 100);
+ assert_eq!(v, box 100i);
}
use std::mem::swap;
pub fn main() {
- let mut i = box 100;
- let mut j = box 200;
+ let mut i = box 100i;
+ let mut j = box 200i;
swap(&mut i, &mut j);
- assert_eq!(i, box 200);
- assert_eq!(j, box 100);
+ assert_eq!(i, box 200i);
+ assert_eq!(j, box 100i);
}
enum myoption<T> { none, some(T), }
-pub fn main() { println!("{}", 5); }
+pub fn main() { println!("{}", 5i); }
enum myoption<T> { none, some(T), }
-pub fn main() { println!("{}", 5); }
+pub fn main() { println!("{}", 5i); }
use std::num;
pub fn main() {
- let ε = 0.00001;
- let Π = 3.14;
+ let ε = 0.00001f64;
+ let Π = 3.14f64;
let लंच = Π * Π + 1.54;
assert!(num::abs((लंच - 1.54) - (Π * Π)) < ε);
assert_eq!(საჭმელად_გემრიელი_სადილი(), 0);
// Lunch in several languages.
- let ランチ = 10;
- let 午餐 = 10;
+ let ランチ = 10i;
+ let 午餐 = 10i;
- let ארוחת_צהריי = 10;
- let غداء = 10;
- let լանչ = 10;
- let обед = 10;
- let абед = 10;
- let μεσημεριανό = 10;
- let hádegismatur = 10;
- let ручек = 10;
+ let ארוחת_צהריי = 10i;
+ let غداء = 10u;
+ let լանչ = 10i;
+ let обед = 10i;
+ let абед = 10i;
+ let μεσημεριανό = 10i;
+ let hádegismatur = 10i;
+ let ручек = 10i;
- let ăn_trưa = 10;
- let อาหารกลางวัน = 10;
+ let ăn_trưa = 10i;
+ let อาหารกลางวัน = 10i;
// Lunchy arithmetic, mm.
assert_eq!(hádegismatur * ручек * обед, 1000);
- assert_eq!(10, ארוחת_צהריי);
+ assert_eq!(10i, ארוחת_צהריי);
assert_eq!(ランチ + 午餐 + μεσημεριανό, 30);
assert_eq!(ăn_trưa + อาหารกลางวัน, 20);
return (абед + լանչ) >> غداء;
pub fn main() {
- let mut v = vec!(1);
- v.push(2);
- v.push(3);
- v.push(4);
- v.push(5);
+ let mut v = vec!(1i);
+ v.push(2i);
+ v.push(3i);
+ v.push(4i);
+ v.push(5i);
assert_eq!(*v.get(0), 1);
assert_eq!(*v.get(1), 2);
assert_eq!(*v.get(2), 3);
pub fn main() {
- assert_eq!(vec!(1), vec!(1,));
- assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3,));
+ assert_eq!(vec!(1i), vec!(1i,));
+ assert_eq!(vec!(1i, 2, 3), vec!(1i, 2, 3,));
}
// except according to those terms.
pub fn main() {
- let x = [1, 2, 3];
+ let x = [1i, 2, 3];
match x {
[2, _, _] => fail!(),
[1, a, b] => {
[_, _, _] => fail!(),
}
- let y = ([(1, true), (2, false)], 0.5);
+ let y = ([(1i, true), (2i, false)], 0.5f64);
match y {
([(1, a), (b, false)], _) => {
assert_eq!(a, true);
// except according to those terms.
fn a() {
- let x = [1, 2, 3];
+ let x = [1i, 2, 3];
match x {
[1, 2, 4] => unreachable!(),
[0, 2, 3, ..] => unreachable!(),
}
pub fn main() {
- let x = [1, 2, 3, 4, 5];
+ let x = [1i, 2, 3, 4, 5];
- let product = foldl(x, 1, |a, b| a * *b);
+ let product = foldl(x, 1i, |a, b| a * *b);
assert_eq!(product, 120);
- let sum = foldr(x, 0, |a, b| *a + b);
+ let sum = foldr(x, 0i, |a, b| *a + b);
assert_eq!(sum, 15);
}
// except according to those terms.
pub fn main() {
- let x = &[1, 2, 3, 4, 5];
+ let x = &[1i, 2, 3, 4, 5];
if !x.is_empty() {
let el = match x {
[1, ..ref tail] => &tail[0],
// except according to those terms.
fn a() {
- let x = [1];
+ let x = [1i];
match x {
[a] => {
assert_eq!(a, 1);
}
fn b() {
- let x = [1, 2, 3];
+ let x = [1i, 2, 3];
match x {
[a, b, ..c] => {
assert_eq!(a, 1);
}
fn c() {
- let x = [1];
+ let x = [1i];
match x {
[2, ..] => fail!(),
[..] => ()
}
fn d() {
- let x = [1, 2, 3];
+ let x = [1i, 2, 3];
let branch = match x {
- [1, 1, ..] => 0,
- [1, 2, 3, ..] => 1,
- [1, 2, ..] => 2,
+ [1, 1, ..] => 0i,
+ [1, 2, 3, ..] => 1i,
+ [1, 2, ..] => 2i,
_ => 3
};
assert_eq!(branch, 1);
// except according to those terms.
pub fn main() {
- let v = vec!(1,2,3,4,5);
+ let v = vec!(1i,2,3,4,5);
let v2 = v.slice(1, 3);
assert_eq!(v2[0], 2);
assert_eq!(v2[1], 3);
// except according to those terms.
pub fn main() {
- assert_eq!((vec!(0, 1)).to_str(), "[0, 1]".to_string());
- assert_eq!((&[1, 2]).to_str(), "[1, 2]".to_string());
+ assert_eq!((vec!(0i, 1)).to_str(), "[0, 1]".to_string());
+ assert_eq!((&[1i, 2]).to_str(), "[1, 2]".to_string());
- let foo = vec!(3, 4);
- let bar = &[4, 5];
+ let foo = vec!(3i, 4);
+ let bar = &[4i, 5];
assert_eq!(foo.to_str(), "[3, 4]".to_string());
assert_eq!(bar.to_str(), "[4, 5]".to_string());
pub fn main() {
// len can't go above 64.
for len in range(2u, MAX_LEN) {
- for _ in range(0, 10) {
+ for _ in range(0i, 10) {
let main = task_rng().gen_iter::<DropCounter>()
.take(len)
.collect::<Vec<DropCounter>>();
main.clone().as_mut_slice().sort_by(|a, b| { count += 1; a.cmp(b) });
// ... and then fail on each and every single one.
- for fail_countdown in range(0, count) {
+ for fail_countdown in range(0i, count) {
// refresh the counters.
unsafe {
drop_counts = [0, .. MAX_LEN];
fn p() -> bool { true }
let _a = (assert!((true)) == (assert!(p())));
let _c = (assert!((p())) == ());
- let _b: bool = (println!("{}", 0) == (return 0u));
+ let _b: bool = (println!("{}", 0i) == (return 0u));
}
fn angrydome() {
// Issue #825: Should recheck the loop condition after continuing
pub fn main() {
- let mut i = 1;
+ let mut i = 1i;
while i > 0 {
assert!((i > 0));
println!("{}", i);
projects / rust.git / commitdiff