Lifetime bounds and ?Sized type parameters

[m-haug]

I am trying to implement a context-generic version of the Bank Account Kata. For this purpose, I am trying to implement a component for computing a running balance for a set of transactions. In trying to keep things generic, I was looking to accept any type that implements IntoIterator:

#[cgp_component(RunningBalanceComputer)]
pub trait CanComputeRunningBalance<TS>: HasTransactionType where for<'a> &'a TS: impl Iterator<Item = &'a Self::Transaction> {
    fn compute_balance<'a>(&self, transactions: &'a TS) -> impl Iterator<Item = (&'a Transaction, Balance)>;
}

When implementing the provider for this trait, however, I ran into an issue because I was trying to use [Context::Transaction] as a type parameter, which isn't Sized. When I tried to loosen the bound (CanComputeRunningBalance<TS: ?Sized>), the macro keeps failing due to IsProviderFor not supporting this use case.

For now, I've switched to naming a concrete type (&[Self::Transaction]) in the trait, which works. I would like to keep this part of the trait generic, however.

What's the best way to model this in CGP?

I've tried to find a similar case in hermes-sdk, but did come up empty. If someone could point me to a comparable case, I'd appreciate it too.

[soareschen]

Hi @m-haug, thanks for trying out CGP and uncovering the issue! The problem with the ?Sized constraint was caused by generic parameters in Rust having the Sized constraint by default, and I have just fixed it in #114.

For the issue with your code, it doesn't seem to be an issue with CGP, as you also get the same error with the plain Rust trait by removing the use of #[cgp_component].

First of all, constraints in the where clause should not include the impl keyword. You probably also don't need the trait bound in the trait definition, as you can include that at the implementation side, thereby simplifying the interface.

Secondly, the lifetime errors for associated types arise because Rust don't know whether the associated type contains lifetime that is shorter than 'a. This is in general an issue with the usage with associated types, but you can fix it by adding a where clause in your method that requires Self::Transaction: 'a.

I am not sure of the intention of your design for CanComputeRunningBalance. But I have tried to redefine it as follows for it to compile:

#[cgp_component(RunningBalanceComputer)]
pub trait CanComputeRunningBalance<TS: ?Sized>: HasTransactionType + HasBalanceType {
    fn compute_balance<'a>(
        &self,
        transactions: &'a TS,
    ) -> impl Iterator<Item = (&'a Self::Transaction, Self::Balance)>
    where
        Self::Transaction: 'a;
}

With this, you can have a context-generic provider that implements the component using IntoIterator, such as:

#[cgp_new_provider]
impl<Context, TS: ?Sized> RunningBalanceComputer<Context, TS> for RunIntoIterator
where
    Context: HasTransactionType + HasBalanceType,
    for<'a> &'a TS: IntoIterator<Item = (&'a Context::Transaction, Context::Balance)>,
{
    fn compute_balance<'a>(
        _context: &Context,
        transactions: &'a TS,
    ) -> impl Iterator<Item = (&'a Context::Transaction, Context::Balance)>
    where
        Context::Transaction: 'a,
    {
        transactions.into_iter()
    }
}

Note that you don't necessarily need a separate trait to get the iterator, as you could also include them as a where bound on the implementation side. So you could implement something like follows, if you main goal is compute the balance from the list of transactions:

#[cgp_component(RunningBalanceComputer)]
pub trait CanComputeRunningBalance<TS: ?Sized>: HasBalanceType {
    fn compute_balance(&self, transactions: &TS) -> Self::Balance;
}

#[cgp_new_provider]
impl<Context, TS: ?Sized> RunningBalanceComputer<Context, TS> for RunIntoIterator
where
    Context: HasTransactionType + HasBalanceType,
    for<'a> &'a TS: IntoIterator<Item = &'a Context::Transaction>,
{
    fn compute_balance(_context: &Context, transactions: &TS) -> Context::Balance {
        for transaction in transactions.into_iter() {
            // do something
        }
        todo!()
    }
}