Claude drafted no_std support (#94)

* Claude drafted no_std support

* Rework Write and WriteBytes relationship

* Tidy unused imports

* Further error suppression

* Restore cargo check for std

Author: frankmcsherry

.github/workflows/test.yml

@@ -24,6 +24,8 @@ jobs:
         with:
           toolchain: ${{ matrix.toolchain }}
       - name: Cargo check
-        run: cargo test
+        run: cargo check
       - name: Cargo test
         run: cargo test --workspace --all-targets
+      - name: Verify no_std support
+        run: cargo check -p test-no-std

Cargo.toml

@@ -13,7 +13,7 @@ repository = "https://github.com/frankmcsherry/columnar.git"
 license = "MIT"
 
 [workspace]
-members = ["columnar_derive"]
+members = ["columnar_derive", "test-no-std"]
 
 [dependencies]
 serde = { version = "1.0", optional = true, features = ["derive"] }
@@ -27,6 +27,8 @@ bincode = "1.3.3"
 serde_json = "1.0"
 
 [features]
+default = ["std"]
+std = []
 serde = ["dep:serde", "columnar_derive/serde", "smallvec/serde"]
 
 [[example]]

src/adts/art.rs

@@ -3,6 +3,7 @@
 //! This ADT represents an unordered collection of byte sequences as a tree.
 //! Like a trie, the paths down the tree correspond to byte sequences, and 
 //! the membership of a byte sequence is determined by the a viable path.
+use alloc::boxed::Box;
 
 /// An ART node exists in the context of a sequence of bytes, and indicates
 /// the possible options based on the next byte in the sequence.

src/adts/tree.rs

@@ -2,6 +2,7 @@
 //!
 //! A `Tree<T>` is a node with a value of type `T` and a list of children.
 //! `Trees<TC>` stores a collection of trees with columnar storage for node values.
+use alloc::{vec::Vec, string::String};
 
 use crate::{Borrow, Index, IndexAs, Len, Clear, Push};
 
@@ -173,7 +174,7 @@ impl<TC: Clear> Clear for Trees<TC> {
 impl<TC: Len> Trees<TC> {
     /// Pushes a tree into the container, storing nodes in BFS order.
     pub fn push_tree<T>(&mut self, tree: Tree<T>) where TC: for<'a> Push<&'a T> {
-        let mut todo = std::collections::VecDeque::default();
+        let mut todo = alloc::collections::VecDeque::default();
         todo.push_back(tree);
         while let Some(node) = todo.pop_front() {
             let cursor = self.values.len() + todo.len() + 1;
@@ -240,6 +241,7 @@ mod louds {
 #[cfg(test)]
 mod test {
 
+    use alloc::{vec, vec::Vec, string::ToString};
     use crate::common::{Index, Len, Clear};
     use crate::{Borrow, AsBytes, FromBytes};
     use super::{Tree, Trees};

src/arc.rs

@@ -1,5 +1,5 @@
 //! Implementations of traits for `Arc<T>`
-use std::sync::Arc;
+use alloc::sync::Arc;
 
 use crate::{Len, Borrow, AsBytes, FromBytes};
 
@@ -24,7 +24,8 @@ impl<'a, T: FromBytes<'a>> FromBytes<'a> for Arc<T> {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
+    use alloc::sync::Arc;
+    use alloc::{vec, vec::Vec};
     use crate::{Borrow, Len, AsBytes, FromBytes};
 
     #[test]

src/boxed.rs

@@ -5,6 +5,7 @@
 //!
 //! We need this wrapper to distinguish which [`Push`] implementation to use, otherwise
 //! the implementations would conflict.
+use alloc::boxed::Box;
 
 use crate::{AsBytes, Borrow, Clear, Columnar, Container, FromBytes, Index, IndexMut, Len, Push, Ref};
 
@@ -18,11 +19,11 @@ impl<T: Columnar> Columnar for Box<T> {
 #[derive(Copy, Clone, Default)]
 pub struct Boxed<T>(pub T);
 
-impl<T> std::ops::Deref for Boxed<T> {
+impl<T> core::ops::Deref for Boxed<T> {
     type Target = T;
     #[inline(always)] fn deref(&self) -> &T { &self.0 }
 }
-impl<T> std::ops::DerefMut for Boxed<T> {
+impl<T> core::ops::DerefMut for Boxed<T> {
     #[inline(always)] fn deref_mut(&mut self) -> &mut T { &mut self.0 }
 }
 impl<C: Borrow> Borrow for Boxed<C> {
@@ -33,7 +34,7 @@ impl<C: Borrow> Borrow for Boxed<C> {
     #[inline(always)] fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b> where Self: 'a { Boxed(C::reborrow_ref(item.0)) }
 }
 impl<C: Container> Container for Boxed<C> {
-    #[inline(always)] fn extend_from_self(&mut self, other: Self::Borrowed<'_>, range: std::ops::Range<usize>) { self.0.extend_from_self(other.0, range) }
+    #[inline(always)] fn extend_from_self(&mut self, other: Self::Borrowed<'_>, range: core::ops::Range<usize>) { self.0.extend_from_self(other.0, range) }
     #[inline(always)] fn reserve_for<'a, I>(&mut self, selves: I) where Self: 'a, I: Iterator<Item = Self::Borrowed<'a>> + Clone { self.0.reserve_for(selves.map(|x| x.0)) }
 }
 impl<C: Len> Len for Boxed<C> {

src/bytes.rs

@@ -9,6 +9,37 @@
 //! which can be formed from any type that implements `Deref<Target=[u8]>`. Doing so will check
 //! `u64` alignment, copy the contents if misaligned, and perform some structural validation.
 
+/// A trait for writing bytes, usable in `no_std` environments.
+///
+/// This replaces `std::io::Write` for the columnar encoding functions.
+/// Implementations exist for `Vec<u8>` (always) and `std::io::Write` (with the `std` feature).
+pub trait WriteBytes {
+    /// The error type returned by write operations.
+    type Error;
+    /// Write all bytes from the slice, or return an error.
+    fn write_all(&mut self, bytes: &[u8]) -> Result<(), Self::Error>;
+}
+
+#[cfg(feature = "std")]
+impl<W: std::io::Write> WriteBytes for W {
+    type Error = std::io::Error;
+    #[inline(always)]
+    fn write_all(&mut self, bytes: &[u8]) -> Result<(), Self::Error> {
+        std::io::Write::write_all(self, bytes)
+    }
+}
+
+#[cfg(not(feature = "std"))]
+impl WriteBytes for alloc::vec::Vec<u8> {
+    type Error = core::convert::Infallible;
+    #[inline(always)]
+    fn write_all(&mut self, bytes: &[u8]) -> Result<(), Self::Error> {
+        self.extend_from_slice(bytes);
+        Ok(())
+    }
+}
+
+
 /// A binary encoding of sequences of byte slices.
 ///
 /// The encoding starts with a sequence of n+1 offsets describing where to find the n slices in the bytes that follow.
@@ -17,6 +48,7 @@
 /// This means that slices that are not multiples of eight bytes may leave unread bytes at their end, which is fine.
 pub mod indexed {
 
+    use alloc::{vec::Vec, string::String};
     use crate::AsBytes;
 
     /// Encoded length in number of `u64` words required.
@@ -44,7 +76,7 @@ pub mod indexed {
         // Read 1: Number of offsets we will record, equal to the number of slices plus one.
         // TODO: right-size `store` before first call to `push`.
         let offsets = 1 + iter.as_bytes().count();
-        let offsets_end: u64 = TryInto::<u64>::try_into((offsets) * std::mem::size_of::<u64>()).unwrap();
+        let offsets_end: u64 = TryInto::<u64>::try_into((offsets) * core::mem::size_of::<u64>()).unwrap();
         store.push(offsets_end);
         // Read 2: Establish each of the offsets based on lengths of byte slices.
         let mut position_bytes = offsets_end;
@@ -73,7 +105,7 @@ pub mod indexed {
             let remaining_bytes = &bytes[whole_words..];
             if !remaining_bytes.is_empty() {
                 let mut remainder = 0u64;
-                let transmute: &mut [u8] = bytemuck::try_cast_slice_mut(std::slice::from_mut(&mut remainder)).expect("&[u64] should convert to &[u8]");
+                let transmute: &mut [u8] = bytemuck::try_cast_slice_mut(core::slice::from_mut(&mut remainder)).expect("&[u64] should convert to &[u8]");
                 for (i, byte) in remaining_bytes.iter().enumerate() {
                     transmute[i] = *byte;
                 }
@@ -82,22 +114,22 @@ pub mod indexed {
         }
     }
 
-    pub fn write<'a, A, W>(mut writer: W, iter: &A) -> std::io::Result<()>
+    pub fn write<'a, A, W>(writer: &mut W, iter: &A) -> Result<(), W::Error>
     where
         A: AsBytes<'a>,
-        W: std::io::Write,
+        W: super::WriteBytes,
     {
         // Read 1: Number of offsets we will record, equal to the number of slices plus one.
         let offsets = 1 + iter.as_bytes().count();
-        let offsets_end: u64 = TryInto::<u64>::try_into((offsets) * std::mem::size_of::<u64>()).unwrap();
-        writer.write_all(bytemuck::cast_slice(std::slice::from_ref(&offsets_end)))?;
+        let offsets_end: u64 = TryInto::<u64>::try_into((offsets) * core::mem::size_of::<u64>()).unwrap();
+        writer.write_all(bytemuck::cast_slice(core::slice::from_ref(&offsets_end)))?;
         // Read 2: Establish each of the offsets based on lengths of byte slices.
         let mut position_bytes = offsets_end;
         for (align, bytes) in iter.as_bytes() {
             assert!(align <= 8);
             // Write length in bytes, but round up to words before updating `position_bytes`.
             let to_push: u64 = position_bytes + TryInto::<u64>::try_into(bytes.len()).unwrap();
-            writer.write_all(bytemuck::cast_slice(std::slice::from_ref(&to_push)))?;
+            writer.write_all(bytemuck::cast_slice(core::slice::from_ref(&to_push)))?;
             let round_len: u64 = ((bytes.len() + 7) & !7).try_into().unwrap();
             position_bytes += round_len;
         }
@@ -256,6 +288,7 @@ pub mod indexed {
     #[cfg(test)]
     mod test {
 
+        use alloc::{vec, vec::Vec, string::String};
         use crate::{Borrow, ContainerOf};
         use crate::common::Push;
         use crate::AsBytes;
@@ -316,6 +349,7 @@ pub mod indexed {
 /// A container of either typed columns, or serialized bytes that can be borrowed as the former.
 pub mod stash {
 
+    use alloc::{vec::Vec, string::String, boxed::Box};
     use crate::{Len, FromBytes};
     /// A container of either typed columns, or serialized bytes that can be borrowed as the former.
     ///
@@ -351,7 +385,7 @@ pub mod stash {
 
     impl<C: Default, B> Default for Stash<C, B> { fn default() -> Self { Self::Typed(Default::default()) } }
 
-    impl<C: crate::ContainerBytes, B: std::ops::Deref<Target = [u8]>> Stash<C, B> {
+    impl<C: crate::ContainerBytes, B: core::ops::Deref<Target = [u8]>> Stash<C, B> {
         /// An analogue of `TryFrom` for any `B: Deref<Target=[u8]>`, avoiding coherence issues.
         ///
         /// This is the recommended way to form a `Stash`, as it performs certain structural validation
@@ -407,7 +441,7 @@ pub mod stash {
         }
     }
 
-    impl<C: crate::ContainerBytes, B: std::ops::Deref<Target=[u8]> + Clone + 'static> crate::Borrow for Stash<C, B> {
+    impl<C: crate::ContainerBytes, B: core::ops::Deref<Target=[u8]> + Clone + 'static> crate::Borrow for Stash<C, B> {
 
         type Ref<'a> = <C as crate::Borrow>::Ref<'a>;
         type Borrowed<'a> = <C as crate::Borrow>::Borrowed<'a>;
@@ -417,11 +451,11 @@ pub mod stash {
         #[inline(always)] fn reborrow_ref<'b, 'a: 'b>(item: Self::Ref<'a>) -> Self::Ref<'b> where Self: 'a { <C as crate::Borrow>::reborrow_ref(item) }
     }
 
-    impl<C: crate::ContainerBytes, B: std::ops::Deref<Target=[u8]>> Len for Stash<C, B> {
+    impl<C: crate::ContainerBytes, B: core::ops::Deref<Target=[u8]>> Len for Stash<C, B> {
         #[inline(always)] fn len(&self) -> usize { self.borrow().len() }
     }
 
-    impl<C: crate::ContainerBytes, B: std::ops::Deref<Target=[u8]>> Stash<C, B> {
+    impl<C: crate::ContainerBytes, B: core::ops::Deref<Target=[u8]>> Stash<C, B> {
         /// Borrows the contents, either from a typed container or by decoding serialized bytes.
         ///
         /// This method is relatively cheap but is not free.
@@ -447,13 +481,14 @@ pub mod stash {
                 Stash::Align(a) => 8 * a.len(),
             }
         }
-        /// Write the contents into a `std::io::Write` using the [`indexed`] encoder.
-        pub fn into_bytes<W: ::std::io::Write>(&self, writer: &mut W) {
+        /// Write the contents into a [`WriteBytes`](crate::bytes::WriteBytes) destination.
+        pub fn into_bytes<W: crate::bytes::WriteBytes>(&self, writer: &mut W) -> Result<(), W::Error> {
             match self {
-                Stash::Typed(t) => { crate::bytes::indexed::write(writer, &t.borrow()).unwrap() },
-                Stash::Bytes(b) => writer.write_all(&b[..]).unwrap(),
-                Stash::Align(a) => writer.write_all(bytemuck::cast_slice(&a[..])).unwrap(),
+                Stash::Typed(t) => { crate::bytes::indexed::write(writer, &t.borrow())?; },
+                Stash::Bytes(b) => writer.write_all(&b[..])?,
+                Stash::Align(a) => writer.write_all(bytemuck::cast_slice(&a[..]))?,
             }
+            Ok(())
         }
     }
 
@@ -481,6 +516,7 @@ pub mod stash {
 #[cfg(test)]
 mod test {
     use crate::ContainerOf;
+    use alloc::{vec, vec::Vec, string::{String, ToString}};
 
     #[test]
     fn round_trip() {