AFIT Case Study: AWS SDK

impl SomeTrait for MyType {
    async fn();
}

builder
    .with_new(MyType);

pub trait ProvideCredentials: Send + Sync + Debug {
    fn provide_credentials<'a>(&'a self) -> ProvideCredentials<'a>
    where
        Self: 'a;
}

pub struct ProvideCredentials<'a>(..);

impl<'a> ProvideCredentials<'a> {
    pub fn new(future: impl Future<Output = Result> + Send + 'a) -> Self;
}

// https://docs.rs/aws-config/0.54.1/aws_config/struct.ConfigLoader.html#method.credentials_provider
impl ConfigLoader {
    pub fn credentials_provider(
        self,
        credentials_provider: impl ProvideCredentials + 'static
    ) -> Self;
}

impl ProvideCredentials for MyProvider {
    fn provide_credentials<'a>(&'a self) -> ProvideCredentials<'a>
    where
        Self: 'a
    {
        ProvideCredentials::new(async move {
            ...
        })
    }
}

let config_loader: SdkConfig = ConfigLoader::new()
    .credentials_provider(MyProvider)
    .load()
    .await;

pub type Result = std::result::Result<Credentials, error::CredentialsError>;

pub trait ProvideCredentials: Send + Sync + Debug {
    async fn provide_credentials<'a>(&'a self) -> Result
    where
        Self: 'a;
}

// https://docs.rs/aws-config/0.54.1/aws_config/struct.ConfigLoader.html#method.credentials_provider
impl ConfigLoader {
    pub fn credentials_provider(
        self,
        credentials_provider: impl ProvideCredentials + 'static
    ) -> Self {
        let b: Box<dyn ProvideCredentialsDyn> = Box::new(credentials_provider);
        self.field = b;
        self
    }
}

// Private to your library

trait ProvideCredentialsDyn {
    fn provide_credentials<'a>(&'a self) -> Box<dyn Future<Output = Result> + Send>
    where
        Self: 'a;
}

impl<T> ProvideCredentialsDyn for T
where
    T: ProvideCredentials<credentials_provider(..): Send>,
    //                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    // needed because we have to say that the future is Send so we can create the future
{
    fn provide_credentials<'a>(&'a self) -> Box<dyn Future<Output = Result> + Send>
    where
        Self: 'a
    {
        Box::new(ProvideCredentials::provide_credentials(self))
    }
}

pub trait AsyncSleep: Debug + Send + Sync {
    // Required method
    fn sleep(&self, duration: Duration) -> Sleep ⓘ;
}

impl<B> AsyncIterator for Inner<B>
where
    B: http_body::Body<Data = Bytes>,
{
    type Item = Result<Bytes, B::Error>;

    async fn next(&mut self, {
        self.project().body.poll_data(cx)
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        let size_hint = http_body::Body::size_hint(&self.body);
        let lower = size_hint.lower().try_into();
        let upper = size_hint.upper().map(|u| u.try_into()).transpose();

        match (lower, upper) {
            (Ok(lower), Ok(upper)) => (lower, upper),
            (Err(_), _) | (_, Err(_)) => {
                panic!("{}", SIZE_HINT_32_BIT_PANIC_MESSAGE)
            }
        }
    }
}

async trait ProvideCredentials {
    async fn ...
}