Struct oso::Class

pub struct Class<T = ()> {
    pub name: String,
    pub constructor: Option<Constructor>,
    pub attributes: HashMap<Symbol, InstanceMethod>,
    pub instance_methods: HashMap<Symbol, InstanceMethod>,
    pub class_methods: HashMap<Symbol, ClassMethod>,
    pub type_id: TypeId,
    // some fields omitted
}

Fields

name: String

The class name. Defaults to the std::any::type_name

constructor: Option<Constructor>

A wrapped method that constructs an instance of T from Polar terms

attributes: HashMap<Symbol, InstanceMethod>

Methods that return simple attribute lookups on an instance of T

instance_methods: HashMap<Symbol, InstanceMethod>

Instance methods on T that expect Polar terms, and an instance of &T

class_methods: HashMap<Symbol, ClassMethod>

Class methods on T

type_id: TypeId

Implementations

impl<T> Class<T> where
    T: 'static, 

pub fn new() -> Self

Create a new class builder.

pub fn with_default() -> Self where
    T: Default, 

Create a new class builder for a type that implements Default and use that as the constructor.

pub fn with_constructor<F, Args>(f: F) -> Self where
    F: Function<Args, Result = T> + 'static,
    Args: FromPolar + 'static, 

Create a new class builder with a given constructor.

pub fn set_constructor<F, Args>(self, f: F) -> Self where
    F: Function<Args, Result = T> + 'static,
    Args: FromPolar + 'static, 

Set the constructor function to use for polar new statements.

pub fn set_equality_check<F>(self, f: F) -> Self where
    F: Fn(&T, &T) -> bool + Send + Sync + 'static, 

Set an equality function to be used for polar == statements.

pub fn with_equality_check(self) -> Self where
    T: PartialEq<T>, 

Use PartialEq::eq as the equality check for polar == statements.

pub fn add_attribute_getter<F, R>(self, name: &str, f: F) -> Self where
    F: Method<T, Result = R> + 'static,
    R: ToPolarResults + 'static,
    T: 'static, 

Add an attribute getter for statments like foo.bar `class.add_attribute_getter("bar", |instance| instance.bar)

pub fn name(self, name: &str) -> Self

Set the name of the polar class.

pub fn add_method<F, Args, R>(self, name: &str, f: F) -> Self where
    Args: FromPolar,
    F: Method<T, Args, Result = R> + 'static,
    R: ToPolarResults + 'static, 

Add a method for polar method calls like foo.plus(1) class.add_attribute_getter("bar", |instance, n| instance.foo + n)

pub fn add_iterator_method<F, Args, I>(self, name: &str, f: F) -> Self where
    Args: FromPolar,
    F: Method<T, Args> + 'static,
    F::Result: IntoIterator<Item = I>,
    <<F as Method<T, Args>>::Result as IntoIterator>::IntoIter: Sized + Clone + 'static,
    I: ToPolarResults + 'static,
    T: 'static, 

A method that returns multiple values. Every element in the iterator returned by the method will be a separate polar return value.

pub fn add_class_method<F, Args, R>(self, name: &str, f: F) -> Self where
    F: Function<Args, Result = R> + 'static,
    Args: FromPolar + 'static,
    R: ToPolarResults + 'static, 

A method that's called on the type instead of an instance. eg Foo.pi

pub fn erase_type(self) -> Class<()>

Erase the generic type parameter This is done before registering so that the host can store all of the same type. The generic paramtere is just used for the builder pattern part of Class TODO: Skip this shenanigans and make there a builder instead?

pub fn build(self) -> Class<()>

pub fn is_class<C: 'static>(&self) -> bool

pub fn is_instance(&self, instance: &Instance) -> bool

pub fn equals(&self, instance: &Instance, other: &Instance) -> Result<bool>

impl Class

pub fn cast_to_instance(&self, instance: impl Any) -> Instance

pub fn init(&self, fields: Vec<Term>, host: &mut Host) -> Result<Instance>

Trait Implementations

impl<T: Clone> Clone for Class<T>

fn clone(&self) -> Class<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Class

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

Formats the value using the given formatter.

impl Default for Class

fn default() -> Self

Returns the "default value" for a type.

impl ToPolar for Class

fn to_polar_value(&self, host: &mut Host) -> Value

fn to_polar(&self, host: &mut Host) -> Term