Struct perseus::state::RxResult

pub struct RxResult<T, E>(_)
where
         T: MakeRx + 'static,
         <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static,
         E: Clone + 'static;

A wrapper for fallible reactive state.

This is intended for use with the suspense state feature and nested state. Imagine you have a struct Song that you derive ReactiveState on, having the album: Album field use nested reactivity, since Album has multiple fields itself. However, for some reason, you’d like to make the album field use #[rx(suspense = "your_handler_fn")]. If your_handler_fn() could lead to an error, then you have to be able to use the pattern song.album.get()?.name.get(), rather than just song.album.name.get(). The extra .get()? is needed since the Album is what is suspended state, and it could be an error of some sort. What you need is a reactive Result, and this is that. Any type can be placed in this that implements MakeRx, Serialize, and Deserialize. No restrictions are placed on the error type.

Note that this is intended for use with fallible, nested, suspended state, although it could be easily used in any case where you want to use reactive state that could be an error, conveniently enabling the pattern explained above.

If you want non-nested, fallible, suspended state, you can simply use Result<T, E> from the standard library.

Trait Implementations

impl<T, E> Clone for RxResult<T, E>where T: MakeRx + 'static + Clone, <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static, E: Clone + 'static + Clone,

fn clone(&self) -> RxResult<T, E>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, E> Debug for RxResult<T, E>where T: MakeRx + 'static + Debug, <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static, E: Clone + 'static + Debug,

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

Formats the value using the given formatter.

impl<'de, T, E> Deserialize<'de> for RxResult<T, E>where T: MakeRx + 'static + Deserialize<'de>, <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static, E: Clone + 'static + Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T, E> From<Result<T, E>> for RxResult<T, E>where T: MakeRx + Serialize + DeserializeOwned + 'static, <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static, E: Serialize + DeserializeOwned + Clone + 'static,

fn from(val: Result<T, E>) -> Self

Converts to this type from the input type.

impl<T, E> MakeRx for RxResult<T, E>where T: MakeRx + Serialize + DeserializeOwned + 'static, <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static, E: Serialize + DeserializeOwned + Clone + 'static,

type Rx = RxResultRx<T, E>

The type of the reactive version that we’ll convert to. By having this as an associated type, we can associate the reactive type with the unreactive, meaning greater inference and fewer arguments that the user needs to provide to macros.

fn make_rx(self) -> Self::Rx

Transforms an instance of the struct into its reactive version.

const HSR_IGNORE: bool = false

This should be set to true to have this type be ignored by the hot state reloading system, which can be useful when working with state that you will regularly update in development.

impl<T, E> Serialize for RxResult<T, E>where T: MakeRx + 'static + Serialize, <T as MakeRx>::Rx: MakeUnrx<Unrx = T> + Freeze + Clone + 'static, E: Clone + 'static + Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.