Struct Tagged

pub struct Tagged<T, Tag> { /* private fields */ }

rust-tagged provides a simple way to define strongly typed wrappers over primitive types like String, i32, Uuid, chrono::DateTime, etc. It helps eliminate bugs caused by misusing raw primitives for conceptually distinct fields such as UserId, Email, ProductId, and more.

Eliminate accidental mixups between similar types (e.g. OrgId vs UserId) Enforce domain modeling in code via the type system Ergonomic .into() support for primitive conversions

Example - Simple

use tagged_core::{Tagged};
 
#[derive(Debug)]
struct EmailTag;
 
type Email = Tagged<String, EmailTag>;
 
fn main() {
    let email: Email = "test@example.com".into();
    println!("Email inner value: {}", email.value());
 
    // Convert back to String
    let raw: String = email.into();
    println!("Raw String: {raw}");
}

Example - Debug

use tagged_core::Tagged;
 
 
#[derive(Debug)]
struct UserIdTag {
    a: Tagged<u32, Self>,
    b: Tagged<u32, Self>,
}
 
 
fn main() {
    let instance = UserIdTag{a: 1.into(), b: 2.into()};
 
    println!("{}", instance.a);
    println!("{:?}", instance.b);
}

Example - Hash

fn main() {
    use tagged_core::Tagged;
    use std::collections::HashSet;
 
    #[derive(Clone, Hash, Debug, PartialEq, Eq)]
    struct User {
        id: Tagged<String, Self>
    }
    let mut s: HashSet<User> = HashSet::new();
    let user = User{id: "me@example.com".into()};
    s.insert(user.clone());
 
    assert!(s.contains(&user));
}

Example - Iter

use tagged_core::Tagged;
 
#[derive(Debug)]
struct Org;
 
type EmployeeNames = Tagged<Vec<String>, Org>;
 
fn main() {
    let names: EmployeeNames = Tagged::new(vec!["Alice".into(), "Bob".into()]);
 
    for name in &names {
        println!("Name: {name}");
    }
 
    // Consuming iterator
    for name in names {
        println!("Owned: {name}");
    }
}
 
/*
Name: Alice
Name: Bob
Owned: Alice
Owned: Bob
*/

Example - Mutation

use tagged_core::Tagged;
 
#[derive(Debug)]
struct Org;
 
type OrgName = Tagged<String, Org>;
 
fn main() {
    let mut name = OrgName::new("Codefonsi".into());
 
    name.set("New Org Name".into());
 
    println!("Updated Org Name: {}", name.value());
}

rust-tagged provides a simple way to define strongly typed wrappers over primitive types like String, i32, Uuid, chrono::DateTime, etc. It helps eliminate bugs caused by misusing raw primitives for conceptually distinct fields such as UserId, Email, ProductId, and more.

Eliminate accidental mixups between similar types (e.g. OrgId vs UserId) Enforce domain modeling in code via the type system Ergonomic .into() support for primitive conversions

Example - Simple

use tagged_core::{Tagged};

#[derive(Debug)]
struct EmailTag;

type Email = Tagged<String, EmailTag>;

fn main() {
    let email: Email = "test@example.com".into();
    println!("Email inner value: {}", email.value());

    // Convert back to String
    let raw: String = email.into();
    println!("Raw String: {raw}");
}

Example - Debug

use tagged_core::Tagged;


#[derive(Debug)]
struct UserIdTag {
    a: Tagged<u32, Self>,
    b: Tagged<u32, Self>,
}


fn main() {
    let instance = UserIdTag{a: 1.into(), b: 2.into()};

    println!("{}", instance.a);
    println!("{:?}", instance.b);
}

Example - Hash

fn main() {
    use tagged_core::Tagged;
    use std::collections::HashSet;

    #[derive(Clone, Hash, Debug, PartialEq, Eq)]
    struct User {
        id: Tagged<String, Self>
    }
    let mut s: HashSet<User> = HashSet::new();
    let user = User{id: "me@example.com".into()};
    s.insert(user.clone());

    assert!(s.contains(&user));
}

Example - Iter

use tagged_core::Tagged;

#[derive(Debug)]
struct Org;

type EmployeeNames = Tagged<Vec<String>, Org>;

fn main() {
    let names: EmployeeNames = Tagged::new(vec!["Alice".into(), "Bob".into()]);

    for name in &names {
        println!("Name: {name}");
    }

    // Consuming iterator
    for name in names {
        println!("Owned: {name}");
    }
}

/*
Name: Alice
Name: Bob
Owned: Alice
Owned: Bob
*/

Example - Mutation

use tagged_core::Tagged;

#[derive(Debug)]
struct Org;

type OrgName = Tagged<String, Org>;

fn main() {
    let mut name = OrgName::new("Codefonsi".into());

    name.set("New Org Name".into());

    println!("Updated Org Name: {}", name.value());
}

Implementations

impl<T, Tag> Tagged<T, Tag>

pub fn new(value: T) -> Tagged<T, Tag>

pub fn value(&self) -> &T

impl<T, Tag> Tagged<T, Tag>

pub fn set(&mut self, new_value: T)

Not allowed feature - Get a mutable reference to the internal value Replace the inner value

Trait Implementations

impl<T, Tag> Clone for Tagged<T, Tag>

where T: Clone,

fn clone(&self) -> Tagged<T, Tag>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, Tag> Debug for Tagged<T, Tag>

where T: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<T, Tag> Deref for Tagged<T, Tag>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<Tagged<T, Tag> as Deref>::Target

Dereferences the value.

impl<'de, T, Tag> Deserialize<'de> for Tagged<T, Tag>

where T: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<Tagged<T, Tag>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, Tag> Display for Tagged<T, Tag>

where T: Display,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<Tag> From<&String> for Tagged<String, Tag>

Support From<&String> → Tagged<String, Tag>

fn from(s: &String) -> Tagged<String, Tag>

Converts to this type from the input type.

impl<Tag> From<&str> for Tagged<String, Tag>

Support From<&str> → Tagged<String, Tag>

fn from(s: &str) -> Tagged<String, Tag>

Converts to this type from the input type.

impl<T, Tag> From<T> for Tagged<T, Tag>

Blanket From<T> for Tagged<T, Tag>

fn from(value: T) -> Tagged<T, Tag>

Converts to this type from the input type.

impl<T, Tag> Hash for Tagged<T, Tag>

where T: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T, Tag> IntoIterator for &'a Tagged<Vec<T>, Tag>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Tagged<Vec<T>, Tag> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, Tag> IntoIterator for Tagged<Vec<T>, Tag>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Tagged<Vec<T>, Tag> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T, Tag> Ord for Tagged<T, Tag>

where T: Ord,

fn cmp(&self, other: &Tagged<T, Tag>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<T, Tag> PartialEq for Tagged<T, Tag>

where T: PartialEq,

fn eq(&self, other: &Tagged<T, Tag>) -> bool

Tests for self and other values to be equal, and is used by ==.

const fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, Tag> PartialOrd for Tagged<T, Tag>

where T: PartialOrd,

fn partial_cmp(&self, other: &Tagged<T, Tag>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T, Tag> Serialize for Tagged<T, Tag>

where T: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, Tag> Eq for Tagged<T, Tag>

where T: Eq,