remove unused code

Author: cosmicexplorer

src/lib.rs

@@ -1,7 +1,7 @@
 // -*- mode: rust; -*-
 //
 // This file is part of subtle, part of the dalek cryptography project.
-// Copyright (c) 2016-2022 isis lovecruft, Henry de Valence
+// Copyright (c) 2016-2023 isis lovecruft, Henry de Valence
 // See LICENSE for licensing information.
 //
 // Authors:
@@ -254,30 +254,6 @@ pub trait IteratedOperation {
     fn extract_result(self) -> Choice;
 }
 
-/// Implementing this trait automatically implements [`ConstantTimeEq`] and/or
-/// [`ConstantTimeGreater`], depending on [`Self::To`].
-///
-///```
-/// use subtle::{ConstantTimeEq, ConstantTimeGreater, Convertible};
-///
-/// struct S(pub u8);
-/// impl Convertible for S {
-///   type To = u8;
-///   fn for_constant_operation(&self) -> u8 { self.0 }
-/// }
-///
-/// assert_eq!(0, S(0).ct_eq(&S(1)).unwrap_u8());
-/// assert_eq!(1, S(1).ct_eq(&S(1)).unwrap_u8());
-/// assert_eq!(1, S(1).ct_gt(&S(0)).unwrap_u8());
-/// assert_eq!(0, S(1).ct_gt(&S(1)).unwrap_u8());
-///```
-pub trait Convertible {
-    /// The type to convert to.
-    type To;
-    /// Convert to a constant-time comparable object.
-    fn for_constant_operation(&self) -> Self::To;
-}
-
 /// An `Eq`-like trait that produces a `Choice` instead of a `bool`.
 ///
 /// # Example
@@ -350,15 +326,6 @@ impl IteratedEq {
     }
 }
 
-impl<T: ConstantTimeEq, C: Convertible<To = T>> ConstantTimeEq for C {
-    #[inline]
-    fn ct_eq(&self, other: &Self) -> Choice {
-        let a: T = self.for_constant_operation();
-        let b: T = other.for_constant_operation();
-        a.ct_eq(&b)
-    }
-}
-
 impl<T: ConstantTimeEq> ConstantTimeEq for [T] {
     /// Check whether two slices of `ConstantTimeEq` types are equal.
     ///
@@ -927,15 +894,6 @@ impl LexicographicIteratedGreater {
     }
 }
 
-impl<T: ConstantTimeGreater, C: Convertible<To = T>> ConstantTimeGreater for C {
-    #[inline]
-    fn ct_gt(&self, other: &Self) -> Choice {
-        let a: T = self.for_constant_operation();
-        let b: T = other.for_constant_operation();
-        a.ct_gt(&b)
-    }
-}
-
 macro_rules! generate_unsigned_integer_greater {
     ($t_u: ty, $bit_width: expr) => {
         impl ConstantTimeGreater for $t_u {
@@ -1141,12 +1099,3 @@ impl LexicographicIteratedLess {
         *was_gt |= b.ct_lt(&a);
     }
 }
-
-impl<T: ConstantTimeLess, C: Convertible<To = T>> ConstantTimeLess for C {
-    #[inline]
-    fn ct_lt(&self, other: &Self) -> Choice {
-        let a: T = self.for_constant_operation();
-        let b: T = other.for_constant_operation();
-        a.ct_lt(&b)
-    }
-}