Start paring down std::str. Issue #855

Author: brson

src/lib/dbg.rs

@@ -49,6 +49,12 @@ fn debug_fn<T>(x: &T) { rustrt::debug_fn::<T>(x); }
 fn ptr_cast<T, U>(x: @T) -> @U { ret rustrt::debug_ptrcast::<T, U>(x); }
 
 fn trap(s: str) { rustrt::debug_trap(s); }
+
+fn refcount<T>(a: &@T) -> uint {
+    let p: *uint = unsafe::reinterpret_cast(a);
+    ret *p;
+}
+
 // Local Variables:
 // mode: rust;
 // fill-column: 78;

src/lib/io.rs

@@ -87,7 +87,7 @@ obj new_reader(rdr: buf_reader) {
 
         }
         let b0 = c0 as u8;
-        let w = str::utf8_char_width(b0);
+        let w = istr::utf8_char_width(b0);
         assert (w > 0u);
         if w == 1u { ret b0 as char; }
         let val = 0u;

src/lib/istr.rs

@@ -4,7 +4,7 @@ concat, connect, to_upper, replace, char_slice, trim_left, trim_right, trim,
 unshift_char, shift_char, pop_char, push_char, is_utf8, from_chars, to_chars,
 char_len, char_at, bytes, is_ascii, shift_byte, pop_byte, unsafe_from_byte,
 unsafe_from_bytes, from_char, char_range_at, str_from_cstr, sbuf,
-as_buf, push_byte;
+as_buf, push_byte, utf8_char_width, safe_slice;
 
 export from_estr, to_estr, from_estrs, to_estrs;
 

src/lib/str.rs

@@ -2,57 +2,57 @@
 import rustrt::sbuf;
 import uint::le;
 export sbuf;
-export rustrt;
+// export rustrt;
 export eq;
 export lteq;
-export hash;
-export is_utf8;
-export is_ascii;
-export alloc;
+// export hash;
+// export is_utf8;
+// export is_ascii;
+// export alloc;
 export byte_len;
 export buf;
-export bytes;
-export unsafe_from_byte;
-export str_from_cstr;
-export str_from_buf;
-export push_utf8_bytes;
+// export bytes;
+// export unsafe_from_byte;
+// export str_from_cstr;
+// export str_from_buf;
+// export push_utf8_bytes;
 export from_char;
-export from_chars;
-export utf8_char_width;
-export char_range_at;
+// export from_chars;
+// export utf8_char_width;
+// export char_range_at;
 export char_at;
 export char_len;
-export to_chars;
-export push_char;
-export pop_char;
-export shift_char;
-export unshift_char;
-export refcount;
-export index;
-export rindex;
+// export to_chars;
+// export push_char;
+// export pop_char;
+// export shift_char;
+// export unshift_char;
+// export refcount;
+// export index;
+// export rindex;
 export find;
-export starts_with;
-export ends_with;
+// export starts_with;
+// export ends_with;
 export substr;
-export slice;
-export shift_byte;
-export pop_byte;
-export push_byte;
-export unshift_byte;
-export split;
-export concat;
-export connect;
+// export slice;
+// export shift_byte;
+// export pop_byte;
+// export push_byte;
+// export unshift_byte;
+// export split;
+// export concat;
+// export connect;
 export to_upper;
-export safe_slice;
+// export safe_slice;
 export unsafe_from_bytes;
-export is_empty;
-export is_not_empty;
-export is_whitespace;
-export replace;
-export char_slice;
-export trim_left;
-export trim_right;
-export trim;
+// export is_empty;
+// export is_not_empty;
+// export is_whitespace;
+// export replace;
+// export char_slice;
+// export trim_left;
+// export trim_right;
+// export trim;
 
 native "rust" mod rustrt {
     type sbuf;
@@ -339,7 +339,7 @@ fn index(s: str, c: u8) -> int {
 }
 
 fn rindex(s: str, c: u8) -> int {
-    let n: int = str::byte_len(s) as int;
+    let n: int = byte_len(s) as int;
     while n >= 0 { if s[n] == c { ret n; } n -= 1; }
     ret n;
 }
@@ -390,15 +390,14 @@ fn slice(s: str, begin: uint, end: uint) -> str {
     // FIXME: Typestate precondition
 
     assert (begin <= end);
-    assert (end <= str::byte_len(s));
+    assert (end <= byte_len(s));
     ret rustrt::str_slice(s, begin, end);
 }
 
 fn safe_slice(s: str, begin: uint, end: uint) : le(begin, end) -> str {
-    assert (end <=
-                str::byte_len(s)); // would need some magic to
-                                   // make this a precondition
-
+    // would need some magic to
+    // make this a precondition
+    assert (end <= byte_len(s));
 
     ret rustrt::str_slice(s, begin, end);
 }
@@ -441,7 +440,7 @@ fn split(s: str, sep: u8) -> [str] {
             ends_with_sep = true;
         } else { accum += unsafe_from_byte(c); ends_with_sep = false; }
     }
-    if str::byte_len(accum) != 0u || ends_with_sep { v += [accum]; }
+    if byte_len(accum) != 0u || ends_with_sep { v += [accum]; }
     ret v;
 }
 

src/test/compile-fail/fn-constraint.rs

@@ -1,9 +1,9 @@
-// error-pattern: Unsatisfied precondition constraint (for example, le(a, b)
+// error-pattern:precondition constraint (for example, uint::le(a, b)
 use std;
-import std::str::*;
+import std::istr::*;
 
 fn main() {
     let a: uint = 4u;
     let b: uint = 1u;
-    log_err safe_slice("kitties", a, b);
+    log_err safe_slice(~"kitties", a, b);
 }

src/test/compile-fail/no-constraint-prop.rs

@@ -1,6 +1,6 @@
 // error-pattern:Unsatisfied precondition constraint (for example, le(b, d
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::*;
 
 fn main() {
@@ -16,5 +16,5 @@ fn main() {
     // the next statement, since it's not true in the
     // prestate.
     let d <- a;
-    log safe_slice("kitties", b, d);
+    log safe_slice(~"kitties", b, d);
 }

src/test/run-fail/fn-constraint.rs

@@ -1,11 +1,11 @@
 // error-pattern:Predicate le(a, b) failed
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::le;
 
 fn main() {
     let a: uint = 4u;
     let b: uint = 1u;
     check (le(a, b));
-    log_err safe_slice("kitties", a, b);
+    log_err safe_slice(~"kitties", a, b);
 }

src/test/run-pass/alt-pattern-drop.rs

@@ -2,16 +2,17 @@
 
 // -*- rust -*-
 use std;
-import std::str;
 
+import std::dbg;
 
 // FIXME: import std::dbg.const_refcount. Currently
 // cross-crate const references don't work.
 const const_refcount: uint = 0x7bad_face_u;
 
-tag t { make_t(str); clam; }
+tag t { make_t(@int); clam; }
 
-fn foo(s: str) {
+fn foo(s: @int) {
+    let count = dbg::refcount(s);
     let x: t = make_t(s); // ref up
 
     alt x {
@@ -21,15 +22,15 @@ fn foo(s: str) {
       }
       _ { log "?"; fail; }
     }
-    log str::refcount(s);
-    assert (str::refcount(s) == const_refcount);
+    log dbg::refcount(s);
+    assert (dbg::refcount(s) == count + 1u);
 }
 
 fn main() {
-    let s: str = "hi"; // ref up
+    let s: @int = @0; // ref up
 
     foo(s); // ref up then down
 
-    log str::refcount(s);
-    assert (str::refcount(s) == const_refcount);
+    log dbg::refcount(s);
+    assert (dbg::refcount(s) == 1u);
 }

src/test/run-pass/constraint-prop-expr-move.rs

@@ -1,5 +1,5 @@
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::*;
 
 fn main() {
@@ -8,5 +8,5 @@ fn main() {
     let c: uint = 17u;
     check (le(a, b));
     c <- a;
-    log safe_slice("kitties", c, b);
+    log safe_slice(~"kitties", c, b);
 }

src/test/run-pass/constraint-prop-move.rs

@@ -1,11 +1,11 @@
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::*;
 
 fn main() {
     let a: uint = 1u;
     let b: uint = 4u;
     check (le(a, b));
     let c <- a;
-    log safe_slice("kitties", c, b);
+    log safe_slice(~"kitties", c, b);
 }

src/test/run-pass/constraint-prop-swap.rs

@@ -1,11 +1,11 @@
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::*;
 
 fn main() {
     let a: uint = 4u;
     let b: uint = 1u;
     check (le(b, a));
     b <-> a;
-    log safe_slice("kitties", a, b);
+    log safe_slice(~"kitties", a, b);
 }

src/test/run-pass/constraint-prop.rs

@@ -1,11 +1,11 @@
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::*;
 
 fn main() {
     let a: uint = 1u;
     let b: uint = 4u;
     check (le(a, b));
     let c = b;
-    log safe_slice("kitties", a, c);
+    log safe_slice(~"kitties", a, c);
 }

src/test/run-pass/fn-constraint.rs

@@ -1,10 +1,10 @@
 use std;
-import std::str::*;
+import std::istr::*;
 import std::uint::*;
 
 fn main() {
     let a: uint = 1u;
     let b: uint = 4u;
     check (le(a, b));
-    log safe_slice("kitties", a, b);
+    log safe_slice(~"kitties", a, b);
 }

src/test/run-pass/hashmap-memory.rs

@@ -9,7 +9,6 @@ use std;
 import option = std::option::t;
 import std::option::some;
 import std::option::none;
-import std::str;
 import std::istr;
 import std::vec;
 import std::map;
@@ -20,40 +19,42 @@ import std::comm::send;
 import std::comm::recv;
 import std::comm;
 
-fn map(filename: str, emit: map_reduce::putter) { emit(filename, "1"); }
+fn map(filename: &istr, emit: map_reduce::putter) { emit(filename, ~"1"); }
 
 mod map_reduce {
     export putter;
     export mapper;
     export map_reduce;
 
-    type putter = fn(str, str);
+    type putter = fn(&istr, &istr);
 
-    type mapper = fn(str, putter);
+    type mapper = fn(&istr, putter);
 
     tag ctrl_proto { find_reducer([u8], chan<int>); mapper_done; }
 
-    fn start_mappers(ctrl: chan<ctrl_proto>, inputs: &[str]) {
-        for i: str in inputs { task::spawn(bind map_task(ctrl, i)); }
+    fn start_mappers(ctrl: chan<ctrl_proto>, inputs: &[istr]) {
+        for i: istr in inputs {
+            task::spawn(bind map_task(ctrl, i));
+        }
     }
 
-    fn map_task(ctrl: chan<ctrl_proto>, input: str) {
+    fn map_task(ctrl: chan<ctrl_proto>, input: -istr) {
 
         let intermediates = map::new_str_hash();
 
         fn emit(im: &map::hashmap<istr, int>, ctrl: chan<ctrl_proto>,
-                key: str, val: str) {
+                key: &istr, val: &istr) {
             let c;
-            alt im.find(istr::from_estr(key)) {
+            alt im.find(key) {
               some(_c) { c = _c }
               none. {
                 let p = port();
                 log_err "sending find_reducer";
-                send(ctrl, find_reducer(str::bytes(key), chan(p)));
+                send(ctrl, find_reducer(istr::bytes(key), chan(p)));
                 log_err "receiving";
                 c = recv(p);
                 log_err c;
-                im.insert(istr::from_estr(key), c);
+                im.insert(key, c);
               }
             }
         }
@@ -62,7 +63,7 @@ mod map_reduce {
         send(ctrl, mapper_done);
     }
 
-    fn map_reduce(inputs: &[str]) {
+    fn map_reduce(inputs: &[istr]) {
         let ctrl = port();
 
         // This task becomes the master control task. It spawns others
@@ -93,5 +94,5 @@ mod map_reduce {
 }
 
 fn main() {
-    map_reduce::map_reduce(["../src/test/run-pass/hashmap-memory.rs"]);
+    map_reduce::map_reduce([~"../src/test/run-pass/hashmap-memory.rs"]);
 }