diff --git a/src/arrayvec.rs b/src/arrayvec.rs index 0fb3c75..680020e 100644 --- a/src/arrayvec.rs +++ b/src/arrayvec.rs @@ -71,7 +71,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 16]>::new(); + /// let mut array = ArrayVec::<_, 16>::new(); /// array.push(1); /// array.push(2); /// assert_eq!(&array[..], &[1, 2]); @@ -131,7 +131,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 1]>::new(); + /// let mut array = ArrayVec::<_, 1>::new(); /// assert!(!array.is_full()); /// array.push(1); /// assert!(array.is_full()); @@ -158,7 +158,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 2]>::new(); + /// let mut array = ArrayVec::<_, 2>::new(); /// /// array.push(1); /// array.push(2); @@ -177,7 +177,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 2]>::new(); + /// let mut array = ArrayVec::<_, 2>::new(); /// /// let push1 = array.try_push(1); /// let push2 = array.try_push(2); @@ -205,7 +205,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 2]>::new(); + /// let mut array = ArrayVec::<_, 2>::new(); /// /// if array.len() + 2 <= array.capacity() { /// unsafe { @@ -263,7 +263,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 2]>::new(); + /// let mut array = ArrayVec::<_, 2>::new(); /// /// array.insert(0, "x"); /// array.insert(0, "y"); @@ -286,7 +286,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 2]>::new(); + /// let mut array = ArrayVec::<_, 2>::new(); /// /// assert!(array.try_insert(0, "x").is_ok()); /// assert!(array.try_insert(0, "y").is_ok()); @@ -327,7 +327,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut array = ArrayVec::<[_; 2]>::new(); + /// let mut array = ArrayVec::<_, 2>::new(); /// /// array.push(1); /// @@ -487,7 +487,7 @@ impl ArrayVec { /// ``` /// use arrayvec::ArrayVec; /// - /// let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); + /// let mut vec: ArrayVec = ArrayVec::new(); /// vec.push(1); /// vec.try_extend_from_slice(&[2, 3]).unwrap(); /// assert_eq!(&vec[..], &[1, 2, 3]); @@ -532,7 +532,7 @@ impl ArrayVec { /// use arrayvec::ArrayVec; /// /// let mut v = ArrayVec::from([1, 2, 3]); - /// let u: ArrayVec<[_; 3]> = v.drain(0..2).collect(); + /// let u: ArrayVec<_, 3> = v.drain(0..2).collect(); /// assert_eq!(&v[..], &[3]); /// assert_eq!(&u[..], &[1, 2]); /// ``` @@ -678,9 +678,9 @@ impl From<[T; CAP]> for ArrayVec { let array = ManuallyDrop::new(array); let mut vec = >::new(); unsafe { - (&*array as *const [T; CAP] as *const [MaybeUninit; CAP]) .copy_to_nonoverlapping(&mut vec.xs as *mut [MaybeUninit; CAP], 1); + vec.set_len(CAP); } vec } @@ -694,7 +694,7 @@ impl From<[T; CAP]> for ArrayVec { /// use arrayvec::ArrayVec; /// use std::convert::TryInto as _; /// -/// let array: ArrayVec<[_; 4]> = (&[1, 2, 3] as &[_]).try_into().unwrap(); +/// let array: ArrayVec<_, 4> = (&[1, 2, 3] as &[_]).try_into().unwrap(); /// assert_eq!(array.len(), 3); /// assert_eq!(array.capacity(), 4); /// ``` diff --git a/tests/tests.rs b/tests/tests.rs index 593b5e4..d1bae4f 100644 --- a/tests/tests.rs +++ b/tests/tests.rs @@ -13,7 +13,7 @@ use std::collections::HashMap; fn test_simple() { use std::ops::Add; - let mut vec: ArrayVec<[Vec; 3]> = ArrayVec::new(); + let mut vec: ArrayVec, 3> = ArrayVec::new(); vec.push(vec![1, 2, 3, 4]); vec.push(vec![10]); @@ -29,7 +29,7 @@ fn test_simple() { #[test] fn test_capacity_left() { - let mut vec: ArrayVec<[usize; 4]> = ArrayVec::new(); + let mut vec: ArrayVec = ArrayVec::new(); assert_eq!(vec.remaining_capacity(), 4); vec.push(1); assert_eq!(vec.remaining_capacity(), 3); @@ -43,7 +43,7 @@ fn test_capacity_left() { #[test] fn test_extend_from_slice() { - let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); + let mut vec: ArrayVec = ArrayVec::new(); vec.try_extend_from_slice(&[1, 2, 3]).unwrap(); assert_eq!(vec.len(), 3); @@ -54,13 +54,13 @@ fn test_extend_from_slice() { #[test] fn test_extend_from_slice_error() { - let mut vec: ArrayVec<[usize; 10]> = ArrayVec::new(); + let mut vec: ArrayVec = ArrayVec::new(); vec.try_extend_from_slice(&[1, 2, 3]).unwrap(); let res = vec.try_extend_from_slice(&[0; 8]); assert_matches!(res, Err(_)); - let mut vec: ArrayVec<[usize; 0]> = ArrayVec::new(); + let mut vec: ArrayVec = ArrayVec::new(); let res = vec.try_extend_from_slice(&[0; 1]); assert_matches!(res, Err(_)); } @@ -70,14 +70,14 @@ fn test_try_from_slice_error() { use arrayvec::ArrayVec; use std::convert::TryInto as _; - let res: Result, _> = (&[1, 2, 3] as &[_]).try_into(); + let res: Result, _> = (&[1, 2, 3] as &[_]).try_into(); assert_matches!(res, Err(_)); } #[test] fn test_u16_index() { const N: usize = 4096; - let mut vec: ArrayVec<[_; N]> = ArrayVec::new(); + let mut vec: ArrayVec<_, N> = ArrayVec::new(); for _ in 0..N { assert!(vec.try_push(1u8).is_ok()); } @@ -113,7 +113,7 @@ fn test_drop() { } { - let mut array = ArrayVec::<[Bump; 128]>::new(); + let mut array = ArrayVec::::new(); array.push(Bump(flag)); array.push(Bump(flag)); } @@ -123,7 +123,7 @@ fn test_drop() { flag.set(0); { - let mut array = ArrayVec::<[_; 3]>::new(); + let mut array = ArrayVec::<_, 3>::new(); array.push(vec![Bump(flag)]); array.push(vec![Bump(flag), Bump(flag)]); array.push(vec![]); @@ -142,7 +142,7 @@ fn test_drop() { // test into_inner flag.set(0); { - let mut array = ArrayVec::<[_; 3]>::new(); + let mut array = ArrayVec::<_, 3>::new(); array.push(Bump(flag)); array.push(Bump(flag)); array.push(Bump(flag)); @@ -156,7 +156,7 @@ fn test_drop() { // test cloning into_iter flag.set(0); { - let mut array = ArrayVec::<[_; 3]>::new(); + let mut array = ArrayVec::<_, 3>::new(); array.push(Bump(flag)); array.push(Bump(flag)); array.push(Bump(flag)); @@ -210,7 +210,7 @@ fn test_drop_panics() { flag.set(0); { - let mut array = ArrayVec::<[Bump; 128]>::new(); + let mut array = ArrayVec::::new(); array.push(Bump(flag)); array.push(Bump(flag)); array.push(Bump(flag)); @@ -226,7 +226,7 @@ fn test_drop_panics() { flag.set(0); { - let mut array = ArrayVec::<[Bump; 16]>::new(); + let mut array = ArrayVec::::new(); array.push(Bump(flag)); array.push(Bump(flag)); array.push(Bump(flag)); @@ -251,14 +251,14 @@ fn test_drop_panics() { fn test_extend() { let mut range = 0..10; - let mut array: ArrayVec<[_; 5]> = range.by_ref().collect(); + let mut array: ArrayVec<_, 5> = range.by_ref().collect(); assert_eq!(&array[..], &[0, 1, 2, 3, 4]); assert_eq!(range.next(), Some(5)); array.extend(range.by_ref()); assert_eq!(range.next(), Some(6)); - let mut array: ArrayVec<[_; 10]> = (0..3).collect(); + let mut array: ArrayVec<_, 10> = (0..3).collect(); assert_eq!(&array[..], &[0, 1, 2]); array.extend(3..5); assert_eq!(&array[..], &[0, 1, 2, 3, 4]); @@ -266,7 +266,7 @@ fn test_extend() { #[test] fn test_is_send_sync() { - let data = ArrayVec::<[Vec; 5]>::new(); + let data = ArrayVec::, 5>::new(); &data as &dyn Send; &data as &dyn Sync; } @@ -275,24 +275,24 @@ fn test_is_send_sync() { fn test_compact_size() { // Future rust will kill these drop flags! // 4 elements size + 1 len + 1 enum tag + [1 drop flag] - type ByteArray = ArrayVec<[u8; 4]>; + type ByteArray = ArrayVec; println!("{}", mem::size_of::()); assert!(mem::size_of::() <= 8); // 1 enum tag + 1 drop flag - type EmptyArray = ArrayVec<[u8; 0]>; + type EmptyArray = ArrayVec; println!("{}", mem::size_of::()); assert!(mem::size_of::() <= 2); // 12 element size + 1 enum tag + 3 padding + 1 len + 1 drop flag + 2 padding - type QuadArray = ArrayVec<[u32; 3]>; + type QuadArray = ArrayVec; println!("{}", mem::size_of::()); assert!(mem::size_of::() <= 24); } #[test] fn test_still_works_with_option_arrayvec() { - type RefArray = ArrayVec<[&'static i32; 2]>; + type RefArray = ArrayVec<&'static i32, 2>; let array = Some(RefArray::new()); assert!(array.is_some()); println!("{:?}", array); @@ -308,7 +308,7 @@ fn test_drain() { v.extend(0..); v.drain(1..4); assert_eq!(&v[..], &[0, 4, 5, 6, 7]); - let u: ArrayVec<[_; 3]> = v.drain(1..4).rev().collect(); + let u: ArrayVec<_, 3> = v.drain(1..4).rev().collect(); assert_eq!(&u[..], &[6, 5, 4]); assert_eq!(&v[..], &[0, 7]); v.drain(..); @@ -324,7 +324,7 @@ fn test_drain_range_inclusive() { v.extend(0..); v.drain(1..=4); assert_eq!(&v[..], &[0, 5, 6, 7]); - let u: ArrayVec<[_; 3]> = v.drain(1..=2).rev().collect(); + let u: ArrayVec<_, 3> = v.drain(1..=2).rev().collect(); assert_eq!(&u[..], &[6, 5]); assert_eq!(&v[..], &[0, 7]); v.drain(..); @@ -374,7 +374,7 @@ fn test_drop_panic() { } } - let mut array = ArrayVec::<[DropPanic; 1]>::new(); + let mut array = ArrayVec::::new(); array.push(DropPanic); } @@ -389,7 +389,7 @@ fn test_drop_panic_into_iter() { } } - let mut array = ArrayVec::<[DropPanic; 1]>::new(); + let mut array = ArrayVec::::new(); array.push(DropPanic); array.into_iter(); } @@ -399,7 +399,7 @@ fn test_insert() { let mut v = ArrayVec::from([]); assert_matches!(v.try_push(1), Err(_)); - let mut v = ArrayVec::<[_; 3]>::new(); + let mut v = ArrayVec::<_, 3>::new(); v.insert(0, 0); v.insert(1, 1); //let ret1 = v.try_insert(3, 3); @@ -428,7 +428,7 @@ fn test_into_inner_1() { #[test] fn test_into_inner_2() { - let mut v = ArrayVec::<[String; 4]>::new(); + let mut v = ArrayVec::::new(); v.push("a".into()); v.push("b".into()); v.push("c".into()); @@ -438,7 +438,7 @@ fn test_into_inner_2() { #[test] fn test_into_inner_3_() { - let mut v = ArrayVec::<[i32; 4]>::new(); + let mut v = ArrayVec::::new(); v.extend(1..); assert_eq!(v.into_inner().unwrap(), [1, 2, 3, 4]); } @@ -447,7 +447,7 @@ fn test_into_inner_3_() { #[test] fn test_write() { use std::io::Write; - let mut v = ArrayVec::<[_; 8]>::new(); + let mut v = ArrayVec::<_, 8>::new(); write!(&mut v, "\x01\x02\x03").unwrap(); assert_eq!(&v[..], &[1, 2, 3]); let r = v.write(&[9; 16]).unwrap(); @@ -457,16 +457,16 @@ fn test_write() { #[test] fn array_clone_from() { - let mut v = ArrayVec::<[_; 4]>::new(); + let mut v = ArrayVec::<_, 4>::new(); v.push(vec![1, 2]); v.push(vec![3, 4, 5]); v.push(vec![6]); let reference = v.to_vec(); - let mut u = ArrayVec::<[_; 4]>::new(); + let mut u = ArrayVec::<_, 4>::new(); u.clone_from(&v); assert_eq!(&u, &reference[..]); - let mut t = ArrayVec::<[_; 4]>::new(); + let mut t = ArrayVec::<_, 4>::new(); t.push(vec![97]); t.push(vec![]); t.push(vec![5, 6, 2]); @@ -565,7 +565,7 @@ fn test_string_push() { #[test] fn test_insert_at_length() { - let mut v = ArrayVec::<[_; 8]>::new(); + let mut v = ArrayVec::<_, 8>::new(); let result1 = v.try_insert(0, "a"); let result2 = v.try_insert(1, "b"); assert!(result1.is_ok() && result2.is_ok()); @@ -575,7 +575,7 @@ fn test_insert_at_length() { #[should_panic] #[test] fn test_insert_out_of_bounds() { - let mut v = ArrayVec::<[_; 8]>::new(); + let mut v = ArrayVec::<_, 8>::new(); let _ = v.try_insert(1, "test"); } @@ -608,7 +608,7 @@ fn test_drop_in_insert() { flag.set(0); { - let mut array = ArrayVec::<[_; 2]>::new(); + let mut array = ArrayVec::<_, 2>::new(); array.push(Bump(flag)); array.insert(0, Bump(flag)); assert_eq!(flag.get(), 0); @@ -623,7 +623,7 @@ fn test_drop_in_insert() { #[test] fn test_pop_at() { - let mut v = ArrayVec::<[String; 4]>::new(); + let mut v = ArrayVec::::new(); let s = String::from; v.push(s("a")); v.push(s("b")); @@ -648,7 +648,7 @@ fn test_default() { use std::net; let s: ArrayString<[u8; 4]> = Default::default(); // Something without `Default` implementation. - let v: ArrayVec<[net::TcpStream; 4]> = Default::default(); + let v: ArrayVec = Default::default(); assert_eq!(s.len(), 0); assert_eq!(v.len(), 0); } @@ -673,14 +673,14 @@ fn test_extend_zst() { #[derive(Copy, Clone, PartialEq, Debug)] struct Z; // Zero sized type - let mut array: ArrayVec<[_; 5]> = range.by_ref().map(|_| Z).collect(); + let mut array: ArrayVec<_, 5> = range.by_ref().map(|_| Z).collect(); assert_eq!(&array[..], &[Z; 5]); assert_eq!(range.next(), Some(5)); array.extend(range.by_ref().map(|_| Z)); assert_eq!(range.next(), Some(6)); - let mut array: ArrayVec<[_; 10]> = (0..3).map(|_| Z).collect(); + let mut array: ArrayVec<_, 10> = (0..3).map(|_| Z).collect(); assert_eq!(&array[..], &[Z; 3]); array.extend((3..5).map(|_| Z)); assert_eq!(&array[..], &[Z; 5]);