From d41c91c1fa6633754e7c88ab45224aedd5b5ed92 Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Sun, 9 Oct 2016 10:46:11 +0200 Subject: [PATCH 1/7] Add or and or_else for ordering. --- src/libcore/cmp.rs | 70 ++++++++++++++++++++++++++++++++++++++++++ src/libcoretest/cmp.rs | 26 ++++++++++++++++ src/libcoretest/lib.rs | 1 + 3 files changed, 97 insertions(+) diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index f990a27e52b..58b3db0ad39 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -245,6 +245,76 @@ impl Ordering { Greater => Less, } } + + /// Chain two orderings. + /// + /// Returns `self` when it's not `Equal`. Otherwise returns `other`. + /// # Examples + /// + /// ``` + /// use std::cmp::Ordering; + /// + /// let result = Ordering::Equal.or(Ordering::Less); + /// assert_eq!(result, Ordering::Less); + /// + /// let result = Ordering::Less.or(Ordering::Equal); + /// assert_eq!(result, Ordering::Less); + /// + /// let result = Ordering::Less.or(Ordering::Greater); + /// assert_eq!(result, Ordering::Less); + /// + /// let result = Ordering::Equal.or(Ordering::Equal); + /// assert_eq!(result, Ordering::Equal); + /// + /// let x = (1, 2, 7); + /// let y = (1, 5, 3); + /// let result = x.0.cmp(y.0).or(x.1.cmp(y.1)).or(x.2.cmp(y.2)); + /// + /// assert_eq!(result, Ordering::Less); + /// ``` + #[unstable(feature = "ordering_chaining", issue = "37053")] + pub fn or(self, other: Ordering) -> Ordering { + match self { + Equal => other, + _ => self, + } + } + + /// Chain the ordering with given function. + /// + /// Returns `self` when it's not `Equal`. Otherwise calls `f` and returns + /// the result. + /// + /// # Examples + /// + /// ``` + /// use std::cmp::Ordering; + /// + /// let result = Ordering::Equal.or_else(|| Ordering::Less); + /// assert_eq!(result, Ordering::Less); + /// + /// let result = Ordering::Less.or_else(|| Ordering::Equal); + /// assert_eq!(result, Ordering::Less); + /// + /// let result = Ordering::Less.or_else(|| Ordering::Greater); + /// assert_eq!(result, Ordering::Less); + /// + /// let result = Ordering::Equal.or_else(|| Ordering::Equal); + /// assert_eq!(result, Ordering::Equal); + /// + /// let x = (1, 2, 7); + /// let y = (1, 5, 3); + /// let result = x.0.cmp(&y.0).or_else(|| x.1.cmp(&y.1)).or_else(|| x.2.cmp(&y.2)); + /// + /// assert_eq!(result, Ordering::Less); + /// ``` + #[unstable(feature = "ordering_chaining", issue = "37053")] + pub fn or_else Ordering>(self, f: F) -> Ordering { + match self { + Equal => f(), + _ => self, + } + } } /// Trait for types that form a [total order](https://en.wikipedia.org/wiki/Total_order). diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs index 051356cad16..94f66e4d151 100644 --- a/src/libcoretest/cmp.rs +++ b/src/libcoretest/cmp.rs @@ -41,6 +41,32 @@ fn test_ordering_order() { assert_eq!(Greater.cmp(&Less), Greater); } +#[test] +fn test_ordering_or() { + assert_eq!(Equal.or(Less), Less); + assert_eq!(Equal.or(Equal), Equal); + assert_eq!(Equal.or(Greater), Greater); + assert_eq!(Less.or(Less), Less); + assert_eq!(Less.or(Equal), Less); + assert_eq!(Less.or(Greater), Less); + assert_eq!(Greater.or(Less), Greater); + assert_eq!(Greater.or(Equal), Greater); + assert_eq!(Greater.or(Greater), Greater); +} + +#[test] +fn test_ordering_or_else() { + assert_eq!(Equal.or_else(|| Less), Less); + assert_eq!(Equal.or_else(|| Equal), Equal); + assert_eq!(Equal.or_else(|| Greater), Greater); + assert_eq!(Less.or_else(|| Less), Less); + assert_eq!(Less.or_else(|| Equal), Less); + assert_eq!(Less.or_else(|| Greater), Less); + assert_eq!(Greater.or_else(|| Less), Greater); + assert_eq!(Greater.or_else(|| Equal), Greater); + assert_eq!(Greater.or_else(|| Greater), Greater); +} + #[test] fn test_user_defined_eq() { // Our type. diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index 590bf478aa7..aad0d2fedaa 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -34,6 +34,7 @@ #![feature(unique)] #![feature(iter_max_by)] #![feature(iter_min_by)] +#![feature(ordering_chaining)] extern crate core; extern crate test; From def0b4ebc8da5cce04bc24881de8c0e6bb13bbe0 Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Sun, 9 Oct 2016 14:10:56 +0200 Subject: [PATCH 2/7] Fix trailing whitespace. --- src/libcore/cmp.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 58b3db0ad39..942a236fe9e 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -246,8 +246,8 @@ impl Ordering { } } - /// Chain two orderings. - /// + /// Chain two orderings. + /// /// Returns `self` when it's not `Equal`. Otherwise returns `other`. /// # Examples /// @@ -281,10 +281,10 @@ impl Ordering { } /// Chain the ordering with given function. - /// + /// /// Returns `self` when it's not `Equal`. Otherwise calls `f` and returns /// the result. - /// + /// /// # Examples /// /// ``` From ca76d43dcb931dc8c0c1fd2a1ea5e68203d341b1 Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Mon, 10 Oct 2016 18:54:37 +0200 Subject: [PATCH 3/7] Fix comments --- src/libcore/cmp.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 942a236fe9e..07f02b9c685 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -246,7 +246,7 @@ impl Ordering { } } - /// Chain two orderings. + /// Chains two orderings. /// /// Returns `self` when it's not `Equal`. Otherwise returns `other`. /// # Examples @@ -280,7 +280,7 @@ impl Ordering { } } - /// Chain the ordering with given function. + /// Chains the ordering with the given function. /// /// Returns `self` when it's not `Equal`. Otherwise calls `f` and returns /// the result. From 43a022660acf414f3463eb63392f344796b8e7dc Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Sun, 16 Oct 2016 20:24:20 +0200 Subject: [PATCH 4/7] Fix doctests --- src/libcore/cmp.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 07f02b9c685..d4566b5a694 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -266,8 +266,8 @@ impl Ordering { /// let result = Ordering::Equal.or(Ordering::Equal); /// assert_eq!(result, Ordering::Equal); /// - /// let x = (1, 2, 7); - /// let y = (1, 5, 3); + /// let x: (i64, i64, i64) = (1, 2, 7); + /// let y: (i64, i64, i64) = (1, 5, 3); /// let result = x.0.cmp(y.0).or(x.1.cmp(y.1)).or(x.2.cmp(y.2)); /// /// assert_eq!(result, Ordering::Less); @@ -302,8 +302,8 @@ impl Ordering { /// let result = Ordering::Equal.or_else(|| Ordering::Equal); /// assert_eq!(result, Ordering::Equal); /// - /// let x = (1, 2, 7); - /// let y = (1, 5, 3); + /// let x: (i64, i64, i64) = (1, 2, 7); + /// let y: (i64, i64, i64) = (1, 5, 3); /// let result = x.0.cmp(&y.0).or_else(|| x.1.cmp(&y.1)).or_else(|| x.2.cmp(&y.2)); /// /// assert_eq!(result, Ordering::Less); From c78a2121105736e951bbbae1cfe48b7874144cf6 Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Mon, 17 Oct 2016 08:37:54 +0200 Subject: [PATCH 5/7] Add ordering_chaining feature to libcore/lib.rs --- src/libcore/lib.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 1ae4cf8e5ef..26eae84dee8 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -92,6 +92,7 @@ #![feature(question_mark)] #![feature(never_type)] #![feature(prelude_import)] +#![feature(ordering_chaining)] #[prelude_import] #[allow(unused)] From 634715a736236ba797036d76aed872ff03277fd7 Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Sat, 22 Oct 2016 12:44:24 +0200 Subject: [PATCH 6/7] Actually fix doctests. --- src/libcore/cmp.rs | 6 +++++- src/libcore/lib.rs | 1 - 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index d4566b5a694..7d4b0139d9b 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -252,6 +252,8 @@ impl Ordering { /// # Examples /// /// ``` + /// #![feature(ordering_chaining)] + /// /// use std::cmp::Ordering; /// /// let result = Ordering::Equal.or(Ordering::Less); @@ -268,7 +270,7 @@ impl Ordering { /// /// let x: (i64, i64, i64) = (1, 2, 7); /// let y: (i64, i64, i64) = (1, 5, 3); - /// let result = x.0.cmp(y.0).or(x.1.cmp(y.1)).or(x.2.cmp(y.2)); + /// let result = x.0.cmp(&y.0).or(x.1.cmp(&y.1)).or(x.2.cmp(&y.2)); /// /// assert_eq!(result, Ordering::Less); /// ``` @@ -288,6 +290,8 @@ impl Ordering { /// # Examples /// /// ``` + /// #![feature(ordering_chaining)] + /// /// use std::cmp::Ordering; /// /// let result = Ordering::Equal.or_else(|| Ordering::Less); diff --git a/src/libcore/lib.rs b/src/libcore/lib.rs index 26eae84dee8..1ae4cf8e5ef 100644 --- a/src/libcore/lib.rs +++ b/src/libcore/lib.rs @@ -92,7 +92,6 @@ #![feature(question_mark)] #![feature(never_type)] #![feature(prelude_import)] -#![feature(ordering_chaining)] #[prelude_import] #[allow(unused)] From 4e2822c5c28bb342e5862ba7cc0b90b865c68be1 Mon Sep 17 00:00:00 2001 From: Marcin Fatyga Date: Thu, 27 Oct 2016 23:31:10 +0200 Subject: [PATCH 7/7] Rename ordering chaining functions. --- src/libcore/cmp.rs | 24 ++++++++++++------------ src/libcoretest/cmp.rs | 40 ++++++++++++++++++++-------------------- 2 files changed, 32 insertions(+), 32 deletions(-) diff --git a/src/libcore/cmp.rs b/src/libcore/cmp.rs index 7d4b0139d9b..31920fcb0f8 100644 --- a/src/libcore/cmp.rs +++ b/src/libcore/cmp.rs @@ -256,26 +256,26 @@ impl Ordering { /// /// use std::cmp::Ordering; /// - /// let result = Ordering::Equal.or(Ordering::Less); + /// let result = Ordering::Equal.then(Ordering::Less); /// assert_eq!(result, Ordering::Less); /// - /// let result = Ordering::Less.or(Ordering::Equal); + /// let result = Ordering::Less.then(Ordering::Equal); /// assert_eq!(result, Ordering::Less); /// - /// let result = Ordering::Less.or(Ordering::Greater); + /// let result = Ordering::Less.then(Ordering::Greater); /// assert_eq!(result, Ordering::Less); /// - /// let result = Ordering::Equal.or(Ordering::Equal); + /// let result = Ordering::Equal.then(Ordering::Equal); /// assert_eq!(result, Ordering::Equal); /// /// let x: (i64, i64, i64) = (1, 2, 7); /// let y: (i64, i64, i64) = (1, 5, 3); - /// let result = x.0.cmp(&y.0).or(x.1.cmp(&y.1)).or(x.2.cmp(&y.2)); + /// let result = x.0.cmp(&y.0).then(x.1.cmp(&y.1)).then(x.2.cmp(&y.2)); /// /// assert_eq!(result, Ordering::Less); /// ``` #[unstable(feature = "ordering_chaining", issue = "37053")] - pub fn or(self, other: Ordering) -> Ordering { + pub fn then(self, other: Ordering) -> Ordering { match self { Equal => other, _ => self, @@ -294,26 +294,26 @@ impl Ordering { /// /// use std::cmp::Ordering; /// - /// let result = Ordering::Equal.or_else(|| Ordering::Less); + /// let result = Ordering::Equal.then_with(|| Ordering::Less); /// assert_eq!(result, Ordering::Less); /// - /// let result = Ordering::Less.or_else(|| Ordering::Equal); + /// let result = Ordering::Less.then_with(|| Ordering::Equal); /// assert_eq!(result, Ordering::Less); /// - /// let result = Ordering::Less.or_else(|| Ordering::Greater); + /// let result = Ordering::Less.then_with(|| Ordering::Greater); /// assert_eq!(result, Ordering::Less); /// - /// let result = Ordering::Equal.or_else(|| Ordering::Equal); + /// let result = Ordering::Equal.then_with(|| Ordering::Equal); /// assert_eq!(result, Ordering::Equal); /// /// let x: (i64, i64, i64) = (1, 2, 7); /// let y: (i64, i64, i64) = (1, 5, 3); - /// let result = x.0.cmp(&y.0).or_else(|| x.1.cmp(&y.1)).or_else(|| x.2.cmp(&y.2)); + /// let result = x.0.cmp(&y.0).then_with(|| x.1.cmp(&y.1)).then_with(|| x.2.cmp(&y.2)); /// /// assert_eq!(result, Ordering::Less); /// ``` #[unstable(feature = "ordering_chaining", issue = "37053")] - pub fn or_else Ordering>(self, f: F) -> Ordering { + pub fn then_with Ordering>(self, f: F) -> Ordering { match self { Equal => f(), _ => self, diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs index 94f66e4d151..e3c65ad8b33 100644 --- a/src/libcoretest/cmp.rs +++ b/src/libcoretest/cmp.rs @@ -42,29 +42,29 @@ fn test_ordering_order() { } #[test] -fn test_ordering_or() { - assert_eq!(Equal.or(Less), Less); - assert_eq!(Equal.or(Equal), Equal); - assert_eq!(Equal.or(Greater), Greater); - assert_eq!(Less.or(Less), Less); - assert_eq!(Less.or(Equal), Less); - assert_eq!(Less.or(Greater), Less); - assert_eq!(Greater.or(Less), Greater); - assert_eq!(Greater.or(Equal), Greater); - assert_eq!(Greater.or(Greater), Greater); +fn test_ordering_then() { + assert_eq!(Equal.then(Less), Less); + assert_eq!(Equal.then(Equal), Equal); + assert_eq!(Equal.then(Greater), Greater); + assert_eq!(Less.then(Less), Less); + assert_eq!(Less.then(Equal), Less); + assert_eq!(Less.then(Greater), Less); + assert_eq!(Greater.then(Less), Greater); + assert_eq!(Greater.then(Equal), Greater); + assert_eq!(Greater.then(Greater), Greater); } #[test] -fn test_ordering_or_else() { - assert_eq!(Equal.or_else(|| Less), Less); - assert_eq!(Equal.or_else(|| Equal), Equal); - assert_eq!(Equal.or_else(|| Greater), Greater); - assert_eq!(Less.or_else(|| Less), Less); - assert_eq!(Less.or_else(|| Equal), Less); - assert_eq!(Less.or_else(|| Greater), Less); - assert_eq!(Greater.or_else(|| Less), Greater); - assert_eq!(Greater.or_else(|| Equal), Greater); - assert_eq!(Greater.or_else(|| Greater), Greater); +fn test_ordering_then_with() { + assert_eq!(Equal.then_with(|| Less), Less); + assert_eq!(Equal.then_with(|| Equal), Equal); + assert_eq!(Equal.then_with(|| Greater), Greater); + assert_eq!(Less.then_with(|| Less), Less); + assert_eq!(Less.then_with(|| Equal), Less); + assert_eq!(Less.then_with(|| Greater), Less); + assert_eq!(Greater.then_with(|| Less), Greater); + assert_eq!(Greater.then_with(|| Equal), Greater); + assert_eq!(Greater.then_with(|| Greater), Greater); } #[test]