CGP 0.7 and mutable implicits

[humb1t]

Hi and big thanks for this library. It is really refreshing to see such projects driving Rust language into the bright future.

When playing with #[cgp_fn] and #[implicit] I found that it will not work with several mutable references:

fn apply_transaction(
    &mut self,
    #[implicit] accounts: &mut HashMap<ClientId, Account>,
    #[implicit] transactions: &mut HashMap<(ClientId, TransactionId), Difference>,
    #[implicit] disputed_transactions: &mut HashMap<(ClientId, TransactionId), Difference>,
    transaction: Transaction,

which is quit logical, as it is unclear how to get mutable references from all of the fields of struct like below at the same time without violating basis of rust borrowing system:

#[derive(HasField, Default)]
pub struct State {
    pub accounts: HashMap<ClientId, Account>,
    pub transactions: HashMap<(ClientId, TransactionId), Difference>,
    pub disputed_transactions: HashMap<(ClientId, TransactionId), Difference>,
}

meanwhile, the question stays in my head. If I have different Contexts, that I want to abstract over in function, how can I combine #[cgp_fn] with mutable references. Maybe there is already a good example that I failed to find or ideas how to do it "idiomatically" in CGP? Thank you in advance, I will be glad to read your thoughts.

[soareschen]

Hi @humb1t, thanks for trying out the library! I'm glad you noticed this limitation with mutable implicit arguments. It is something I didn't go into in the blog post and tutorials, so as not to overwhelm readers with too much information all at once.

The short answer is exactly as you suspect. A key limitation of trait-based abstractions in Rust is that the entire &mut self is locked for as long as a method holds a &mut reference. This limitation exists in plain Rust as well, making it genuinely hard to work with multiple mutable fields through getter methods.

A proper solution would require Rust to implement more refined borrow checking through Polonius or view types, which would allow the borrow checker to understand that two mutable borrows do not overlap. CGP also has more advanced techniques to split a &mut self into a generic list of individual &mut fields so that each one can be acquired safely without overlap.

However, even with those workarounds, dealing with &mut inside traits continues to cause interference in practice. While holding a &mut reference, you cannot call other trait methods that take &self, because the borrow is exclusive. Worse, having a single &mut self method tends to propagate up the call chain, forcing other methods that neither read nor write any state to also accept &mut self, and the whole design becomes difficult to reason about.

The most reliable way to avoid this in practice is to wrap mutable fields in RefCell, which lets you keep a non-mutable &self receiver throughout and grants far more flexibility at call sites. This is a common pattern across trait-based Rust code, not just CGP.

That said, if you can confine the mutability to a very small scope, it is still possible to access more than one mutable field through CGP. The key is to use #[cgp_auto_getter] to define a separate getter trait rather than relying on implicit arguments. The implicit arguments are essentially syntactic sugar around auto getters that bind field values to local variables automatically. With an explicit getter, you have full control over exactly when each one is called. As long as you do not hold onto a mutable reference past the statement that uses it, you can call one mutable getter after another without conflict. For example:

#[cgp_auto_getter]
pub trait HasMutableStates {
    fn accounts(&mut self) -> &mut HashMap<ClientId, Account>;

    fn transactions(&mut self) -> &mut HashMap<(ClientId, TransactionId), Difference>;

    fn disputed_transactions(&mut self) -> &mut HashMap<(ClientId, TransactionId), Difference>;
}

#[cgp_fn]
#[uses(HasMutableStates)]
pub fn update_state(&mut self) {
    self.accounts().get_mut(&ClientId(1)).unwrap().last_active = Instant::now();
    self.transactions().insert((ClientId(1), TransactionId(1)), Difference(100));
}

Each call to a mutable getter is completed before the next one begins, so the borrow checker is satisfied. The moment you try to hold two of those references alive at the same time, you are back in the territory where RefCell is the right tool.

[humb1t]

Thanks @soareschen - it seems that I was close enough as I was able to work with #[cgp_auto_getter] https://github.com/humb1t/toy-payments-engine/blob/main/src/validation/mod.rs and then wired it to providers.

I am still discovering CGP and it is really great that you are active not only in blog, but also here, answering such newbee questions, additional thank you for that 💜