Remove result aliases

Author: clarfonthey

src/lib.rs

@@ -57,7 +57,7 @@ pub use crate::quick_check::{
     check_nfc, check_nfc_quick, check_nfc_stream_safe, check_nfc_stream_safe_quick, check_nfd,
     check_nfd_quick, check_nfd_stream_safe, check_nfd_stream_safe_quick, check_nfkc,
     check_nfkc_quick, check_nfkd, check_nfkd_quick, is_nfc, is_nfc_stream_safe, is_nfd,
-    is_nfd_stream_safe, is_nfkc, is_nfkd, FullResult, NormalizationError, QuickCheck, QuickResult,
+    is_nfd_stream_safe, is_nfkc, is_nfkd, NormalizationError, QuickCheck,
 };
 pub use crate::recompose::Recompositions;
 pub use crate::replace::Replacements;

src/quick_check.rs

@@ -47,12 +47,6 @@ pub enum QuickCheck {
     Maybe,
 }
 
-/// Result of quickly checking if a string is normalized.
-pub type QuickResult = Result<QuickCheck, NormalizationError>;
-
-/// Result of authoritatively checking if a string is normalized.
-pub type FullResult = Result<(), NormalizationError>;
-
 /// Normalization status of single character.
 pub(crate) enum IsNormalized {
     Yes,
@@ -62,7 +56,11 @@ pub(crate) enum IsNormalized {
 
 // https://unicode.org/reports/tr15/#Detecting_Normalization_Forms
 #[inline]
-fn quick_check<F, I>(s: I, is_allowed: F, stream_safe: bool) -> QuickResult
+fn quick_check<F, I>(
+    s: I,
+    is_allowed: F,
+    stream_safe: bool,
+) -> Result<QuickCheck, NormalizationError>
 where
     I: Iterator<Item = (usize, char)>,
     F: Fn(char) -> IsNormalized,
@@ -112,7 +110,7 @@ where
 fn full_check<I: Iterator<Item = (usize, char)>, J: Iterator<Item = char>>(
     check: I,
     normalized: J,
-) -> FullResult {
+) -> Result<(), NormalizationError> {
     check.zip(normalized).try_for_each(|((idx, lhs), rhs)| {
         if lhs == rhs {
             Ok(())
@@ -124,43 +122,43 @@ fn full_check<I: Iterator<Item = (usize, char)>, J: Iterator<Item = char>>(
 
 /// Quickly check if a string is in NFC.
 #[inline]
-pub fn check_nfc_quick(s: &str) -> QuickResult {
+pub fn check_nfc_quick(s: &str) -> Result<QuickCheck, NormalizationError> {
     quick_check(s.char_indices(), tables::qc_nfc, false)
 }
 
 /// Quickly check if a string is in NFKC.
 #[inline]
-pub fn check_nfkc_quick(s: &str) -> QuickResult {
+pub fn check_nfkc_quick(s: &str) -> Result<QuickCheck, NormalizationError> {
     quick_check(s.char_indices(), tables::qc_nfkc, false)
 }
 
 /// Quickly check if a string is in NFD.
 #[inline]
-pub fn check_nfd_quick(s: &str) -> QuickResult {
+pub fn check_nfd_quick(s: &str) -> Result<QuickCheck, NormalizationError> {
     quick_check(s.char_indices(), tables::qc_nfd, false)
 }
 
 /// Quickly check if a string is in NFKD.
 #[inline]
-pub fn check_nfkd_quick(s: &str) -> QuickResult {
+pub fn check_nfkd_quick(s: &str) -> Result<QuickCheck, NormalizationError> {
     quick_check(s.char_indices(), tables::qc_nfkd, false)
 }
 
 /// Quickly check if a string is Stream-Safe NFC.
 #[inline]
-pub fn check_nfc_stream_safe_quick(s: &str) -> QuickResult {
+pub fn check_nfc_stream_safe_quick(s: &str) -> Result<QuickCheck, NormalizationError> {
     quick_check(s.char_indices(), tables::qc_nfc, true)
 }
 
 /// Quickly check if a string is Stream-Safe NFD.
 #[inline]
-pub fn check_nfd_stream_safe_quick(s: &str) -> QuickResult {
+pub fn check_nfd_stream_safe_quick(s: &str) -> Result<QuickCheck, NormalizationError> {
     quick_check(s.char_indices(), tables::qc_nfd, true)
 }
 
 /// Authoritatively check if a string is in NFC.
 #[inline]
-pub fn check_nfc(s: &str) -> FullResult {
+pub fn check_nfc(s: &str) -> Result<(), NormalizationError> {
     match check_nfc_quick(s)? {
         QuickCheck::Yes => Ok(()),
         QuickCheck::Maybe => full_check(s.char_indices(), s.chars().nfc()),
@@ -175,7 +173,7 @@ pub fn is_nfc(s: &str) -> bool {
 
 /// Authoritatively check if a string is in NFKC.
 #[inline]
-pub fn check_nfkc(s: &str) -> FullResult {
+pub fn check_nfkc(s: &str) -> Result<(), NormalizationError> {
     match check_nfkc_quick(s)? {
         QuickCheck::Yes => Ok(()),
         QuickCheck::Maybe => full_check(s.char_indices(), s.chars().nfkc()),
@@ -190,7 +188,7 @@ pub fn is_nfkc(s: &str) -> bool {
 
 /// Authoritatively check if a string is in NFD.
 #[inline]
-pub fn check_nfd(s: &str) -> FullResult {
+pub fn check_nfd(s: &str) -> Result<(), NormalizationError> {
     match check_nfd_quick(s)? {
         QuickCheck::Yes => Ok(()),
         QuickCheck::Maybe => full_check(s.char_indices(), s.chars().nfd()),
@@ -205,7 +203,7 @@ pub fn is_nfd(s: &str) -> bool {
 
 /// Authoritatively check if a string is in NFKD.
 #[inline]
-pub fn check_nfkd(s: &str) -> FullResult {
+pub fn check_nfkd(s: &str) -> Result<(), NormalizationError> {
     match check_nfkd_quick(s)? {
         QuickCheck::Yes => Ok(()),
         QuickCheck::Maybe => full_check(s.char_indices(), s.chars().nfkd()),
@@ -220,7 +218,7 @@ pub fn is_nfkd(s: &str) -> bool {
 
 /// Authoritatively check if a string is Stream-Safe NFC.
 #[inline]
-pub fn check_nfc_stream_safe(s: &str) -> FullResult {
+pub fn check_nfc_stream_safe(s: &str) -> Result<(), NormalizationError> {
     match check_nfc_stream_safe_quick(s)? {
         QuickCheck::Yes => Ok(()),
         QuickCheck::Maybe => full_check(s.char_indices(), s.chars().stream_safe().nfc()),
@@ -235,7 +233,7 @@ pub fn is_nfc_stream_safe(s: &str) -> bool {
 
 /// Authoritatively check if a string is Stream-Safe NFD.
 #[inline]
-pub fn check_nfd_stream_safe(s: &str) -> FullResult {
+pub fn check_nfd_stream_safe(s: &str) -> Result<(), NormalizationError> {
     match check_nfd_stream_safe_quick(s)? {
         QuickCheck::Yes => Ok(()),
         QuickCheck::Maybe => full_check(s.char_indices(), s.chars().stream_safe().nfd()),