Merge pull request #8 from rodrimati1992/more_const_markers

1.6.0 release

Author: rodrimati1992

.github/workflows/rust.yml

@@ -58,7 +58,7 @@ jobs:
         cargo test --no-default-features --features "rust_stable nightly_mut_refs"
         cargo test --no-default-features --features "rust_stable alloc nightly_mut_refs"
         cargo test --no-default-features --features \
-          "rust_stable const_marker __ui_tests alloc nightly_mut_refs"
+          "rust_stable adt_const_marker __ui_tests alloc nightly_mut_refs"
 
         MIRI_NIGHTLY=nightly-$(curl -s https://rust-lang.github.io/rustup-components-history/x86_64-unknown-linux-gnu/miri)
         echo "Installing latest nightly with Miri"
@@ -72,4 +72,4 @@ jobs:
         cargo clean 
 
         env RUST_BACKTRACE=0 cargo miri test --no-default-features \
-            --features "${{env.rustv}} const_marker alloc nightly_mut_refs"
+            --features "${{env.rustv}} adt_const_marker alloc nightly_mut_refs"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "typewit"
-version = "1.5.0"
+version = "1.6.0"
 authors = ["rodrimati1992 <rodrimatt1985@gmail.com>"]
 rust-version = "1.57.0"
 edition = "2021"
@@ -18,6 +18,10 @@ include = [
     "LICENSE-ZLIB.md", 
 ]
 
+[dev-dependencies.arrayvec]
+version = "0.7"
+default-features = false
+
 [dev-dependencies.trybuild]
 version = "1.0"
 
@@ -26,9 +30,10 @@ default = ["const_marker"]
 rust_1_61 = []
 rust_stable = ["rust_1_61"]
 const_marker = []
+adt_const_marker = ["rust_stable","const_marker"]
 alloc = []
 mut_refs = []
-nightly_mut_refs = ["mut_refs"]
+nightly_mut_refs = ["rust_stable", "mut_refs"]
 docsrs = []
 __ui_tests = []
 

Changelog.md

@@ -2,6 +2,34 @@ This is the changelog, summarising changes in each version(some minor changes ma
 
 # 1.0
 
+### 1.6.0
+
+Added `"adt_const_marker"` feature.
+
+Added `BoolWit` in `typewit::const_marker`
+
+Added these structs in `typewit::const_marker`(under the `"adt_const_marker"` feature):
+- `Str` (unit struct)
+
+Added these structs in `typewit::const_marker::slice`(under the `"adt_const_marker"` feature):
+- `BoolSlice` (unit struct)
+- `CharSlice` (unit struct)
+- `I8Slice` (unit struct)
+- `I16Slice` (unit struct)
+- `I32Slice` (unit struct)
+- `I64Slice` (unit struct)
+- `I128Slice` (unit struct)
+- `IsizeSlice` (unit struct)
+- `StrSlice` (unit struct)
+- `U8Slice` (unit struct)
+- `U16Slice` (unit struct)
+- `U32Slice` (unit struct)
+- `U64Slice` (unit struct)
+- `U128Slice` (unit struct)
+- `UsizeSlice` (unit struct)
+
+Changed `"nightly_mut_refs*"` crate feature to enable the `"rust_stable"` feature.
+
 ### 1.5.0
 
 Added support for these to `simple_type_witness` macro:

README.md

@@ -229,16 +229,21 @@ These are the features of this crates:
 
 - `"alloc"`: enable items that use anything from the standard `alloc` crate.
 
-- `"const_marker"`(enabled by default): Enables the [`const_marker`] module,
+- `"const_marker"`(enabled by default): enables the [`const_marker`] module,
 and all items that depend on it.
 
+- `"adt_const_marker"`(requires the nightly compiler):
+enables the `"rust_stable"` and `"const_marker"` crate features,
+and marker types in the [`const_marker`] module that have
+non-primitive `const` parameters.
+
 - `"mut_refs"`: turns functions that take mutable references into const fns.
-note: as of July 2023, 
+note: as of September 2023, 
 this crate feature requires a stable compiler from the future.
 
 - `"nightly_mut_refs"`(requires the nightly compiler):
-Enables the `"mut_refs"` crate feature and 
-the `const_mut_refs` nightly feature.
+Enables the `"rust_stable"` and `"mut_refs"` crate features,
+and the `const_mut_refs` nightly feature.
 
 None of the crate features are enabled by default.
 

src/all_init_bytes.rs

@@ -0,0 +1,44 @@
+#[cfg(test)]
+mod tests;
+
+/// Marker trait for type for which all bytes are initialized
+/// 
+/// # Safety
+/// 
+/// All of the bytes in this type must be initialized.
+/// Uninitialized bytes includes padding and `MaybeUninit` fields.
+pub(crate) unsafe trait AllInitBytes {}
+
+#[allow(dead_code)]
+pub(crate) const fn as_bytes<T: AllInitBytes>(reff: &T) -> &[u8] {
+    unsafe {
+        core::slice::from_raw_parts (
+            reff as *const T as *const u8,
+            core::mem::size_of::<T>(),
+        )
+    }
+}
+pub(crate) const fn slice_as_bytes<T: AllInitBytes>(reff: &[T]) -> &[u8] {
+    unsafe {
+        core::slice::from_raw_parts (
+            reff.as_ptr() as *const u8,
+            reff.len() * core::mem::size_of::<T>(),
+        )
+    }
+}
+
+unsafe impl AllInitBytes for bool {}
+unsafe impl AllInitBytes for char {}
+unsafe impl AllInitBytes for u8 {}
+unsafe impl AllInitBytes for u16 {}
+unsafe impl AllInitBytes for u32 {}
+unsafe impl AllInitBytes for u64 {}
+unsafe impl AllInitBytes for u128 {}
+unsafe impl AllInitBytes for usize {}
+unsafe impl AllInitBytes for i8 {}
+unsafe impl AllInitBytes for i16 {}
+unsafe impl AllInitBytes for i32 {}
+unsafe impl AllInitBytes for i64 {}
+unsafe impl AllInitBytes for i128 {}
+unsafe impl AllInitBytes for isize {}
+

src/all_init_bytes/tests.rs

@@ -0,0 +1,116 @@
+use super::{as_bytes, slice_as_bytes};
+
+
+macro_rules! test_int {
+    ($vals:expr) => ({
+        for val in $vals {
+            assert_eq!(as_bytes(&val), val.to_ne_bytes());
+
+            let mut vec = arrayvec::ArrayVec::<u8, 32>::new();
+            vec.try_extend_from_slice(&val.to_ne_bytes()).unwrap();
+            vec.try_extend_from_slice(&val.to_ne_bytes()).unwrap();
+
+            assert_eq!(slice_as_bytes(&[val, val]), &vec[..]);
+        }
+    });
+}
+
+macro_rules! test_signed_int {
+    ($vals:expr) => ({
+        for val in $vals {
+            test_int!{[val, -val]}
+        }
+    });
+}
+
+
+#[test]
+fn test_bool_as_bytes() {
+    for b in [false, true] {
+        assert_eq!(as_bytes(&b), &[b as u8][..]);
+        assert_eq!(slice_as_bytes(&[b]), &[b as u8][..]);
+    }
+}
+
+#[test]
+fn test_char_as_bytes() {
+    for c in ['f', 'o', '\n', '\t', 'ñ', '个', '\u{100000}', char::MAX] {
+        assert_eq!(as_bytes(&c), (c as u32).to_ne_bytes());
+        assert_eq!(slice_as_bytes(&[c]), (c as u32).to_ne_bytes());
+    }
+}
+
+#[test]
+fn test_u8_as_bytes() {
+    test_int!{[0u8, 233u8]}
+}
+
+#[test]
+fn test_u16_as_bytes() {
+    test_int!{[0u16, 500u16, 1000u16]}
+}
+
+#[test]
+fn test_u32_as_bytes() {
+    test_int!{[0u32, 500u32, 1000u32, 1_000_000u32, 1_000_000_000u32]}
+}
+
+#[test]
+fn test_u64_as_bytes() {
+    test_int!{[
+        0u64, 500u64, 1000u64, 1_000_000u64, 1_000_000_000u64, 
+        1_000_000_000_000_000_000u64,
+    ]}
+}
+
+#[test]
+fn test_u128_as_bytes() {
+    test_int!{[
+        0u128, 500u128, 1000u128, 1_000_000u128, 1_000_000_000u128, 
+        1_000_000_000_000_000_000u128, 1_000_000_000_000_000_000_000_000_000u128, 
+        1_000_000_000_000_000_000_000_000_000_000_000_000u128,
+    ]}
+}
+
+#[test]
+fn test_usize_as_bytes() {
+    test_int!{[0usize, 500usize, 1000usize, 12345usize]}
+}
+
+
+#[test]
+fn test_i8_as_bytes() {
+    test_signed_int!{[0i8, 111i8]}
+}
+
+#[test]
+fn test_i16_as_bytes() {
+    test_signed_int!{[0i16, 500i16, 1000i16]}
+}
+
+#[test]
+fn test_i32_as_bytes() {
+    test_signed_int!{[0i32, 500i32, 1000i32, 1_000_000i32, 1_000_000_000i32]}
+}
+
+#[test]
+fn test_i64_as_bytes() {
+    test_signed_int!{[
+        0i64, 500i64, 1000i64, 1_000_000i64, 1_000_000_000i64, 
+        1_000_000_000_000_000_000i64,
+    ]}
+}
+
+#[test]
+fn test_i128_as_bytes() {
+    test_signed_int!{[
+        0i128, 500i128, 1000i128, 1_000_000i128, 1_000_000_000i128, 
+        1_000_000_000_000_000_000i128, 1_000_000_000_000_000_000_000_000_000i128, 
+        1_000_000_000_000_000_000_000_000_000_000_000_000i128,
+    ]}
+}
+
+#[test]
+fn test_isize_as_bytes() {
+    test_signed_int!{[0isize, 500isize, 1000isize, 12345isize]}
+}

src/const_marker.rs

@@ -38,7 +38,51 @@ use crate::{
     TypeNe,
 };
 
+mod const_witnesses;
 
+pub use const_witnesses::*;
+
+#[cfg(feature = "adt_const_marker")]
+mod slice_const_markers;
+
+#[cfg(feature = "adt_const_marker")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "adt_const_marker")))]
+pub use slice_const_markers::Str;
+
+/// Marker types for `const FOO: &'static [T]` parameters.
+#[cfg(feature = "adt_const_marker")]
+#[cfg_attr(feature = "docsrs", doc(cfg(feature = "adt_const_marker")))]
+pub mod slice {
+    pub use super::slice_const_markers::{
+        BoolSlice,
+        CharSlice,
+        U8Slice,
+        U16Slice,
+        U32Slice,
+        U64Slice,
+        U128Slice,
+        UsizeSlice,
+        I8Slice,
+        I16Slice,
+        I32Slice,
+        I64Slice,
+        I128Slice,
+        IsizeSlice,
+        StrSlice,
+    };
+}
+
+
+macro_rules! __const_eq_with {
+    ($L:ident, $R:ident) => {
+        $L == $R
+    };
+    ($L:ident, $R:ident, ($L2:ident, $R2:ident) $cmp:expr) => ({
+        let $L2 = $L;
+        let $R2 = $R;
+        $cmp
+    });
+} pub(crate) use __const_eq_with;
 
 macro_rules! declare_const_param_type {
     (
@@ -47,7 +91,7 @@ macro_rules! declare_const_param_type {
 
         $(
             $(#[$eq_docs:meta])*
-            fn eq;
+            fn eq $(($L:ident, $R:ident) $comparator:block)?;
         )?
     ) => {
         #[doc = concat!(
@@ -80,7 +124,11 @@ macro_rules! declare_const_param_type {
                     const EQ: Result<
                         TypeEq<$struct<L>, $struct<R>>,
                         TypeNe<$struct<L>, $struct<R>>,
-                    > = if L == R {
+                    > = if crate::const_marker::__const_eq_with!(
+                        L,
+                        R
+                        $($(, ($L, $R) $comparator)?)?
+                    ) {
                         // SAFETY: `L == R` (both are std types with sensible Eq impls)
                         // therefore `$struct<L> == $struct<R>`
                         unsafe {
@@ -100,10 +148,21 @@ macro_rules! declare_const_param_type {
         }
 
     };
-}
+} pub(crate) use declare_const_param_type;
 
 
-declare_const_param_type!{Bool(bool)}
+declare_const_param_type!{
+    Bool(bool)
+
+    /// 
+    /// For getting a type witness that
+    /// `Bool<B>` is either `Bool<true>` or `Bool<false>`,
+    /// you can use [`BoolWit`].
+
+
+    /// 
+    fn eq;
+}
 declare_const_param_type!{Char(char)}
 
 declare_const_param_type!{U8(u8)}