Struct View 

pub struct View<T> { /* private fields */ }

Extracts a view to a sub-element of the global state indicated by the path.

The type of the sub-element is given by the type parameter T.

The View extractor expects that the location pointed by the Job path exists and is deserializable into T. If the value may not exist (or is null), then make sure to use View<Option<T>>.

Example

use mahler::{
    extract::View,
    task::{Handler, create, update, with_io, IO},
    worker::{Worker, Ready}
};
use serde::{Serialize, Deserialize};
#[derive(Serialize,Deserialize)]
struct SystemState {/* ... */};

fn foo_bar(mut view: View<i32>) -> IO<i32> {
    // view can be dereferenced into the given type
    // and is guaranteed to exist at this point
    if *view < 5 {
        *view += 1;
    }

    with_io(view, |view| async {
        // do something with view at runtime
        Ok(view)
    })
}

fn create_counter(mut view: View<Option<i32>>) -> IO<Option<i32>> {
    if view.is_none() {
        // Initialize with default value if it doesn't exist
        *view = Some(0);
    }

    with_io(view, |view| async {
        // do something with view at runtime
        Ok(view)
    })
}

let worker: Worker<SystemState, Ready> = Worker::new()
    .job("/{foo}/{bar}", create(create_counter))
    .job("/{foo}/{bar}", update(foo_bar))
    .initial_state(SystemState {/* ... */})
    .unwrap();

Errors

Initializing the extractor will fail if the path assigned to the job cannot be resolved or the value pointed by the path cannot be deserialized into type <T>

Trait Implementations

impl<T: Debug> Debug for View<T>

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

Formats the value using the given formatter.

impl<T> Deref for View<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for View<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T, E> From<View<T>> for IO<T, E>

Convert a View<T> directly into an IO operation.

This creates an IO operation that immediately succeeds with the given view, without performing any actual I/O. This is useful for bailing out early in jobs before creating the effectful computation.

Examples

fn plus_one(mut view: View<u32>, Target(tgt): Target<u32>) -> IO<u32> {
    if *view >= tgt {
        // exit early if we already reached the target
        return view.into();
    }

    with_io(view, |view| async {
        // do some async work
        Ok(view)
    })
    // increase the target after the IO operation
    // terminates (at runtime)
    .map(|mut counter| {
        *counter = *counter + 1;
        counter
    })
}

fn from(view: View<T>) -> Self

Converts to this type from the input type.

impl<T: DeserializeOwned> FromSystem for View<T>

type Error = ExtractionError

fn from_system(system: &System, context: &Context) -> Result<Self, Self::Error>

Try to initialize an extractor from the system state and context

fn is_scoped() -> bool

Return true if the extractor is scoped