Skip to content

Use generic trait parameters to minimize associated types #493

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
calebzulawski wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Use generic trait parameters to minimize associated types #493

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
46 changes: 18 additions & 28 deletions crates/core_simd/src/simd/cmp/eq.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -4,35 +4,32 @@ use crate::simd::{
};

/// Parallel `PartialEq`.
pub trait SimdPartialEq {
/// The mask type returned by each comparison.
type Mask;

pub trait SimdPartialEq<T, const N: usize>
Copy link
Copy Markdown
Member

@programmerjake programmerjake Dec 22, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

imo N should be an associated #[type_const] but last I knew that's not done being implemented yet.

something like:

pub trait SimdLen {
    #[type_const]
    const LEN: usize;
}

impl<T: SimdElement, const N: usize> SimdLen for Simd<T, N> {
    #[type_const]
    const LEN: usize = N;
}

impl<T: MaskElement, const N: usize> SimdLen for Mask<T, N> {
    #[type_const]
    const LEN: usize = N;
}

pub trait SimdBase: SimdLen {
    type Element: SimdElement;
}

impl<T: SimdElement, const N: usize> SimdBase for Simd<T, N> {
    type Element = T;
}

pub trait SimdPartialEq: SimdBase {
    fn simd_eq(self, other: Self) -> Mask<<Self::Element as SimdElement>::Mask, { Self::LEN }>;
    ...
}

Copy link
Copy Markdown
Member

@programmerjake programmerjake Dec 22, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

that would allow your example function's bounds to just be:

fn foo<T: SimdElement>(x: Simd<T, 4>) -> Mask<T::Mask, 4>
where
    // output types are completely deduced from the blanket
    // SimdBase and SimdLen impls so no additional bounds are needed
    Simd<T, 4>: SimdFloat,
{
    x.is_sign_negative()
}

Copy link
Copy Markdown
Member

@programmerjake programmerjake Dec 22, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

sadly, it seems that hits the bug where specifying bounds hides information that could be deduced so the bound ends up having to be:
Simd<T, 4>: SimdFloat<Element = T, LEN = 4>

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=c84993a34513e1f45a01b986533be269

Copy link
Copy Markdown
Member

@programmerjake programmerjake Dec 22, 2025

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I got it to work with just Simd<T, 4>: SimdFloat by removing SimdFloat: SimdBase and instead having where Self: SimdBase on all items in the trait.

https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=c13634f70837e4b761b6a19592d069d9

Copy link
Copy Markdown
Member

@programmerjake programmerjake Jan 8, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

further reduced feature gates: https://play.rust-lang.org/?version=nightly&mode=debug&edition=2024&gist=b57a420a75142e3eda48993dc2f981f1

Copy link
Copy Markdown

@Keith-Cancel Keith-Cancel Jan 14, 2026 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

the Inc/Dec parts seems very much like typenum which I think is something Rust should avoid in stable interfaces in the standard library since I think Rust should have generic const expressions for that kind of thing instead of using types to do arithmetic. Also, the finite list of impls for specific integers is what we just removed in #485.

@programmerjake Those where more there at least for what I am using that for to generically do truncate or extend with operations while allowing me to specify constraints on the N, since const equality is also not stable either, not sure such operation would be needed for SIMD though. I more of just posted what I had to show that types can be used to replace a [type_const] associated const. A first class language construct is definitely nicer than a bunch type machinery boilerplate definitely agree!

Copy link
Copy Markdown
Member

@programmerjake programmerjake Jan 14, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

if you're trying to be generic over multiple lengths, of course you need a const N: usize generic. if you instead have one or more known lengths that you're not generic over, I intended that you shouldn't need bounds mentioning generic lengths.

imo Simd<T, N> ideally shouldn't need more or less trait bounds for lengths than [T; N], so if you're trying to be generic over length having fn f<const N: usize>(v: Simd<f32, N>) seems good to me. imo you shouldn't need to mention known or generic lengths anywhere other than the N in Simd<T, N> (or Mask), so I don't like having to have Simd<T, N>: SomeTrait<N> + OtherTrait<N> where you have to repeat the N in all the trait bounds.

Copy link
Copy Markdown

@Keith-Cancel Keith-Cancel Jan 14, 2026 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

if you're trying to be generic over multiple lengths, of course you need a const N: usize generic. if you instead have one or more known lengths that you're not generic over, I intended that you shouldn't need bounds mentioning generic lengths.

imo Simd<T, N> ideally shouldn't need more or less trait bounds for lengths than [T; N], so if you're trying to be generic over length having fn f<const N: usize>(v: Simd<f32, N>) seems good to me. imo you shouldn't need to mention known or generic lengths anywhere other than the N in Simd<T, N> (or Mask), so I don't like having to have Simd<T, N>: SomeTrait<N> + OtherTrait<N> where you have to repeat the N in all the trait bounds.

Yea but an associated #[type_const] would allow such a function to just be fn f<T: Simd<f32>>(v: T).

--Edit
@programmerjake Also if you need constraint the length you could do something like:
fn f<T: Simd<f32, N = 4>>(v: T) ect..

That number trait I have allows something similar, I guess the main thing I don't like about it is that it makes my arrays opaque to just what trait constraint I put on it. Although the commented out ArrayLike trait allowed me to get around most the issues of that.

Copy link
Copy Markdown
Member

@programmerjake programmerjake Jan 14, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Yea but an associated #[type_const] would allow such a function to just be fn f<T: Simd<f32>>(v: T).

Yes (if you used an actual trait rather than the Simd type). That said, I think using the Simd<f32, N> type is waay better, similar to how it's standard practice to write fn f<const N: usize>(v: [f32; N]) instead of fn f<T: ArrayOf<f32>>(v: T).

-Also if you need constraint the length you could do something like: fn f<T: Simd<f32, N = 4>>(v: T) ect..

if you already know both the length and element type then there's only one Simd type that matches, using a generic is just extra complexity for no reason, just use Simd<f32, 4> or the f32x4 type alias. this is similar to how you'd write [f32; 4] instead of T: Array<f32, 4>

Copy link
Copy Markdown

@Keith-Cancel Keith-Cancel Jan 14, 2026

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

I guess that depends on what your doing/preference, I am just saying #[type_const] can allow for less verbose signatures.

where
T: SimdElement,
{
/// Test if each element is equal to the corresponding element in `other`.
#[must_use = "method returns a new mask and does not mutate the original value"]
fn simd_eq(self, other: Self) -> Self::Mask;
fn simd_eq(self, other: Self) -> Mask<<T as SimdElement>::Mask, N>;

/// Test if each element is not equal to the corresponding element in `other`.
#[must_use = "method returns a new mask and does not mutate the original value"]
fn simd_ne(self, other: Self) -> Self::Mask;
fn simd_ne(self, other: Self) -> Mask<<T as SimdElement>::Mask, N>;
}

macro_rules! impl_number {
{ $($number:ty),* } => {
$(
impl<const N: usize> SimdPartialEq for Simd<$number, N>
{
type Mask = Mask<<$number as SimdElement>::Mask, N>;

impl<const N: usize> SimdPartialEq<$number, N> for Simd<$number, N> {
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {
fn simd_eq(self, other: Self) -> Mask<<$number as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_eq(self, other)) }
}

#[inline]
fn simd_ne(self, other: Self) -> Self::Mask {
fn simd_ne(self, other: Self) -> Mask<<$number as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ne(self, other)) }
Expand All @@ -47,19 +44,16 @@ impl_number! { f32, f64, u8, u16, u32, u64, usize, i8, i16, i32, i64, isize }
macro_rules! impl_mask {
{ $($integer:ty),* } => {
$(
impl<const N: usize> SimdPartialEq for Mask<$integer, N>
{
type Mask = Self;

impl<const N: usize> SimdPartialEq<$integer, N> for Mask<$integer, N> {
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {
fn simd_eq(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_eq(self.to_simd(), other.to_simd())) }
}

#[inline]
fn simd_ne(self, other: Self) -> Self::Mask {
fn simd_ne(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_ne(self.to_simd(), other.to_simd())) }
Expand All @@ -71,30 +65,26 @@ macro_rules! impl_mask {

impl_mask! { i8, i16, i32, i64, isize }

impl<T, const N: usize> SimdPartialEq for Simd<*const T, N> {
type Mask = Mask<isize, N>;

impl<T, const N: usize> SimdPartialEq<*const T, N> for Simd<*const T, N> {
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {
fn simd_eq(self, other: Self) -> Mask<isize, N> {
self.addr().simd_eq(other.addr())
}

#[inline]
fn simd_ne(self, other: Self) -> Self::Mask {
fn simd_ne(self, other: Self) -> Mask<isize, N> {
self.addr().simd_ne(other.addr())
}
}

impl<T, const N: usize> SimdPartialEq for Simd<*mut T, N> {
type Mask = Mask<isize, N>;

impl<T, const N: usize> SimdPartialEq<*mut T, N> for Simd<*mut T, N> {
#[inline]
fn simd_eq(self, other: Self) -> Self::Mask {
fn simd_eq(self, other: Self) -> Mask<isize, N> {
self.addr().simd_eq(other.addr())
}

#[inline]
fn simd_ne(self, other: Self) -> Self::Mask {
fn simd_ne(self, other: Self) -> Mask<isize, N> {
self.addr().simd_ne(other.addr())
}
}
78 changes: 42 additions & 36 deletions crates/core_simd/src/simd/cmp/ord.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -1,30 +1,36 @@
use crate::simd::{
Mask, Select, Simd,
Mask, Select, Simd, SimdElement,
cmp::SimdPartialEq,
ptr::{SimdConstPtr, SimdMutPtr},
};

/// Parallel `PartialOrd`.
pub trait SimdPartialOrd: SimdPartialEq {
pub trait SimdPartialOrd<T, const N: usize>: SimdPartialEq<T, N>
where
T: SimdElement,
{
/// Test if each element is less than the corresponding element in `other`.
#[must_use = "method returns a new mask and does not mutate the original value"]
fn simd_lt(self, other: Self) -> Self::Mask;
fn simd_lt(self, other: Self) -> Mask<<T as SimdElement>::Mask, N>;

/// Test if each element is less than or equal to the corresponding element in `other`.
#[must_use = "method returns a new mask and does not mutate the original value"]
fn simd_le(self, other: Self) -> Self::Mask;
fn simd_le(self, other: Self) -> Mask<<T as SimdElement>::Mask, N>;

/// Test if each element is greater than the corresponding element in `other`.
#[must_use = "method returns a new mask and does not mutate the original value"]
fn simd_gt(self, other: Self) -> Self::Mask;
fn simd_gt(self, other: Self) -> Mask<<T as SimdElement>::Mask, N>;

/// Test if each element is greater than or equal to the corresponding element in `other`.
#[must_use = "method returns a new mask and does not mutate the original value"]
fn simd_ge(self, other: Self) -> Self::Mask;
fn simd_ge(self, other: Self) -> Mask<<T as SimdElement>::Mask, N>;
}

/// Parallel `Ord`.
pub trait SimdOrd: SimdPartialOrd {
pub trait SimdOrd<T, const N: usize>: SimdPartialOrd<T, N>
where
T: SimdElement,
{
/// Returns the element-wise maximum with `other`.
#[must_use = "method returns a new vector and does not mutate the original value"]
fn simd_max(self, other: Self) -> Self;
Expand All @@ -48,38 +54,38 @@ pub trait SimdOrd: SimdPartialOrd {
macro_rules! impl_integer {
{ $($integer:ty),* } => {
$(
impl<const N: usize> SimdPartialOrd for Simd<$integer, N>
impl<const N: usize> SimdPartialOrd<$integer, N> for Simd<$integer, N>
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
fn simd_lt(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_lt(self, other)) }
}

#[inline]
fn simd_le(self, other: Self) -> Self::Mask {
fn simd_le(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_le(self, other)) }
}

#[inline]
fn simd_gt(self, other: Self) -> Self::Mask {
fn simd_gt(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_gt(self, other)) }
}

#[inline]
fn simd_ge(self, other: Self) -> Self::Mask {
fn simd_ge(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ge(self, other)) }
}
}

impl<const N: usize> SimdOrd for Simd<$integer, N>
impl<const N: usize> SimdOrd<$integer, N> for Simd<$integer, N>
{
#[inline]
fn simd_max(self, other: Self) -> Self {
Expand Down Expand Up @@ -110,31 +116,31 @@ impl_integer! { u8, u16, u32, u64, usize, i8, i16, i32, i64, isize }
macro_rules! impl_float {
{ $($float:ty),* } => {
$(
impl<const N: usize> SimdPartialOrd for Simd<$float, N>
impl<const N: usize> SimdPartialOrd<$float, N> for Simd<$float, N>
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
fn simd_lt(self, other: Self) -> Mask<<$float as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_lt(self, other)) }
}

#[inline]
fn simd_le(self, other: Self) -> Self::Mask {
fn simd_le(self, other: Self) -> Mask<<$float as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_le(self, other)) }
}

#[inline]
fn simd_gt(self, other: Self) -> Self::Mask {
fn simd_gt(self, other: Self) -> Mask<<$float as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_gt(self, other)) }
}

#[inline]
fn simd_ge(self, other: Self) -> Self::Mask {
fn simd_ge(self, other: Self) -> Mask<<$float as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Mask::from_simd_unchecked(core::intrinsics::simd::simd_ge(self, other)) }
Expand All @@ -149,38 +155,38 @@ impl_float! { f32, f64 }
macro_rules! impl_mask {
{ $($integer:ty),* } => {
$(
impl<const N: usize> SimdPartialOrd for Mask<$integer, N>
impl<const N: usize> SimdPartialOrd<$integer, N> for Mask<$integer, N>
{
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
fn simd_lt(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_lt(self.to_simd(), other.to_simd())) }
}

#[inline]
fn simd_le(self, other: Self) -> Self::Mask {
fn simd_le(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_le(self.to_simd(), other.to_simd())) }
}

#[inline]
fn simd_gt(self, other: Self) -> Self::Mask {
fn simd_gt(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_gt(self.to_simd(), other.to_simd())) }
}

#[inline]
fn simd_ge(self, other: Self) -> Self::Mask {
fn simd_ge(self, other: Self) -> Mask<<$integer as SimdElement>::Mask, N> {
// Safety: `self` is a vector, and the result of the comparison
// is always a valid mask.
unsafe { Self::from_simd_unchecked(core::intrinsics::simd::simd_ge(self.to_simd(), other.to_simd())) }
}
}

impl<const N: usize> SimdOrd for Mask<$integer, N>
impl<const N: usize> SimdOrd<$integer, N> for Mask<$integer, N>
{
#[inline]
fn simd_max(self, other: Self) -> Self {
Expand Down Expand Up @@ -208,29 +214,29 @@ macro_rules! impl_mask {

impl_mask! { i8, i16, i32, i64, isize }

impl<T, const N: usize> SimdPartialOrd for Simd<*const T, N> {
impl<T, const N: usize> SimdPartialOrd<*const T, N> for Simd<*const T, N> {
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
fn simd_lt(self, other: Self) -> Mask<isize, N> {
self.addr().simd_lt(other.addr())
}

#[inline]
fn simd_le(self, other: Self) -> Self::Mask {
fn simd_le(self, other: Self) -> Mask<isize, N> {
self.addr().simd_le(other.addr())
}

#[inline]
fn simd_gt(self, other: Self) -> Self::Mask {
fn simd_gt(self, other: Self) -> Mask<isize, N> {
self.addr().simd_gt(other.addr())
}

#[inline]
fn simd_ge(self, other: Self) -> Self::Mask {
fn simd_ge(self, other: Self) -> Mask<isize, N> {
self.addr().simd_ge(other.addr())
}
}

impl<T, const N: usize> SimdOrd for Simd<*const T, N> {
impl<T, const N: usize> SimdOrd<*const T, N> for Simd<*const T, N> {
#[inline]
fn simd_max(self, other: Self) -> Self {
self.simd_lt(other).select(other, self)
Expand All @@ -252,29 +258,29 @@ impl<T, const N: usize> SimdOrd for Simd<*const T, N> {
}
}

impl<T, const N: usize> SimdPartialOrd for Simd<*mut T, N> {
impl<T, const N: usize> SimdPartialOrd<*mut T, N> for Simd<*mut T, N> {
#[inline]
fn simd_lt(self, other: Self) -> Self::Mask {
fn simd_lt(self, other: Self) -> Mask<isize, N> {
self.addr().simd_lt(other.addr())
}

#[inline]
fn simd_le(self, other: Self) -> Self::Mask {
fn simd_le(self, other: Self) -> Mask<isize, N> {
self.addr().simd_le(other.addr())
}

#[inline]
fn simd_gt(self, other: Self) -> Self::Mask {
fn simd_gt(self, other: Self) -> Mask<isize, N> {
self.addr().simd_gt(other.addr())
}

#[inline]
fn simd_ge(self, other: Self) -> Self::Mask {
fn simd_ge(self, other: Self) -> Mask<isize, N> {
self.addr().simd_ge(other.addr())
}
}

impl<T, const N: usize> SimdOrd for Simd<*mut T, N> {
impl<T, const N: usize> SimdOrd<*mut T, N> for Simd<*mut T, N> {
#[inline]
fn simd_max(self, other: Self) -> Self {
self.simd_lt(other).select(other, self)
Expand Down
Loading
Loading