Implement traits for Refinement manually.

Author: nekitdev

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "refinement-types"
-version = "0.1.0"
+version = "0.0.0"
 authors = ["nekitdev <[email protected]>"]
 edition = "2024"
 description = "Refinement types."
@@ -28,6 +28,10 @@ optional = true
 version = "2.0.11"
 default-features = false
 
+[dev-dependencies.refinement-types]
+features = ["regex", "serde"]
+path = "."
+
 [features]
 default = ["std"]
 serde = ["dep:serde"]
@@ -36,5 +40,5 @@ alloc = []
 std = []
 
 [package.metadata.docs.rs]
-features = ["regex", "serde", "std"]
+features = ["regex", "serde"]
 rustdoc-args = ["--cfg", "docsrs"]

README.md

@@ -21,7 +21,7 @@ Or by directly specifying it in the configuration like so:
 
 ```toml
 [dependencies]
-refinement-types = "0.1.0"
+refinement-types = "0.0.0"
 ```
 
 Alternatively, you can add it directly from the source:
@@ -33,11 +33,70 @@ git = "https://github.com/nekitdev/refinement-types.git"
 
 ## Examples
 
-TODO
+### Library
+
+```rust
+// lib.rs
+
+#![no_std]
+
+use core::fmt;
+
+use refinement_types::{Refinement, int::U8Closed, length::Closed, logic::And, str::IsAscii};
+
+/// Represents device names.
+pub type Name<'n> = Refinement<&'n str, And<Closed<1, 32>, IsAscii>>;
+
+/// Represents device charge, in percentage.
+pub type Charge = Refinement<u8, U8Closed<1, 100>>;
+
+/// Represents devices.
+#[derive(Debug)]
+pub struct Device<'d> {
+    /// The name of the device.
+    name: Name<'d>,
+    /// The charge of the device.
+    charge: Charge,
+}
+
+impl fmt::Display for Device<'_> {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            formatter,
+            "{name}: {charge}%",
+            name = self.name,
+            charge = self.charge
+        )
+    }
+}
+
+impl<'d> Device<'d> {
+    /// Constructs [`Self`].
+    pub fn new(name: Name<'d>, charge: Charge) -> Self {
+        Self { name, charge }
+    }
+}
+```
+
+### Binary
+
+```rust
+// main.rs
+
+use device::{Charge, Device, Name};
+use refinement_types::MessageError;
 
-## Features
+fn main() -> Result<(), MessageError> {
+    let charge = Charge::refine(69)?;
+    let name = Name::refine("nekit")?;
 
-TODO
+    let device = Device::new(name, charge);
+
+    println!("{device}"); // nekit: 69%
+
+    Ok(())
+}
+```
 
 ## Documentation
 

changelogging.toml

@@ -1,6 +1,6 @@
 [context]
 name = "refinement-types"
-version = "0.1.0"
+version = "0.0.0"
 url = "https://github.com/nekitdev/refinement-types"
 
 [formats]

src/char.rs

@@ -71,7 +71,7 @@ macro_rules! predicate {
         Expected = $expected: expr,
     ) => {
         paste! {
-            #[derive(Debug, Error)]
+            #[derive(Debug, Error, Default)]
             #[error($message)]
             #[doc = $error]
             pub struct [<Non $name Error>];

src/core.rs

@@ -1,6 +1,12 @@
 //! Core functionality.
 
-use core::{fmt, marker::PhantomData, ops::Deref};
+use core::{
+    cmp::Ordering,
+    fmt,
+    hash::{Hash, Hasher},
+    marker::PhantomData,
+    ops::Deref,
+};
 
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Deserializer, Serialize, Serializer, de};
@@ -79,19 +85,100 @@ impl<T: ?Sized, P: Predicate<T> + ?Sized> fmt::Display for Expected<T, P> {
 ///
 /// Values of this type are guaranteed to contain values of type `T`
 /// that satisfy the predicate `P`.
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Refinement<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized = NoContext> {
     value: T,
     predicate: PhantomData<P>,
     context: PhantomData<C>,
 }
 
+impl<T: fmt::Debug, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> fmt::Debug
+    for Refinement<T, P, C>
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.get().fmt(formatter)
+    }
+}
+
+impl<T: fmt::Display, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> fmt::Display
+    for Refinement<T, P, C>
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.get().fmt(formatter)
+    }
+}
+
+impl<T: Clone, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Clone for Refinement<T, P, C> {
+    fn clone(&self) -> Self {
+        unsafe { Self::unchecked(self.get().clone()) }
+    }
+}
+
+impl<T: Copy, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Copy for Refinement<T, P, C> {}
+
+impl<T: PartialEq, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> PartialEq
+    for Refinement<T, P, C>
+{
+    fn eq(&self, other: &Self) -> bool {
+        self.get().eq(other.get())
+    }
+}
+
+impl<T: Eq, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Eq for Refinement<T, P, C> {}
+
+impl<T: PartialOrd, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> PartialOrd
+    for Refinement<T, P, C>
+{
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.get().partial_cmp(other.get())
+    }
+}
+
+impl<T: Ord, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Ord for Refinement<T, P, C> {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.get().cmp(other.get())
+    }
+}
+
+impl<T: Hash, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Hash for Refinement<T, P, C> {
+    fn hash<H: Hasher>(&self, hasher: &mut H) {
+        self.get().hash(hasher);
+    }
+}
+
+impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Deref for Refinement<T, P, C> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.get()
+    }
+}
+
+impl<T: Default, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Refinement<T, P, C> {
+    /// Refines the default value of type `T`.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`struct@Error`] if the default value does not satisfy the predicate.
+    pub fn try_default() -> Result<Self, Error<T, P, C>> {
+        Self::refine(T::default())
+    }
+
+    /// Constructs [`Self`] without checking the default value.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the default value satisfies the predicate.
+    pub unsafe fn unchecked_default() -> Self {
+        unsafe { Self::unchecked(T::default()) }
+    }
+}
+
 #[cfg(feature = "serde")]
 impl<T: Serialize, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Serialize
     for Refinement<T, P, C>
 {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        self.value.serialize(serializer)
+        self.get().serialize(serializer)
     }
 }
 
@@ -128,7 +215,7 @@ impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Refinement<T, P, C> {
 /// This error is constructed from the value that failed to satisfy the predicate
 /// and the error produced by the predicate.
 #[derive(Debug, Error)]
-#[error("expected {expected} [{context}]", expected = P::expected(), context = C::VALUE)]
+#[error("expected {expected} [{context}]", expected = P::expected(), context = Self::context())]
 pub struct Error<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized = NoContext> {
     /// The value that failed to satisfy the predicate.
     pub value: T,
@@ -141,6 +228,48 @@ pub struct Error<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized = NoContext> {
     pub context: PhantomData<C>,
 }
 
+#[cfg(feature = "alloc")]
+use alloc::string::{String, ToString};
+
+/// Represents errors that retain their message and invalid value.
+#[cfg(any(feature = "alloc", feature = "std"))]
+#[derive(Debug, Error)]
+#[error("{message}")]
+pub struct ErasedError<T> {
+    /// The value that failed to satisfy the predicate.
+    pub value: T,
+    /// The expectation message.
+    pub message: String,
+}
+
+impl<T> ErasedError<T> {
+    /// Constructs [`Self`].
+    pub const fn new(value: T, message: String) -> Self {
+        Self { value, message }
+    }
+}
+
+/// Represents errors that only retain their message.
+#[cfg(any(feature = "alloc", feature = "std"))]
+#[derive(Debug, Error)]
+#[error("{string}")]
+pub struct MessageError {
+    /// The expectation message.
+    pub string: String,
+}
+
+impl MessageError {
+    /// Constructs [`Self`].
+    pub const fn new(string: String) -> Self {
+        Self { string }
+    }
+
+    /// Returns the expectation message.
+    pub fn string(&self) -> &str {
+        self.string.as_str()
+    }
+}
+
 impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Error<T, P, C> {
     /// Constructs [`Self`].
     pub const fn new(value: T, error: P::Error) -> Self {
@@ -167,6 +296,34 @@ impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Error<T, P, C> {
     }
 }
 
+impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Error<T, P, C> {
+    /// Erases the source error, retaining only the value and the expectation message.
+    pub fn erase(self) -> ErasedError<T> {
+        let string = self.to_string();
+
+        ErasedError::new(self.value, string)
+    }
+}
+
+impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Error<T, P, C> {
+    /// Erases the source error and discards the value, retaining only the expectation message.
+    pub fn message(&self) -> MessageError {
+        MessageError::new(self.to_string())
+    }
+}
+
+impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> From<Error<T, P, C>> for ErasedError<T> {
+    fn from(error: Error<T, P, C>) -> Self {
+        error.erase()
+    }
+}
+
+impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> From<Error<T, P, C>> for MessageError {
+    fn from(error: Error<T, P, C>) -> Self {
+        error.message()
+    }
+}
+
 impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Error<T, P, C> {
     /// Returns the contained value and the received error.
     pub fn into_parts(self) -> (T, P::Error) {
@@ -206,7 +363,7 @@ impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Refinement<T, P, C> {
     ///
     /// Returns [`struct@Error`] if the resulting value does not satisfy the predicate.
     pub fn map<F: FnOnce(T) -> T>(self, function: F) -> Result<Self, Error<T, P, C>> {
-        Self::refine(function(self.value))
+        Self::refine(function(self.take()))
     }
 
     /// Replaces the value of the refinement.
@@ -218,8 +375,8 @@ impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Refinement<T, P, C> {
         Self::refine(value)
     }
 
-    /// Extracts the value from the refinement.
-    pub fn extract(self) -> T {
+    /// Takes the value from the refinement.
+    pub fn take(self) -> T {
         self.value
     }
 
@@ -228,30 +385,3 @@ impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Refinement<T, P, C> {
         &self.value
     }
 }
-
-impl<T: Default, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Refinement<T, P, C> {
-    /// Refines the default value of type `T`.
-    ///
-    /// # Errors
-    ///
-    /// Returns [`struct@Error`] if the default value does not satisfy the predicate.
-    pub fn try_default() -> Result<Self, Error<T, P, C>> {
-        Self::refine(T::default())
-    }
-}
-
-impl<T: fmt::Display, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> fmt::Display
-    for Refinement<T, P, C>
-{
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        self.value.fmt(formatter)
-    }
-}
-
-impl<T, P: Predicate<T> + ?Sized, C: TypeStr + ?Sized> Deref for Refinement<T, P, C> {
-    type Target = T;
-
-    fn deref(&self) -> &Self::Target {
-        self.get()
-    }
-}

src/empty.rs

@@ -14,7 +14,7 @@ pub trait HasEmpty {
 }
 
 /// Represents errors that occur when the provided value is non-empty.
-#[derive(Debug, Error)]
+#[derive(Debug, Error, Default)]
 #[error("received non-empty value")]
 pub struct NonEmptyError;