Struct leptos::Action

pub struct Action<I, O>(_)
where
         I: 'static,
         O: 'static;

An action synchronizes an imperative async call to the synchronous reactive system.

If you’re trying to load data by running an async function reactively, you probably want to use a Resource instead. If you’re trying to occasionally run an async function in response to something like a user clicking a button, you’re in the right place.

async fn send_new_todo_to_api(task: String) -> usize {
    // do something...
    // return a task id
    42
}
let save_data = create_action(cx, |task: &String| {
  // `task` is given as `&String` because its value is available in `input`
  send_new_todo_to_api(task.clone())
});

// the argument currently running
let input = save_data.input();
// the most recent returned result
let result_of_call = save_data.value();
// whether the call is pending
let pending = save_data.pending();
// how many times the action has run
// useful for reactively updating something else in response to a `dispatch` and response
let version = save_data.version();

// before we do anything
assert_eq!(input(), None); // no argument yet
assert_eq!(pending(), false); // isn't pending a response
assert_eq!(result_of_call(), None); // there's no "last value"
assert_eq!(version(), 0);
// dispatch the action
save_data.dispatch("My todo".to_string());

// when we're making the call
// assert_eq!(input(), Some("My todo".to_string()));
// assert_eq!(pending(), true); // is pending
// assert_eq!(result_of_call(), None); // has not yet gotten a response

// after call has resolved
assert_eq!(input(), None); // input clears out after resolved
assert_eq!(pending(), false); // no longer pending
assert_eq!(result_of_call(), Some(42));
assert_eq!(version(), 1);

The input to the async function should always be a single value, but it can be of any type. The argument is always passed by reference to the function, because it is stored in Action::input as well.

// if there's a single argument, just use that
let action1 = create_action(cx, |input: &String| {
    let input = input.clone();
    async move { todo!() }
});

// if there are no arguments, use the unit type `()`
let action2 = create_action(cx, |input: &()| async { todo!() });

// if there are multiple arguments, use a tuple
let action3 =
    create_action(cx, |input: &(usize, String)| async { todo!() });

Implementations

impl<I, O> Action<I, O>where I: 'static, O: 'static,

pub fn dispatch(&self, input: I)

Calls the async function with a reference to the input type as its argument.

pub fn pending(&self) -> ReadSignal<bool>

Whether the action has been dispatched and is currently waiting for its future to be resolved.

pub fn set_pending(&self, pending: bool)

Updates whether the action is currently pending.

pub fn url(&self) -> Option<String>

The URL associated with the action (typically as part of a server function.) This enables integration with the ActionForm component in leptos_router.

pub fn using_server_fn<T>(self) -> Action<I, O>where T: ServerFn,

Associates the URL of the given server function with this action. This enables integration with the ActionForm component in leptos_router.

pub fn version(&self) -> RwSignal<usize>

How many times the action has successfully resolved.

pub fn input(&self) -> RwSignal<Option<I>>

The current argument that was dispatched to the async function. Some while we are waiting for it to resolve, None if it has resolved.

pub fn value(&self) -> RwSignal<Option<O>>

The most recent return value of the async function.

Trait Implementations

impl<I, O> Clone for Action<I, O>where I: 'static, O: 'static,

fn clone(&self) -> Action<I, O>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<I, O> Copy for Action<I, O>where I: 'static, O: 'static,