Имя

Я не могу просто взять и изменить поле memory_backend: &'a mut dyn MemoryBackend на

// crate::sync::cache;

pub struct Cache<'a, T> {
    memory_backend: &'a mut dyn MemoryBackend + Send + Sync,
    phantom_data: core::marker::PhantomData<T>,
}

// crate::cache;

pub struct Cache<'a, T> {
    memory_backend: &'a mut dyn MemoryBackend,
    phantom_data: core::marker::PhantomData<T>,
}

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)
}

Почему drop принимает ссылку, а не значение?

Причём если вызывать drop() руками

Почему сначала вызывается drop для A, а потом для B? По логике drop должен сначала вызываться для полей.

Вплоть до 29 пакета всё кажется идёт хорошо, но в 29 пакете браузер пытается отправить ACK, как я понял в ответ на FIN ACK, но похоже тут что-то не так.

У меня подозрение, что в после того как сервер в 28 пакете отправил FIN ACK он не дожидается ACK от клиента, верно ли это?

но браузер тут-же создаёт новое подключение

не присылает никаких запросов в этом подключении

поскольку я хочу просто отправить ответ и закрыть соединение

в этом варианте клиенту с сервером чуть-чуть не хватило что-бы полностью обработать последовательность:

Правильно ли я понимаю, что сервер посылая FIN ACK не дожидается ACK и в целом неверно производит завершение TCP подключения, завершая соединение раньше времени?

Именно поэтому браузер инициирует повторное подключение, но не присылает никаких данных.

Я попробовал отправлять запрос с помощью сторонней утилиты, в этом случае соединение завершается корректно

(я пробовал разные браузеры)

fn main() -> MainResultWrapper {
    MainResultWrapper(main_inner())
}

#[inline(always)]
fn main_inner() -> Result<(), GlobalError> {
    let config = read_config_from_file()?;
    Ok(())
}

pub fn build_server_config(&self) -> Result<Config, ConfigError> {
    let socket_addr_v4 = self.socket_addr.parse::<SocketAddrV4>()
        .map_err(ConfigError::WrongSocketAddr)?;
    Ok(Config {
        // инициализация полей Config
    })
}

Cell<T> has the same memory layout and caveats as UnsafeCell<T>. In particular, this means that Cell<T>has the same in-memory representation as its inner type T.

pub struct HashMap<K, V> {
    table: Table<(K, V)>,
}

struct Table<T> {
    // битовая маска занятых ячеек в items
    mask: u64,
    items: Box<[std::mem::MaybeUninit<Item<T>>; 64]>,
    len: usize,
}

struct Item<T> {
    data: T,
    next: Option<std::ptr::NonNull<Item<T>>>,
}

pub enum Entry<'a, K, V> {
    Vacant(VacantEntry<'a, K, V>),
    Occupied(OccupiedEntry<'a, K, V>),
}

pub struct VacantEntry<'a, K, V> {
    hash: u64,
    key: K,
    table: &'a mut Table<(K, V)>,
}

pub struct OccupiedEntry<'a, K, V> {
    elem: Bucket<(K, V)>,
    table: &'a mut Table<(K, V)>,
}

// указатель на Item.data
struct Bucket<T> {
    ptr: std::ptr::NonNull<T>,
}

impl<K, V> HashMap<K, V> {
    pub fn entry<'a>(&'a mut self, key: K) -> Entry<'a, K, V>
    where
        K: Eq + std::hash::Hash,
    {
        use std::hash::Hasher as _;
        let mut hasher = self.get_hasher();
        key.hash(&mut hasher);
        let hash = hasher.finish();

        if let Some(elem) = self.table.find(hash, |(k, _)| key == *k) {
            Entry::Occupied(OccupiedEntry {
                elem,
                table: &mut self.table,
            })
        } else {
            Entry::Vacant(VacantEntry {
                hash,
                key,
                table: &mut self.table,
            })
        }
    }

    fn get_hasher(&self) -> impl std::hash::Hasher {
        todo!()
    }
}

impl<T> Table<T> {
    fn find(&self, hash: u64, is_match: impl FnMut(&T) -> bool) -> Option<Bucket<T>> {
        todo!()
    }
}

Как устранить ошибку конверсии при использовании битовых полей?