### Handling Commands with State-Stored Aggregate in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This example illustrates using a `StateStoredAggregate` with an `InMemoryOrderStateRepository` and the `decider` function. It demonstrates handling a `CreateOrderCommand`, asserting that the operation is successful and that the aggregate's state is correctly updated to the `OrderState` reflecting the creation.

```Rust
    let repository = InMemoryOrderStateRepository::new();
    let aggregate = StateStoredAggregate::new(repository, decider());

    let command = OrderCommand::Create(CreateOrderCommand {
        order_id: 1,
        customer_name: "John Doe".to_string(),
        items: vec!["Item 1".to_string(), "Item 2".to_string()],
    });
    let result = aggregate.handle(&command).await;
    assert!(result.is_ok());
    assert_eq!(
        result.unwrap(),
        (
            OrderState {
                order_id: 1,
                customer_name: "John Doe".to_string(),
                items: vec!["Item 1".to_string(), "Item 2".to_string()],
                is_cancelled: false,
            },
            0
        )
    );
```

--------------------------------

### Handling Commands with Event-Sourced Aggregate in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This example demonstrates how to use an `EventSourcedAggregate` with an `InMemoryOrderEventRepository` and the `decider` function. It shows handling a `CreateOrderCommand`, asserting that the operation is successful and that the correct `OrderEvent::Created` is produced.

```Rust
    let repository = InMemoryOrderEventRepository::new();
    let aggregate = EventSourcedAggregate::new(repository, decider());

    let command = OrderCommand::Create(CreateOrderCommand {
        order_id: 1,
        customer_name: "John Doe".to_string(),
        items: vec!["Item 1".to_string(), "Item 2".to_string()],
    });

    let result = aggregate.handle(&command).await;
    assert!(result.is_ok());
    assert_eq!(
        result.unwrap(),
        [(
            OrderEvent::Created(OrderCreatedEvent {
                order_id: 1,
                customer_name: "John Doe".to_string(),
                items: vec!["Item 1".to_string(), "Item 2".to_string()],
            }),
            0
        )]
    );
```

--------------------------------

### Defining the View Struct in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This Rust struct `View` represents the event handling algorithm for translating events into a denormalized state, suitable for querying in a CQRS pattern. It contains an `evolve` function to update the state based on events and an `initial_state` function to provide the starting state for the view. It is generic over State (S) and Event (E) types.

```Rust
pub struct View<'a, S: 'a, E: 'a> {
    pub evolve: EvolveFunction<'a, S, E>,
    pub initial_state: InitialStateFunction<'a, S>,
}
```

--------------------------------

### Defining the Decider Struct in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This Rust struct `Decider` encapsulates the core decision-making logic in a functional domain model. It combines a `decide` function (to handle commands and produce events), an `evolve` function (to update state based on events), and an `initial_state` function (to provide the starting state). It is generic over Command (C), State (S), and Event (E) types.

```Rust
pub struct Decider<'a, C: 'a, S: 'a, E: 'a> {
    pub decide: DecideFunction<'a, C, S, E>,
    pub evolve: EvolveFunction<'a, S, E>,
    pub initial_state: InitialStateFunction<'a, S>,
}
```

--------------------------------

### Adding fmodel-rust Crate via Cargo Command

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This shell command uses Cargo, Rust's package manager, to add the `fmodel-rust` library as a dependency to your current project. Running this command automatically updates your `Cargo.toml` file with the latest compatible version of the crate.

```Shell
cargo add fmodel-rust
```

--------------------------------

### Implementing a View for Order Events in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This snippet defines the `OrderViewState` struct and the `view` function, which implements the `View` component. The `View` is responsible for evolving a denormalized state (suitable for querying) based on domain events. It includes `evolve` logic to update the view state for `Created`, `Updated`, and `Cancelled` events, and an `initial_state`.

```Rust
// The state of the view component
struct OrderViewState {
    order_id: u32,
    customer_name: String,
    items: Vec<String>,
    is_cancelled: bool,
}

fn view<'a>() -> View<'a, OrderViewState, OrderEvent> {
    View {
        // Evolve the state of the `view` based on the event(s)
        evolve: Box::new(|state, event| {
            let mut new_state = state.clone();
            // Exhaustive pattern matching on the event
            match event {
                OrderEvent::Created(created_event) => {
                    new_state.order_id = created_event.order_id;
                    new_state.customer_name = created_event.customer_name.to_owned();
                    new_state.items = created_event.items.to_owned();
                }
                OrderEvent::Updated(updated_event) => {
                    new_state.items = updated_event.updated_items.to_owned();
                }
                OrderEvent::Cancelled(_) => {
                    new_state.is_cancelled = true;
                }
            }
            new_state
        }),
        // Initial state
        initial_state: Box::new(|| OrderViewState {
            order_id: 0,
            customer_name: "".to_string(),
            items: Vec::new(),
            is_cancelled: false,
        }),
    }
}
```

--------------------------------

### Manually Adding fmodel-rust to Cargo.toml

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This TOML snippet shows how to manually declare `fmodel-rust` as a dependency in your project's `Cargo.toml` file. Placing this line under the `[dependencies]` section specifies the crate name and its desired version, allowing Cargo to fetch and link the library during compilation.

```TOML
fmodel-rust = "0.8.0"
```

--------------------------------

### Implementing a Decider for Order Commands in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This function implements the `Decider` component, which is responsible for making decisions based on incoming commands and the current state, producing a list of events. It defines the `decide` logic to handle `Create`, `Update`, and `Cancel` commands, the `evolve` logic to transition state based on events, and an `initial_state` for new aggregates.

```Rust
fn decider<'a>() -> Decider<'a, OrderCommand, OrderState, OrderEvent> {
    Decider {
        decide: Box::new(|command, state| match command {
            OrderCommand::Create(cmd) => Ok(vec![OrderEvent::Created(OrderCreatedEvent {
                order_id: cmd.order_id,
                customer_name: cmd.customer_name.to_owned(),
                items: cmd.items.to_owned(),
            })]),
            OrderCommand::Update(cmd) => {
                if state.order_id == cmd.order_id {
                    Ok(vec![OrderEvent::Updated(OrderUpdatedEvent {
                        order_id: cmd.order_id,
                        updated_items: cmd.new_items.to_owned(),
                    })])
                } else {
                    Ok(vec![])
                }
            }
            OrderCommand::Cancel(cmd) => {
                if state.order_id == cmd.order_id {
                    Ok(vec![OrderEvent::Cancelled(OrderCancelledEvent {
                        order_id: cmd.order_id,
                    })])
                } else {
                    Ok(vec![])
                }
            }
        }),
        evolve: Box::new(|state, event| {
            let mut new_state = state.clone();
            match event {
                OrderEvent::Created(evt) => {
                    new_state.order_id = evt.order_id;
                    new_state.customer_name = evt.customer_name.to_owned();
                    new_state.items = evt.items.to_owned();
                }
                OrderEvent::Updated(evt) => {
                    new_state.items = evt.updated_items.to_owned();
                }
                OrderEvent::Cancelled(_) => {
                    new_state.is_cancelled = true;
                }
            }
            new_state
        }),
        initial_state: Box::new(|| OrderState {
            order_id: 0,
            customer_name: "".to_string(),
            items: Vec::new(),
            is_cancelled: false,
        }),
    }
}
```

--------------------------------

### Modeling Order Commands with Rust ADTs

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This Rust code demonstrates the use of Algebraic Data Types (ADTs) to model various order commands. `OrderCommand` is an `enum` (sum type) representing different command variants (Create, Update, Cancel), while `CreateOrderCommand`, `UpdateOrderCommand`, and `CancelOrderCommand` are `struct`s (product types) defining the specific fields for each command. This structure accurately represents the business domain and enforces type safety.

```Rust
// models Sum/Or type / multiple possible variants
pub enum OrderCommand {
    Create(CreateOrderCommand),
    Update(UpdateOrderCommand),
    Cancel(CancelOrderCommand),
}
// models Product/And type / a concrete variant, consisting of named fields
pub struct CreateOrderCommand {
    pub order_id: u32,
    pub customer_name: String,
    pub items: Vec<String>,
}
// models Product/And type / a concrete variant, consisting of named fields
pub struct UpdateOrderCommand {
    pub order_id: u32,
    pub new_items: Vec<String>,
}
// models Product/And type / a concrete variant, consisting of named fields
#[derive(Debug)]
pub struct CancelOrderCommand {
    pub order_id: u32,
}
```

--------------------------------

### Executing Concurrent Aggregate Operations in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This Rust asynchronous function demonstrates how to safely perform concurrent operations on an event-sourced aggregate using `Arc` for shared ownership and `thread::spawn` for parallel execution. Each spawned thread handles a sequence of commands (Create, Update, Cancel) for a distinct order, asserting the correct event outcomes and versions, showcasing Rust's thread safety guarantees.

```Rust
async fn es_test() {
    let repository = InMemoryOrderEventRepository::new();
    let aggregate = Arc::new(EventSourcedAggregate::new(repository, decider()));
    // Makes a clone of the Arc pointer. This creates another pointer to the same allocation, increasing the strong reference count.
    let aggregate2 = Arc::clone(&aggregate);

    // Lets spawn two threads to simulate two concurrent requests
    let handle1 = thread::spawn(|| async move {
        let command = OrderCommand::Create(CreateOrderCommand {
            order_id: 1,
            customer_name: "John Doe".to_string(),
            items: vec!["Item 1".to_string(), "Item 2".to_string()],
        });

        let result = aggregate.handle(&command).await;
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap(),
            [(
                OrderEvent::Created(OrderCreatedEvent {
                    order_id: 1,
                    customer_name: "John Doe".to_string(),
                    items: vec!["Item 1".to_string(), "Item 2".to_string()],
                }),
                0
            )]
        );
        let command = OrderCommand::Update(UpdateOrderCommand {
            order_id: 1,
            new_items: vec!["Item 3".to_string(), "Item 4".to_string()],
        });
        let result = aggregate.handle(&command).await;
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap(),
            [(
                OrderEvent::Updated(OrderUpdatedEvent {
                    order_id: 1,
                    updated_items: vec!["Item 3".to_string(), "Item 4".to_string()],
                }),
                1
            )]
        );
        let command = OrderCommand::Cancel(CancelOrderCommand { order_id: 1 });
        let result = aggregate.handle(&command).await;
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap(),
            [(
                OrderEvent::Cancelled(OrderCancelledEvent { order_id: 1 }),
                2
            )]
        );
    });

    let handle2 = thread::spawn(|| async move {
        let command = OrderCommand::Create(CreateOrderCommand {
            order_id: 2,
            customer_name: "John Doe".to_string(),
            items: vec!["Item 1".to_string(), "Item 2".to_string()],
        });
        let result = aggregate2.handle(&command).await;
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap(),
            [(
                OrderEvent::Created(OrderCreatedEvent {
                    order_id: 2,
                    customer_name: "John Doe".to_string(),
                    items: vec!["Item 1".to_string(), "Item 2".to_string()],
                }),
                0
            )]
        );
        let command = OrderCommand::Update(UpdateOrderCommand {
            order_id: 2,
            new_items: vec!["Item 3".to_string(), "Item 4".to_string()],
        });
        let result = aggregate2.handle(&command).await;
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap(),
            [(
                OrderEvent::Updated(OrderUpdatedEvent {
                    order_id: 2,
                    updated_items: vec!["Item 3".to_string(), "Item 4".to_string()],
                }),
                    1
            )]
        );
        let command = OrderCommand::Cancel(CancelOrderCommand { order_id: 2 });
        let result = aggregate2.handle(&command).await;
        assert!(result.is_ok());
        assert_eq!(
            result.unwrap(),
            [(
                OrderEvent::Cancelled(OrderCancelledEvent { order_id: 2 }),
                2
            )]
        );
    });

    handle1.join().unwrap().await;
    handle2.join().unwrap().await;
}
```

--------------------------------

### Defining Decider Functions and Struct in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

These type aliases define the functional interfaces for `DecideFunction`, `EvolveFunction`, and `InitialStateFunction`, which are then used within the `Decider` struct. `DecideFunction` maps commands and states to events, `EvolveFunction` updates state from events, and `InitialStateFunction` provides the initial state. The `Decider` struct bundles these functions, forming the core of the domain's decision-making logic.

```Rust
pub type DecideFunction<'a, C, S, E, Error> = Box<dyn Fn(&C, &S) -> Result<Vec<E>, Error> + 'a + Send + Sync>;
pub type EvolveFunction<'a, S, E> = Box<dyn Fn(&S, &E) -> S + 'a + Send + Sync>;
pub type InitialStateFunction<'a, S> = Box<dyn Fn() -> S + 'a + Send + Sync>;

pub struct Decider<'a, C: 'a, S: 'a, E: 'a> {
    pub decide: DecideFunction<'a, C, S, E>,
    pub evolve: EvolveFunction<'a, S, E>,
    pub initial_state: InitialStateFunction<'a, S>,
}
```

--------------------------------

### Defining Aggregate State in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This snippet defines the `OrderState` struct, which represents the current state of an `Order` aggregate. It includes fields like `order_id`, `customer_name`, `items`, and `is_cancelled`, capturing the essential attributes of an order at any given time.

```Rust
struct OrderState {
    order_id: u32,
    customer_name: String,
    items: Vec<String>,
    is_cancelled: bool,
}
```

--------------------------------

### Defining Domain Events and Facts in Rust

Source: https://github.com/fraktalio/fmodel-rust/blob/main/README.md

This snippet defines the `OrderEvent` enum as a sum type representing various possible events (Created, Updated, Cancelled) and corresponding product structs (`OrderCreatedEvent`, `OrderUpdatedEvent`, `OrderCancelledEvent`) that hold the specific data for each event. These events model facts about changes in the system.

```Rust
// models Sum/Or type / multiple possible variants
pub enum OrderEvent {
    Created(OrderCreatedEvent),
    Updated(OrderUpdatedEvent),
    Cancelled(OrderCancelledEvent),
}
// models Product/And type / a concrete variant, consisting of named fields
pub struct OrderCreatedEvent {
    pub order_id: u32,
    pub customer_name: String,
    pub items: Vec<String>,
}
// models Product/And type / a concrete variant, consisting of named fields
pub struct OrderUpdatedEvent {
    pub order_id: u32,
    pub updated_items: Vec<String>,
}
// models Product/And type / a concrete variant, consisting of named fields
pub struct OrderCancelledEvent {
    pub order_id: u32,
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.