Eugene Usachev

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

use mlua::Lua;

fn main() -> mlua::Result<()> {
    let lua = Lua::new();
    lua.load(r#"
        print("Hello from Lua!")
    "#).exec()?;
    Ok(())
}

extern "C" {
    fn c_function(arg: c_int) -> c_int;
}

fn main() {
    unsafe {
        c_function(5);
    }
}

use libloading::{Library, Symbol};

fn main() {
    let lib = Library::new("path_to_library.so").unwrap();
    unsafe {
        let func: Symbol<unsafe extern fn() -> ()> = lib.get(b"my_function").unwrap();
        func();
    }
}

Изучил основы JavaScript, понял что всякие манипуляции DOM мне не нужны, потому что это не используется больше

Думаю такой, может мне надо выучить React?

Но есть почему-то ощущение что React в чистом виде мне не нужен, чтобы пользоваться Next.js.

Я остановился и понял что я занимаюсь какой-то фигней. Что я хватаю отовсюду понемногу знаний, но они не складываются в общую картинку.

Собственно вопрос: по какому пути лучше пойти, чтобы потихоньку прийти к желаемому?

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

ARG RUST_VERSION=1.71.0
ARG APP_NAME=project
FROM rust:${RUST_VERSION}-slim-bullseye AS build
ARG APP_NAME
WORKDIR /app

# Build the application.
# Leverage a cache mount to /usr/local/cargo/registry/
# for downloaded dependencies and a cache mount to /app/target/ for
# compiled dependencies which will speed up subsequent builds.
# Leverage a bind mount to the src directory to avoid having to copy the
# source code into the container. Once built, copy the executable to an
# output directory before the cache mounted /app/target is unmounted.
RUN --mount=type=bind,source=src,target=src \
    --mount=type=bind,source=Cargo.toml,target=Cargo.toml \
    --mount=type=bind,source=Cargo.lock,target=Cargo.lock \
    --mount=type=cache,target=/app/target/ \
    --mount=type=cache,target=/usr/local/cargo/registry/ \
    <<EOF
set -e
cargo build --locked --release
cp ./target/release/$APP_NAME /bin/server
EOF

# FROM, Установка rust и прочих зависимостей
# ...

RUN cargo new /app
COPY app/Cargo.toml /app/

# This step compiles only our dependencies and saves them in a layer. This is the most impactful time savings
# Note the use of --mount=type=cache. On subsequent runs, we'll have the crates already downloaded
WORKDIR /app
RUN --mount=type=cache,target=/usr/local/cargo/registry cargo build --release

COPY ./app /app

# touch нужен, чтобы изменить дату изменения файла
RUN --mount=type=cache,target=/usr/local/cargo/registry \
  set -e; \
  touch /app/src/main.rs; \
  cargo build --release;

cd /path/to && docker compose pull && docker compose up -d

Сначала я прогнал тест на Windows... я и не стал проверять на Windows неделю назад (работал в Docker).

• вот тут товарищи тоже задаются года с 2018
  
• а вот и кое-какой продукт