Fallout - change array syntax to use ;

Author: nrc

src/doc/guide.md

@@ -1606,15 +1606,15 @@ things. The most basic is the **array**, a fixed-size list of elements of the
 same type. By default, arrays are immutable.
 
 ```{rust}
-let a = [1i, 2i, 3i];     // a: [int, ..3]
-let mut m = [1i, 2i, 3i]; // mut m: [int, ..3]
+let a = [1i, 2i, 3i];     // a: [int; 3]
+let mut m = [1i, 2i, 3i]; // mut m: [int; 3]
 ```
 
 There's a shorthand for initializing each element of an array to the same
 value. In this example, each element of `a` will be initialized to `0i`:
 
 ```{rust}
-let a = [0i, ..20]; // a: [int, ..20]
+let a = [0i; 20]; // a: [int; 20]
 ```
 
 Arrays have type `[T,..N]`. We'll talk about this `T` notation later, when we

src/doc/reference.md

@@ -1438,11 +1438,11 @@ the `static` lifetime, fixed-size arrays, tuples, enum variants, and structs.
 const BIT1: uint = 1 << 0;
 const BIT2: uint = 1 << 1;
 
-const BITS: [uint, ..2] = [BIT1, BIT2];
+const BITS: [uint; 2] = [BIT1, BIT2];
 const STRING: &'static str = "bitstring";
 
 struct BitsNStrings<'a> {
-    mybits: [uint, ..2],
+    mybits: [uint; 2],
     mystring: &'a str
 }
 
@@ -2923,7 +2923,7 @@ constant expression that can be evaluated at compile time, such as a
 ```
 [1i, 2, 3, 4];
 ["a", "b", "c", "d"];
-[0i, ..128];             // array with 128 zeros
+[0i; 128];             // array with 128 zeros
 [0u8, 0u8, 0u8, 0u8];
 ```
 
@@ -3691,7 +3691,7 @@ An example of each kind:
 
 ```{rust}
 let vec: Vec<int>  = vec![1, 2, 3];
-let arr: [int, ..3] = [1, 2, 3];
+let arr: [int; 3] = [1, 2, 3];
 let s: &[int]      = vec.as_slice();
 ```
 

src/libcollections/dlist.rs

@@ -1322,7 +1322,7 @@ mod tests {
 
     #[bench]
     fn bench_collect_into(b: &mut test::Bencher) {
-        let v = &[0i, ..64];
+        let v = &[0i; 64];
         b.iter(|| {
             let _: DList<int> = v.iter().map(|x| *x).collect();
         })
@@ -1384,31 +1384,31 @@ mod tests {
 
     #[bench]
     fn bench_iter(b: &mut test::Bencher) {
-        let v = &[0i, ..128];
+        let v = &[0i; 128];
         let m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
             assert!(m.iter().count() == 128);
         })
     }
     #[bench]
     fn bench_iter_mut(b: &mut test::Bencher) {
-        let v = &[0i, ..128];
+        let v = &[0i; 128];
         let mut m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
             assert!(m.iter_mut().count() == 128);
         })
     }
     #[bench]
     fn bench_iter_rev(b: &mut test::Bencher) {
-        let v = &[0i, ..128];
+        let v = &[0i; 128];
         let m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
             assert!(m.iter().rev().count() == 128);
         })
     }
     #[bench]
     fn bench_iter_mut_rev(b: &mut test::Bencher) {
-        let v = &[0i, ..128];
+        let v = &[0i; 128];
         let mut m: DList<int> = v.iter().map(|&x|x).collect();
         b.iter(|| {
             assert!(m.iter_mut().rev().count() == 128);

src/libcollections/slice.rs

@@ -861,6 +861,7 @@ pub trait CloneSliceExt<T> for Sized? {
     fn clone_from_slice(&mut self, &[T]) -> uint;
 }
 
+
 #[unstable = "trait is unstable"]
 impl<T: Clone> CloneSliceExt<T> for [T] {
     /// Returns a copy of `v`.
@@ -1482,14 +1483,14 @@ mod tests {
 
     #[test]
     fn test_is_empty() {
-        let xs: [int, ..0] = [];
+        let xs: [int; 0] = [];
         assert!(xs.is_empty());
         assert!(![0i].is_empty());
     }
 
     #[test]
     fn test_len_divzero() {
-        type Z = [i8, ..0];
+        type Z = [i8; 0];
         let v0 : &[Z] = &[];
         let v1 : &[Z] = &[[]];
         let v2 : &[Z] = &[[], []];
@@ -1856,7 +1857,7 @@ mod tests {
     #[test]
     fn test_permutations() {
         {
-            let v: [int, ..0] = [];
+            let v: [int; 0] = [];
             let mut it = v.permutations();
             let (min_size, max_opt) = it.size_hint();
             assert_eq!(min_size, 1);
@@ -2116,28 +2117,28 @@ mod tests {
 
     #[test]
     fn test_concat() {
-        let v: [Vec<int>, ..0] = [];
+        let v: [Vec<int>; 0] = [];
         let c: Vec<int> = v.concat();
         assert_eq!(c, []);
         let d: Vec<int> = [vec![1i], vec![2i,3i]].concat();
         assert_eq!(d, vec![1i, 2, 3]);
 
-        let v: [&[int], ..2] = [&[1], &[2, 3]];
+        let v: [&[int]; 2] = [&[1], &[2, 3]];
         assert_eq!(v.connect(&0), vec![1i, 0, 2, 3]);
-        let v: [&[int], ..3] = [&[1i], &[2], &[3]];
+        let v: [&[int]; 3] = [&[1i], &[2], &[3]];
         assert_eq!(v.connect(&0), vec![1i, 0, 2, 0, 3]);
     }
 
     #[test]
     fn test_connect() {
-        let v: [Vec<int>, ..0] = [];
+        let v: [Vec<int>; 0] = [];
         assert_eq!(v.connect_vec(&0), vec![]);
         assert_eq!([vec![1i], vec![2i, 3]].connect_vec(&0), vec![1, 0, 2, 3]);
         assert_eq!([vec![1i], vec![2i], vec![3i]].connect_vec(&0), vec![1, 0, 2, 0, 3]);
 
-        let v: [&[int], ..2] = [&[1], &[2, 3]];
+        let v: [&[int]; 2] = [&[1], &[2, 3]];
         assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 3]);
-        let v: [&[int], ..3] = [&[1], &[2], &[3]];
+        let v: [&[int]; 3] = [&[1], &[2], &[3]];
         assert_eq!(v.connect_vec(&0), vec![1, 0, 2, 0, 3]);
     }
 
@@ -2710,7 +2711,7 @@ mod tests {
         }
         assert_eq!(cnt, 11);
 
-        let xs: [Foo, ..3] = [Foo, Foo, Foo];
+        let xs: [Foo; 3] = [Foo, Foo, Foo];
         cnt = 0;
         for f in xs.iter() {
             assert!(*f == Foo);

src/libcollections/str.rs

@@ -2517,7 +2517,7 @@ mod tests {
 
     #[test]
     fn test_chars_decoding() {
-        let mut bytes = [0u8, ..4];
+        let mut bytes = [0u8; 4];
         for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(bytes[..len]).unwrap();
@@ -2529,7 +2529,7 @@ mod tests {
 
     #[test]
     fn test_chars_rev_decoding() {
-        let mut bytes = [0u8, ..4];
+        let mut bytes = [0u8; 4];
         for c in range(0u32, 0x110000).filter_map(|c| ::core::char::from_u32(c)) {
             let len = c.encode_utf8(&mut bytes).unwrap_or(0);
             let s = ::core::str::from_utf8(bytes[..len]).unwrap();

src/libcollections/string.rs

@@ -675,7 +675,7 @@ impl String {
         assert!(idx <= len);
         assert!(self.is_char_boundary(idx));
         self.vec.reserve(4);
-        let mut bits = [0, ..4];
+        let mut bits = [0; 4];
         let amt = ch.encode_utf8(&mut bits).unwrap();
 
         unsafe {

src/libcore/fmt/float.rs

@@ -123,7 +123,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
     // For an f64 the exponent is in the range of [-1022, 1023] for base 2, so
     // we may have up to that many digits. Give ourselves some extra wiggle room
     // otherwise as well.
-    let mut buf = [0u8, ..1536];
+    let mut buf = [0u8; 1536];
     let mut end = 0;
     let radix_gen: T = cast(radix as int).unwrap();
 

src/libcore/fmt/mod.rs

@@ -400,7 +400,7 @@ impl<'a> Formatter<'a> {
         // Writes the sign if it exists, and then the prefix if it was requested
         let write_prefix = |&: f: &mut Formatter| {
             for c in sign.into_iter() {
-                let mut b = [0, ..4];
+                let mut b = [0; 4];
                 let n = c.encode_utf8(&mut b).unwrap_or(0);
                 try!(f.buf.write(b[..n]));
             }
@@ -505,7 +505,7 @@ impl<'a> Formatter<'a> {
             rt::AlignCenter => (padding / 2, (padding + 1) / 2),
         };
 
-        let mut fill = [0u8, ..4];
+        let mut fill = [0u8; 4];
         let len = self.fill.encode_utf8(&mut fill).unwrap_or(0);
 
         for _ in range(0, pre_pad) {
@@ -606,7 +606,7 @@ impl Show for char {
     fn fmt(&self, f: &mut Formatter) -> Result {
         use char::Char;
 
-        let mut utf8 = [0u8, ..4];
+        let mut utf8 = [0u8; 4];
         let amt = self.encode_utf8(&mut utf8).unwrap_or(0);
         let s: &str = unsafe { mem::transmute(utf8[..amt]) };
         Show::fmt(s, f)

src/libcore/fmt/num.rs

@@ -37,7 +37,7 @@ trait GenericRadix {
         // characters for a base 2 number.
         let zero = Int::zero();
         let is_positive = x >= zero;
-        let mut buf = [0u8, ..64];
+        let mut buf = [0u8; 64];
         let mut curr = buf.len();
         let base = cast(self.base()).unwrap();
         if is_positive {

src/libcore/hash/sip.rs

@@ -292,7 +292,7 @@ mod tests {
     #[test]
     #[allow(unused_must_use)]
     fn test_siphash() {
-        let vecs : [[u8, ..8], ..64] = [
+        let vecs : [[u8; 8]; 64] = [
             [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ],
             [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ],
             [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ],
@@ -366,7 +366,7 @@ mod tests {
         let mut state_inc = SipState::new_with_keys(k0, k1);
         let mut state_full = SipState::new_with_keys(k0, k1);
 
-        fn to_hex_str(r: &[u8, ..8]) -> String {
+        fn to_hex_str(r: &[u8; 8]) -> String {
             let mut s = String::new();
             for b in r.iter() {
                 s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice());

src/libcore/iter.rs

@@ -1037,7 +1037,7 @@ pub trait IteratorOrdExt<A> {
     /// ```rust
     /// use std::iter::{NoElements, OneElement, MinMax};
     ///
-    /// let v: [int, ..0] = [];
+    /// let v: [int; 0] = [];
     /// assert_eq!(v.iter().min_max(), NoElements);
     ///
     /// let v = [1i];

src/libcore/str/mod.rs

@@ -1027,7 +1027,7 @@ pub fn truncate_utf16_at_nul<'a>(v: &'a [u16]) -> &'a [u16] {
 }
 
 // https://tools.ietf.org/html/rfc3629
-static UTF8_CHAR_WIDTH: [u8, ..256] = [
+static UTF8_CHAR_WIDTH: [u8; 256] = [
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F
 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,

src/libcoretest/any.rs

@@ -113,10 +113,10 @@ fn any_downcast_mut() {
 
 #[test]
 fn any_fixed_vec() {
-    let test = [0u, ..8];
+    let test = [0u; 8];
     let test = &test as &Any;
-    assert!(test.is::<[uint, ..8]>());
-    assert!(!test.is::<[uint, ..10]>());
+    assert!(test.is::<[uint; 8]>());
+    assert!(!test.is::<[uint; 10]>());
 }
 
 

src/libcoretest/char.rs

@@ -169,7 +169,7 @@ fn test_escape_unicode() {
 #[test]
 fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
-        let mut buf = [0u8, ..4];
+        let mut buf = [0u8; 4];
         let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
         assert_eq!(buf[..n], expect);
     }
@@ -183,7 +183,7 @@ fn test_encode_utf8() {
 #[test]
 fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
-        let mut buf = [0u16, ..2];
+        let mut buf = [0u16; 2];
         let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
         assert_eq!(buf[..n], expect);
     }

src/libcoretest/hash/sip.rs

@@ -33,7 +33,7 @@ impl<'a, S: Writer> Hash<S> for Bytes<'a> {
 #[test]
 #[allow(unused_must_use)]
 fn test_siphash() {
-    let vecs : [[u8, ..8], ..64] = [
+    let vecs : [[u8; 8]; 64] = [
         [ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72, ],
         [ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74, ],
         [ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d, ],
@@ -107,7 +107,7 @@ fn test_siphash() {
     let mut state_inc = SipState::new_with_keys(k0, k1);
     let mut state_full = SipState::new_with_keys(k0, k1);
 
-    fn to_hex_str(r: &[u8, ..8]) -> String {
+    fn to_hex_str(r: &[u8; 8]) -> String {
         let mut s = String::new();
         for b in r.iter() {
             s.push_str(format!("{}", fmt::radix(*b, 16)).as_slice());

src/libcoretest/iter.rs

@@ -19,7 +19,7 @@ use test::Bencher;
 
 #[test]
 fn test_lt() {
-    let empty: [int, ..0] = [];
+    let empty: [int; 0] = [];
     let xs = [1i,2,3];
     let ys = [1i,2,0];
 
@@ -781,7 +781,7 @@ fn test_peekable_is_empty() {
 
 #[test]
 fn test_min_max() {
-    let v: [int, ..0] = [];
+    let v: [int; 0] = [];
     assert_eq!(v.iter().min_max(), NoElements);
 
     let v = [1i];

src/libcoretest/ptr.rs

@@ -165,8 +165,8 @@ fn test_ptr_subtraction() {
 
 #[test]
 fn test_set_memory() {
-    let mut xs = [0u8, ..20];
+    let mut xs = [0u8; 20];
     let ptr = xs.as_mut_ptr();
     unsafe { set_memory(ptr, 5u8, xs.len()); }
-    assert!(xs == [5u8, ..20]);
+    assert!(xs == [5u8; 20]);
 }