Enum Ty 

pub enum Ty {
    Bool,
    Int,
    Uint,
    Float,
    String,
    Path,
    Url,
    Duration,
    Object,
    List(&'static Ty),
    Set(&'static Ty),
    Map(&'static Ty),
    Option(&'static Ty),
    Any,
}

A declared type, as a generated registry holds it.

Containers borrow so the whole thing is const-constructible: Ty::List(&Ty::String).

Variants

Bool

Int

Uint

An integer that may not be negative.

Float

String

Path

A filesystem path. Read as a string here; what makes it a path is what the CLI does with it, and refusing one because it does not exist yet would be wrong.

Url

Duration

A span of time, as text — "30s", "1h". Not parsed here: the crate that owns the duration type owns its spelling, and the generated struct is where it is turned into one.

Object

A table whose keys the spec does not describe.

List(&'static Ty)

Set(&'static Ty)

Like a list, but duplicates are dropped on merge.

Map(&'static Ty)

A table with values of one type.

Option(&'static Ty)

Absent is a legitimate state. Only meaningful about the setting as a whole, so coercion looks straight through it.

Any

A union, or a type only the tool understands. Nothing is coerced and nothing is refused: the spec said usage cannot know what belongs here, so it takes what it is given.

Implementations

impl Ty

pub fn inner(self) -> Ty

The innermost type, looking through option.

pub fn name(self) -> String

This type as the spec spells it: uint, list<string>, option<path>.

Distinct from Ty::describe, which is prose for an error message. An explanation shows the author’s own vocabulary, because that is what a reader will search the docs for — “type a non-negative integer” sends them looking for something no spec says.

pub fn describe(self) -> &'static str

The name of this type as an error message should say it.

pub fn coerce(self, value: Value) -> Result<Value, TypeError>

value read as this type.

Text arriving from a layer that has no types of its own is converted; a value that already has the right shape passes through untouched. Anything else is an error rather than a silent reinterpretation — the whole point of declaring the type.

Trait Implementations

impl Clone for Ty

fn clone(&self) -> Ty

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Ty

impl Debug for Ty

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

Formats the value using the given formatter.

impl PartialEq for Ty

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Ty