Enum Typing

#[non_exhaustive]
pub enum Typing<Validation = AlwaysValid> {
    None,
    Common(UniversalType),
    Extension(ExtensionType),
    Named(String),
    Path {
        absolute: bool,
        path: Vec<String>,
        name: String,
    },
    Option(Box<Self>),
    Tuple(Vec<Self>),
    Array(usize, Box<Self>),
    Vec(Box<Self>),
    Set(Box<Self>),
    Map(Box<Self>, Box<Self>),
    Foreign(Box<Self>),
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

None

The none type.

Common(UniversalType)

Universal types in almost every language.

See UniversalType

Extension(ExtensionType)

Common types hard to describe with normal data structures. Prefixed with +.

i.e. +datetime, +rgba, +uuid

See ExtensionType

Named(String)

A named type, with its contents defined elsewhere.

Path

A type with a path.

Fields

absolute: bool

if true, indicate this is an absolute path i.e.::path

path: Vec<String>

path to name i.e [path::to]::name

name: String

last item in the path i.e path::to::[name]

Option(Box<Self>)

An optional or nullable type.

Tuple(Vec<Self>)

A nameless product type deliminated with comma.

i.e. (int,string,char)

Array(usize, Box<Self>)

A fix sized array.

i.e. [10]int

Vec(Box<Self>)

A variable sized array.

i.e. []int

Set(Box<Self>)

A set of keys.

i.e. [int]

Map(Box<Self>, Box<Self>)

A set of key value pairs.

i.e. [string]int

Foreign(Box<Self>)

A hint that the type is foreign.

i.e. @path::to::struct

Trait Implementations

impl<Validation: Clone> Clone for Typing<Validation>

fn clone(&self) -> Typing<Validation>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Validation: Debug> Debug for Typing<Validation>

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

Formats the value using the given formatter.

impl<V> Display for Typing<V>

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

Formats the value using the given formatter.

impl<V: IdentValidation> FromStr for Typing<V>

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

type-protocol assumes compact whitespace-less strings. This function does not identify whitespaces in any way and will keep them in the resulting ident. Remove them before calling this function if you need to.

type Err = Error

The associated error which can be returned from parsing.

impl<Validation: Hash> Hash for Typing<Validation>

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<Validation: PartialEq> PartialEq for Typing<Validation>

fn eq(&self, other: &Typing<Validation>) -> 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<Validation: Eq> Eq for Typing<Validation>

impl<Validation> StructuralPartialEq for Typing<Validation>