libcore: Replace a bunch of "== None" with ".is_none()".

Generally, "== None" calls into the shape glue, and it's also more useful.

src/libcore/char.rs

@@ -230,8 +230,8 @@ fn test_to_digit() {
     assert to_digit('z', 36u) == Some(35u);
     assert to_digit('Z', 36u) == Some(35u);
 
-    assert to_digit(' ', 10u) == None;
-    assert to_digit('$', 36u) == None;
+    assert to_digit(' ', 10u).is_none();
+    assert to_digit('$', 36u).is_none();
 }
 
 #[test]

src/libcore/dlist.rs

@@ -779,7 +779,7 @@ mod tests {
         l.assert_consistent(); l.remove(two);
         l.assert_consistent(); l.remove(three);
         l.assert_consistent(); l.remove(one); // Twenty-three is number one!
-        l.assert_consistent(); assert l.peek() == None;
+        l.assert_consistent(); assert l.peek().is_none();
         l.assert_consistent(); assert l.is_empty();
     }
     #[test]

src/libcore/float.rs

@@ -457,16 +457,16 @@ fn test_from_str() {
        None => fail
    }
 
-   assert from_str(~"") == None;
-   assert from_str(~"x") == None;
-   assert from_str(~" ") == None;
-   assert from_str(~"   ") == None;
-   assert from_str(~"e") == None;
-   assert from_str(~"E") == None;
-   assert from_str(~"E1") == None;
-   assert from_str(~"1e1e1") == None;
-   assert from_str(~"1e1.1") == None;
-   assert from_str(~"1e1-1") == None;
+   assert from_str(~"").is_none();
+   assert from_str(~"x").is_none();
+   assert from_str(~" ").is_none();
+   assert from_str(~"   ").is_none();
+   assert from_str(~"e").is_none();
+   assert from_str(~"E").is_none();
+   assert from_str(~"E1").is_none();
+   assert from_str(~"1e1e1").is_none();
+   assert from_str(~"1e1.1").is_none();
+   assert from_str(~"1e1-1").is_none();
 }
 
 #[test]

src/libcore/int-template.rs

@@ -193,8 +193,8 @@ fn test_from_str() {
     assert from_str(~"-123456789") == Some(-123456789 as T);
     assert from_str(~"-00100") == Some(-100 as T);
 
-    assert from_str(~" ") == None;
-    assert from_str(~"x") == None;
+    assert from_str(~" ").is_none();
+    assert from_str(~"x").is_none();
 }
 
 // FIXME: Has alignment issues on windows and 32-bit linux (#2609)
@@ -220,8 +220,8 @@ fn test_parse_buf() {
     assert parse_buf(to_bytes(~"-z"), 36u) == Some(-35 as T);
     assert parse_buf(to_bytes(~"-Z"), 36u) == Some(-35 as T);
 
-    assert parse_buf(to_bytes(~"Z"), 35u) == None;
-    assert parse_buf(to_bytes(~"-9"), 2u) == None;
+    assert parse_buf(to_bytes(~"Z"), 35u).is_none();
+    assert parse_buf(to_bytes(~"-9"), 2u).is_none();
 }
 
 #[test]

src/libcore/os.rs

@@ -931,7 +931,7 @@ mod tests {
         assert os::homedir() == Some(Path("/home/MountainView"));
 
         setenv(~"HOME", ~"");
-        assert os::homedir() == None;
+        assert os::homedir().is_none();
 
         option::iter(oldhome, |s| setenv(~"HOME", s));
     }
@@ -946,7 +946,7 @@ mod tests {
         setenv(~"HOME", ~"");
         setenv(~"USERPROFILE", ~"");
 
-        assert os::homedir() == None;
+        assert os::homedir().is_none();
 
         setenv(~"HOME", ~"/home/MountainView");
         assert os::homedir() == Some(Path("/home/MountainView"));

src/libcore/path2.rs

@@ -506,8 +506,8 @@ mod windows {
 
     #[test]
     fn test_extract_unc_prefixes() {
-        assert extract_unc_prefix("\\\\") == None;
-        assert extract_unc_prefix("\\\\hi") == None;
+        assert extract_unc_prefix("\\\\").is_none();
+        assert extract_unc_prefix("\\\\hi").is_none();
         assert extract_unc_prefix("\\\\hi\\") == Some((~"hi", ~"\\"));
         assert extract_unc_prefix("\\\\hi\\there") ==
             Some((~"hi", ~"\\there"));
@@ -517,7 +517,7 @@ mod windows {
 
     #[test]
     fn test_extract_drive_prefixes() {
-        assert extract_drive_prefix("c") == None;
+        assert extract_drive_prefix("c").is_none();
         assert extract_drive_prefix("c:") == Some((~"c", ~""));
         assert extract_drive_prefix("d:") == Some((~"d", ~""));
         assert extract_drive_prefix("z:") == Some((~"z", ~""));

src/libcore/pipes.rs

@@ -1027,7 +1027,7 @@ struct PortSet<T: send> : recv<T> {
         // aliasable mutable memory.
         let mut ports = ~[];
         ports <-> self.ports;
-        while result == None && ports.len() > 0 {
+        while result.is_none() && ports.len() > 0 {
             let i = wait_many(ports);
             match move ports[i].try_recv() {
                 Some(move m) => {
@@ -1153,7 +1153,7 @@ fn recv_one<T: send>(+port: port_one<T>) -> T {
 fn try_recv_one<T: send> (+port: port_one<T>) -> Option<T> {
     let message = try_recv(port);
 
-    if message == None { None }
+    if message.is_none() { None }
     else {
         let oneshot::send(message) = option::unwrap(message);
         Some(message)

src/libcore/rand.rs

@@ -408,7 +408,7 @@ mod tests {
     #[test]
     fn choose_option() {
         let r = rand::Rng();
-        assert r.choose_option(~[]) == None::<int>;
+        assert r.choose_option(~[]).is_none();
         assert r.choose_option(~[1, 1, 1]) == Some(1);
     }
 
@@ -431,7 +431,7 @@ mod tests {
             {weight: 0u, item: 42},
             {weight: 1u, item: 43}
         ]) == Some(43);
-        assert r.choose_weighted_option(~[]) == None::<int>;
+        assert r.choose_weighted_option(~[]).is_none();
     }
 
     #[test]

src/libcore/str.rs

@@ -2195,7 +2195,7 @@ mod tests {
         assert rfind_char(~"hello", 'l') == Some(3u);
         assert rfind_char(~"hello", 'o') == Some(4u);
         assert rfind_char(~"hello", 'h') == Some(0u);
-        assert rfind_char(~"hello", 'z') == None;
+        assert rfind_char(~"hello", 'z').is_none();
         assert rfind_char(~"ประเทศไทย中华Việt Nam", '华') == Some(30u);
     }
 
@@ -2393,7 +2393,7 @@ mod tests {
     #[test]
     fn test_find_str() {
         // byte positions
-        assert find_str(~"banana", ~"apple pie") == None;
+        assert find_str(~"banana", ~"apple pie").is_none();
         assert find_str(~"", ~"") == Some(0u);
 
         let data = ~"ประเทศไทย中华Việt Nam";
@@ -2401,7 +2401,7 @@ mod tests {
         assert find_str(data, ~"ประเ") == Some( 0u);
         assert find_str(data, ~"ะเ")   == Some( 6u);
         assert find_str(data, ~"中华") == Some(27u);
-        assert find_str(data, ~"ไท华") == None;
+        assert find_str(data, ~"ไท华").is_none();
     }
 
     #[test]
@@ -2412,7 +2412,7 @@ mod tests {
         let data = ~"abcabc";
         assert find_str_between(data, ~"ab", 0u, 6u) == Some(0u);
         assert find_str_between(data, ~"ab", 2u, 6u) == Some(3u);
-        assert find_str_between(data, ~"ab", 2u, 4u) == None;
+        assert find_str_between(data, ~"ab", 2u, 4u).is_none();
 
         let mut data = ~"ประเทศไทย中华Việt Nam";
         data += data;

src/libcore/task.rs

@@ -2090,7 +2090,7 @@ fn test_tls_multitask() unsafe {
     fn my_key(+_x: @~str) { }
     local_data_set(my_key, @~"parent data");
     do task::spawn unsafe {
-        assert local_data_get(my_key) == None; // TLS shouldn't carry over.
+        assert local_data_get(my_key).is_none(); // TLS shouldn't carry over.
         local_data_set(my_key, @~"child data");
         assert *(local_data_get(my_key).get()) == ~"child data";
         // should be cleaned up for us
@@ -2115,7 +2115,7 @@ fn test_tls_pop() unsafe {
     local_data_set(my_key, @~"weasel");
     assert *(local_data_pop(my_key).get()) == ~"weasel";
     // Pop must remove the data from the map.
-    assert local_data_pop(my_key) == None;
+    assert local_data_pop(my_key).is_none();
 }
 
 #[test]

src/libcore/uint-template.rs

@@ -259,9 +259,9 @@ fn test_from_str() {
     assert from_str(~"123456789") == Some(123456789u as T);
     assert from_str(~"00100") == Some(100u as T);
 
-    assert from_str(~"") == None;
-    assert from_str(~" ") == None;
-    assert from_str(~"x") == None;
+    assert from_str(~"").is_none();
+    assert from_str(~" ").is_none();
+    assert from_str(~"x").is_none();
 }
 
 #[test]
@@ -275,8 +275,8 @@ fn test_parse_buf() {
     assert parse_buf(to_bytes(~"ffff"), 16u) == Some(65535u as T);
     assert parse_buf(to_bytes(~"z"), 36u) == Some(35u as T);
 
-    assert parse_buf(to_bytes(~"Z"), 10u) == None;
-    assert parse_buf(to_bytes(~"_"), 2u) == None;
+    assert parse_buf(to_bytes(~"Z"), 10u).is_none();
+    assert parse_buf(to_bytes(~"_"), 2u).is_none();
 }
 
 #[test]

src/libcore/vec.rs

@@ -2029,7 +2029,7 @@ mod tests {
     #[test]
     fn test_last() {
         let mut n = last_opt(~[]);
-        assert (n == None);
+        assert (n.is_none());
         n = last_opt(~[1, 2, 3]);
         assert (n == Some(3));
         n = last_opt(~[1, 2, 3, 4, 5]);
@@ -2393,13 +2393,13 @@ mod tests {
 
     #[test]
     fn test_position_elem() {
-        assert position_elem(~[], 1) == None;
+        assert position_elem(~[], 1).is_none();
 
         let v1 = ~[1, 2, 3, 3, 2, 5];
         assert position_elem(v1, 1) == Some(0u);
         assert position_elem(v1, 2) == Some(1u);
         assert position_elem(v1, 5) == Some(5u);
-        assert position_elem(v1, 4) == None;
+        assert position_elem(v1, 4).is_none();
     }
 
     #[test]
@@ -2407,159 +2407,159 @@ mod tests {
         fn less_than_three(&&i: int) -> bool { return i < 3; }
         fn is_eighteen(&&i: int) -> bool { return i == 18; }
 
-        assert position(~[], less_than_three) == None;
+        assert position(~[], less_than_three).is_none();
 
         let v1 = ~[5, 4, 3, 2, 1];
         assert position(v1, less_than_three) == Some(3u);
-        assert position(v1, is_eighteen) == None;
+        assert position(v1, is_eighteen).is_none();
     }
 
     #[test]
     fn test_position_between() {
-        assert position_between(~[], 0u, 0u, f) == None;
+        assert position_between(~[], 0u, 0u, f).is_none();
 
         fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        assert position_between(v, 0u, 0u, f) == None;
-        assert position_between(v, 0u, 1u, f) == None;
+        assert position_between(v, 0u, 0u, f).is_none();
+        assert position_between(v, 0u, 1u, f).is_none();
         assert position_between(v, 0u, 2u, f) == Some(1u);
         assert position_between(v, 0u, 3u, f) == Some(1u);
         assert position_between(v, 0u, 4u, f) == Some(1u);
 
-        assert position_between(v, 1u, 1u, f) == None;
+        assert position_between(v, 1u, 1u, f).is_none();
         assert position_between(v, 1u, 2u, f) == Some(1u);
         assert position_between(v, 1u, 3u, f) == Some(1u);
         assert position_between(v, 1u, 4u, f) == Some(1u);
 
-        assert position_between(v, 2u, 2u, f) == None;
-        assert position_between(v, 2u, 3u, f) == None;
+        assert position_between(v, 2u, 2u, f).is_none();
+        assert position_between(v, 2u, 3u, f).is_none();
         assert position_between(v, 2u, 4u, f) == Some(3u);
 
-        assert position_between(v, 3u, 3u, f) == None;
+        assert position_between(v, 3u, 3u, f).is_none();
         assert position_between(v, 3u, 4u, f) == Some(3u);
 
-        assert position_between(v, 4u, 4u, f) == None;
+        assert position_between(v, 4u, 4u, f).is_none();
     }
 
     #[test]
     fn test_find() {
-        assert find(~[], f) == None;
+        assert find(~[], f).is_none();
 
         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 mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert find(v, f) == Some((1, 'b'));
-        assert find(v, g) == None;
+        assert find(v, g).is_none();
     }
 
     #[test]
     fn test_find_between() {
-        assert find_between(~[], 0u, 0u, f) == None;
+        assert find_between(~[], 0u, 0u, f).is_none();
 
         fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        assert find_between(v, 0u, 0u, f) == None;
-        assert find_between(v, 0u, 1u, f) == None;
+        assert find_between(v, 0u, 0u, f).is_none();
+        assert find_between(v, 0u, 1u, f).is_none();
         assert find_between(v, 0u, 2u, f) == Some((1, 'b'));
         assert find_between(v, 0u, 3u, f) == Some((1, 'b'));
         assert find_between(v, 0u, 4u, f) == Some((1, 'b'));
 
-        assert find_between(v, 1u, 1u, f) == None;
+        assert find_between(v, 1u, 1u, f).is_none();
         assert find_between(v, 1u, 2u, f) == Some((1, 'b'));
         assert find_between(v, 1u, 3u, f) == Some((1, 'b'));
         assert find_between(v, 1u, 4u, f) == Some((1, 'b'));
 
-        assert find_between(v, 2u, 2u, f) == None;
-        assert find_between(v, 2u, 3u, f) == None;
+        assert find_between(v, 2u, 2u, f).is_none();
+        assert find_between(v, 2u, 3u, f).is_none();
         assert find_between(v, 2u, 4u, f) == Some((3, 'b'));
 
-        assert find_between(v, 3u, 3u, f) == None;
+        assert find_between(v, 3u, 3u, f).is_none();
         assert find_between(v, 3u, 4u, f) == Some((3, 'b'));
 
-        assert find_between(v, 4u, 4u, f) == None;
+        assert find_between(v, 4u, 4u, f).is_none();
     }
 
     #[test]
     fn test_rposition() {
-        assert find(~[], f) == None;
+        assert find(~[], f).is_none();
 
         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 mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert position(v, f) == Some(1u);
-        assert position(v, g) == None;
+        assert position(v, g).is_none();
     }
 
     #[test]
     fn test_rposition_between() {
-        assert rposition_between(~[], 0u, 0u, f) == None;
+        assert rposition_between(~[], 0u, 0u, f).is_none();
 
         fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        assert rposition_between(v, 0u, 0u, f) == None;
-        assert rposition_between(v, 0u, 1u, f) == None;
+        assert rposition_between(v, 0u, 0u, f).is_none();
+        assert rposition_between(v, 0u, 1u, f).is_none();
         assert rposition_between(v, 0u, 2u, f) == Some(1u);
         assert rposition_between(v, 0u, 3u, f) == Some(1u);
         assert rposition_between(v, 0u, 4u, f) == Some(3u);
 
-        assert rposition_between(v, 1u, 1u, f) == None;
+        assert rposition_between(v, 1u, 1u, f).is_none();
         assert rposition_between(v, 1u, 2u, f) == Some(1u);
         assert rposition_between(v, 1u, 3u, f) == Some(1u);
         assert rposition_between(v, 1u, 4u, f) == Some(3u);
 
-        assert rposition_between(v, 2u, 2u, f) == None;
-        assert rposition_between(v, 2u, 3u, f) == None;
+        assert rposition_between(v, 2u, 2u, f).is_none();
+        assert rposition_between(v, 2u, 3u, f).is_none();
         assert rposition_between(v, 2u, 4u, f) == Some(3u);
 
-        assert rposition_between(v, 3u, 3u, f) == None;
+        assert rposition_between(v, 3u, 3u, f).is_none();
         assert rposition_between(v, 3u, 4u, f) == Some(3u);
 
-        assert rposition_between(v, 4u, 4u, f) == None;
+        assert rposition_between(v, 4u, 4u, f).is_none();
     }
 
     #[test]
     fn test_rfind() {
-        assert rfind(~[], f) == None;
+        assert rfind(~[], f).is_none();
 
         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 mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
         assert rfind(v, f) == Some((3, 'b'));
-        assert rfind(v, g) == None;
+        assert rfind(v, g).is_none();
     }
 
     #[test]
     fn test_rfind_between() {
-        assert rfind_between(~[], 0u, 0u, f) == None;
+        assert rfind_between(~[], 0u, 0u, f).is_none();
 
         fn f(xy: (int, char)) -> bool { let (_x, y) = xy; y == 'b' }
         let mut v = ~[(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
-        assert rfind_between(v, 0u, 0u, f) == None;
-        assert rfind_between(v, 0u, 1u, f) == None;
+        assert rfind_between(v, 0u, 0u, f).is_none();
+        assert rfind_between(v, 0u, 1u, f).is_none();
         assert rfind_between(v, 0u, 2u, f) == Some((1, 'b'));
         assert rfind_between(v, 0u, 3u, f) == Some((1, 'b'));
         assert rfind_between(v, 0u, 4u, f) == Some((3, 'b'));
 
-        assert rfind_between(v, 1u, 1u, f) == None;
+        assert rfind_between(v, 1u, 1u, f).is_none();
         assert rfind_between(v, 1u, 2u, f) == Some((1, 'b'));
         assert rfind_between(v, 1u, 3u, f) == Some((1, 'b'));
         assert rfind_between(v, 1u, 4u, f) == Some((3, 'b'));
 
-        assert rfind_between(v, 2u, 2u, f) == None;
-        assert rfind_between(v, 2u, 3u, f) == None;
+        assert rfind_between(v, 2u, 2u, f).is_none();
+        assert rfind_between(v, 2u, 3u, f).is_none();
         assert rfind_between(v, 2u, 4u, f) == Some((3, 'b'));
 
-        assert rfind_between(v, 3u, 3u, f) == None;
+        assert rfind_between(v, 3u, 3u, f).is_none();
         assert rfind_between(v, 3u, 4u, f) == Some((3, 'b'));
 
-        assert rfind_between(v, 4u, 4u, f) == None;
+        assert rfind_between(v, 4u, 4u, f).is_none();
     }
 
     #[test]