Struct BuiltinSchema 

pub struct BuiltinSchema {
    pub name: &'static str,
    pub parameters: &'static [&'static str],
    pub namespace: bool,
    pub cases: &'static [CaseSchema],
    pub fields: &'static [FieldSchema],
    pub methods: &'static [MethodSchema],
    pub associated: &'static [MethodSchema],
}

One builtin type: its name, its type parameters, and what may be called on a value of it or on the name of it.

Fields

name: &'static str

The name Cove source writes, such as Array.

parameters: &'static [&'static str]

The type parameters the receiver binds, in the order they are written: ["K", "V"] for Map<K, V>.

A method’s signature names these, and a call site reads them off the receiver the method was called on.

namespace: bool

Whether the name may be written as a namespace, as in Vector.of(...) or Int.parse(...).

This is not the same question as whether the type has associated functions. Array.something() is a call on the builtin type Array whatever something turns out to be, and answering “Array has no associated function something” is better than treating Array as an undeclared name. The types that say false are the ones no program writes the name of: a Task comes from scope.spawn, a Shared from the Shared(...) constructor, a Scope from scope name { ... }, and a Range or a Unit from an expression that makes one. Duration used to be in that list and is not any more — a duration built from a number a program computed is written Duration.millis(n), so the name is one a program writes.

cases: &'static [CaseSchema]

The cases, for a builtin enum. Empty for everything else.

Option and Result are the two, and this is the one list of what they are made of: match exhaustiveness, the sentence that names a missing case, the type a pattern’s binding gets, and the value the interpreter builds all read it here.

fields: &'static [FieldSchema]

The fields, for a builtin struct. Empty for everything else.

Error and MapEntry are the two. The order is the order an initializer takes them in and a diagnostic reads them out.

methods: &'static [MethodSchema]

What may be called on a value of this type.

The order is the order a diagnostic lists them in when it has to say what does exist.

associated: &'static [MethodSchema]

What may be called on the type itself.

Implementations

impl BuiltinSchema

pub fn method(&self, name: &str) -> Option<&'static MethodSchema>

The method name, if this type has one.

pub fn associated_function(&self, name: &str) -> Option<&'static MethodSchema>

The associated function name, if this type has one.

pub fn case(&self, name: &str) -> Option<&'static CaseSchema>

The case name, if this type declares one.

pub fn field(&self, name: &str) -> Option<&'static FieldSchema>

The field name, if this type declares one.

pub fn is_enum(&self) -> bool

Whether this is a builtin enum, which is what having cases means.

pub fn is_struct(&self) -> bool

Whether this is a builtin struct, which is what having fields means.

Trait Implementations

impl Clone for BuiltinSchema

fn clone(&self) -> BuiltinSchema

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BuiltinSchema

impl Debug for BuiltinSchema

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

Formats the value using the given formatter.

impl Eq for BuiltinSchema

impl PartialEq for BuiltinSchema

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