Can't migrate away from Foo::KIND

[JPFrancoia]

Hi,

I'm posting this as a question as I aknowledge this is due to a lack of knowledge on my side :/. I'm updating an old codebase and I have a function defined like this:

pub async fn apply_resource<K: Resource + Serialize> (
    name: &str,
    data: K,
    ns: &str,
) -> Result<bool> {
    use std::{
        fs::{self, File},
        io::Write,
        path::Path,
    };

    // some stuff happening here
 
    // Old version
    debug!("Writing {} CRD for {} to {}", K::KIND, name, pth.display());

    // TODO: fix the kind, this line isn't working
    debug!("Writing {} CRD for {} to {}", K::kind(&()), name, pth.display());

In this migration guide here: https://github.com/kube-rs/kube/blob/main/CHANGELOG.md#kube-derive, it's mentioned that Foo::KIND is deprecated and that I should replace it with Foo::kind(&()).

However in my case I don't really have a well defined Foo struct, I just have a type K that implements Resource + Serialize. And I can't figure out how to replace the old K::KIND with.

As it's defined above, I'm getting this error message:

269 |     debug!("Writing {} CRD for {} to {}", K::kind(&()), name, pth.display());
    |                                           ------- ^^^ expected associated type, found `()`
    |                                           |
    |                                           arguments to this function are incorrect
    |
    = note: expected reference `&<K as kube::Resource>::DynamicType`
               found reference `&()`
    = help: consider constraining the associated type `<K as kube::Resource>::DynamicType` to `()`
    = note: for more information, visit https://doc.rust-lang.org/book/ch19-03-advanced-traits.html
note: associated function defined here
   --> /Users/jean-patrickfrancoia/.cargo/registry/src/git.luolix.top-1ecc6299db9ec823/kube-core-0.76.0/src/resource.rs:43:8
    |
43  |     fn kind(dt: &Self::DynamicType) -> Cow<'_, str>;
    |        ^^^^

Would you know how to resolve that?

[clux]

Ah, yeah, writing generics on top of kube's Resource traits is currently a little tricky with the associated type.

The key part that you are trying to interact with is this bit of the Resource trait.

If you were just calling this in a non-generic setting you'd be fine with just passing in an empty tuple as the generic associated type DynamicType (which is the right type for the static k8s-openapi types), but because you are writing a generic function, you are also trying to cover all possible resources (such as DynamicObject and Object in kube, or other Resource implementors).

Thus you need to constrain the DynamicType to the subset you want (i.e. where it is just the empty tuple). The way we normally do it is to just constrain K::DynamicType: Default so that you can instead call the K::kind function with Default::default() to use whatever the default implementation for the dynamic type is.

See for instance:

kube/kube-runtime/src/controller/mod.rs

Lines 483 to 488 in f6ca7df

	pub fn new(owned_api: Api<K>, lp: ListParams) -> Self
	where
	K::DynamicType: Default,
	{
	Self::new_with(owned_api, lp, Default::default())
	}

[JPFrancoia]

I tried this:

pub async fn apply_resource<K: Resource + Serialize> (
    name: &str,
    data: K,
    ns: &str,
) -> Result<bool> 
    where
        K::DynamicType: Default,
    {
        use std::{
        fs::{self, File},
        io::Write,
        path::Path,
    };

    // some stuff happening here

    // TODO: fix the kind, this line isn't working
    debug!("Writing {} CRD for {} to {}", K::kind(Default::default()), name, pth.display());

But it didn't work:

error[E0277]: the trait bound `&<K as kube::Resource>::DynamicType: Default` is not satisfied
   --> shipcat_cli/src/kubectl.rs:275:51
    |
275 |     debug!("Writing {} CRD for {} to {}", K::kind(Default::default()), name, pth.display());
    |                                                   ^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `&<K as kube::Resource>::DynamicType`
    |
help: consider extending the `where` clause, but there might be an alternative better way to express this requirement
    |
259 |         K::DynamicType: Default, &<K as kube::Resource>::DynamicType: Default
    |                                ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

However this form does compile:

pub async fn apply_resource<K: Resource<DynamicType = ()> + Serialize> (
    name: &str,
    data: K,
    ns: &str,
) -> Result<bool> 
    where
        K::DynamicType: Default,
    {
    use std::{
        fs::{self, File},
        io::Write,
        path::Path,
    };

    // TODO: fix the kind
    debug!("Writing {} CRD for {} to {}", K::kind(&()), name, pth.display());

Note: I initially had the function implemented for K with pub async fn apply_resource<K: k8s_openapi::Resource + Serialize>(

Does that make sense?

[clux]

Yeah, the latter does make sense. i'd be surprised if you even need the default constraint in the where clause there since you've already limited the amount of Resources you're implementing for.

[JPFrancoia]

Yep indeed I don't. Thanks, looks like this works!