Как оптимизировать код в rust при помощи trait?

Question

[Олег]

Доброго времени суток!

Я начинающий программист в rust, пытаюсь разобраться, как правильно обыграть trait для f32 и f64.

Есть задача опционально задавать f32 или f64.
В коде закомментированная часть (в ней ошибка) - это я как предполагал должен был выглядеть оптимально код, но видимо я не до конца уловил дженерики, пришлось городить impl'ы для f32 и f64:

mod float_trait {
    pub trait Float {}
    impl Float for f32 {}
    impl Float for f64 {}
}

mod float_struct {
    use crate::float_trait::Float;

    #[derive(Debug)]
    pub struct FloatStruct<T: Float> {
        _a: i8,
        _b: String,
        pub c: T,
    }

    /*impl<T: Float> FloatStruct<T> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: 0.3,  // error[E0308]: mismatched types
            }
        }
    }*/

    impl FloatStruct<f32> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: 0.3,
            }
        }
    }

    impl FloatStruct<f64> {
        #![allow(dead_code)]
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: 0.3,
            }
        }
    }
}

fn main() {
    let fs = float_struct::FloatStruct::<f32>::new();
    println!("{:#?}", fs.c)
}

Как сделать impl<T: Float> FloatStruct<T> (то что закоменчено), без impl FloatStruct<f32> и impl FloatStruct<f64>?

Ссылка на playground

Answer 1

[Roman K]

Во-первых, непонятно, как ты хочешь использовать этот трейт
Во-вторых, он у тебя без методов, что делает его целиком бесполезным

Подозреваю, что тебе хочется что-то вроде "сложить два числа, но чтобы можно было и f32 туда и f64". Для этого есть множество стандартных трейтов: Add, Sub, Div, Mul, *Assign, которые и стоит использовать. Например:

fn f<T: Add<Output = T>>(x1: T, x2: T) -> T {
    x1 + x2
}

fn main() {
    println!("{}", f(3.14_f32, 2.7)); // можно f32 + f32
    println!("{}", f(3.14_f64, 2.7)); // а можно f64 + f64
}

Answer 2

[Василий Банников]

1. Действительно непонятно, для чего и как ты хочешь эти трейты использовать.
2. Кажется, ты пытаешься переизобрести num
3. Ошибка у тебя из-за того что ожидается какой-то неизвестный T, а ты пихаешь туда f64
Тоесть, например, я бы мог захотеть сделать FloatStruct::<f32>::new() но вместо FloatStruct<f32> ты пытаешься вернуть мне FloatStruct<f64>

Comments

[Олег]

Как я и сказал, я новичок в расте, большого смысла в коде выше нет, я пытаюсь понять механику дженериков.

Идея примерно такова:
- Есть приложение (main) в котором подключается либа (mod float_trait и mod float_struct).
- В мэйне создаем экземпляр FloatStruct, и опционально можно выбрать тип с которым будет работать эта либа f32 или f64.
- И хотел бы ограничиться этим куском:

impl<T: Float> FloatStruct<T> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: 0.3,  // error[E0308]: mismatched types
            }
        }
    }

а не это с повторяющимися конструкторами:

impl FloatStruct<f32> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: 0.3,
            }
        }
    }

    impl FloatStruct<f64> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: 0.3,
            }
        }
    }

Т.е. мэйн можно переписать так:

fn main() {
    // Дать возможность выбора.
    // Опционально создать экземпляр объекта, который работает с f32
    let fs_32 = float_struct::FloatStruct::<f32>::new();
    // или f64
    let fs_64 = float_struct::FloatStruct::<f64>::new();
    println!("{:#?} {:#?}", fs_32.c, fs_64.c)
}

[Василий Банников]

Олег, а почему именно 0.3? Почему бы не дать потребителю самому выбрать значение? - в таком случае всё будет легко.

Если нужно именно 0.3, то есть два варианта:
1. Через num сделать 0.3 из единицы
2. Сделать через Into или From, но тогда надо навесить ограничение, что можно из f64 получить T

[Олег]

0.3 - это значение по умолчанию (может быть любое число, как и остальные поля в стракте).
Если быть точнее 0.3 это коэфициент обучения в нейросетях (персептроне).

Я начал недавно учить раст, делая либу на простенькую нейронку, вот ссыль, пока не на рабочий код

Идея такова: человек подключает либу и опционально выбирает f32 или f64.
Не спрашивайте зачем, просто ставя такие задачи я постигаю нюансы языка )

п.с.
За наводку на Into или From, благодарю, в начале когда я пытался решить задачу я мучал Into/From, но тогда не догнал, ща еще раз проштудирую тему.

[Василий Банников]

Если через From, то можно так:

impl<T: Float + From<f64>> FloatStruct<T> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: T::from(0.3),
            }
        }
    }

[Дмитрий Беляев]

Василий Банников, для f32 нет From<f64>, только TryFrom
а если наоборот делать, то точность потеряется при конвертации

[Василий Банников]

Дмитрий Беляев, а. Реально

[Дмитрий Беляев]

Василий Банников, Олег, конкретно в данном примере можно константой на трейте делать, правда не очень гибко будет:

mod float_trait {
    pub trait Float {
        const INITIAL_VALUE: Self;
    }
    impl Float for f32 {
        const INITIAL_VALUE: Self = 0.3;
    }
    impl Float for f64 {
        const INITIAL_VALUE: Self = 0.3;
    }
}

// ...
    impl<T: Float> FloatStruct<T> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: T::INITIAL_VALUE,
            }
        }
    }
// ...

[Олег]

Дмитрий Беляев, Благодарю за идею!
Пришлось доки перечитывать по трейтам, многое узнал )))
Ваша идея хороша, но действительно не очень гибкая.

Answer 3

[Артём]

Как я понял, дать гарантии компилятору, для того, чтобы сделать то, что вы хотите, пока нельзя, или сделать это будет очень неочевидно. Гарантии нужны потому что язык безопасный. Возможно когда добавят кастомные маркеры в язык, тогда можно будет чё-то гарантировать. А пока можно пользоваться макросами. Это не так плохо как кажеться. Это не нагружает бинарник, нагружает только компилятор. Причем линейно. Нагрузка на компилятор будет составлять (Количество типов * количество функций). Правда если будет использоваться больше одного типа в структуре, тогда будет применятся комбинаторика для определения нагрузки на компилятор. То есть само приложение будет таким же производительным, правда из-за нагрузки на компилятор, он может перестать немного оптимизировать код. Вот решение чтобы не дублировать код:

mod float_trait {
    pub trait Float {}
    impl Float for f32 {}
    impl Float for f64 {}
}

use crate::float_trait::Float;

mod float_struct {
    use crate::float_trait::Float;

    #[derive(Debug)]
    pub struct FloatStruct<T: Float>
    {
        _a: i8,
        _b: String,
        pub c: T,
    }
    
    macro_rules! impl_float_struct {
        ($($type:ty),*) => {
            $(
                impl FloatStruct<$type> {
                    pub fn new() -> Self {
                        Self {
                            _a: 2,
                            _b: String::from("hi"),
                            c: 0.3,
                        }
                    }
                }
            )*
        }
    }
    
    impl_float_struct![f32, f64];
}

fn main() {
    let fs = float_struct::FloatStruct::<f32>::new();
    println!("{:#?}", fs.c)
}

Другое решение, очевидно нагружающее само приложение, и лёгкое для компилятора

mod float_trait {
    pub trait Float {}
    impl Float for f32 {}
    impl Float for f64 {}
}

mod float_struct {
    use crate::float_trait::Float;

    #[derive(Debug)]
    pub struct FloatStruct<T: std::str::FromStr + Float>
    {
        _a: i8,
        _b: String,
        pub c: T,
    }

    impl<T: std::str::FromStr + Float> FloatStruct<T> {
        pub fn new() -> Self {
            Self {
                _a: 2,
                _b: String::from("hi"),
                c: {
                    let Ok(r) = "0.3".parse::<T>()
                        else {unreachable!()};
                    r
                }
            }
        }
    }
}

fn main() {
    let fs = float_struct::FloatStruct::<f32>::new();
    println!("{:#?}", fs.c)
}

Comments

[Олег]

Благодарю за помощь!
Я уже понял, что, то что я задумал и как это должно выглядеть, не реализуемо, буду разбираться с вашим кодом.