diff --git a/validator/src/validation/length.rs b/validator/src/validation/length.rs
index 3f0b4307..e0bf1a3c 100644
--- a/validator/src/validation/length.rs
+++ b/validator/src/validation/length.rs
@@ -15,15 +15,8 @@ pub fn validate_length<T: ValidateLength>(
     max: Option<u64>,
     equal: Option<u64>,
 ) -> bool {
-    value.validate_length(min, max, equal)
-}
+    let length = value.length();
 
-fn validate_length_for_trait(
-    length: u64,
-    min: Option<u64>,
-    max: Option<u64>,
-    equal: Option<u64>,
-) -> bool {
     if let Some(eq) = equal {
         return length == eq;
     } else {
@@ -43,117 +36,190 @@ fn validate_length_for_trait(
 }
 
 pub trait ValidateLength {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool;
+    //fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool;
+    fn length(&self) -> u64;
 }
 
 impl ValidateLength for String {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.chars().count() as u64
     }
 }
 
 impl<'a> ValidateLength for &'a String {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.chars().count() as u64
     }
 }
 
 impl<'a> ValidateLength for &'a str {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.chars().count() as u64
     }
 }
 
 impl<'a> ValidateLength for Cow<'a, str> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.chars().count() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.chars().count() as u64
     }
 }
 
 impl<T> ValidateLength for Vec<T> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<'a, T> ValidateLength for &'a Vec<T> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<T> ValidateLength for &[T] {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<T, const N: usize> ValidateLength for [T; N] {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(N as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(N as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        N as u64
     }
 }
 
 impl<T, const N: usize> ValidateLength for &[T; N] {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(N as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(N as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        N as u64
     }
 }
 
 impl<'a, K, V, S> ValidateLength for &'a HashMap<K, V, S> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<K, V, S> ValidateLength for HashMap<K, V, S> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<'a, T, S> ValidateLength for &'a HashSet<T, S> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<'a, K, V> ValidateLength for &'a BTreeMap<K, V> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<'a, T> ValidateLength for &'a BTreeSet<T> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 impl<T> ValidateLength for BTreeSet<T> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 #[cfg(feature = "indexmap")]
 impl<'a, K, V> ValidateLength for &'a IndexMap<K, V> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 #[cfg(feature = "indexmap")]
 impl<'a, T> ValidateLength for &'a IndexSet<T> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
 #[cfg(feature = "indexmap")]
 impl<T> ValidateLength for IndexSet<T> {
-    fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-        validate_length_for_trait(self.len() as u64, min, max, equal)
+    // fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
+    //     validate_length_for_trait(self.len() as u64, min, max, equal)
+    // }
+
+    fn length(&self) -> u64 {
+        self.len() as u64
     }
 }
 
@@ -161,7 +227,7 @@ impl<T> ValidateLength for IndexSet<T> {
 mod tests {
     use std::borrow::Cow;
 
-    use crate::{validate_length, validation::length::ValidateLength};
+    use crate::{validate_length};
 
     #[test]
     fn test_validate_length_equal_overrides_min_max() {
@@ -202,43 +268,42 @@ mod tests {
         assert!(validate_length("日本", None, None, Some(2)));
     }
 
-
-    #[test]
-    fn test_validate_length_trait_equal_overrides_min_max() {
-        assert!(String::from("hello").validate_length(Some(1), Some(2), Some(5)));
-    }
-
-    #[test]
-    fn test_validate_length_trait_string_min_max() {
-        assert!(String::from("hello").validate_length(Some(1), Some(10), None));
-    }
-
-    #[test]
-    fn test_validate_length_trait_string_min_only() {
-        assert!(!String::from("hello").validate_length(Some(10), None, None));
-    }
-
-    #[test]
-    fn test_validate_length_trait_string_max_only() {
-        assert!(!String::from("hello").validate_length(None, Some(1), None));
-    }
-
-    #[test]
-    fn test_validate_length_trait_cow() {
-        let test: Cow<'static, str> = "hello".into();
-        assert!(test.validate_length(None, None, Some(5)));
-
-        let test: Cow<'static, str> = String::from("hello").into();
-        assert!(test.validate_length(None, None, Some(5)));
-    }
-
-    #[test]
-    fn test_validate_length_trait_vec() {
-        assert!(vec![1, 2, 3].validate_length(None, None, Some(3)));
-    }
-
-    #[test]
-    fn test_validate_length_trait_unicode_chars() {
-        assert!(String::from("日本").validate_length(None, None, Some(2)));
-    }
+    // #[test]
+    // fn test_validate_length_trait_equal_overrides_min_max() {
+    //     assert!(String::from("hello").validate_length(Some(1), Some(2), Some(5)));
+    // }
+
+    // #[test]
+    // fn test_validate_length_trait_string_min_max() {
+    //     assert!(String::from("hello").validate_length(Some(1), Some(10), None));
+    // }
+
+    // #[test]
+    // fn test_validate_length_trait_string_min_only() {
+    //     assert!(!String::from("hello").validate_length(Some(10), None, None));
+    // }
+
+    // #[test]
+    // fn test_validate_length_trait_string_max_only() {
+    //     assert!(!String::from("hello").validate_length(None, Some(1), None));
+    // }
+
+    // #[test]
+    // fn test_validate_length_trait_cow() {
+    //     let test: Cow<'static, str> = "hello".into();
+    //     assert!(test.validate_length(None, None, Some(5)));
+
+    //     let test: Cow<'static, str> = String::from("hello").into();
+    //     assert!(test.validate_length(None, None, Some(5)));
+    // }
+
+    // #[test]
+    // fn test_validate_length_trait_vec() {
+    //     assert!(vec![1, 2, 3].validate_length(None, None, Some(3)));
+    // }
+
+    // #[test]
+    // fn test_validate_length_trait_unicode_chars() {
+    //     assert!(String::from("日本").validate_length(None, None, Some(2)));
+    // }
 }
diff --git a/validator_derive_tests/tests/length.rs b/validator_derive_tests/tests/length.rs
index 45745ea1..fd2bce4a 100644
--- a/validator_derive_tests/tests/length.rs
+++ b/validator_derive_tests/tests/length.rs
@@ -225,31 +225,14 @@ fn can_validate_set_ref_for_length() {
 
 #[test]
 fn can_validate_custom_impl_for_length() {
-	use serde::Serialize;
+    use serde::Serialize;
 
-	#[derive(Debug, Serialize)]
+    #[derive(Debug, Serialize)]
     struct CustomString(String);
 
     impl validator::ValidateLength for &CustomString {
-        fn validate_length(&self, min: Option<u64>, max: Option<u64>, equal: Option<u64>) -> bool {
-			let length = self.0.chars().count() as u64;
-
-			if let Some(eq) = equal {
-				return length == eq;
-			} else {
-				if let Some(m) = min {
-					if length < m {
-						return false;
-					}
-				}
-				if let Some(m) = max {
-					if length > m {
-						return false;
-					}
-				}
-			}
-		
-			true
+        fn length(&self) -> u64 {
+            self.0.chars().count() as u64
         }
     }
 
@@ -259,30 +242,30 @@ fn can_validate_custom_impl_for_length() {
         val: CustomString,
     }
 
-	#[derive(Debug, Validate)]
-	struct EqualsTestStruct {
-		#[validate(length(equal = 11))]
-		val: CustomString
-	}
+    #[derive(Debug, Validate)]
+    struct EqualsTestStruct {
+        #[validate(length(equal = 11))]
+        val: CustomString
+    }
 
     let too_short = TestStruct {
         val: CustomString(String::from("oops"))
     };
 
-	let too_long = TestStruct {
-		val: CustomString(String::from("too long for this"))
-	};
+    let too_long = TestStruct {
+        val: CustomString(String::from("too long for this"))
+    };
 
-	let ok = TestStruct {
-		val: CustomString(String::from("perfect"))
-	};
+    let ok = TestStruct {
+        val: CustomString(String::from("perfect"))
+    };
 
-	let equals_ok = EqualsTestStruct {
-		val: CustomString(String::from("just enough"))
-	};
+    let equals_ok = EqualsTestStruct {
+        val: CustomString(String::from("just enough"))
+    };
 
     assert!(too_short.validate().is_err());
     assert!(too_long.validate().is_err());
-	assert!(ok.validate().is_ok());
-	assert!(equals_ok.validate().is_ok());
+    assert!(ok.validate().is_ok());
+    assert!(equals_ok.validate().is_ok());
 }
\ No newline at end of file