better inverse Refine<Rep> for Tag trait

Author: functora

rust/functora-tagged/src/lib.rs

@@ -1,3 +1,4 @@
+#![doc = include_str!("../README.md")]
 use std::fmt::Debug;
 use std::marker::PhantomData;
 use std::str::FromStr;
@@ -6,20 +7,20 @@ use thiserror::Error;
 #[derive(Debug)]
 pub struct Tagged<Rep, Tag>(Rep, PhantomData<Tag>);
 
-pub trait Refine<Tag>: Sized {
+pub trait Refine<Rep>: Sized {
     type RefineError;
 
-    fn refine(self) -> Result<Self, Self::RefineError> {
-        Ok(self)
+    fn refine(rep: Rep) -> Result<Rep, Self::RefineError> {
+        Ok(rep)
     }
 }
 
 impl<Rep, Tag> Tagged<Rep, Tag> {
-    pub fn new(rep: Rep) -> Result<Self, Rep::RefineError>
+    pub fn new(rep: Rep) -> Result<Self, Tag::RefineError>
     where
-        Rep: Refine<Tag>,
+        Tag: Refine<Rep>,
     {
-        rep.refine().map(|rep| Tagged(rep, PhantomData))
+        Tag::refine(rep).map(|rep| Tagged(rep, PhantomData))
     }
     pub fn rep(&self) -> &Rep {
         &self.0
@@ -58,17 +59,19 @@ impl<Rep: Clone, Tag> Clone for Tagged<Rep, Tag> {
 #[derive(Debug, Error)]
 pub enum ParseError<Rep, Tag>
 where
-    Rep: FromStr + Refine<Tag>,
+    Rep: FromStr,
+    Tag: Refine<Rep>,
 {
     #[error("Decode failed: {0}")]
     Decode(Rep::Err),
     #[error("Refine failed: {0}")]
-    Refine(Rep::RefineError),
+    Refine(Tag::RefineError),
 }
 
 impl<Rep, Tag> FromStr for Tagged<Rep, Tag>
 where
-    Rep: FromStr + Refine<Tag>,
+    Rep: FromStr,
+    Tag: Refine<Rep>,
 {
     type Err = ParseError<Rep, Tag>;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -100,8 +103,9 @@ impl<Rep: Serialize, Tag> Serialize for Tagged<Rep, Tag> {
 #[cfg(feature = "serde")]
 impl<'de, Rep, Tag> Deserialize<'de> for Tagged<Rep, Tag>
 where
-    Rep: Deserialize<'de> + Refine<Tag>,
-    Rep::RefineError: Display,
+    Rep: Deserialize<'de>,
+    Tag: Refine<Rep>,
+    Tag::RefineError: Display,
 {
     fn deserialize<D>(
         deserializer: D,
@@ -165,8 +169,9 @@ mod diesel_impl {
 
     impl<DB, Rep, Tag, ST> FromSql<ST, DB> for Tagged<Rep, Tag>
     where
-        Rep: FromSql<ST, DB> + Refine<Tag>,
-        Rep::RefineError: 'static + Error + Send + Sync,
+        Rep: FromSql<ST, DB>,
+        Tag: Refine<Rep>,
+        Tag::RefineError: 'static + Error + Send + Sync,
         DB: Backend,
     {
         fn from_sql(
@@ -180,8 +185,9 @@ mod diesel_impl {
     impl<Rep, Tag, ST, DB> Queryable<ST, DB>
         for Tagged<Rep, Tag>
     where
-        Rep: Queryable<ST, DB> + Refine<Tag>,
-        Rep::RefineError: 'static + Error + Send + Sync,
+        Rep: Queryable<ST, DB>,
+        Tag: Refine<Rep>,
+        Tag::RefineError: 'static + Error + Send + Sync,
         DB: Backend,
     {
         type Row = Rep::Row;

rust/functora-tagged/tests/integration.rs

@@ -22,13 +22,15 @@ pub type Email = Tagged<NonEmpty<String>, EmailTag>;
 #[error("Empty value is not allowed")]
 pub struct EmptyError;
 
-impl Refine<NonEmptyTag> for String {
+impl Refine<String> for NonEmptyTag {
     type RefineError = EmptyError;
-    fn refine(self) -> Result<Self, Self::RefineError> {
-        if self.is_empty() {
+    fn refine(
+        rep: String,
+    ) -> Result<String, Self::RefineError> {
+        if rep.is_empty() {
             Err(EmptyError)
         } else {
-            Ok(self)
+            Ok(rep)
         }
     }
 }
@@ -37,12 +39,14 @@ impl Refine<NonEmptyTag> for String {
 #[error("Invalid UserId format")]
 pub struct UserIdError;
 
-impl Refine<UserIdTag> for NonEmpty<String> {
+impl Refine<NonEmpty<String>> for UserIdTag {
     type RefineError = UserIdError;
-    fn refine(self) -> Result<Self, Self::RefineError> {
-        let txt = self.rep();
+    fn refine(
+        rep: NonEmpty<String>,
+    ) -> Result<NonEmpty<String>, Self::RefineError> {
+        let txt = rep.rep();
         if txt.starts_with("user_") && txt.len() > 5 {
-            Ok(self)
+            Ok(rep)
         } else {
             Err(UserIdError)
         }
@@ -53,14 +57,16 @@ impl Refine<UserIdTag> for NonEmpty<String> {
 #[error("String is too short: {0}, minimum length: 3")]
 pub struct EmailError(usize);
 
-impl Refine<EmailTag> for NonEmpty<String> {
+impl Refine<NonEmpty<String>> for EmailTag {
     type RefineError = EmailError;
-    fn refine(self) -> Result<Self, Self::RefineError> {
-        let len = self.clone().rep().len();
+    fn refine(
+        rep: NonEmpty<String>,
+    ) -> Result<NonEmpty<String>, Self::RefineError> {
+        let len = rep.clone().rep().len();
         if len < 3 {
             Err(EmailError(len))
         } else {
-            Ok(self)
+            Ok(rep)
         }
     }
 }