Задача. Сохранить в файл вектор чисел, затем позиционировать на нужном элементе и изменить его

use std::fmt::{Display, Debug};
use std::fs::{OpenOptions, File};
use std::io::{BufWriter, BufReader, Write, BufRead};
use std::str::FromStr;
 
fn write_to_file<T: Display>(arr: Vec<T>, file_path: &str) {
    let file = OpenOptions::new()
        .write(true)
        .truncate(true)
        .open(file_path)
        .expect(format!("unable to open file {}", file_path).as_str());
    let mut writer = BufWriter::new(file);
 
    for el in arr {
        writeln!(writer, "{}", el.to_string()).expect("unable to write");
    }
}
 
fn read_from_file<T: FromStr>(file_path: &str) -> Vec<T> where <T as FromStr>::Err: Debug {
    let file = File::open(file_path).expect("file not found.");
    let reader = BufReader::new(file);
 
    let results = reader
        .lines()
        .map(|line| T::from_str(&line.unwrap()).unwrap())
        .collect();
    results
}
 
fn main() {
    let file_path = "test.txt";
    let arr = vec![1, 2, 3];
    write_to_file(arr, file_path);
    let mut saved = read_from_file::<i64>(file_path);
 
    saved.push(1);
    saved.remove(2);
    saved[0] = 3;
 
    write_to_file(saved, file_path);
}

struct WorkFile<Tp>
where Tp: AsRef<[u8]> // FromPrimitive + ToPrimitive
{
  file: File,
  path: String,
  data: Vec<Tp>
}

use std::mem;
 
fn to_bytes<T: ?Sized>(value: &T) -> &[u8]
where
    T: AsRef<[u8]>,
{
    value.as_ref()
}
 
fn to_bytes_for_numeric<T: ?Sized>(value: &T) -> &[u8]
where
    T: Copy + std::fmt::Debug,
{
    let size = mem::size_of_val(value);
    let mut buffer = vec![0; size as usize].into_boxed_slice();
    unsafe {
        match *value {
            i if i == i32::min_value()..=i32::max_value() => {
                let ptr = buffer.as_mut_ptr() as *mut i32;
                ptr.write(*value as i32);
            },
            f if f == f32::min_value()..=f32::max_value() => {
                let ptr = buffer.as_mut_ptr() as *mut f32;
                ptr.write(*value as f32);
            },
            _ => panic!("Unsupported type"),
        }
        std::slice::from_raw_parts(buffer.as_ptr(), size as usize)
    }
}
 
fn main() {
    let i: i32 = 42;
    let f: f32 = 3.14;
    let s: &str = "Hello, world!";
 
    println!("{:?}", to_bytes(&s)); // Использует AsRef<[u8]>
    println!("{:?}", to_bytes_for_numeric(&i)); // Специальная обработка для чисел
    println!("{:?}", to_bytes_for_numeric(&f)); // Специальная обработка для чисел
}

trait Serializable {
    fn serialize(&self, writer: &mut impl Write) -> bool;
    fn deserialize(reader: &mut impl Read) -> Option<Self> where Self: Sized;
}

impl Serializable for usize {
    fn serialize(&self, writer: &mut impl Write) -> bool {
        writer.write(&self.to_ne_bytes()).is_ok()
    }
 
    fn deserialize(reader: &mut impl Read) -> Option<Self> {
        let mut buf = [0; 8];
        reader.read(&mut buf).ok()?;
        Some(Self::from_ne_bytes(buf))
    }
}

assert!(42usize.serialize(&mut file));

let x = usize::deserialize(&mut file).unwrap();

pub use std::path::Path;
use std::fs::{File, OpenOptions};
use std::io::{Result, Seek, SeekFrom, Write};
 
/// Реализация преобразования в байты
/// .to_bytes()->Vec\<u8\> 
trait ToBytes {
  fn to_bytes(&self)->Vec<u8>;
}
 
impl ToBytes for i32 {
  fn to_bytes(&self)->Vec<u8> {
    self.to_ne_bytes().to_vec()
  }
}
impl ToBytes for f32 {
  fn to_bytes(&self)->Vec<u8> {
    self.to_ne_bytes().to_vec()
  }
}
 
struct WorkFile<Tp: ToBytes> {
  file: File,
  path: String,
  data: Vec<Tp>,
}
 
impl<Tp: ToBytes> WorkFile<Tp> {
  pub fn open(pth: &str) -> Result<Self> {
    let file = OpenOptions::new()
        .read(true).write(true).create(true).open(pth)?;
    Ok(Self {
      file,
      path: pth.to_string(),
      data: Vec::new(),
    })
  }
  pub fn seek(&mut self, pos: u64) -> Result<u64> {
    self.file.seek(SeekFrom::Start(pos))
  }
  pub fn save(&mut self) -> Result<()> {
    for item in &self.data {
      self.file.write_all(&item.to_bytes())?;
    }
    Ok(())
  }
  pub fn add(&mut self,value:Tp){
    self.data.push(value)
  }
}
 
fn main() {
  let mut mf = WorkFile::<f32>::open("d:/zzz/data.i32").unwrap();
 
  mf.add(1.0);
  mf.add(2.0);
  mf.add(3.0);
 
  match mf.seek(40) {
    Ok(_) => match mf.save() {
      Ok(_) => println!("Данные успешно сохранены"),
      Err(e) => println!("Ошибка при сохранении данных: {}", e),
    },
    Err(err) => println!("Ошибка {}", err),
  }
 
  println!("{}, {:?}", mf.path, mf.data);
}