Vibe check: can `Simd<T, N>: Receiver<Target = T>`?

[programmerjake]

In project-portable-simd, we're trying to come up with a good API for Simd<T, N> where we have much of the API split up into traits so there aren't tons of inherent methods on Simd itself to avoid overwhelming docs readers with hundreds of methods that only work for some element types. After several attempts of implementing all the traits with Self = Simd<T, N> and running into issues trying to use related types with different element types but the same length, it occurred to me to instead implement the traits directly for the element types and have methods use self: Simd<Self, N> which is slightly odd but makes the API waay nicer.

We want to get a vibe-check from t-libs and t-lang that implementing Receiver for Simd and Mask is ok.

Zulip thread on design proposal

[programmerjake]

@rust-lang/project-portable-simd

[programmerjake]

if possible, we'd probably also want to impl LegacyReceiver so it works without needing the arbitrary self types feature since the Simd type may stabilize first.

(edit: LegacyReceiver won't work without compiler changes so we probably don't want to use that)

[programmerjake]

implementation sketch and example usage:

#![feature(arbitrary_self_types)]
use std::ops::Receiver;
pub trait SimdElement: Sized {
    type Mask: MaskElement;
}

pub trait MaskElement: SimdElement<Mask = Self> {}

pub struct Simd<T: SimdElement, const N: usize>([T; N]);

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

pub struct Mask<T: MaskElement, const N: usize>(Simd<T, N>);

impl<T: MaskElement, const N: usize> Receiver for Mask<T, N> {
    type Target = T;
}

pub trait SimdPartialEq: SimdElement {
    fn simd_eq<const N: usize>(
        self: Simd<Self, N>,
        other: Simd<Self, N>,
    ) -> Mask<Self::Mask, N>;
    fn simd_ne<const N: usize>(
        self: Simd<Self, N>,
        other: Simd<Self, N>,
    ) -> Mask<Self::Mask, N>;
}

pub trait SimdFloat: SimdElement {
    type Bits: SimdElement<Mask = Self::Mask>;
    fn to_bits<const N: usize>(self: Simd<Self, N>) -> Simd<Self::Bits, N>;
    fn from_bits<const N: usize>(bits: Simd<Self::Bits, N>) -> Simd<Self, N>;
    fn is_sign_positive<const N: usize>(
        self: Simd<Self, N>,
    ) -> Mask<Self::Mask, N>;
    fn is_sign_negative<const N: usize>(
        self: Simd<Self, N>,
    ) -> Mask<Self::Mask, N>;
}

fn foo<T: SimdFloat>(x: Simd<T, 4>) -> Mask<T::Mask, 4>
{
    x.is_sign_negative()
}

fn bar<T: SimdFloat, const N: usize>(x: Simd<T, N>) -> Mask<T::Mask, N>
{
    x.is_sign_negative()
}