Fix errors and inconcistency with this requirement in the part of the minimal viable solution of the problems, written in rust code, using only std and libraries that is explicitly used in code below, pointing in which files which update needed and which new files need to create with which code. Task: define in …/project/src/datacode.rs a Global Struct and a Generic, that can be read and updated by any function or macro in …/project/src/main.rs or …/project/src/subproject/src/lib.rs, intended for filling data from a bunch of files. Above data strutures are initializing with the same set of rows, taken from files, which rows consisting of 3 cells type of &str. Although I explicitly mentioning the type of the cells in this task as &str, this is just for example, so design each data structs so it can deal with any type of data not limiting to string cells or example ones. Again, just for example, use hashmap (use 1st &str as a key, two rest as values), hashset (all three cells goes into hashset as \t tab-separated in one string), vec (use 1st &str as a key, rest as values), and another entity BinaryHeap in similar fashion. There are errors 

/*
error: src/datacode.rs:44: the trait bound `T: Ord` is not satisfied
error: src/datacode.rs:44: the trait `Ord` is not implemented for `T`
note: src/datacode.rs:44: required for `(T, &str, T)` to implement `Ord`
note: src/datacode.rs:21: required by a bound in this
note: src/datacode.rs:20: required by a bound in `datacode::BinaryHeap::<T>::new`
note: src/datacode.rs:20: required by this bound in `BinaryHeap::<T>::new`
help: src/datacode.rs:37: consider further restricting this bound
error: src/datacode.rs:73: mismatched types
error: src/datacode.rs:73: expected type parameter `T`, found struct `String`
error: src/datacode.rs:73: arguments to this enum variant are incorrect
note: src/datacode.rs:73: expected struct `MyGlobalStruct<'_, T>`
   found struct `MyGlobalStruct<'_, String>`
help: src/datacode.rs:73: this argument influences the type of `Ok`
help: src/datacode.rs:73: the type constructed contains `MyGlobalStruct<'_, String>` due to the type of the argument passed
note: src/datacode.rs:73: tuple variant defined here
error: src/datacode.rs:35: this type parameter

*/

in the …/project/src/datacode.rs part:  use std::collections::{BTreeMap, HashMap, HashSet};
use std::cmp::Reverse;
use std::fs::File;
use std::io::{self, BufRead, BufReader};

#[derive(Debug)]
pub struct MyGlobalStruct<'a, T> {
    hashmap: HashMap<&'a str, (T, T, T)>,
    hashset: HashSet<String>,
    vec: Vec<(&'a str, (T, T, T))>,
    binary_heap: BinaryHeap<(T, &'a str, T)>,
    // add other fields as needed
}

#[derive(Debug)]
pub struct BinaryHeap<T> {
    heap: Vec<T>,
}

impl<T: Ord> BinaryHeap<T> {
    pub fn new() -> Self {
        BinaryHeap { heap: Vec::new() }
    }

    pub fn push(&mut self, x: T) {
        self.heap.push(x);
        self.heap.sort_by_key(|k| Reverse(k));
    }

    pub fn pop(&mut self) -> Option<T> {
        self.heap.pop()
    }
}

impl<'a, T> MyGlobalStruct<'a, T>
where
    T: Clone,
{
    pub fn new() -> MyGlobalStruct<'a, T> {
        MyGlobalStruct {
            hashmap: HashMap::new(),
            hashset: HashSet::new(),
            vec: Vec::new(),
            binary_heap: BinaryHeap::new(),
            // initialize other fields as needed
        }
    }

    pub fn from_files(file_paths: &[&str]) -> io::Result<MyGlobalStruct<'a, T>> {
        let mut data = MyGlobalStruct::new();

        for file_path in file_paths {
            let file = File::open(file_path)?;
            let reader = BufReader::new(file);

            for line in reader.lines() {
                if let Ok(data_row) = line {
                    let row = data_row.split('\t').collect::<Vec<&str>>();

                    if row.len() == 3 {
                        let (key, value1, value2) = (row[0], row[1], row[2]);
                        data
                            .hashmap
                            .insert(key, (value1.to_string(), value2.to_string(), "".to_string()));
                        data.hashset.insert(data_row);
                        data.vec.push((key, (value1.to_string(), value2.to_string(), "".to_string())));
                        data.binary_heap.push((value1.to_string(), key, value2.to_string()));
                    }
                }
            }
        }

        Ok(data)
    }

    // add other methods as needed
}