Struct Decider 

pub struct Decider<C, S: State, D> { /* private fields */ }

A decision on a command, given the state of its subject: the events to write, or an error if the command is refused.

Create one from a function that receives the command and the state, and returns the events in a future, so that it can load what else it needs to decide, such as the state of another subject:

use architecturekit::{Decider, DomainError};

let borrow_book = Decider::new(|cmd: BorrowBook, book: Book| async move {
    if book.is_borrowed {
        return Err(DomainError::new(format!("book {} is already borrowed", cmd.book_id)));
    }

    Ok(vec![BookEvent::Borrowed(BookBorrowed { reader: cmd.reader })])
});

The types of the command, the state and the error come from the function, so that none of them has to be named. A decider that never refuses names its error type, as in Decider::<_, _, DomainError>::new(…).

The function takes the command and the state rather than references to them, so that its future can be sent across threads, which a web server needs.

Implementations

impl<C, S: State, D> Decider<C, S, D>

pub fn new<F, Fut>(decide: F) -> Self

where F: Fn(C, S) -> Fut + Send + Sync + 'static, Fut: Future<Output = Result<Vec<<S as State>::Event>, D>> + Send + 'static,

Creates a decider from a function that decides on a command, given the state of its subject.

pub async fn decide( &self, command: C, state: S, ) -> Result<Vec<<S as State>::Event>, D>

Decides on a command, given the state of its subject, with the function the decider was created with, and returns what that function returns.

Errors

Fails with the error of the function, if it refuses the command.

Trait Implementations

impl<C, S: State, D> Debug for Decider<C, S, D>

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

Formats the value using the given formatter.