Enum RustType

pub enum RustType {
    Generic {
        id: TypeName,
        parameters: Vec<RustType>,
    },
    Special(SpecialRustType),
    Simple {
        id: TypeName,
    },
}

A named Rust type.

Variants

Generic

A type with generic parameters. Consists of a type ID + parameters that come after in angled brackets. Examples include:

• SomeStruct<String>
• SomeEnum<u32>
• SomeTypeAlias<(), &str> However, there are some generic types that are considered to be special. These include Vec<T> HashMap<K, V>, and Option<T>, which are part of SpecialRustType instead of RustType::Generic.

If a generic type is type-mapped via typeshare.toml, the generic parameters will be dropped automatically.

Fields

id: TypeName

parameters: Vec<RustType>

Special(SpecialRustType)

A type that requires a special transformation to its respective language. This includes many core types, like string types, basic container types, numbers, and other primitives.

Simple

A type with no generic parameters that is not considered a special type. This includes all user-generated types and some types from the standard library or third-party crates. However, these types can still be transformed as part of the type-map in typeshare.toml.

Fields

id: TypeName

Implementations

impl RustType

pub fn contains_type(&self, ty: &TypeName) -> bool

Check if a type contains a type with an ID that matches ty. For example, Box<String> contains the types Box and String. Similarly, Vec<Option<HashMap<String, Url>>> contains the types Vec, Option, HashMap, String, and Url.

pub fn id(&self) -> &TypeName

Get the ID (AKA name) of the type.

pub fn is_optional(&self) -> bool

Check if the type is Option<T>

pub fn is_double_optional(&self) -> bool

Check if the type is Option<Option<T>>

pub fn is_vec(&self) -> bool

Check if the type is Vec<T>

pub fn is_hash_map(&self) -> bool

Check if the type is HashMap<K, V>

pub fn parameters(&self) -> Box<dyn Iterator<Item = &Self> + '_>

Get the generic parameters for this type. Returns an empty iterator if there are none. For example, Vec<String>’s generic parameters would be [String]. Meanwhile, HashMap<i64, u32>’s generic parameters would be [i64, u32]. Finally, a type like String would have no generic parameters.

Trait Implementations

impl Clone for RustType

fn clone(&self) -> RustType

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for RustType

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

Formats the value using the given formatter.

impl PartialEq for RustType

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

impl StructuralPartialEq for RustType