TicSo

Имя таблицы как параметр нельзя передать.
Используй format! или concat!

Для конкатенации строк нужно одно из двух:
1. Одна из строк должна быть String, а не &str и тогда ты просто добавляешь к ней вторую
2. Ты должнен в процессе конкатенации создавать новый String.

А второй вариант у тебя не работает из-за того что ты дропаешь String, который был создан при конкатенации.

Первый вариант имхо не очень читабельный получился. Лучше попробуй вот так:

fn main() {
    let a = "x";
    println!("1. {:?}", a);   // "x"

    let b = format!("{}y", a);
    println!("2. {:?}", b);    // "xy"
}

Либо:

fn main() {
    let mut s = "x".to_string();
    println!("1. {}", s);   // "x"
    s += "y";
    println!("2. {}", s);   // "xy"
}

use std::slice;

fn main() {
    let range = (0..u8::MAX).collect::<Vec<_>>();
    let v = range
        .iter()
        .map(|x| std::str::from_utf8(slice::from_ref(x)).unwrap_or("Err"))
        .collect::<Vec<_>>();
    println!("{v:?}")
}

fn main() {
    let src: Vec<[u8; 1]> = (0..u8::MAX).map(|i| [i]).collect();
    let mut info =  Vec::<&str>::with_capacity(u8::MAX.into());
    for u in &src {
        let t = std::str::from_utf8(&*u).unwrap_or("Err");
        info.push(t);
    }
    println!("\n{:#?}", info);
}

но надо понимать, что info будет связан лайфтаймом с src, чтоб избавится от этого нужно хранить в нём не &str а String или Box<str>

fn main() {
    let info: Vec<Box<str>> = (0..u8::MAX).map(|i| {
        let u = [i];
        let t = std::str::from_utf8(&u).unwrap_or("Err");
        t.into()
    }).collect();
    println!("\n{:#?}", info);
}

Сумбурный вопрос, но если правильно понял, то автор хочет получить Vec<&str> элементы которого ссылаются на исходный вектор байт и в каждом элементе строка из 1 символа:

let u01 = vec![59, 13, 10, 32, 47, 42];
let u01_str = std::str::from_utf8(&u01).expect("invalid utf8");
let mut u02 = Vec::with_capacity(u01.len());
let mut i0 = 0;
for (i, _) in u01_str.char_indices().skip(1) {
    u02.push(&u01_str[i0..i]);
    i0 = i;
}
u02.push(&u01_str[i0..]);
println!("u02 = {:?}", u02);

Начну с того, что код представленный автором в комментах к вопросу имеет deadlock между мьютексом и recv() из канала и завершается лишь по тому, что мы не ждем фоновые потоки. Вариант без deadlock будет выглядеть так:

fn test() {
    let mut channels = Arc::new(Mutex::new(Vec::with_capacity(PAR)));
    let mut joins = Vec::with_capacity(PAR);
    for _ in 0..N / PAR {
        for _ in 0..PAR {
            let mut channels = Arc::clone(&channels);
            joins.push(thread::spawn(move || {
                get(channels.lock().unwrap());
            }));
        }
    }
    for j in joins {
        j.join().unwrap();
    }
}

#[inline(always)]
fn get(mut channels: MutexGuard<Vec<mpsc::Sender<i32>>>) -> i32 {
    let (tx, rx) = mpsc::channel();
    channels.push(tx);
    if channels.len() == PAR {
        exec(channels);
    } else {
        drop(channels); // drop гварда отпускает мьютекс
    }
    rx.recv().unwrap()
}

#[inline(always)]
fn exec(mut channels: MutexGuard<Vec<mpsc::Sender<i32>>>) {
    let mut i = 0;
    for c in channels.iter() {
        i += 1;
        c.send(1).unwrap();
    }
    println!("{}", i);
    channels.clear();
    // а здесь гвард дропнется сам
}

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

fn test() {
    let (tx, rx) = mpsc::channel::<mpsc::Sender<i32>>();
    let mut handles = Vec::with_capacity(N + 1);
    handles.push(thread::spawn(move || exec(rx)));
    for _ in 0..N {
        let tx = tx.clone();
        handles.push(thread::spawn(move || {
            get(tx);
        }))
    }
    drop(tx);
    for handle in handles {
        handle.join().unwrap();
    }
}

fn get(sender: mpsc::Sender<mpsc::Sender<i32>>) -> i32 {
    let (tx, rx) = mpsc::channel();
    sender.send(tx).unwrap();
    rx.recv().unwrap()
}

fn exec(receiver: mpsc::Receiver<mpsc::Sender<i32>>) {
    let mut channels = Vec::with_capacity(PAR);
    loop {
        for _ in 0..PAR {
            let Ok(tx) = receiver.recv() else {
                return;
            };
            channels.push(tx);
        }
        let mut i = 0;
        for c in channels.iter() {
            i += 1;
            c.send(1).unwrap();
        }
        println!("{}", i);
        channels.clear();
    }
}

Но особо это профита не дает, так как основной пожиратель перфоманса - switch context в ОС. Тысячи потоков делают только хуже. Запускать потоков сильно больше чем есть ядер - это вообще плохая идея. Просто ради интереса переписал еще раз на асинхронных каналах tokio:

async fn test() {
    let (tx, rx) = mpsc::unbounded_channel::<mpsc::UnboundedSender<i32>>();
    let mut handles = Vec::with_capacity(N + 1);
    handles.push(tokio::spawn(async move { exec(rx).await }));
    for _ in 0..N {
        let tx = tx.clone();
        handles.push(tokio::spawn(async move {
            get(tx).await;
        }))
    }
    drop(tx);
    for handle in handles {
        handle.await.unwrap();
    }
}

async fn get(sender: mpsc::UnboundedSender<mpsc::UnboundedSender<i32>>) -> i32 {
    let (tx, mut rx) = mpsc::unbounded_channel();
    sender.send(tx).unwrap();
    rx.recv().await.unwrap()
}

async fn exec(mut receiver: mpsc::UnboundedReceiver<mpsc::UnboundedSender<i32>>) {
    let mut channels = Vec::with_capacity(PAR);
    loop {
        for _ in 0..PAR {
            let Some(tx) = receiver.recv().await else {
                return;
            };
            channels.push(tx);
        }
        let mut i = 0;
        for c in channels.iter() {
            i += 1;
            c.send(1).unwrap();
        }
        println!("{}", i);
        channels.clear();
    }
}

и запустил в многопоточном рантайме в дефолтной конфигурации (количество воркеров == количеству ядер), работает быстрее в 19 раз.

P.S. без I/O операций асинхронщина тоже создает ненужные накладные расходы, я ее здесь использовал только из-за простоты переписывания, лучше взять обычный thread pool с синхронными тасками.

Это уже и так из коробки работает в терминале. Не нужно усложнять своё приложение этим.
Попробуй использовать shift+insert или ctrl+shift+v, если у тебя в терминале на ctrl+v пишется ^V.
Либо посмотри настройки.

https://doc.rust-lang.org/std/path/struct.Path.htm...

let cwd = std::env::current_dir().unwrap().parent().unwrap();

Arc нужно клонировать до move в замыкание, которое запускается на потоке. Если данные используются только на чтение, то этого будет достаточно, если данные будут меняться из нескольких потоков, то следует дополнительно обернуть их в Mutex/RwLock (или из std::sync или из библиотеки parking_lot).

use std::sync::Arc;

fn main() {
    let data = Arc::new(vec![1, 2, 3]);

    let thread_1 = std::thread::spawn({
        let data = Arc::clone(&data);
        move || {
            println!("Thread 1 data: {:?}", data);
        }
    });

    let thread_2 = std::thread::spawn({
        let data = Arc::clone(&data);
        move || {
            println!("Thread 2 data: {:?}", data);
        }
    });

    thread_1.join().unwrap();
    thread_2.join().unwrap();
}

Передавать так можно хоть вектор, хоть свою структуру, главное чтоб у типа был трейт Send и лайфтайм 'static (все владеющие типы имеют такой лайфтайм).
Так как передаем мы по сути Arc, то Send должен быть у него, а он будет для любого содержимого реализующего Sync.

Я обернул создание отдельного потока в функцию и так передавал в поток данные. Удобно, что такую функцию могу вынести в отдельный файл-модуль. Но не смог такое сделать динамически в цикле для группы потоков. Хочу подойти к варианту, когда поток, который закончил выполнение своего кода (раньше других), можно опять запустить из main и передать ему новую задачу (новые данные), - структуру данных, которую привёл в основном вопросе.

Если правильно понял, то Вам нужен thread pool. Можно использовать из библиотеки rayon: https://docs.rs/rayon/1.7.0/rayon/struct.ThreadPoo...
Но если хочется повелосипедить, можно нечто такое сделать:

use std::{
    sync::{
        mpsc::{self, Sender},
        Arc, Mutex,
    },
    thread::{self, JoinHandle},
};

type Task = Box<dyn FnOnce() + Send + 'static>;

pub struct ThreadPool {
    handles: Vec<JoinHandle<()>>,
    task_sender: Sender<Task>,
}

impl ThreadPool {
    pub fn new() -> Self {
        let threads_count = thread::available_parallelism()
            .map(|n| n.get())
            .unwrap_or(2);
        let (task_sender, task_receiver) = mpsc::channel::<Task>();
        let task_receiver = Arc::new(Mutex::new(task_receiver));
        let mut handles = Vec::with_capacity(threads_count);
        for _ in 0..threads_count {
            let task_receiver = Arc::clone(&task_receiver);
            handles.push(thread::spawn(move || loop {
                let task_receiver = task_receiver.lock().unwrap_or_else(|e| e.into_inner());
                let Ok(task) = task_receiver.recv() else {
                    return;
                };
                drop(task_receiver);
                task();
            }));
        }
        Self {
            handles,
            task_sender,
        }
    }

    pub fn spawn_task<F: FnOnce() + Send + 'static>(&self, f: F) {
        self.task_sender.send(Box::new(f)).expect("All threads ended");
    }

    pub fn join(self) -> thread::Result<()> {
        drop(self.task_sender);
        for handle in self.handles {
            handle.join()?;
        }
        Ok(())
    }
}

#[test]
fn thread_pool() {
    let pool = ThreadPool::new();
    for i in 0..500 {
        pool.spawn_task(move || {
            println!("Task {} working on thread {:?}", i, thread::current().id());
        });
    }
    pool.join().unwrap();
}

use chrono::prelude::*;
use std::sync::mpsc;
use std::sync::mpsc::{Receiver, Sender};
use std::{thread, time};

fn main() {
    println!("- - - - -");
    let mut children = Vec::with_capacity(3);

    for id in 0..children.capacity() {
        let child = thread::spawn(move || {
            let mut date_times = Vec::with_capacity(5);
            for i in 0..date_times.capacity() {
                let t: DateTime<Local> = Local::now();
                date_times.push(t);
                println!("{:?}_ поток, задача _{:?}, время: {:?}", id, i, t);
                thread::sleep(time::Duration::from_millis(3));
            }
            (id, date_times)
        });

        children.push(child);
    }

    for child in children {
        let (id, date_times) = child.join().expect("Дочерний поток паникует");
        println!("thd_{} = {:?}", id, date_times);
    }
    println!("- - - - -");
}

Нет, нельзя. Модули в Rust оперируют функциями/типами/трейтами, но не отдельными кусками кода.
Ты можешь вынести функции f1 и f2 в отдельные файлы:

main.rs

mod m01;
mod m02;
mod m03;

fn main() {
    m01::f1();
    m02::f2();
    let (i, p) = m03::f3();
    println!("i = {:?}", i);
    println!("p = {:?}", p);
}

m01.rs

pub fn f1() {
 let num: u8 = 12;
 println!("num = {:?}", num);
}

m03.rs

pub fn f2() {
 let s: String = "abc".to_string();
 println!("s = {:?}", s);
}

В случае m03 ты можешь попробовать сделать функцию, которая будет возвращать значения переменных i и p:

pub fn f3() -> (u8, String) {
  let i: u8 = 88;
  let p: String = "xyz".to_string();
  (i, p)
}

PS: Я уже было хотел предложить макрос вида:

macro_rules! f4 {
  () => {
    let i: u8 = 88;
    let p: String = "xyz".to_string();
  }
}

Но он работать не будет, ибо гигиена.

Но можно сделать так:

macro_rules! f4 {
  ($a: ident, $b: ident) => {
    let $a: u8 = 88;
    let $b: String = "xyz".to_string();
  }
}

fn main() {
    f4!(i, p);
    println!("{} {}", i, p);
}

PPS: ну и ещё есть макрос include!, который буквально решает твою задачу - вставить кусок кода из файла, но его я не советую использовать.

На GO, "православный" стек, это стандартный пакет net/http + какой нибудь внешний роутер, например chi, либо вообще не http/rest, а gRPC (если мы говорим об API).
Для БД чистый SQL, максимум какой нибудь маппер на структуру, типа sqlx(можно ещё использовать sql builder, но в IDE Goland хорошая поддержка чистого sql).

ORM очень не советую, есть конечно gorm(генерирует запросы не эффективно, N+1 при связях), для мелких проектов хватит, но вот со сложными запросами любая ORM не справляется.
Я категорически против ORM, так как за всё время моей работы в вебе, в любом проекте, самым слабым звеном всегда была ORM(долбит кучей запросов БД, когда на чистом sql это 1-2 запроса), либо программист, вместо того, чтобы написать запрос вида "SELECT SUM(amount) FROM book WHERE author = 'Petya'", достаёт все записи и суммирует это в коде(делает работу за БД + тратит ресурсы БД на чтение данных с диска и передачу их по сети).

Не нужно использовать фреймворки, это не даст опыта написания на go(как и в большинстве языков).
Go используют, где производительности других решений не достаточно, или нужна многопоточность, что фреймворки так себе обеспечивают.
Шаблоны в go практически не использую, пишу фронт на vuejs и обращаюсь к go api.
Есть генераторы документаций, но я тут не посоветую, их нужно тестировать отдельно, у каждого есть свои плюсы и минусы, сам использую другое решение(опишу в конце).

Самое главное, побыстрее понять, что на go нужно писать как на go, а не так как привыкли в других языках, потому-что, в нём нет привычных классов, строгая типизация, процесс живёт долго и могут быть race condition(гонка состояний) при многопотоке(веб сервер многопоточный), поэтому о подходах из php советую поскорее забыть.

В своих проектах(в проде), использую go только как сервис предоставляющий апи. Недавно начал использовать grpc-gateway(так как использую gRPC, но так же необходимо делать API доступное через web), проект позволяет описать всё что необходимо в proto файлах (см. gRPC), сгенерировать модели и обёртки под большенство языков + документацию в OpenAPI 2.0. Это не фреймворк, это обёртка над стандартным net/http, которая сразу валидирует и маппит данные на структуру.

Коротко:
Для новичка, советую забыть про фреймворки(они не помогут в изучении) и ORM(не эффективно).

Использовать для веб сервера:
net/http - встроен в го
chi(проще) или gorilla/mux - роутер

Для взаимодействия с БД:
sqlx - обёртка над стандартным пакетом sql, но позволяет сразу считывать данные в структуру, без ручного сканирования.

Для работы с полями ввода есть набор событий:
1. focus - пользователь поставил фокус на поле ввода.
2. blur - пользователь убрал фокус с элемента вода.
3. input - пользователь как-то что-то ввел. Это лучше, чем keyup, ибо не надо проверки keyCode, второе потому что пользователь может в поле вставить текст, что тогда будет с Вашим keyUp? Событие input срабатывает каждый раз, как пользователь сделал изменение в поле ввода.
4. change - пользователь ввел данные и убрал фокус с поля ввода, то есть это input + blur. Событие происходит не так часто, как input, но и не заставляет проверять value на изменение, как это придется делать при blur.
5. submit - срабатывает на всей форме, при попытке отправить данные, в данной задаче скорее не интересное событие.

Для живого поиска логично использовать input, по которому надо отправить текущее value через ajax на сервер и далее ответ куда-то распечатать. Вопрос в другом, ведь событие срабатывает довольно часто, и кто-то печатает так быстро, что и запрос-ответ не успеет, поэтому логично сделать тут debounce с задержкой в приблизительно 300мс, чтобы отправка/получение сработало когда пользователь притормозил в наборе текста или вообще прекратил ввод.