Primitive type Type

If this type is an array, return a pair of (element type, size type).

Example:

comptime {
    let array_type = quote { [Field; 3] }.as_type();
    let (field_type, three_type) = array_type.as_array().unwrap();

    assert(field_type.is_field());
    assert_eq(three_type.as_constant().unwrap(), 3);
}

If this type is a constant integer (such as the 3 in the array type [Field; 3]), return the numeric constant.

If this is an integer type, return a boolean which is true if the type is signed, as well as the number of bits of this integer type.

If this is a mutable reference type &mut T, returns the mutable type T.

If this is a slice type, return the element type of the slice.

If this is a str<N> type, returns the length N as a type.

If this is a struct or enum type, returns the type in addition to any generic arguments on this type.

If this is a tuple type, returns each element type of the tuple.

Retrieves the trait implementation that implements the given trait constraint for this type. If the trait constraint is not found, None is returned. Note that since the concrete trait implementation for a trait constraint specified from a where clause is unknown, this function will return None in these cases. If you only want to know whether a type implements a trait, use implements instead.

Example:

comptime {
    let field_type = quote { Field }.as_type();
    let default = quote { Default }.as_trait_constraint();

    let the_impl: TraitImpl = field_type.get_trait_impl(default).unwrap();
    assert(the_impl.methods().len(), 1);
}

Returns true if this type implements the given trait. Note that unlike get_trait_impl this will also return true for any where constraints in scope.

Example:

fn foo<T>() where T: Default {
    comptime {
        let field_type = quote { Field }.as_type();
        let default = quote { Default }.as_trait_constraint();
        assert(field_type.implements(default));

        let t = quote { T }.as_type();
        assert(t.implements(default));
    }
}

Returns true if this type is bool.

Returns true if this type is Field.

Returns true if this type is the unit () type.

Note that this is syntactic equality, this is not the same as whether two types will type check to be the same type. Unless type inference or generics are being used however, users should not typically have to worry about this distinction.