chore: Add stdutil crate

crates/rayexec_execution/Cargo.toml

@@ -9,6 +9,7 @@ rayexec_proto = { path = "../rayexec_proto" }
 rayexec_parser = { path = "../rayexec_parser" }
 # rayexec_bullet = { path = "../rayexec_bullet" }
 rayexec_io = { path = "../rayexec_io" }
+stdutil = { path = "../stdutil" }
 fmtutil = { path = "../fmtutil" }
 # stackutil = { path = "../stackutil" } TODO: psm hash issues when compiling to wasm on macos
 

crates/rayexec_execution/src/functions/aggregate/states.rs

@@ -1,9 +1,9 @@
 use core::fmt;
 use std::any::Any;
 use std::fmt::Debug;
-use std::marker::PhantomData;
 
 use rayexec_error::{RayexecError, Result};
+use stdutil::marker::PhantomCovariant;
 
 use super::ChunkGroupAddressIter;
 use crate::arrays::array::{Array, ArrayData};
@@ -26,8 +26,10 @@ pub struct TypedAggregateGroupStates<State, Input, Output, StateInit, StateUpdat
     state_update: StateUpdate,
     state_finalize: StateFinalize,
 
-    _input: PhantomData<Input>,
-    _output: PhantomData<Output>,
+    // Note that these don't use `PhantomData` since we'll want to allow unsized
+    // types for the output type.
+    _input: PhantomCovariant<Input>,
+    _output: PhantomCovariant<Output>,
 }
 
 impl<State, Input, Output, StateInit, StateUpdate, StateFinalize>
@@ -43,8 +45,8 @@ impl<State, Input, Output, StateInit, StateUpdate, StateFinalize>
             state_init,
             state_update,
             state_finalize,
-            _input: PhantomData,
-            _output: PhantomData,
+            _input: PhantomCovariant::new(),
+            _output: PhantomCovariant::new(),
         }
     }
 }
@@ -71,8 +73,8 @@ where
         state_init,
         state_update: unary_update::<State, Storage, Output>,
         state_finalize,
-        _input: PhantomData,
-        _output: PhantomData,
+        _input: PhantomCovariant::new(),
+        _output: PhantomCovariant::new(),
     })
 }
 
@@ -97,8 +99,8 @@ where
         state_init,
         state_update: binary_update::<State, Storage1, Storage2, Output>,
         state_finalize,
-        _input: PhantomData,
-        _output: PhantomData,
+        _input: PhantomCovariant::new(),
+        _output: PhantomCovariant::new(),
     })
 }
 

crates/stdutil/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "stdutil"
+version.workspace = true
+edition.workspace = true
+
+[dependencies]

crates/stdutil/src/iter.rs

@@ -0,0 +1,35 @@
+/// Similar to `IntoIterator`, but for an iterator with an exact size.
+pub trait IntoExactSizeIterator {
+    type Item;
+    type IntoIter: ExactSizeIterator<Item = Self::Item>;
+
+    /// Converts self into the `ExactSizeIteror`.
+    fn into_iter(self) -> Self::IntoIter;
+}
+
+/// Auto-implement for any exact size iterator.
+impl<I> IntoExactSizeIterator for I
+where
+    I: IntoIterator,
+    I::IntoIter: ExactSizeIterator,
+{
+    type Item = I::Item;
+    type IntoIter = I::IntoIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.into_iter()
+    }
+}
+
+pub trait FromExactSizeIterator<A>: Sized {
+    /// Create Self from an exact size iterator.
+    fn from_iter<T: IntoExactSizeIterator<Item = A>>(iter: T) -> Self;
+}
+
+pub trait TryFromExactSizeIterator<A>: Sized {
+    /// Error type that will be returned.
+    type Error;
+
+    /// Try to create Self from an exact size iterator.
+    fn try_from_iter<T: IntoExactSizeIterator<Item = A>>(iter: T) -> Result<Self, Self::Error>;
+}

crates/stdutil/src/lib.rs

@@ -0,0 +1,4 @@
+//! Utilities that are closely related to items found in std.
+
+pub mod iter;
+pub mod marker;

crates/stdutil/src/marker.rs

@@ -0,0 +1,42 @@
+use std::marker::PhantomData;
+
+/// Marker type that indicates covariance of `T` but does not inherit the bounds
+/// of `T`.
+///
+/// Has all the same properties of `PhantomData` minus the inherited trait
+/// bounds. This lets us make structs and other types covariant to `T` but
+/// without the potential inheritence of `?Sized` (or other undesired traits) in
+/// the outer type.
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct PhantomCovariant<T>(PhantomData<fn() -> T>)
+where
+    T: ?Sized;
+
+impl<T> PhantomCovariant<T>
+where
+    T: ?Sized,
+{
+    pub const fn new() -> Self {
+        PhantomCovariant(PhantomData)
+    }
+}
+
+impl<T> Clone for PhantomCovariant<T>
+where
+    T: ?Sized,
+{
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<T> Copy for PhantomCovariant<T> where T: ?Sized {}
+
+impl<T> Default for PhantomCovariant<T>
+where
+    T: ?Sized,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}