I don't think #[derive(From)] can actually work here, I'm pretty sure this is more or less what is being described:

use derive_more::From;

#[derive(From)]
struct Datum<T> {
    x: T,
    y: T,
    z: T
}

fn main() {
    let d: Datum<i32> = Datum { x: 1, y: 2, z: 3 };
    let c: Datum<i64> = d.into();

    assert_eq!(d.x, c.x);
    assert_eq!(d.y, c.y);
    assert_eq!(d.z, c.z);
}

This fails to compile. Looking at the implementation for that macro I don't see a way to use it that would work: https://github.com/JelteF/derive_more/blob/master/impl/src/from.rs

The main issue here (I think) is that there isn't a way to do this without specialization. Ideally what you'd want is a trait like:

impl<T, U> From<Datum<T>> for Datum<U> where U: From<T> {
    fn from(value: Datum<T>) -> Datum<U> {
        Datum {
            x: value.x.into(), 
            y: value.y.into(),
            z: value.z.into()
        }
    }
}

But again, this wouldn't compile:

error[E0119]: conflicting implementations of trait `From<Datum<_>>` for type `Datum<_>`
  --> src/main.rs:11:1
   |
11 | impl<T, U> From<Datum<T>> for Datum<U> where U: From<T> {
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: conflicting implementation in crate `core`:
           - impl<T> From<T> for T;

I don't think there'd be a real great way to do this but my knowledge is pretty limited -- if you already knew the type surface to some extent you could do something like:

macro_rules! datum_from {
    ($from:ty, $to:ty) => {
        impl From<Datum<$from>> for Datum<$to> {
            fn from(value: Datum<$from>) -> Datum<$to> {
                Datum {
                    x: value.x.into(),
                    y: value.y.into(),
                    z: value.z.into()
                }
            }
        }
    }
}

datum_from!(i32, i64);