commit 42349a315ef1c43e03b40070ad431b9ee2d54ca3
Author: Andrew Golovashevich <landgrafhomyak@gmail.com>
Date:   Thu Dec 11 19:57:53 2025 +0300

    Draft interfaces

diff --git a/.cargo/config.toml b/.cargo/config.toml
new file mode 100644
index 0000000..d4fa5d9
--- /dev/null
+++ b/.cargo/config.toml
@@ -0,0 +1,2 @@
+[registries]
+landgrafhomyak = { index = "sparse+https://cargo.landgrafhomyak.ru/" }
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..b5488f8
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,3 @@
+/.idea/
+Cargo.lock
+target/
\ No newline at end of file
diff --git a/Cargo.toml b/Cargo.toml
new file mode 100644
index 0000000..ebb1e1d
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "dynamic-memory-api-0"
+edition = "2024"
+
+[dependencies]
+
+[lints]
+rust = { nonstandard_style = "allow" }
+
+[workspace]
+
+[patch.landgrafhomyak]
diff --git a/src/dyn.rs b/src/dyn.rs
new file mode 100644
index 0000000..a381e5f
--- /dev/null
+++ b/src/dyn.rs
@@ -0,0 +1,5 @@
+pub unsafe trait Dyn<T: Sized>: Drop + Sized {
+    fn getRef<'s>(&'s self) -> &'s mut T;
+    fn free<'s>(&'s mut self);
+}
+
diff --git a/src/general.rs b/src/general.rs
new file mode 100644
index 0000000..eaa03ce
--- /dev/null
+++ b/src/general.rs
@@ -0,0 +1,27 @@
+use std::mem::MaybeUninit;
+
+pub unsafe trait GeneralPurposeHeap {
+    type Dyn<T: Sized>: crate::Dyn<T>;
+
+    fn alloc<'s, T: Sized>(&'s mut self, value: T) -> Self::Dyn<T> {
+        return self
+            .tryAlloc(value)
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn allocUninitialized<'s, T: Sized>(&'s mut self) -> Self::Dyn<MaybeUninit<T>> {
+        return self
+            .tryAllocUninitialized()
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn allocZeroed<'s, T: Sized>(&'s mut self) -> Self::Dyn<MaybeUninit<T>> {
+        return self
+            .tryAllocZeroed()
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn tryAlloc<'s, T: Sized>(&'s mut self, value: T) -> Option<Self::Dyn<T>>;
+    fn tryAllocUninitialized<'s, T: Sized>(&'s mut self) -> Option<Self::Dyn<MaybeUninit<T>>>;
+    fn tryAllocZeroed<'s, T: Sized>(&'s mut self) -> Option<Self::Dyn<MaybeUninit<T>>>;
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..09c1390
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,12 @@
+mod r#dyn;
+mod general;
+mod pages;
+mod stack;
+mod typed;
+
+pub use pages::Page;
+pub use pages::PagesManager;
+pub use r#dyn::Dyn;
+pub use stack::StackHeap;
+pub use typed::TypedHeap;
+pub use general::GeneralPurposeHeap;
\ No newline at end of file
diff --git a/src/pages.rs b/src/pages.rs
new file mode 100644
index 0000000..db72e3d
--- /dev/null
+++ b/src/pages.rs
@@ -0,0 +1,27 @@
+use std::ptr::NonNull;
+
+enum ExtensionResult {
+    OK,
+    NO_MEMORY,
+    EXTENSION_BUSY,
+}
+
+pub unsafe trait Page {
+    fn getMemory(&self) -> NonNull<[u8]>;
+
+    fn releasePage(self);
+
+    fn tryExtend(&mut self, minimalAdditionalSize: usize) -> ExtensionResult;
+}
+
+pub unsafe trait PagesManager {
+    type Page: Page;
+
+    fn offerPage<'s>(&'s mut self, minsize: usize) -> &'s Self::Page {
+        return self
+            .tryOfferPage(minsize)
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn tryOfferPage<'s>(&'s mut self, minimalSize: usize) -> Option<&'s Self::Page>;
+}
diff --git a/src/stack.rs b/src/stack.rs
new file mode 100644
index 0000000..8b34716
--- /dev/null
+++ b/src/stack.rs
@@ -0,0 +1,25 @@
+use std::mem::MaybeUninit;
+
+pub unsafe trait StackHeap {
+    fn childScope<'s>(&'s mut self) -> impl StackHeap;
+
+    fn alloc<'s, T: Sized>(&'s mut self, value: T) -> &'s mut T {
+        return self
+            .tryAlloc(value)
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+    fn allocUninitialized<'s, T: Sized>(&'s mut self) -> &'s mut MaybeUninit<T> {
+        return self
+            .tryAllocUninitialized()
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+    fn allocZeroed<'s, T: Sized>(&'s mut self) -> &'s mut MaybeUninit<T> {
+        return self
+            .tryAllocZeroed()
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn tryAlloc<'s, T: Sized>(&'s mut self, value: T) -> Option<&'s mut T>;
+    fn tryAllocUninitialized<'s, T: Sized>(&'s mut self) -> Option<&'s mut MaybeUninit<T>>;
+    fn tryAllocZeroed<'s, T: Sized>(&'s mut self) -> Option<&'s mut MaybeUninit<T>>;
+}
diff --git a/src/typed.rs b/src/typed.rs
new file mode 100644
index 0000000..b9a1c65
--- /dev/null
+++ b/src/typed.rs
@@ -0,0 +1,28 @@
+use std::mem::MaybeUninit;
+
+pub unsafe trait TypedHeap<T: Sized> {
+    type Dyn<_T: Sized>: crate::Dyn<_T>;
+
+    fn alloc<'s>(&'s mut self, value: T) -> Self::Dyn<T> {
+        return self
+            .tryAlloc(value)
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn allocUninitialized<'s>(&'s mut self) -> Self::Dyn<MaybeUninit<T>> {
+        return self
+            .tryAllocUninitialized()
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn allocZeroed<'s>(&'s mut self) -> Self::Dyn<MaybeUninit<T>> {
+        return self
+            .tryAllocZeroed()
+            .unwrap_or_else(|| panic!("Out of memory"));
+    }
+
+    fn tryAlloc<'s>(&'s mut self, value: T) -> Option<Self::Dyn<T>>;
+    fn tryAllocUninitialized<'s>(&'s mut self) -> Option<Self::Dyn<MaybeUninit<T>>>;
+    fn tryAllocZeroed<'s>(&'s mut self) -> Option<Self::Dyn<MaybeUninit<T>>>;
+}
+