I have to write some long and winded math code which needs to work with f32 and f64 and there are plenty of constants like 2 and 6 inside it. Example:

```
fn foo<T>(x: T, y: T, z: T)
where
T: Float,
u32: Into<T>,
{
x * x * ((y + z) / 3.into() + y * y) / 4.into()
+ ((z - x) / 2.into() + 6.into() * y * y - x * x * x) / 3.into();
}
```

Initially I had troubles with the constants, but found a way to do it with `Into`

.

Is that the recommended way to deal with constants? The `*.into()`

expressions are cluttering the code and make it hard to spot implementation mistakes..