How to derive Reflect for a function?

[haath]

Hey, I'm trying to contribute something to a crate, and I would like to extend an existing enum with a new field, which would contain an fn as a field.

My problem is that the author of the crate is already deriving Reflect for this enum, and I would prefer not to break that if possible.

#[derive(Debug, Clone, Reflect)]
#[reflect(Default)]
pub enum ColorOverTime {
    // existing fields
    Constant(Color),
    Lerp(Lerp<Color>),
    Gradient(Curve<Color>),

    // new field
    Fn(fn(f32) -> Color),
}

However here I'm a little stuck:

1. Leaving it as-is, I get the error that TypePath is not implemented for the fn(..)->..
2. If I add #[reflect(ignore)], then the error becomes that Default is not implemented for the fn(..)->..
3. If I create a newtype to wrap my fn(..)->.., then I can successfully add #[derive(TypePath)] on it, but then I need to manually implement Reflect which has many methods I don't understand, and it also gave me some doubt that maybe it's not the proper way to go.

So how should I go about implementing this while having the minimum impact on the crate?

[atornity]

I don't think you can reflect functions unfortunately. what happens if you wrap it in an Option and add #[reflect(ignore)]?

[MrGVSV]

You can't reflect functions yet (see #13152).

The Default requirement is only needed for FromReflect to work properly. Iirc enums require FromReflect so I don't think you can opt out using #[reflect(from_reflect = false)].

If you can, I’d maybe give the field a custom default value like: #[reflect(default = "my::custom::default_fn")] (where default_fn is a function that returns a default function pointer for your field.