Enum Type

pub enum Type<'a> {
    NamedType(NamedType<'a>),
    ListType(&'a Type<'a>),
    NonNullType(&'a Type<'a>),
}

AST Node for a type reference.

VariableDefinitions must describe their type when they’re defined, including whether they expect lists, non-null values, or a type reference, which is a recursive type definition. Reference

Variants

NamedType(NamedType<'a>)

A reference to a named input type, which is a leaf node of a Type.

ListType(&'a Type<'a>)

A list node wrapper for a Type, which indicates that a GraphQL API will always pass a list of the contained type in place.

NonNullType(&'a Type<'a>)

A non-null node wrapper for a Type, which indicates that a GraphQL API may not pass null instead of the conained type.

Implementations

impl<'a> Type<'a>

pub fn into_list(self, ctx: &'a ASTContext) -> Type<'a>

Wraps this type in a list, indicating that it expects the current Type to be a list of itself instead.

pub fn into_nonnull(self, ctx: &'a ASTContext) -> Type<'a>

A non-null node wrapper for a Type, indicating that a GraphQL API may not pass null instead of the conained type.

pub fn of_type(&'a self) -> &'a NamedType<'a>

Unwraps a Type recursively and returns the NamedType that is contained within its wrappers.

Trait Implementations

impl<'a> Clone for Type<'a>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Type<'a>

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

Formats the value using the given formatter.

impl<'a> From<NamedType<'a>> for Type<'a>

fn from(x: NamedType<'a>) -> Self

Converts to this type from the input type.

impl<'a> Hash for Type<'a>

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<'a> PartialEq for Type<'a>

fn eq(&self, other: &Type<'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> PrintNode for Type<'a>

fn write_to_buffer(&self, level: usize, buffer: &mut dyn Write) -> Result

Write an AST node to a buffer implementing the Write trait.

fn print(&self) -> String

Print an AST Node to source text as a String allocated on the heap.

impl<'a> Copy for Type<'a>

impl<'a> Eq for Type<'a>

impl<'a> StructuralPartialEq for Type<'a>