@@ -266,12 +266,12 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool {
266
266
/// ```
267
267
/// use std::rc::{self, Rc};
268
268
///
269
- /// let x = Rc::new(3u );
270
- /// assert_eq!(rc::try_unwrap(x), Ok(3u ));
269
+ /// let x = Rc::new(3 );
270
+ /// assert_eq!(rc::try_unwrap(x), Ok(3 ));
271
271
///
272
- /// let x = Rc::new(4u );
272
+ /// let x = Rc::new(4 );
273
273
/// let _y = x.clone();
274
- /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4u )));
274
+ /// assert_eq!(rc::try_unwrap(x), Err(Rc::new(4 )));
275
275
/// ```
276
276
#[ inline]
277
277
#[ unstable( feature = "alloc" ) ]
@@ -300,9 +300,9 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> {
300
300
/// ```
301
301
/// use std::rc::{self, Rc};
302
302
///
303
- /// let mut x = Rc::new(3u );
304
- /// *rc::get_mut(&mut x).unwrap() = 4u ;
305
- /// assert_eq!(*x, 4u );
303
+ /// let mut x = Rc::new(3 );
304
+ /// *rc::get_mut(&mut x).unwrap() = 4 ;
305
+ /// assert_eq!(*x, 4 );
306
306
///
307
307
/// let _y = x.clone();
308
308
/// assert!(rc::get_mut(&mut x).is_none());
@@ -845,7 +845,7 @@ mod tests {
845
845
846
846
#[ test]
847
847
fn is_unique ( ) {
848
- let x = Rc :: new ( 3 u ) ;
848
+ let x = Rc :: new ( 3 ) ;
849
849
assert ! ( super :: is_unique( & x) ) ;
850
850
let y = x. clone ( ) ;
851
851
assert ! ( !super :: is_unique( & x) ) ;
@@ -893,21 +893,21 @@ mod tests {
893
893
894
894
#[ test]
895
895
fn try_unwrap ( ) {
896
- let x = Rc :: new ( 3 u ) ;
897
- assert_eq ! ( super :: try_unwrap( x) , Ok ( 3 u ) ) ;
898
- let x = Rc :: new ( 4 u ) ;
896
+ let x = Rc :: new ( 3 ) ;
897
+ assert_eq ! ( super :: try_unwrap( x) , Ok ( 3 ) ) ;
898
+ let x = Rc :: new ( 4 ) ;
899
899
let _y = x. clone ( ) ;
900
- assert_eq ! ( super :: try_unwrap( x) , Err ( Rc :: new( 4 u ) ) ) ;
901
- let x = Rc :: new ( 5 u ) ;
900
+ assert_eq ! ( super :: try_unwrap( x) , Err ( Rc :: new( 4 ) ) ) ;
901
+ let x = Rc :: new ( 5 ) ;
902
902
let _w = x. downgrade ( ) ;
903
- assert_eq ! ( super :: try_unwrap( x) , Err ( Rc :: new( 5 u ) ) ) ;
903
+ assert_eq ! ( super :: try_unwrap( x) , Err ( Rc :: new( 5 ) ) ) ;
904
904
}
905
905
906
906
#[ test]
907
907
fn get_mut ( ) {
908
- let mut x = Rc :: new ( 3 u ) ;
909
- * super :: get_mut ( & mut x) . unwrap ( ) = 4 u ;
910
- assert_eq ! ( * x, 4 u ) ;
908
+ let mut x = Rc :: new ( 3 ) ;
909
+ * super :: get_mut ( & mut x) . unwrap ( ) = 4 ;
910
+ assert_eq ! ( * x, 4 ) ;
911
911
let y = x. clone ( ) ;
912
912
assert ! ( super :: get_mut( & mut x) . is_none( ) ) ;
913
913
drop ( y) ;
@@ -918,7 +918,7 @@ mod tests {
918
918
919
919
#[ test]
920
920
fn test_cowrc_clone_make_unique ( ) {
921
- let mut cow0 = Rc :: new ( 75 u ) ;
921
+ let mut cow0 = Rc :: new ( 75 ) ;
922
922
let mut cow1 = cow0. clone ( ) ;
923
923
let mut cow2 = cow1. clone ( ) ;
924
924
@@ -942,7 +942,7 @@ mod tests {
942
942
943
943
#[ test]
944
944
fn test_cowrc_clone_unique2 ( ) {
945
- let mut cow0 = Rc :: new ( 75 u ) ;
945
+ let mut cow0 = Rc :: new ( 75 ) ;
946
946
let cow1 = cow0. clone ( ) ;
947
947
let cow2 = cow1. clone ( ) ;
948
948
@@ -965,7 +965,7 @@ mod tests {
965
965
966
966
#[ test]
967
967
fn test_cowrc_clone_weak ( ) {
968
- let mut cow0 = Rc :: new ( 75 u ) ;
968
+ let mut cow0 = Rc :: new ( 75 ) ;
969
969
let cow1_weak = cow0. downgrade ( ) ;
970
970
971
971
assert ! ( 75 == * cow0) ;
@@ -979,7 +979,7 @@ mod tests {
979
979
980
980
#[ test]
981
981
fn test_show ( ) {
982
- let foo = Rc :: new ( 75 u ) ;
982
+ let foo = Rc :: new ( 75 ) ;
983
983
assert_eq ! ( format!( "{:?}" , foo) , "75" ) ;
984
984
}
985
985
0 commit comments