From f04ac5dc60a6c29e671aeea1e4248147a9d472af Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Tue, 15 Sep 2026 13:23:57 +0300
Subject: [PATCH 1/2] Implement `From`

Our code has a feature that requires aligned data when enabled.
To avoid adding `cfg`s to tests, I added `From`.
This allows us to call `into()` on the data, so it is automatically
wrapped in `Aligned` when the feature is enabled.
---
 src/lib.rs | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index 4958354..766704d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -133,6 +133,15 @@ pub const fn Aligned<A, T>(value: T) -> Aligned<A, T> {
     }
 }
 
+impl<A, T> From<T> for Aligned<A, T>
+where
+    A: Alignment,
+{
+    fn from(value: T) -> Self {
+        Aligned(value)
+    }
+}
+
 impl<A, T> ops::Deref for Aligned<A, T>
 where
     A: Alignment,
@@ -989,3 +998,10 @@ fn test_range_from_out_of_bounds() {
     let a: &Aligned<A2, [u8]> = &Aligned::<A2, _>([0u8; 4]);
     let _ = &a[6..];
 }
+
+#[test]
+fn test_from() {
+    let a: Aligned<A4, _> = [1, 2, 3].into();
+    assert_eq!(*a, [1, 2, 3]);
+    assert_eq!(core::mem::align_of_val(&a), 4);
+}

From ac54e6422bf24984f341c818a915df814d0fffcd Mon Sep 17 00:00:00 2001
From: Hennadii Chernyshchyk <genaloner@gmail.com>
Date: Tue, 15 Sep 2026 16:04:39 +0300
Subject: [PATCH 2/2] Add `AsRef` and `AsMut`

---
 src/lib.rs | 51 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index 766704d..45ab6fb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -306,6 +306,42 @@ where
     }
 }
 
+impl<A, T, const N: usize> AsRef<Aligned<A, [T]>> for Aligned<A, [T; N]>
+where
+    A: Alignment,
+{
+    fn as_ref(&self) -> &Aligned<A, [T]> {
+        self
+    }
+}
+
+impl<A, T, const N: usize> AsMut<Aligned<A, [T]>> for Aligned<A, [T; N]>
+where
+    A: Alignment,
+{
+    fn as_mut(&mut self) -> &mut Aligned<A, [T]> {
+        self
+    }
+}
+
+impl<A, T, const N: usize> AsRef<[T]> for Aligned<A, [T; N]>
+where
+    A: Alignment,
+{
+    fn as_ref(&self) -> &[T] {
+        &self.value[..]
+    }
+}
+
+impl<A, T, const N: usize> AsMut<[T]> for Aligned<A, [T; N]>
+where
+    A: Alignment,
+{
+    fn as_mut(&mut self) -> &mut [T] {
+        &mut self.value[..]
+    }
+}
+
 impl<A, T> AsSlice for Aligned<A, T>
 where
     A: Alignment,
@@ -1005,3 +1041,18 @@ fn test_from() {
     assert_eq!(*a, [1, 2, 3]);
     assert_eq!(core::mem::align_of_val(&a), 4);
 }
+
+#[test]
+fn array_as_ref() {
+    let array = Aligned::<A4, _>([1, 2, 3]);
+    let slice: &[u8] = array.as_ref();
+    assert_eq!(slice.as_ptr(), array.as_ptr());
+}
+
+#[test]
+fn array_as_mut() {
+    let mut array = Aligned::<A4, _>([1, 2, 3]);
+    let slice: &mut [u8] = array.as_mut();
+    slice[0] = 4;
+    assert_eq!(slice.as_ptr(), array.as_ptr());
+}