Where to put DataProvider load_payload method

[sffc]

Implementors of the DataProvider trait need to implement load_to_receiver. However, load_payload is easier to think about and use. I currently implement load_payload via impl dyn, like this:

/// An abstract data provider that loads a payload given a request object.
pub trait DataProvider<'d> {
    /// Query the provider for data, loading it into a DataReceiver.
    ///
    /// Returns Ok if the request successfully loaded data. If data failed to load, returns an
    /// Error with more information.
    fn load_to_receiver(
        &self,
        req: &DataRequest,
        receiver: &mut dyn DataReceiver<'d, 'static>,
    ) -> Result<DataResponse, Error>;
}

/// A response object containing an object as payload and metadata about it.
pub struct DataResponseWithPayload<'d, T>
where
    T: Clone + Debug,
{
    /// Metadata about the returned object.
    pub response: DataResponse,

    /// The object itself; None if it was not loaded.
    pub payload: Option<Cow<'d, T>>,
}

impl<'d> dyn DataProvider<'d> + 'd {
    /// Query the provider for data, returning the result.
    ///
    /// Returns Ok if the request successfully loaded data. If data failed to load, returns an
    /// Error with more information.
    pub fn load_payload<T>(
        &self,
        req: &DataRequest,
    ) -> Result<DataResponseWithPayload<'d, T>, Error>
    where
        T: serde::Deserialize<'static> + erased_serde::Serialize + Any + Clone + Debug,
    {
        let mut receiver = DataReceiverForType::<T>::new();
        let response = self.load_to_receiver(req, &mut receiver)?;
        Ok(DataResponseWithPayload {
            response,
            payload: receiver.payload,
        })
    }
}

However, I could instead implement it in a few other ways:

1. Function on DataProvider with a default implementation. I think this won't work, because DataProvider is trait object safe.
2. New trait, like DataProviderPlusPlus, with a impl<S> DataProviderPlusPlus for S where S: DataProvider
3. Standalone function, called like icu_provider::load_payload::<T>(&provider, &req)

I would ideally like to reach a decision that applies not only to this specific case of load_payload, but also more generally when we have low-level traits intended to be implemented paired with high-level traits intended to be used. I have a few other examples where this has come up already.

CC @Manishearth

[sffc]

Closely related: #422

[Manishearth]

I'm not really in favor of impl dyn, it means the method is only available on the trait object.

I really like impl TraitExt for T where T: Trait + ?Sized. It is something people have to import, but the TraitExt pattern is reasonably idiomatic rust.

I wish Rust had a way to just .. imply traits this way so that they don't need to be imported.

Standalone functions are also fine, but I prefer methods when possible.