Struct EmailAddress 

pub struct EmailAddress { /* private fields */ }

A parsed, validated, and normalized email address.

Immutable after construction. All accessors return borrowed data.

Implementations

impl EmailAddress

pub fn parse_with(input: &str, config: &Config) -> Result<Self, Error>

Parse and validate with the given configuration.

pub fn local_part(&self) -> &str

The canonical local part (after normalization).

If subaddress stripping is enabled, this excludes the +tag. If dot stripping is enabled, dots are removed.

pub fn tag(&self) -> Option<&str>

The extracted subaddress tag, if present.

For user+promo@example.com, returns Some("promo"). Always extracted regardless of SubaddressPolicy — the policy only affects whether it appears in canonical().

pub fn domain(&self) -> &str

The canonical domain (IDNA-encoded, lowercased).

pub fn domain_unicode(&self) -> &str

The canonical domain in Unicode form.

For internationalized domains (münchen.de → xn--mnchen-3ya.de), returns the Unicode form of the canonical domain. For ASCII-only domains, returns the same value as domain().

Security

The Unicode form is intended for display only. It may reintroduce IDN homograph attacks where visually similar characters from different scripts produce different domain names (e.g. Cyrillic а vs Latin a).

For security-sensitive comparisons (allow-lists, deduplication, access control), always use domain() which returns the ACE/Punycode form. If you must compare Unicode domains, apply your own confusable-detection logic (see confusable_skeleton()).

use structured_email_address::EmailAddress;

let email: EmailAddress = "user@münchen.de".parse().unwrap();
assert_eq!(email.domain(), "xn--mnchen-3ya.de");
assert_eq!(email.domain_unicode(), "münchen.de");

let ascii: EmailAddress = "user@example.com".parse().unwrap();
assert_eq!(ascii.domain_unicode(), "example.com");

pub fn display_name(&self) -> Option<&str>

The display name, if parsed from "Name" <addr> or Name <addr> format.

pub fn canonical(&self) -> String

The full canonical address: local_part@domain.

If the local part contains characters that require quoting (spaces, special chars), it is wrapped in quotes for RFC compliance.

pub fn original(&self) -> &str

The original input (trimmed).

pub fn skeleton(&self) -> Option<&str>

The confusable skeleton of the local part (if config enabled it).

Two addresses with the same skeleton + domain are visually confusable.

pub fn is_freemail(&self) -> bool

Check if the domain is a well-known freemail provider.

pub fn parse_batch(inputs: &[&str], config: &Config) -> Vec<Result<Self, Error>>

Parse a batch of email addresses with the given configuration.

Returns one Result per input, in the same order. The config is shared across all inputs, amortizing setup cost.

Example

use structured_email_address::{EmailAddress, Config};

let config = Config::default();
let results = EmailAddress::parse_batch(
    &["alice@example.com", "invalid", "bob@example.org"],
    &config,
);
assert!(results[0].is_ok());
assert!(results[1].is_err());
assert!(results[2].is_ok());

Trait Implementations

impl Clone for EmailAddress

fn clone(&self) -> EmailAddress

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EmailAddress

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EmailAddress

Available on crate feature serde only.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl Display for EmailAddress

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

Formats the value using the given formatter.

impl FromStr for EmailAddress

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for EmailAddress

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

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 PartialEq for EmailAddress

Equality is based on canonical form (local_part + domain) only. Display name, tag, and skeleton are intentionally excluded — "John" <user@example.com> equals "Jane" <user@example.com> because they route to the same mailbox.

fn eq(&self, other: &Self) -> bool

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

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 Serialize for EmailAddress

Available on crate feature serde only.

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

Serialize this value into the given Serde serializer.

impl Eq for EmailAddress