Struct Function 

pub struct Function<S> {
    pub name: String,
    pub body: Rc<dyn FunctionBodyObject<S>>,
    pub origin: Location,
    pub read_only_location: Option<Location>,
}

Definition of a function.

Fields

name: String

String that identifies the function.

body: Rc<dyn FunctionBodyObject<S>>

Command that is executed when the function is called.

This is wrapped in Rc so that we don’t have to clone the entire command when we define a function. The function definition command only clones the Rc object from the abstract syntax tree to create a Function object.

origin: Location

Location of the function definition command that defined this function.

read_only_location: Option<Location>

Optional location where this function was made read-only.

If this function is not read-only, read_only_location is None. Otherwise, read_only_location is the location of the simple command that executed the readonly built-in that made this function read-only.

Implementations

impl<S> Function<S>

pub fn new<N: Into<String>, B: Into<Rc<dyn FunctionBodyObject<S>>>>( name: N, body: B, origin: Location, ) -> Self

Creates a new function.

This is a convenience function for constructing a Function object. The read_only_location is set to None.

pub fn make_read_only(self, location: Location) -> Self

Makes the function read-only.

This is a convenience function for doing self.read_only_location = Some(location) in a method chain.

pub const fn is_read_only(&self) -> bool

Whether this function is read-only or not.

Trait Implementations

impl<S> Clone for Function<S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S> Debug for Function<S>

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

Formats the value using the given formatter.

impl<S> From<Function<S>> for Target<S>

fn from(function: Function<S>) -> Target<S>

Converts to this type from the input type.

impl<S> PartialEq for Function<S>

Compares two functions for equality.

Two functions are considered equal if all their members are equal. This includes comparing the body members by pointer equality.

fn eq(&self, other: &Self) -> 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<S> Eq for Function<S>