Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 8756ed2

Browse files
borsbors
committed
Auto merge of rust-lang#94834 - Dylan-DPC:rollup-sza4qc2, r=Dylan-DPC
Rollup of 5 pull requests Successful merges: - rust-lang#93293 (Implement `MIN`/`MAX` constants for non-zero integers) - rust-lang#94356 (Rename unix::net::SocketAddr::from_path to from_pathname and stabilize it) - rust-lang#94765 (Rename is_{some,ok,err}_with to is_{some,ok,err}_and.) - rust-lang#94819 (configure: don't serialize empty array elements) - rust-lang#94826 (Improve doc wording for retain on some collections) Failed merges: r? `@ghost` `@rustbot` modify labels: rollup
2 parents c5a43b8 + f97a1c6 commit 8756ed2

File tree

12 files changed

+132
-29
lines changed

12 files changed

+132
-29
lines changed

‎library/alloc/src/collections/binary_heap.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -779,7 +779,7 @@ impl<T: Ord> BinaryHeap<T> {
779779

780780
/// Retains only the elements specified by the predicate.
781781
///
782-
/// In other words, remove all elements `e` such that `f(&e)` returns
782+
/// In other words, remove all elements `e` for which `f(&e)` returns
783783
/// `false`. The elements are visited in unsorted (and unspecified) order.
784784
///
785785
/// # Examples

‎library/alloc/src/collections/btree/map.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -963,7 +963,7 @@ impl<K, V> BTreeMap<K, V> {
963963

964964
/// Retains only the elements specified by the predicate.
965965
///
966-
/// In other words, remove all pairs `(k, v)` such that `f(&k, &mut v)` returns `false`.
966+
/// In other words, remove all pairs `(k, v)` for which `f(&k, &mut v)` returns `false`.
967967
/// The elements are visited in ascending key order.
968968
///
969969
/// # Examples

‎library/alloc/src/collections/btree/set.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -873,7 +873,7 @@ impl<T> BTreeSet<T> {
873873

874874
/// Retains only the elements specified by the predicate.
875875
///
876-
/// In other words, remove all elements `e` such that `f(&e)` returns `false`.
876+
/// In other words, remove all elements `e` for which `f(&e)` returns `false`.
877877
/// The elements are visited in ascending order.
878878
///
879879
/// # Examples

‎library/alloc/src/collections/vec_deque/mod.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2119,7 +2119,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
21192119

21202120
/// Retains only the elements specified by the predicate.
21212121
///
2122-
/// In other words, remove all elements `e` such that `f(&e)` returns false.
2122+
/// In other words, remove all elements `e` for which `f(&e)` returns false.
21232123
/// This method operates in place, visiting each element exactly once in the
21242124
/// original order, and preserves the order of the retained elements.
21252125
///
@@ -2158,7 +2158,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
21582158

21592159
/// Retains only the elements specified by the predicate.
21602160
///
2161-
/// In other words, remove all elements `e` such that `f(&e)` returns false.
2161+
/// In other words, remove all elements `e` for which `f(&e)` returns false.
21622162
/// This method operates in place, visiting each element exactly once in the
21632163
/// original order, and preserves the order of the retained elements.
21642164
///

‎library/alloc/src/vec/mod.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1424,7 +1424,7 @@ impl<T, A: Allocator> Vec<T, A> {
14241424

14251425
/// Retains only the elements specified by the predicate.
14261426
///
1427-
/// In other words, remove all elements `e` such that `f(&e)` returns `false`.
1427+
/// In other words, remove all elements `e` for which `f(&e)` returns `false`.
14281428
/// This method operates in place, visiting each element exactly once in the
14291429
/// original order, and preserves the order of the retained elements.
14301430
///

‎library/core/src/num/nonzero.rs‎

Lines changed: 101 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -989,3 +989,104 @@ macro_rules! nonzero_unsigned_is_power_of_two {
989989
}
990990

991991
nonzero_unsigned_is_power_of_two! { NonZeroU8 NonZeroU16 NonZeroU32 NonZeroU64 NonZeroU128 NonZeroUsize }
992+
993+
macro_rules! nonzero_min_max_unsigned {
994+
( $( $Ty: ident($Int: ident); )+ ) => {
995+
$(
996+
impl $Ty {
997+
/// The smallest value that can be represented by this non-zero
998+
/// integer type, 1.
999+
///
1000+
/// # Examples
1001+
///
1002+
/// ```
1003+
/// #![feature(nonzero_min_max)]
1004+
#[doc = concat!("# use std::num::", stringify!($Ty), ";")]
1005+
///
1006+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::MIN.get(), 1", stringify!($Int), ");")]
1007+
/// ```
1008+
#[unstable(feature = "nonzero_min_max", issue = "89065")]
1009+
pub const MIN: Self = Self::new(1).unwrap();
1010+
1011+
/// The largest value that can be represented by this non-zero
1012+
/// integer type,
1013+
#[doc = concat!("equal to [`", stringify!($Int), "::MAX`].")]
1014+
///
1015+
/// # Examples
1016+
///
1017+
/// ```
1018+
/// #![feature(nonzero_min_max)]
1019+
#[doc = concat!("# use std::num::", stringify!($Ty), ";")]
1020+
///
1021+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::MAX.get(), ", stringify!($Int), "::MAX);")]
1022+
/// ```
1023+
#[unstable(feature = "nonzero_min_max", issue = "89065")]
1024+
pub const MAX: Self = Self::new(<$Int>::MAX).unwrap();
1025+
}
1026+
)+
1027+
}
1028+
}
1029+
1030+
macro_rules! nonzero_min_max_signed {
1031+
( $( $Ty: ident($Int: ident); )+ ) => {
1032+
$(
1033+
impl $Ty {
1034+
/// The smallest value that can be represented by this non-zero
1035+
/// integer type,
1036+
#[doc = concat!("equal to [`", stringify!($Int), "::MIN`].")]
1037+
///
1038+
/// Note: While most integer types are defined for every whole
1039+
/// number between `MIN` and `MAX`, signed non-zero integers are
1040+
/// a special case. They have a "gap" at 0.
1041+
///
1042+
/// # Examples
1043+
///
1044+
/// ```
1045+
/// #![feature(nonzero_min_max)]
1046+
#[doc = concat!("# use std::num::", stringify!($Ty), ";")]
1047+
///
1048+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::MIN.get(), ", stringify!($Int), "::MIN);")]
1049+
/// ```
1050+
#[unstable(feature = "nonzero_min_max", issue = "89065")]
1051+
pub const MIN: Self = Self::new(<$Int>::MIN).unwrap();
1052+
1053+
/// The largest value that can be represented by this non-zero
1054+
/// integer type,
1055+
#[doc = concat!("equal to [`", stringify!($Int), "::MAX`].")]
1056+
///
1057+
/// Note: While most integer types are defined for every whole
1058+
/// number between `MIN` and `MAX`, signed non-zero integers are
1059+
/// a special case. They have a "gap" at 0.
1060+
///
1061+
/// # Examples
1062+
///
1063+
/// ```
1064+
/// #![feature(nonzero_min_max)]
1065+
#[doc = concat!("# use std::num::", stringify!($Ty), ";")]
1066+
///
1067+
#[doc = concat!("assert_eq!(", stringify!($Ty), "::MAX.get(), ", stringify!($Int), "::MAX);")]
1068+
/// ```
1069+
#[unstable(feature = "nonzero_min_max", issue = "89065")]
1070+
pub const MAX: Self = Self::new(<$Int>::MAX).unwrap();
1071+
}
1072+
)+
1073+
}
1074+
}
1075+
1076+
nonzero_min_max_unsigned! {
1077+
NonZeroU8(u8);
1078+
NonZeroU16(u16);
1079+
NonZeroU32(u32);
1080+
NonZeroU64(u64);
1081+
NonZeroU128(u128);
1082+
NonZeroUsize(usize);
1083+
}
1084+
1085+
nonzero_min_max_signed! {
1086+
NonZeroI8(i8);
1087+
NonZeroI16(i16);
1088+
NonZeroI32(i32);
1089+
NonZeroI64(i64);
1090+
NonZeroI128(i128);
1091+
NonZeroIsize(isize);
1092+
}

‎library/core/src/option.rs‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -551,26 +551,26 @@ impl<T> Option<T> {
551551
matches!(*self, Some(_))
552552
}
553553

554-
/// Returns `true` if the option is a [`Some`] wrapping a value matching the predicate.
554+
/// Returns `true` if the option is a [`Some`] and the value inside of it matches a predicate.
555555
///
556556
/// # Examples
557557
///
558558
/// ```
559559
/// #![feature(is_some_with)]
560560
///
561561
/// let x: Option<u32> = Some(2);
562-
/// assert_eq!(x.is_some_with(|&x| x > 1), true);
562+
/// assert_eq!(x.is_some_and(|&x| x > 1), true);
563563
///
564564
/// let x: Option<u32> = Some(0);
565-
/// assert_eq!(x.is_some_with(|&x| x > 1), false);
565+
/// assert_eq!(x.is_some_and(|&x| x > 1), false);
566566
///
567567
/// let x: Option<u32> = None;
568-
/// assert_eq!(x.is_some_with(|&x| x > 1), false);
568+
/// assert_eq!(x.is_some_and(|&x| x > 1), false);
569569
/// ```
570570
#[must_use]
571571
#[inline]
572572
#[unstable(feature = "is_some_with", issue = "93050")]
573-
pub fn is_some_with(&self, f: impl FnOnce(&T) -> bool) -> bool {
573+
pub fn is_some_and(&self, f: impl FnOnce(&T) -> bool) -> bool {
574574
matches!(self, Some(x) if f(x))
575575
}
576576

‎library/core/src/result.rs‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -542,26 +542,26 @@ impl<T, E> Result<T, E> {
542542
matches!(*self, Ok(_))
543543
}
544544

545-
/// Returns `true` if the result is [`Ok`] wrapping a value matching the predicate.
545+
/// Returns `true` if the result is [`Ok`] and the value inside of it matches a predicate.
546546
///
547547
/// # Examples
548548
///
549549
/// ```
550550
/// #![feature(is_some_with)]
551551
///
552552
/// let x: Result<u32, &str> = Ok(2);
553-
/// assert_eq!(x.is_ok_with(|&x| x > 1), true);
553+
/// assert_eq!(x.is_ok_and(|&x| x > 1), true);
554554
///
555555
/// let x: Result<u32, &str> = Ok(0);
556-
/// assert_eq!(x.is_ok_with(|&x| x > 1), false);
556+
/// assert_eq!(x.is_ok_and(|&x| x > 1), false);
557557
///
558558
/// let x: Result<u32, &str> = Err("hey");
559-
/// assert_eq!(x.is_ok_with(|&x| x > 1), false);
559+
/// assert_eq!(x.is_ok_and(|&x| x > 1), false);
560560
/// ```
561561
#[must_use]
562562
#[inline]
563563
#[unstable(feature = "is_some_with", issue = "93050")]
564-
pub fn is_ok_with(&self, f: impl FnOnce(&T) -> bool) -> bool {
564+
pub fn is_ok_and(&self, f: impl FnOnce(&T) -> bool) -> bool {
565565
matches!(self, Ok(x) if f(x))
566566
}
567567

@@ -586,7 +586,7 @@ impl<T, E> Result<T, E> {
586586
!self.is_ok()
587587
}
588588

589-
/// Returns `true` if the result is [`Err`] wrapping a value matching the predicate.
589+
/// Returns `true` if the result is [`Err`] and the value inside of it matches a predicate.
590590
///
591591
/// # Examples
592592
///
@@ -595,18 +595,18 @@ impl<T, E> Result<T, E> {
595595
/// use std::io::{Error, ErrorKind};
596596
///
597597
/// let x: Result<u32, Error> = Err(Error::new(ErrorKind::NotFound, "!"));
598-
/// assert_eq!(x.is_err_with(|x| x.kind() == ErrorKind::NotFound), true);
598+
/// assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), true);
599599
///
600600
/// let x: Result<u32, Error> = Err(Error::new(ErrorKind::PermissionDenied, "!"));
601-
/// assert_eq!(x.is_err_with(|x| x.kind() == ErrorKind::NotFound), false);
601+
/// assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
602602
///
603603
/// let x: Result<u32, Error> = Ok(123);
604-
/// assert_eq!(x.is_err_with(|x| x.kind() == ErrorKind::NotFound), false);
604+
/// assert_eq!(x.is_err_and(|x| x.kind() == ErrorKind::NotFound), false);
605605
/// ```
606606
#[must_use]
607607
#[inline]
608608
#[unstable(feature = "is_some_with", issue = "93050")]
609-
pub fn is_err_with(&self, f: impl FnOnce(&E) -> bool) -> bool {
609+
pub fn is_err_and(&self, f: impl FnOnce(&E) -> bool) -> bool {
610610
matches!(self, Err(x) if f(x))
611611
}
612612

‎library/std/src/collections/hash/map.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -621,7 +621,7 @@ impl<K, V, S> HashMap<K, V, S> {
621621

622622
/// Retains only the elements specified by the predicate.
623623
///
624-
/// In other words, remove all pairs `(k, v)` such that `f(&k, &mut v)` returns `false`.
624+
/// In other words, remove all pairs `(k, v)` for which `f(&k, &mut v)` returns `false`.
625625
/// The elements are visited in unsorted (and unspecified) order.
626626
///
627627
/// # Examples

‎library/std/src/collections/hash/set.rs‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -300,7 +300,7 @@ impl<T, S> HashSet<T, S> {
300300

301301
/// Retains only the elements specified by the predicate.
302302
///
303-
/// In other words, remove all elements `e` such that `f(&e)` returns `false`.
303+
/// In other words, remove all elements `e` for which `f(&e)` returns `false`.
304304
/// The elements are visited in unsorted (and unspecified) order.
305305
///
306306
/// # Examples

0 commit comments

Comments
 (0)