use std::sync::atomic::{AtomicU32, Ordering};
async fn create_user(
Json(payload): Json<FromBrowser>,
) -> (StatusCode, Json<User>) {
static COUNTER: AtomicU32 = AtomicU32::new(0);
// подготавливаю данные на отправку в браузер:
let user = User {
id: payload.id,
username: payload.username,
tm: payload.tm,
cnt: COUNTER.fetch_add(1, Ordering::SeqCst), // считаю отправки;
};
(StatusCode::CREATED, Json(user))
}&mut [MaybeUninit<*mut State>], инициализируете элементы и после std::mem::transmute в &mut [*mut State]
document.addEventListener('DOMContentLoaded', () => {
// ...
}, {once: true});fn main() {
println!("cargo:rustc-link-lib=dylib=Gdi32.dll");
}Proxy all HTTP traffic to the passed URL.Проксирует весь HTTP трафик
Proxy all HTTPS traffic to the passed URL.Проксирует весь HTTPS трафик
Proxy all traffic to the passed URL.Пооксирует вообще весь трафик
pub fn run<T, F>(self, event_handler: F) -> Result<(), EventLoopError>
where
F: for<'a> FnMut(Event<T>, &'a EventLoopWindowTarget<T>),
{
self.event_loop.run(event_handler)
}Я знаю, что следует избегать всяких "продвинутых" штук из ряда связных списков, самореферентных структур и т.п.Односвязные списки никаких проблем не доставляют (ну кроме того, что они плохо ложатся на процессорный кэш). Для двусвязных списков и самореферентных структур придётся использовать сырые указатели и unsafe.
Ещё я обнаружил, что создание больших структур, с методами, с кучей полей, обычно приводит к проблемам с borrow checker.Borrow checker абсолютно плевать на размер структур. Это никак не связано.
А если в структуре будет ссылка или иное заимствование, то это гарантированные проблемы.Нет ни каких проблем.
Насколько я понимаю, самым рабочим выглядит чисто функциональный подход, а не структур с методами.Одно другому никак не противоречит.
И правильно ли я понимаю, что следует избегать структур хранящих ссылки и имеющими лайфтайм?Не правильно.
Так, наличие в умеренных размерах программе, которая по сути была одной функцией, лишь одной структуры хранящей ссылку, поставило крест на попытке структуризации программы в более человеческий вид.Что-то делаете не так. Без конкретных примеров кода сказать сложно.
И очень часто в Rust программах, мне приходится идти на более уродливую архитектуру, дабы избежать проблем с (почти ненужным в однопоточном коде) borrow checker.Что-то делаете не так. Скорее всего просто не понимаете borrow checker и пытаетесь писать на новом языке так, как привыкли в каком-то другом.
И в вопросе о borrow checker, разве не является тот факт, что большинство библиотек избегает &mut self в изменяющих что-то методах, звоночком к наличию большим проблем в языке?О каком большинстве речь? Библиотеки используют мутабельные ссылки там где это нужно. Если метод действительно что-то меняет, то будет мутабельная ссылка ну и иногда будет использоваться interior mutability там где это необходимо. В языке нет проблем с мутабельными ссылками.
В общем, посоветуйте что-то что-бы помогало меньше бороться с borrow checker, потому что сейчас я очень много времени трачу именно на это.Для начала понять его. Понять какую проблему он решает. Почитайте, что такое undefined behavior. Почитайте, что такое алиасинг.
1) Не понятно, что конкретно должна делать hash функцияВычисляет хэш от ключа. Остаток от деления хэша на длину массива - это индекс бакета, в котором будет хранится пара ключ-значение.
2) Какой тип использовать у bucketsКак вариант такой:
type Buckets<K, V> = ([K, V] | undefined)[];
'static.use std::cell::RefCell;
use std::rc::Rc;
#[derive(Default, Clone, Debug)]
struct NodeInner {
name: String,
source: String,
path: String,
leaf: bool,
children: Vec<Node>,
}
#[derive(Default, Clone, Debug)]
struct Node(Rc<RefCell<NodeInner>>);
impl Node {
fn fast(name: impl Into<String>, source: impl Into<String>) -> Self {
Self(Rc::new(RefCell::new(NodeInner {
name: name.into(),
source: source.into(),
path: String::new(),
leaf: true,
children: Vec::new(),
})))
}
fn insert(&self, node: Node) {
let mut current = self.clone();
for part in node.0.borrow().source.split(".") {
let inner = node.0.borrow();
let found = inner.children.iter().find(|&v| v.0.borrow().path == part);
match found {
None => {
let tmp = Node::fast(String::new(), String::new());
current.0.borrow_mut().children.push(tmp.clone());
current = tmp;
}
Some(val) => current = val.clone(),
}
}
}
}
fn main() {
let mut root = Node::default();
root.insert(Node::fast("First", "e"));
root.insert(Node::fast("First", "e.sources"));
root.insert(Node::fast("First", "e.sources.two"));
root.insert(Node::fast("First", "e.secret"));
root.insert(Node::fast("First", "e.secret.left"));
root.insert(Node::fast("First", "e.secret.right"));
print!("{:#?}", root);
}extern C обёртку над библиотекой и биндится уже с ней. Ну и надо понимать, что никакие абстракции плюсов вроде темплейтов, классов и т.д. в раст не протащить.