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 обёртку над библиотекой и биндится уже с ней. Ну и надо понимать, что никакие абстракции плюсов вроде темплейтов, классов и т.д. в раст не протащить.
Мальчик 15 лет, хочет в будущем стать программистом
fn example<'a>(r: &'a u32) -> &'a u32 { r }
fn f_a() {
let a = 1;
let r = example(&a);
}
fn f_b() {
let b = 1;
let r = example(&b);
}fn make_array<const SIZE: usize>(el: u32) -> [u32; SIZE] {
[el; SIZE]
}
let arr = make_array::<3>(1); // [1, 1, 1]Почему drop принимает ссылку, а не значение?
Причём если вызывать drop() рукамиФункция core::mem::drop никакого отношения к трейту Drop не имеет. Если Вы глянете на её реализацию, то это просто пустая функция, которая принимает аргумент по значению, а он уже дропается на общих основаниях, так как выходит из области видимости в ней.
Почему сначала вызывается drop для A, а потом для B? По логике drop должен сначала вызываться для полей.У Вас неверная логика. В метод трейта Drop приходит ссылка, а значит должна быть гарантия того что данные по ней полностью валидные. Всегда дропается сначала внешняя структура,а затем её поля. Более того компилятор не даст Вам даже мувнуть части структуры имплиментирующей Drop.
#[r]
fn bar(a: usize) -> usize {
if a % 2 == 0 {
return 0;
}
1
}fn bar(a: usize, res: *mut usize) {
fn bar_impl(a: usize) -> usize {
if a % 2 == 0 {
return 0;
}
1
}
unsafe { *res = bar_impl(a); }
}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);
}