Struct TupleSpecifier 

pub struct TupleSpecifier<'a> {
    pub span: &'a str,
    pub types: Vec<TypeSpecifier<'a>>,
}

A tuple specifier, with no array suffixes. Corresponds to a sequence of types.

The internal types are all TypeSpecifier, and may be arbitrarily complex.

Examples

let spec = TupleSpecifier::parse("(uint256,uint256)")?;
assert_eq!(spec.span(), "(uint256,uint256)");
assert_eq!(spec.types.len(), 2);
assert_eq!(spec.types[0].span(), "uint256");

// No array suffixes. Use `TypeSpecifier` instead.
assert!(TupleSpecifier::parse("(uint256,uint256)[]").is_err());

Fields

span: &'a str

The full span of the tuple specifier.

types: Vec<TypeSpecifier<'a>>

The internal types.

Implementations

impl<'a> TupleSpecifier<'a>

pub fn parse(input: &'a str) -> Result<Self>

Parse a tuple specifier from a string.

pub const fn span(&self) -> &'a str

Returns the tuple specifier as a string.

pub fn try_basic_solidity(&self) -> Result<()>

Returns true if the type is a basic Solidity type.

Trait Implementations

impl AsRef<str> for TupleSpecifier<'_>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for TupleSpecifier<'a>

fn clone(&self) -> TupleSpecifier<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for TupleSpecifier<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for TupleSpecifier<'a>

fn eq(&self, other: &TupleSpecifier<'a>) -> 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<'a> TryFrom<&'a str> for TupleSpecifier<'a>

type Error = Error

The type returned in the event of a conversion error.

fn try_from(value: &'a str) -> Result<Self>

Performs the conversion.

impl<'a> Eq for TupleSpecifier<'a>

impl<'a> StructuralPartialEq for TupleSpecifier<'a>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 20 bytes