bare-types 0.3.0

A zero-cost foundation for type-safe domain modeling in Rust. Implements the 'Parse, don't validate' philosophy to eliminate primitive obsession and ensure data integrity at the system boundary.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

//! Example demonstrating the net module types
#![allow(unused_crate_dependencies)]

use bare_types::net::{DomainName, Host, Hostname, IpAddr, Port, SocketAddr};

fn main() {
    println!("=== bare-types net module demo ===\n");

    // IP Address
    let ipv4: IpAddr = "192.168.1.1".parse().expect("valid IPv4");
    let ipv6: IpAddr = "::1".parse().expect("valid IPv6");
    println!("IP Address examples:");
    println!("  - IPv4: {}", ipv4);
    println!("  - IPv6: {}", ipv6);
    println!("  - IPv4 is loopback: {}", ipv4.is_loopback());
    println!("  - IPv6 is loopback: {}\n", ipv6.is_loopback());

    // Port
    let http_port = Port::HTTP;
    let custom_port: Port = 8080.try_into().expect("valid port");
    println!("Port examples:");
    println!("  - HTTP: {}", http_port);
    println!("  - Custom: {}", custom_port);
    println!("  - Is system port: {}\n", http_port.is_system_port());

    // Hostname
    let hostname: Hostname = "my-server".parse().expect("valid hostname");
    println!("Hostname example: {}", hostname);
    println!("  - Is localhost: {}", hostname.is_localhost());
    println!("  - Labels: {:?}\n", hostname.labels().collect::<Vec<_>>());

    // Domain Name
    let domain: DomainName = "example.com".parse().expect("valid domain");
    println!("Domain Name example: {}", domain);
    println!("  - Depth: {}", domain.depth());
    println!("  - Labels: {:?}\n", domain.labels().collect::<Vec<_>>());

    // Host (unified type)
    let ip_host: Host = "192.168.1.1".parse().expect("valid host");
    let domain_host: Host = "example.com".parse().expect("valid host");
    println!("Host examples:");
    println!("  - IP host: {}", ip_host);
    println!("  - Domain host: {}", domain_host);
    println!("  - IP host is localhost: {}\n", ip_host.is_localhost());

    // Socket Address
    let socket: SocketAddr = "example.com:443".parse().expect("valid socket address");
    println!("Socket Address example: {}", socket);
    let (host, port) = socket.into_parts();
    println!("  - Host: {}", host);
    println!("  - Port: {}", port);

    println!("\nAll types are:");
    println!("  - Zero-cost abstractions");
    println!("  - Fully no_std compatible");
    println!("  - Type-safe with validation at construction");
    println!("  - RFC compliant (RFC 1035, RFC 1123)");
}