about summary refs log tree commit diff
path: root/src/lib
diff options
context:
space:
mode:
Diffstat (limited to 'src/lib')
-rw-r--r--src/lib/_int.rs12
-rw-r--r--src/lib/_io.rs10
-rw-r--r--src/lib/_u8.rs2
-rw-r--r--src/lib/_vec.rs10
-rw-r--r--src/lib/deque.rs44
-rw-r--r--src/lib/map.rs30
6 files changed, 54 insertions, 54 deletions
diff --git a/src/lib/_int.rs b/src/lib/_int.rs
index b6399669c43..29144a821a4 100644
--- a/src/lib/_int.rs
+++ b/src/lib/_int.rs
@@ -23,19 +23,19 @@ iter range(mutable int lo, int hi) -> int {
 iter urange(mutable uint lo, uint hi) -> uint {
   while (lo < hi) {
     put lo;
-    lo += uint(1);
+    lo += 1u;
   }
 }
 
 fn next_power_of_two(uint n) -> uint {
   // FIXME change |* uint(4)| below to |* uint(8) / uint(2)| and watch the
   // world explode.
-  let uint halfbits = sys.rustrt.size_of[uint]() * uint(4);
-  let uint tmp = n - uint(1);
-  let uint shift = uint(1);
+  let uint halfbits = sys.rustrt.size_of[uint]() * 4u;
+  let uint tmp = n - 1u;
+  let uint shift = 1u;
   while (shift <= halfbits) {
     tmp |= tmp >> shift;
-    shift <<= uint(1);
+    shift <<= 1u;
   }
-  ret tmp + uint(1);
+  ret tmp + 1u;
 }
diff --git a/src/lib/_io.rs b/src/lib/_io.rs
index e171e617b94..94021aa650a 100644
--- a/src/lib/_io.rs
+++ b/src/lib/_io.rs
@@ -3,15 +3,15 @@ type buf_reader = unsafe obj {
 };
 
 fn default_bufsz() -> uint {
-  ret uint(4096);
+  ret 4096u;
 }
 
 fn new_buf() -> vec[u8] {
   let vec[u8] v = vec();
   let uint i = default_bufsz();
-  while (i > uint(0)) {
-    i -= uint(1);
-    v += vec(u8(0));
+  while (i > 0u) {
+    i -= 1u;
+    v += vec(0u8);
   }
   // FIXME (issue #93): should be:
   // ret _vec.alloc[u8](default_bufsz());
@@ -25,7 +25,7 @@ fn new_buf_reader(str s) -> buf_reader {
     fn read() -> vec[u8] {
 
       // Ensure our buf is singly-referenced.
-      if (_vec.rustrt.refcount[u8](buf) != uint(1)) {
+      if (_vec.rustrt.refcount[u8](buf) != 1u) {
         buf = new_buf();
       }
 
diff --git a/src/lib/_u8.rs b/src/lib/_u8.rs
index e1f671e752a..7749e30e467 100644
--- a/src/lib/_u8.rs
+++ b/src/lib/_u8.rs
@@ -14,7 +14,7 @@ fn gt(u8 x, u8 y) -> bool { ret x > y; }
 iter range(mutable u8 lo, u8 hi) -> u8 {
   while (lo < hi) {
     put lo;
-    lo += u8(1);
+    lo += 1u8;
   }
 }
 
diff --git a/src/lib/_vec.rs b/src/lib/_vec.rs
index 849e750a4ca..0008295f35f 100644
--- a/src/lib/_vec.rs
+++ b/src/lib/_vec.rs
@@ -21,8 +21,8 @@ type init_op[T] = fn(uint i) -> T;
 fn init_fn[T](&init_op[T] op, uint n_elts) -> vec[T] {
   let vec[T] v = alloc[T](n_elts);
   let uint i = n_elts;
-  while (i > uint(0)) {
-    i -= uint(1);
+  while (i > 0u) {
+    i -= 1u;
     v += vec(op(i));
   }
   ret v;
@@ -38,8 +38,8 @@ fn init_elt[T](&T t, uint n_elts) -> vec[T] {
    */
   let vec[T] v = alloc[T](n_elts);
   let uint i = n_elts;
-  while (i > uint(0)) {
-    i -= uint(1);
+  while (i > 0u) {
+    i -= 1u;
     v += vec(t);
   }
   ret v;
@@ -59,7 +59,7 @@ fn slice[T](vec[T] v, int start, int end) -> vec[T] {
   check(start <= end);
   // FIXME #108: This doesn't work yet.
   //check(end <= int(len[T](v)));
-  auto result = alloc[T](uint(end - start));
+  auto result = alloc[T]((end - start) as uint);
   let mutable int i = start;
   while (i < end) {
     result += vec(v.(i));
diff --git a/src/lib/deque.rs b/src/lib/deque.rs
index b41c051f5fc..699b3f0da08 100644
--- a/src/lib/deque.rs
+++ b/src/lib/deque.rs
@@ -23,7 +23,7 @@ fn create[T]() -> t[T] {
 
   type cell[T] = mutable util.option[T];
 
-  let uint initial_capacity = uint(32); // 2^5
+  let uint initial_capacity = 32u; // 2^5
 
   /**
    * Grow is only called on full elts, so nelts is also len(elts), unlike
@@ -34,13 +34,13 @@ fn create[T]() -> t[T] {
 
     fn fill[T](uint i, uint nelts, uint lo, &vec[cell[T]] old) -> cell[T] {
       if (i < nelts) {
-        ret old.(int((lo + i) % nelts));
+        ret old.(((lo + i) % nelts) as int);
       } else {
         ret util.none[T]();
       }
     }
 
-    let uint nalloc = _int.next_power_of_two(nelts + uint(1));
+    let uint nalloc = _int.next_power_of_two(nelts + 1u);
     let _vec.init_op[cell[T]] copy_op = bind fill[T](_, nelts, lo, elts);
     ret _vec.init_fn[cell[T]](copy_op, nalloc);
   }
@@ -52,7 +52,7 @@ fn create[T]() -> t[T] {
    */
 
   fn get[T](&vec[cell[T]] elts, uint i) -> T {
-    alt (elts.(int(i))) {
+    alt (elts.(i as int)) {
       case (util.some[T](t)) { ret t; }
       case (_) { fail; }
     }
@@ -68,33 +68,33 @@ fn create[T]() -> t[T] {
     fn add_front(&T t) {
       let uint oldlo = lo;
 
-      if (lo == uint(0)) {
-        lo = _vec.len[cell[T]](elts) - uint(1);
+      if (lo == 0u) {
+        lo = _vec.len[cell[T]](elts) - 1u;
       } else {
-        lo -= uint(1);
+        lo -= 1u;
       }
 
       if (lo == hi) {
         elts = grow[T](nelts, oldlo, elts);
-        lo = _vec.len[cell[T]](elts) - uint(1);
-        hi = nelts - uint(1);
+        lo = _vec.len[cell[T]](elts) - 1u;
+        hi = nelts - 1u;
       }
 
-      elts.(int(lo)) = util.some[T](t);
-      nelts += uint(1);
+      elts.(lo as int) = util.some[T](t);
+      nelts += 1u;
     }
 
     fn add_back(&T t) {
-      hi = (hi + uint(1)) % _vec.len[cell[T]](elts);
+      hi = (hi + 1u) % _vec.len[cell[T]](elts);
 
       if (lo == hi) {
         elts = grow[T](nelts, lo, elts);
-        lo = uint(0);
+        lo = 0u;
         hi = nelts;
       }
 
-      elts.(int(hi)) = util.some[T](t);
-      nelts += uint(1);
+      elts.(hi as int) = util.some[T](t);
+      nelts += 1u;
     }
 
     /**
@@ -103,19 +103,19 @@ fn create[T]() -> t[T] {
      */
     fn pop_front() -> T {
       let T t = get[T](elts, lo);
-      elts.(int(lo)) = util.none[T]();
-      lo = (lo + uint(1)) % _vec.len[cell[T]](elts);
+      elts.(lo as int) = util.none[T]();
+      lo = (lo + 1u) % _vec.len[cell[T]](elts);
       ret t;
     }
 
     fn pop_back() -> T {
       let T t = get[T](elts, hi);
-      elts.(int(hi)) = util.none[T]();
+      elts.(hi as int) = util.none[T]();
 
-      if (hi == uint(0)) {
-        hi = _vec.len[cell[T]](elts) - uint(1);
+      if (hi == 0u) {
+        hi = _vec.len[cell[T]](elts) - 1u;
       } else {
-        hi -= uint(1);
+        hi -= 1u;
       }
 
       ret t;
@@ -133,5 +133,5 @@ fn create[T]() -> t[T] {
   let vec[cell[T]] v = _vec.init_elt[cell[T]](util.none[T](),
                                               initial_capacity);
 
-  ret deque[T](uint(0), uint(0), uint(0), v);
+  ret deque[T](0u, 0u, 0u, v);
 }
diff --git a/src/lib/map.rs b/src/lib/map.rs
index 06139bb7c9b..540dfd00c35 100644
--- a/src/lib/map.rs
+++ b/src/lib/map.rs
@@ -23,7 +23,7 @@ type hashmap[K, V] = obj {
 
 fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
 
-  let uint initial_capacity = uint(32); // 2^5
+  let uint initial_capacity = 32u; // 2^5
   let util.rational load_factor = rec(num=3, den=4);
 
   type bucket[V] = tag(nil(), deleted(), some(V));
@@ -43,13 +43,13 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   // fixed key.
 
   fn hashl[K](hashfn[K] hasher, uint nbkts, &K key) -> uint {
-    ret (hasher(key) >>> (sys.rustrt.size_of[uint]() * uint(8) / uint(2)))
+    ret (hasher(key) >>> (sys.rustrt.size_of[uint]() * 8u / 2u))
       % nbkts;
   }
 
   fn hashr[K](hashfn[K] hasher, uint nbkts, &K key) -> uint {
-    ret ((((~ uint(0)) >>> (sys.rustrt.size_of[uint]() * uint(8) / uint(2)))
-          & hasher(key)) * uint(2) + uint(1))
+    ret ((((~ 0u) >>> (sys.rustrt.size_of[uint]() * 8u / 2u))
+          & hasher(key)) * 2u + 1u)
       % nbkts;
   }
 
@@ -63,10 +63,10 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
                        &K key)
     -> util.option[V]
   {
-    let uint i = uint(0);
+    let uint i = 0u;
     while (i < nbkts) {
       // Pending fix to issue #94, remove uint coercion.
-      let int j = int(hash[K](hasher, nbkts, key, i));
+      let int j = (hash[K](hasher, nbkts, key, i)) as int;
       alt (bkts.(j)) {
         case (some[V](val)) {
           ret util.some[V](val);
@@ -75,7 +75,7 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
           ret util.none[V]();
         }
         case (deleted[V]()) {
-          i += uint(1);
+          i += 1u;
         }
       }
     }
@@ -91,17 +91,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   {
     fn insert(&K key, &V val) {
       // FIXME grow the table and rehash if we ought to.
-      let uint i = uint(0);
+      let uint i = 0u;
       while (i < nbkts) {
         // Issue #94, as in find_common()
-        let int j = int(hash[K](hasher, nbkts, key, i));
+        let int j = (hash[K](hasher, nbkts, key, i)) as int;
         alt (bkts.(j)) {
           case (some[V](_)) {
-            i += uint(1);
+            i += 1u;
           }
           case (_) {
             bkts.(j) = some[V](val);
-            nelts += uint(1);
+            nelts += 1u;
             ret;
           }
         }
@@ -129,17 +129,17 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
     }
 
     fn remove(&K key) -> util.option[V] {
-      let uint i = uint(0);
+      let uint i = 0u;
       while (i < nbkts) {
         // Issue #94, as in find_common()
-        let int j = int(hash[K](hasher, nbkts, key, i));
+        let int j = (hash[K](hasher, nbkts, key, i)) as int;
         alt (bkts.(j)) {
           case (some[V](val)) {
             bkts.(j) = deleted[V]();
             ret util.some[V](val);
           }
           case (deleted[V]()) {
-            nelts += uint(1);
+            nelts += 1u;
           }
           case (nil[V]()) {
             ret util.none[V]();
@@ -155,5 +155,5 @@ fn mk_hashmap[K, V](&hashfn[K] hasher, &eqfn[K] eqer) -> hashmap[K, V] {
   let vec[mutable bucket[V]] bkts =
     _vec.init_elt[mutable bucket[V]](nil[V](), initial_capacity);
 
-  ret hashmap[K, V](hasher, eqer, bkts, uint(0), uint(0), load_factor);
+  ret hashmap[K, V](hasher, eqer, bkts, 0u, 0u, load_factor);
 }
generated by cgit-pink 1.4.1-3-g733a5 (git 2.37.1) at 2026-09-20 22:35:40 +0000