ip

type struct Name { ... }
type enum Name { ... }
type trait Name { ... }
type union Name { ... }

Begins a type declaration; the keyword that follows says which kind. On its own, type Name = Existing; declares an alias.

type struct Name {
    field: Type;
    method(&this) -> Ret { ... }
}

A value type with named fields and optional methods. Structs live on the stack and are passed by value. Fields are public by default and may carry = default values; methods take their receiver as &this, mut &this, or this.

primitive u8

8-bit unsigned integer.

static name(param: Type) -> Ret { ... }

A method that belongs to the type rather than an instance, called as Type::name(..). For structs, static new(..) returning a struct literal is the idiomatic constructor.

static IpV4Addr::unspecified() -> IpV4Addr

0.0.0.0: "any interface" for a bound listener.

static IpV4Addr::localhost() -> IpV4Addr

127.0.0.1.

static IpV4Addr::broadcast() -> IpV4Addr

255.255.255.255.

IpV4Addr::octet(&this, index: u64) -> u8

Returns the four octets in big-endian (network) order.

&this
mut &this
this

The receiver of a method. Its first parameter declares how the method takes it: &this borrows read-only, mut &this borrows exclusively, and this / mut this move the value in and consume it. In the body, this.field reaches the members.

primitive u64

64-bit unsigned integer.

primitive boolean

true / false. Not interchangeable with integers. 1 byte.

IpV4Addr::to_u32(&this) -> u32

Host-byte-order u32 representation. High byte is a.

primitive u32

32-bit unsigned integer.

static IpV4Addr::parse(source: Str) -> Result<IpV4Addr, ConversionError>

Parse canonical a.b.c.d. Returns Err(ConversionError) on any failure (extra whitespace, out-of-range octets, missing or extra dots, leading/trailing separators); the error is describable/printable. Use parse_opt if you only need presence, not the reason.

type struct Str {
    bytes: u8*;
    length: u64;
}

Str: a borrowed UTF-8 string slice.

type enum Result<T, E> {
    Ok(T);
    Err(E);
}

Result: a value that may be an error.

type struct ConversionError {
    reason: string;
}

What went wrong in a TryFrom / TryInto. Carries a short static message describing the failure; richer diagnostics are a caller concern.

static IpV4Addr::parse_opt(source: Str) -> Option<IpV4Addr>

Detail-free variant of parse: None on any failure. Backs parse and suits callers that branch only on success/failure.

type enum Option<T> {
    Some(T);
    None;
}

Option: a value that may be absent.

type struct IpV6Addr {
    segments: [u8;
    16];
}

Sixteen octets in network byte order. parse accepts the canonical text forms (full 8-group, ::-compressed, and trailing embedded-v4); addresses may also be constructed directly.

type struct IpV6Addr {
    segments: [u8;
    16];
}

Sixteen octets in network byte order. parse accepts the canonical text forms (full 8-group, ::-compressed, and trailing embedded-v4); addresses may also be constructed directly.

static IpV6Addr::from_buf(p: u8*) -> IpV6Addr

Build from sixteen network-order octets at p[0..16] (e.g. the sin6_addr of a kernel-filled sockaddr_in6).

IpV6Addr::group_at(&this, group: u64) -> u16

The two-byte group at group (0..8), big-endian (segments are in network order, so the high byte comes first).

primitive u16

16-bit unsigned integer.

IpV6Addr::is_loopback(&this) -> boolean

::1.

IpV6Addr::is_unspecified(&this) -> boolean

::.

static IpV6Addr::parse(source: Str) -> Result<IpV6Addr, ConversionError>

Parse canonical IPv6 text: full a:b:c:d:e:f:g:h, ::-compressed (one run at most), and a trailing embedded IPv4 (::ffff:1.2.3.4). Returns Err(ConversionError) on any malformed input; use parse_opt for the detail-free variant.

static IpV6Addr::parse_opt(source: Str) -> Option<IpV6Addr>

Detail-free variant of parse: None on any malformed input.

type enum Name {
    Unit,
    Payload(T),
    Named { x: i32 },
}

An algebraic data type. Variants may be bare or carry a tuple or struct payload, and a match on an enum must cover every variant. Name::Variant names a variant; methods are added with implement enum Name { ... }.

implement struct Name { ... }
implement trait Trait for Type { ... }
implement u64 { ... }

Adds methods to a type outside its declaration. implement struct T (or enum, or a bare primitive) opens an inherent block; implement trait Tr for T supplies a trait's methods for one type. Resolution is at compile time - no dynamic dispatch.

implement enum Name { ... }

Names the enum an inherent block extends - the only way to give an enum methods.

static IpAddr::parse(source: Str) -> Result<IpAddr, ConversionError>

Parse textual form. A ':' routes to the v6 parser; otherwise v4. Returns Err(ConversionError) if the selected parser rejects the input; use parse_opt for the detail-free variant.

static IpAddr::parse_opt(source: Str) -> Option<IpAddr>

Detail-free variant of parse: None if the selected parser rejects.

import a::b;
import a::b::{ X, Y };
import a::b as c;
import a::b::*;

Brings a module, or selected items from it, into scope. One path per declaration: use the brace form for several items, as to alias, and * for everything public (prefer the brace form; wildcards invite name collisions).

namespace std;

std: the Cryo standard library.

namespace std::net;

net: network primitives + HTTP.

namespace std::net::addr;

net::addr: addressing primitives.

namespace std::net::addr::ip;

IP addresses.

const NAME: Type = value;

At module level, a true compile-time constant, conventionally SCREAMING_SNAKE_CASE. (mut at module level declares mutable global state instead.)

static IpV4Addr::localhost() -> IpV4Addr

127.0.0.1.

match (subject) {
    Pattern(x) => { ... }
    _          => { ... }
}

The primary discriminator: branches on enum variants, integers, ranges, and destructuring patterns, and the compiler rejects a match that misses a case. There is no fallthrough. As an expression it evaluates to the chosen arm's value, so every arm must produce the same type.

static IpAddr::parse(source: Str) -> Result<IpAddr, ConversionError>

Parse textual form. A ':' routes to the v6 parser; otherwise v4. Returns Err(ConversionError) if the selected parser rejects the input; use parse_opt for the detail-free variant.

static Str::new(text: string) -> Str

Construct from a NUL-terminated C-style string literal. The caller certifies that text is valid UTF-8 and outlives this view. The NUL terminator is not included in the view.

pattern => { body }

Separates a match arm's pattern from its body. Arms do not fall through.

static IpV4Addr::unspecified() -> IpV4Addr

0.0.0.0: "any interface" for a bound listener.

static IpV4Addr::broadcast() -> IpV4Addr

255.255.255.255.

static IpV4Addr::parse(source: Str) -> Result<IpV4Addr, ConversionError>

Parse canonical a.b.c.d. Returns Err(ConversionError) on any failure (extra whitespace, out-of-range octets, missing or extra dots, leading/trailing separators); the error is describable/printable. Use parse_opt if you only need presence, not the reason.

static IpV4Addr::parse_opt(source: Str) -> Option<IpV4Addr>

Detail-free variant of parse: None on any failure. Backs parse and suits callers that branch only on success/failure.

IpV4Addr::to_u32(&this) -> u32

Host-byte-order u32 representation. High byte is a.

IpV4Addr::octet(&this, index: u64) -> u8

Returns the four octets in big-endian (network) order.

IpV6Addr::group_at(&this, group: u64) -> u16

The two-byte group at group (0..8), big-endian (segments are in network order, so the high byte comes first).

static IpV6Addr::from_buf(p: u8*) -> IpV6Addr

Build from sixteen network-order octets at p[0..16] (e.g. the sin6_addr of a kernel-filled sockaddr_in6).

start..end

A half-open range - start up to but excluding end - and sugar for Range::new(start, end): an iterator usable in for, and an ordinary value anywhere else. It binds looser than arithmetic, so a..b + 1 is a..(b + 1).