core: Factor out uint/u8/16/32/64 mods into uint-template

Author: brson

src/libcore/core.rc

@@ -81,18 +81,61 @@ mod i64 {
     mod inst;
 }
 
+#[doc = "Operations and constants for `uint`"]
+#[path = "uint-template"]
+mod uint {
+    import inst::{
+        div_ceil, div_round, div_floor, hash, iterate,
+        next_power_of_two, parse_buf, from_str, to_str, str
+    };
+    export div_ceil, div_round, div_floor, hash, iterate,
+    next_power_of_two, parse_buf, from_str, to_str, str;
+
+    #[path = "uint.rs"]
+    mod inst;
+}
+
+#[doc = "Operations and constants for `u8`"]
+#[path = "uint-template"]
+mod u8 {
+    import inst::is_ascii;
+    export is_ascii;
+
+    #[path = "u8.rs"]
+    mod inst;
+}
+
+#[doc = "Operations and constants for `u16`"]
+#[path = "uint-template"]
+mod u16 {
+    #[path = "u16.rs"]
+    mod inst;
+}
+
+#[doc = "Operations and constants for `u32`"]
+#[path = "uint-template"]
+mod u32 {
+    #[path = "u32.rs"]
+    mod inst;
+}
+
+#[doc = "Operations and constants for `u64`"]
+#[path = "uint-template"]
+mod u64 {
+    import inst::{ to_str, str, from_str };
+    export to_str, str, from_str;
+
+    #[path = "u64.rs"]
+    mod inst;
+}
+
 mod box;
 mod char;
 mod float;
 mod f32;
 mod f64;
 mod str;
 mod ptr;
-mod uint;
-mod u8;
-mod u16;
-mod u32;
-mod u64;
 mod vec;
 mod bool;
 

src/libcore/u16.rs

@@ -0,0 +1,45 @@
+import T = inst::T;
+
+export min_value, max_value;
+export min, max;
+export add, sub, mul, div, rem;
+export lt, le, eq, ne, ge, gt;
+export is_positive, is_negative;
+export is_nonpositive, is_nonnegative;
+export range;
+export compl;
+
+const min_value: T = 0 as T;
+const max_value: T = 0 as T - 1 as T;
+
+pure fn min(x: T, y: T) -> T { if x < y { x } else { y } }
+pure fn max(x: T, y: T) -> T { if x > y { x } else { y } }
+
+pure fn add(x: T, y: T) -> T { x + y }
+pure fn sub(x: T, y: T) -> T { x - y }
+pure fn mul(x: T, y: T) -> T { x * y }
+pure fn div(x: T, y: T) -> T { x / y }
+pure fn rem(x: T, y: T) -> T { x % y }
+
+pure fn lt(x: T, y: T) -> bool { x < y }
+pure fn le(x: T, y: T) -> bool { x <= y }
+pure fn eq(x: T, y: T) -> bool { x == y }
+pure fn ne(x: T, y: T) -> bool { x != y }
+pure fn ge(x: T, y: T) -> bool { x >= y }
+pure fn gt(x: T, y: T) -> bool { x > y }
+
+pure fn is_positive(x: T) -> bool { x > 0 as T }
+pure fn is_negative(x: T) -> bool { x < 0 as T }
+pure fn is_nonpositive(x: T) -> bool { x <= 0 as T }
+pure fn is_nonnegative(x: T) -> bool { x >= 0 as T }
+
+#[doc = "Iterate over the range [`lo`..`hi`)"]
+fn range(lo: T, hi: T, it: fn(T)) {
+    let mut i = lo;
+    while i < hi { it(i); i += 1 as T; }
+}
+
+#[doc = "Computes the bitwise complement"]
+pure fn compl(i: T) -> T {
+    max_value ^ i
+}

src/libcore/u32.rs

@@ -0,0 +1 @@
+type T = u16;

src/libcore/u8.rs

@@ -0,0 +1 @@
+type T = u32;

src/libcore/uint-template.rs

@@ -1,30 +1,10 @@
-#[doc = "Operations and constants for `u64`"];
+type T = u64;
 
-const min_value: u64 = 0u64;
-const max_value: u64 = 0u64 - 1u64;
+// Type-specific functions here. These must be reexported by the
+// parent module so that they appear in core::u8 and not core::u8::u8;
 
-pure fn min(x: u64, y: u64) -> u64 { if x < y { x } else { y } }
-pure fn max(x: u64, y: u64) -> u64 { if x > y { x } else { y } }
-
-pure fn add(x: u64, y: u64) -> u64 { ret x + y; }
-pure fn sub(x: u64, y: u64) -> u64 { ret x - y; }
-pure fn mul(x: u64, y: u64) -> u64 { ret x * y; }
-pure fn div(x: u64, y: u64) -> u64 { ret x / y; }
-pure fn rem(x: u64, y: u64) -> u64 { ret x % y; }
-
-pure fn lt(x: u64, y: u64) -> bool { ret x < y; }
-pure fn le(x: u64, y: u64) -> bool { ret x <= y; }
-pure fn eq(x: u64, y: u64) -> bool { ret x == y; }
-pure fn ne(x: u64, y: u64) -> bool { ret x != y; }
-pure fn ge(x: u64, y: u64) -> bool { ret x >= y; }
-pure fn gt(x: u64, y: u64) -> bool { ret x > y; }
-
-#[doc = "Iterate over the range [`lo`..`hi`)"]
-fn range(lo: u64, hi: u64, it: fn(u64)) {
-    let mut i = lo;
-    while i < hi { it(i); i += 1u64; }
-}
 
+// FIXME: Surely we can generalize this to apply to all uint types
 #[doc = "Convert to a string in a given base"]
 fn to_str(n: u64, radix: uint) -> str {
     assert (0u < radix && radix <= 16u);
@@ -80,8 +60,3 @@ fn from_str(buf: str, radix: u64) -> option<u64> {
         i -= 1u;
     };
 }
-
-#[doc = "Computes the bitwise complement"]
-pure fn compl(i: u64) -> u64 {
-    max_value ^ i
-}

src/libcore/uint-template/u16.rs

@@ -0,0 +1,6 @@
+type T = u8;
+
+// Type-specific functions here. These must be reexported by the
+// parent module so that they appear in core::u8 and not core::u8::u8;
+
+pure fn is_ascii(x: T) -> bool { ret 0 as T == x & 128 as T; }