Struct EntryMut 

pub struct EntryMut<'t> {
    table: &'t mut Table,
    id: Handle,
}

A mutable, object-like entry in a Table.

Entry wraps a Table and a Handle, and provides an ergonomic interface for querying information about the state of the node at that Handle.

Its immutable counterpart, Entry, provides a similar interface for querying the state of the Table, which may be shared among multiple Entries.

Fields

table: &'t mut Table

id: Handle

Implementations

impl<'t> EntryMut<'t>

pub fn new(table: &'t mut Table, id: Handle) -> Self

Constructs a new EntryMut from a &mut Table and a Handle.

pub const fn id(&self) -> Handle

Gets the Handle associated with this Entry

pub const fn inner(&'t self) -> &'t Table

Gets the Table associated with this Entry

pub fn kind(&self) -> Option<&NodeKind>

Gets the NodeKind of this Entry in the Table

pub const fn root(&self) -> Entry<'_>

Gets the Entry of the root node in the Table

pub fn children(&self) -> Option<&SymMap<Handle>>

Gets the children of this node

pub fn lazy_imports(&self) -> Option<&SymMap<Path>>

Gets the lazy-imports list for this node

pub fn glob_imports(&self) -> Option<&[Path]>

Gets the glob-imports list for this node

pub fn meta(&self) -> Option<&[Expr]>

Gets the meta-Expr list for this node

pub fn name(&self) -> Option<Sym>

Gets an identifying Symbol for this node, if possible

pub fn ty(&self) -> Option<&TypeKind>

Gets the TypeKind of this EntryMut

pub fn inner_mut(&mut self) -> &mut Table

Reborrows the inner Table reference

pub fn as_ref(&self) -> Entry<'_>

Cheaply constructs an Entry from this EntryMut

pub fn evaluate<Out>( &mut self, ty: &impl TypeExpression<Out>, ) -> Result<Out, Error>

Evaluates a TypeExpression in this entry’s context

pub fn categorize(&mut self) -> Result<(), Error>

Calls categorize on this node in the table

pub fn with_id(&mut self, parent: Handle) -> EntryMut<'_>

Constructs a new Handle with the provided parent Handle

pub fn nav(&mut self, path: &[Sym]) -> Option<EntryMut<'_>>

Navigates to another EntryMut, reborrowing the table.

pub fn new_entry(&mut self, kind: NodeKind) -> EntryMut<'_>

Constructs a new node with the given NodeKind, and returns its EntryMut.

pub fn add_child(&mut self, name: Sym, child: Handle) -> Option<Handle>

Adds an existing node as a child with the given name.

If that name is already taken, its previous Handle is returned.

pub fn add_import(&mut self, name: Sym, path: Path)

Adds a lazy-import edge from name to path

pub fn add_glob(&mut self, path: Path)

Adds a glob-import edge to path.

Glob imports act as secondary (tertiary, etc.) parent edges, which are always transparent. They are checked in reverse order, giving later glob imports precedence over earlier ones.

pub fn set_name(&mut self, name: Sym) -> Option<Sym>

Sets the name of this EntryMut.

pub fn set_ty(&mut self, kind: TypeKind) -> Option<TypeKind>

Sets the TypeKind of this EntryMut

pub fn set_meta(&mut self, meta: Vec<Expr>)

Appends a list of Exprs to this EntryMut’s meta.

pub fn add_meta(&mut self, meta: Expr)

Adds a single Expr to this EntryMut’s meta

pub fn set_impl_target(&mut self, target: Handle) -> Option<Handle>

Sets the impl target to target

pub fn mark_unchecked(&mut self)

Marks this EntryMut as unchecked.

pub fn mark_impl_item(&mut self)

Marks this EntryMut as an impl item

pub fn mark_lang_item(&mut self, lang_item: &'static str)

Marks this EntryMut as a lang item

Trait Implementations

impl<'t> Debug for EntryMut<'t>

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

Formats the value using the given formatter.