Rename str::bytes to str::to_bytes

Closes #3245

doc/tutorial.md

@@ -2713,7 +2713,7 @@ fn as_hex(data: ~[u8]) -> ~str {
 }
 
 fn sha1(data: ~str) -> ~str unsafe {
- let bytes = str::bytes(data);
+ let bytes = str::to_bytes(data);
  let hash = crypto::SHA1(vec::unsafe::to_ptr(bytes),
  vec::len(bytes) as c_uint, ptr::null());
  return as_hex(vec::unsafe::from_buf(hash, 20u));
@@ -2813,7 +2813,7 @@ The `sha1` function is the most obscure part of the program.
 # fn as_hex(data: ~[u8]) -> ~str { ~"hi" }
 fn sha1(data: ~str) -> ~str {
  unsafe {
- let bytes = str::bytes(data);
+ let bytes = str::to_bytes(data);
  let hash = crypto::SHA1(vec::unsafe::to_ptr(bytes),
  vec::len(bytes), ptr::null());
  return as_hex(vec::unsafe::from_buf(hash, 20u));
@@ -2856,16 +2856,16 @@ Let's look at our `sha1` function again.
 # fn as_hex(data: ~[u8]) -> ~str { ~"hi" }
 # fn x(data: ~str) -> ~str {
 # unsafe {
-let bytes = str::bytes(data);
+let bytes = str::to_bytes(data);
 let hash = crypto::SHA1(vec::unsafe::to_ptr(bytes),
  vec::len(bytes), ptr::null());
 return as_hex(vec::unsafe::from_buf(hash, 20u));
 # }
 # }
 ~~~~
 
-The `str::bytes` function is perfectly safe, it converts a string to
-an `[u8]`. This byte array is then fed to `vec::unsafe::to_ptr`, which
+The `str::to_bytes` function is perfectly safe: it converts a string to
+a `[u8]`. This byte array is then fed to `vec::unsafe::to_ptr`, which
 returns an unsafe pointer to its contents.
 
 This pointer will become invalid as soon as the vector it points into

src/libcore/int-template.rs

@@ -156,7 +156,7 @@ fn parse_buf(buf: ~[u8], radix: uint) -> option<T> {
 }
 
 /// Parse a string to an int
-fn from_str(s: ~str) -> option<T> { parse_buf(str::bytes(s), 10u) }
+fn from_str(s: ~str) -> option<T> { parse_buf(str::to_bytes(s), 10u) }
 
 /// Convert to a string in a given base
 fn to_str(n: T, radix: uint) -> ~str {
@@ -202,27 +202,27 @@ fn test_from_str() {
 #[test]
 #[ignore]
 fn test_parse_buf() {
- import str::bytes;
- assert parse_buf(bytes(~"123"), 10u) == some(123 as T);
- assert parse_buf(bytes(~"1001"), 2u) == some(9 as T);
- assert parse_buf(bytes(~"123"), 8u) == some(83 as T);
- assert parse_buf(bytes(~"123"), 16u) == some(291 as T);
- assert parse_buf(bytes(~"ffff"), 16u) == some(65535 as T);
- assert parse_buf(bytes(~"FFFF"), 16u) == some(65535 as T);
- assert parse_buf(bytes(~"z"), 36u) == some(35 as T);
- assert parse_buf(bytes(~"Z"), 36u) == some(35 as T);
-
- assert parse_buf(bytes(~"-123"), 10u) == some(-123 as T);
- assert parse_buf(bytes(~"-1001"), 2u) == some(-9 as T);
- assert parse_buf(bytes(~"-123"), 8u) == some(-83 as T);
- assert parse_buf(bytes(~"-123"), 16u) == some(-291 as T);
- assert parse_buf(bytes(~"-ffff"), 16u) == some(-65535 as T);
- assert parse_buf(bytes(~"-FFFF"), 16u) == some(-65535 as T);
- assert parse_buf(bytes(~"-z"), 36u) == some(-35 as T);
- assert parse_buf(bytes(~"-Z"), 36u) == some(-35 as T);
-
- assert parse_buf(str::bytes(~"Z"), 35u) == none;
- assert parse_buf(str::bytes(~"-9"), 2u) == none;
+ import str::to_bytes;
+ assert parse_buf(to_bytes(~"123"), 10u) == some(123 as T);
+ assert parse_buf(to_bytes(~"1001"), 2u) == some(9 as T);
+ assert parse_buf(to_bytes(~"123"), 8u) == some(83 as T);
+ assert parse_buf(to_bytes(~"123"), 16u) == some(291 as T);
+ assert parse_buf(to_bytes(~"ffff"), 16u) == some(65535 as T);
+ assert parse_buf(to_bytes(~"FFFF"), 16u) == some(65535 as T);
+ 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(~"-123"), 10u) == some(-123 as T);
+ assert parse_buf(to_bytes(~"-1001"), 2u) == some(-9 as T);
+ assert parse_buf(to_bytes(~"-123"), 8u) == some(-83 as T);
+ assert parse_buf(to_bytes(~"-123"), 16u) == some(-291 as T);
+ assert parse_buf(to_bytes(~"-ffff"), 16u) == some(-65535 as T);
+ assert parse_buf(to_bytes(~"-FFFF"), 16u) == some(-65535 as T);
+ 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;
 }
 
 #[test]

src/libcore/io.rs

@@ -319,7 +319,7 @@ fn with_bytes_reader_between<t>(bytes: ~[u8], start: uint, end: uint,
 }
 
 fn str_reader(s: ~str) -> Reader {
- bytes_reader(str::bytes(s))
+ bytes_reader(str::to_bytes(s))
 }
 
 fn with_str_reader<T>(s: ~str, f: fn(Reader) -> T) -> T {

src/libcore/os.rs

@@ -1028,7 +1028,7 @@ mod tests {
  };
  assert (ostream as uint != 0u);
  let s = ~"hello";
- let mut buf = vec::to_mut(str::bytes(s) + ~[0 as u8]);
+ let mut buf = vec::to_mut(str::to_bytes(s) + ~[0 as u8]);
  do vec::as_mut_buf(buf) |b, _len| {
  assert (libc::fwrite(b as *c_void, 1u as size_t,
  (str::len(s) + 1u) as size_t, ostream)

src/libcore/str.rs

@@ -38,7 +38,7 @@ export
  trim,
 
  // Transforming strings
- bytes,
+ to_bytes,
  byte_slice,
  chars,
  substr,
@@ -372,7 +372,7 @@ Section: Transforming strings
  *
  * The result vector is not null-terminated.
  */
-pure fn bytes(s: &str) -> ~[u8] {
+pure fn to_bytes(s: &str) -> ~[u8] {
  unsafe {
  let mut s_copy = from_slice(s);
  let mut v: ~[u8] = ::unsafe::transmute(s_copy);
@@ -2727,7 +2727,7 @@ mod tests {
  fn vec_str_conversions() {
  let s1: ~str = ~"All mimsy were the borogoves";
 
- let v: ~[u8] = bytes(s1);
+ let v: ~[u8] = to_bytes(s1);
  let s2: ~str = from_bytes(v);
  let mut i: uint = 0u;
  let n1: uint = len(s1);

src/libcore/to_bytes.rs

@@ -15,9 +15,9 @@ impl @~[u8]: ToBytes {
 }
 
 impl ~str: ToBytes {
- fn to_bytes() -> ~[u8] { str::bytes(self) }
+ fn to_bytes() -> ~[u8] { str::to_bytes(self) }
 }
 
 impl @(~str): ToBytes {
- fn to_bytes() -> ~[u8] { str::bytes(*self) }
+ fn to_bytes() -> ~[u8] { str::to_bytes(*self) }
 }

src/libcore/uint-template.rs

@@ -138,7 +138,7 @@ fn parse_buf(buf: &[const u8], radix: uint) -> option<T> {
 }
 
 /// Parse a string to an int
-fn from_str(s: ~str) -> option<T> { parse_buf(str::bytes(s), 10u) }
+fn from_str(s: ~str) -> option<T> { parse_buf(str::to_bytes(s), 10u) }
 
 /// Parse a string as an unsigned integer.
 fn from_str_radix(buf: ~str, radix: u64) -> option<u64> {
@@ -267,16 +267,16 @@ fn test_from_str() {
 #[test]
 #[ignore]
 fn test_parse_buf() {
- import str::bytes;
- assert parse_buf(bytes(~"123"), 10u) == some(123u as T);
- assert parse_buf(bytes(~"1001"), 2u) == some(9u as T);
- assert parse_buf(bytes(~"123"), 8u) == some(83u as T);
- assert parse_buf(bytes(~"123"), 16u) == some(291u as T);
- assert parse_buf(bytes(~"ffff"), 16u) == some(65535u as T);
- assert parse_buf(bytes(~"z"), 36u) == some(35u as T);
-
- assert parse_buf(str::bytes(~"Z"), 10u) == none;
- assert parse_buf(str::bytes(~"_"), 2u) == none;
+ import str::to_bytes;
+ assert parse_buf(to_bytes(~"123"), 10u) == some(123u as T);
+ assert parse_buf(to_bytes(~"1001"), 2u) == some(9u as T);
+ assert parse_buf(to_bytes(~"123"), 8u) == some(83u as T);
+ assert parse_buf(to_bytes(~"123"), 16u) == some(291u as T);
+ 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;
 }
 
 #[test]

src/libstd/base64.rs

@@ -57,7 +57,7 @@ impl ~[u8]: to_base64 {
 
 impl ~str: to_base64 {
  fn to_base64() -> ~str {
- str::bytes(self).to_base64()
+ str::to_bytes(self).to_base64()
  }
 }
 
@@ -129,7 +129,7 @@ impl ~[u8]: from_base64 {
 
 impl ~str: from_base64 {
  fn from_base64() -> ~[u8] {
- str::bytes(self).from_base64()
+ str::to_bytes(self).from_base64()
  }
 }
 
@@ -148,12 +148,12 @@ mod tests {
 
  #[test]
  fn test_from_base64() {
- assert (~"").from_base64() == str::bytes(~"");
- assert (~"Zg==").from_base64() == str::bytes(~"f");
- assert (~"Zm8=").from_base64() == str::bytes(~"fo");
- assert (~"Zm9v").from_base64() == str::bytes(~"foo");
- assert (~"Zm9vYg==").from_base64() == str::bytes(~"foob");
- assert (~"Zm9vYmE=").from_base64() == str::bytes(~"fooba");
- assert (~"Zm9vYmFy").from_base64() == str::bytes(~"foobar");
+ assert (~"").from_base64() == str::to_bytes(~"");
+ assert (~"Zg==").from_base64() == str::to_bytes(~"f");
+ assert (~"Zm8=").from_base64() == str::to_bytes(~"fo");
+ assert (~"Zm9v").from_base64() == str::to_bytes(~"foo");
+ assert (~"Zm9vYg==").from_base64() == str::to_bytes(~"foob");
+ assert (~"Zm9vYmE=").from_base64() == str::to_bytes(~"fooba");
+ assert (~"Zm9vYmFy").from_base64() == str::to_bytes(~"foobar");
  }
 }

src/libstd/ebml.rs

@@ -295,7 +295,7 @@ impl writer {
 
  fn wr_str(s: ~str) {
  debug!("Write str: %?", s);
- self.writer.write(str::bytes(s));
+ self.writer.write(str::to_bytes(s));
  }
 }
 

src/libstd/md4.rs

@@ -100,7 +100,7 @@ fn md4_str(msg: ~[u8]) -> ~str {
  result
 }
 
-fn md4_text(msg: ~str) -> ~str { md4_str(str::bytes(msg)) }
+fn md4_text(msg: ~str) -> ~str { md4_str(str::to_bytes(msg)) }
 
 #[test]
 fn test_md4() {

src/libstd/net_tcp.rs

@@ -1523,7 +1523,7 @@ mod test {
  server_ch.send(
  str::from_bytes(data));
  log(debug, ~"SERVER: before write");
- tcp_write_single(sock, str::bytes(resp));
+ tcp_write_single(sock, str::to_bytes(resp));
  log(debug, ~"SERVER: after write.. die");
  core::comm::send(kill_ch, none);
  }
@@ -1599,7 +1599,7 @@ mod test {
  }
  else {
  let sock = result::unwrap(connect_result);
- let resp_bytes = str::bytes(resp);
+ let resp_bytes = str::to_bytes(resp);
  tcp_write_single(sock, resp_bytes);
  let read_result = sock.read(0u);
  if read_result.is_err() {

src/libstd/net_url.rs

@@ -1029,7 +1029,7 @@ mod tests {
 
  assert decode_form_urlencoded(~[]) == str_hash();
 
- let s = str::bytes(~"a=1&foo+bar=abc&foo+bar=12+%3D+34");
+ let s = str::to_bytes(~"a=1&foo+bar=abc&foo+bar=12+%3D+34");
  assert decode_form_urlencoded(s) == hash_from_strs(~[
  (~"a", @dvec::from_elem(@~"1")),
  (~"foo bar", @dvec::from_vec(~[mut @~"abc", @~"12 = 34"]))

src/libstd/sha1.rs

@@ -228,7 +228,7 @@ fn sha1() -> sha1 {
  self.computed = false;
  }
  fn input(msg: ~[u8]) { add_input(self, msg); }
- fn input_str(msg: ~str) { add_input(self, str::bytes(msg)); }
+ fn input_str(msg: ~str) { add_input(self, str::to_bytes(msg)); }
  fn result() -> ~[u8] { return mk_result(self); }
  fn result_str() -> ~str {
  let r = mk_result(self);

src/libstd/treemap.rs

@@ -132,8 +132,8 @@ mod tests {
  fn u8_map() {
  let m = treemap();
 
- let k1 = str::bytes(~"foo");
- let k2 = str::bytes(~"bar");
+ let k1 = str::to_bytes(~"foo");
+ let k2 = str::to_bytes(~"bar");
 
  insert(m, k1, ~"foo");
  insert(m, k2, ~"bar");

src/libstd/uv_ll.rs

@@ -1119,7 +1119,7 @@ mod test {
  // In C, this would be a malloc'd or stack-allocated
  // struct that we'd cast to a void* and store as the
  // data field in our uv_connect_t struct
- let req_str_bytes = str::bytes(req_str);
+ let req_str_bytes = str::to_bytes(req_str);
  let req_msg_ptr: *u8 = vec::unsafe::to_ptr(req_str_bytes);
  log(debug, fmt!("req_msg ptr: %u", req_msg_ptr as uint));
  let req_msg = ~[
@@ -1367,7 +1367,7 @@ mod test {
  let server_write_req = write_t();
  let server_write_req_ptr = ptr::addr_of(server_write_req);
 
- let resp_str_bytes = str::bytes(server_resp_msg);
+ let resp_str_bytes = str::to_bytes(server_resp_msg);
  let resp_msg_ptr: *u8 = vec::unsafe::to_ptr(resp_str_bytes);
  log(debug, fmt!("resp_msg ptr: %u", resp_msg_ptr as uint));
  let resp_msg = ~[