Enum Val

pub enum Val<S: State, T: 'static> {
    State {
        factory: Box<dyn Fn(&S) -> T>,
        value: Option<T>,
    },
    Val(T),
}

A value that’s either dependent on the state or independent.

Use Val::new_state or the val!() macro from the maycoon-macros crate to create a new state dependent value.

Use Val::new_val or just YourValue.into() to create an independent value. You can also use val!(), because why not?

NOTE for Widget Developers: Inside the Widget::update method, all values must be invalidated using Val::invalidate.

Variants

State

A state dependent value.

The inner value may need to be re-computed, when invalid.

Fields

factory: Box<dyn Fn(&S) -> T>

The factory that produces the inner value.

This is called in order to “compute” the value T.

value: Option<T>

The inner value.

If computed (valid), this is Some(T). If not computed (invalid), this is None.

Val(T)

An independent value.

The inner value will always be the same and does not need any re-computation.

More performant than state dependent values.

Implementations

impl<S: State, T: 'static> Val<S, T>

pub fn new_state(factory: impl Fn(&S) -> T + 'static) -> Self

Create a new state dependent value from the given closure.

pub fn new_val(value: T) -> Self

Create a new state independent value.

pub fn get(self, state: &S) -> T

Get the inner value of this Val.

This will compute the value if it’s state dependent and not yet computed, so it will always return something.

pub fn get_ref(&mut self, state: &S) -> &T

Get a reference to the inner value of this Val.

This will compute the value if it’s state dependent and not yet computed, so it will always return something.

pub fn get_mut(&mut self, state: &S) -> &mut T

Get a mutable reference to the inner value of this Val.

This will compute the value if it’s state dependent and not yet computed, so it will always return something.

pub fn compute(&mut self, state: &S)

If the inner value is state dependent, compute it using the given state.

pub fn invalid(&self) -> bool

Returns if the inner value is state dependent and not yet computed.

pub fn invalidate(&mut self)

Invalidates the inner value, if it’s state dependent.

This makes Val::get and other methods re-compute the value (if it’s state dependent).

pub fn value(self) -> Option<T>

Returns the inner value or None if it’s state dependent and not yet computed.

pub fn value_ref(&self) -> Option<&T>

Returns a reference to the inner value or None if it’s state dependent and not yet computed.

pub fn value_mut(&mut self) -> Option<&mut T>

Returns a mutable reference to the inner value or None if it’s state dependent and not yet computed.

pub fn map<U, F: Fn(T) -> U + 'static>(self, f: F) -> Val<S, U>

Applies a function to the inner value, transforming it into another value.

Similar to the Option::map method.

Trait Implementations

impl<S: State, T> From<T> for Val<S, T>

fn from(value: T) -> Self

Converts to this type from the input type.