Struct valkyrie_ast::ClassDeclaration

pub struct ClassDeclaration {
    pub name: IdentifierNode,
    pub kind: ClassKind,
    pub annotations: AnnotationNode,
    pub generic: Option<ParametersList>,
    pub inherits: Option<String>,
    pub implements: Vec<String>,
    pub terms: Vec<ClassTerm>,
    pub span: Range<u32>,
}

class Name(Super): Trait {}

Full Form

constraint T {
    where {
        T: A
    }
}
//? documents
#[mod1, mod2]
mod3 mod4 class module::Name(Base::<T>): DeriveA + DeriveB {
    _field: int = 1;
    
    construct() {
    
    }
    
    construct(args) {
    
    }
    
    #? documents
    extract() {
    
    }
    
    destruct() {
    
    }
    
    infix `+`() {
    
    }
}

extends module::Name: TraitA + TraitB {
   
}

Generics

constraint A {
    alias {
        Type: <A as Iterator>::Item
    }
    where {
        A: Trait1
    }
}
class Structure<B: Trait2> {
    a: A,
    b: B,
}

∀ A, B {
    where {
        A: Trait1,
        B: Trait2,
        <A as Trait>::Item: B
    }
}
structure Record<B> {
    a: A,
    b: B,
}

Fields

name: IdentifierNode

The name of the class.

kind: ClassKind

The kind of class

annotations: AnnotationNode

The document of the class

generic: Option<ParametersList>

The parameter arguments of the class.

inherits: Option<String>

The super class of the class.

implements: Vec<String>

The traits that the class implements.

terms: Vec<ClassTerm>

All fields declared in this block, exclude extensions.

span: Range<u32>

The range of the number.

Trait Implementations

impl Clone for ClassDeclaration

fn clone(&self) -> ClassDeclaration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ClassDeclaration

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

Formats the value using the given formatter.

impl From<ClassDeclaration> for StatementKind

fn from(o: ClassDeclaration) -> Self

Converts to this type from the input type.

impl Hash for ClassDeclaration

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 PartialEq for ClassDeclaration

fn eq(&self, other: &ClassDeclaration) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ClassDeclaration

impl StructuralPartialEq for ClassDeclaration