HRTB and GAT problem

[davidli2010]

I tried this code (playground):

use std::ops::Not;

trait Type {
    type Native<'a>
    where
        Self: 'a;
}

fn not<T: Type>(val: T::Native<'_>) -> T::Native<'_>
where
    for<'a> T::Native<'a>: Not<Output = T::Native<'a>>,
{
    !val
}

fn main() {}

I expected to see this happen: should compile fine

Instead, this happened: error

Meta

rustc --version --verbose:

rustc 1.78.0-nightly (3406ada96 2024-02-21)
binary: rustc
commit-hash: 3406ada96f8e16e49e947a91db3eba0db45245fa
commit-date: 2024-02-21
host: x86_64-unknown-linux-gnu
release: 1.78.0-nightly
LLVM version: 18.1.0

Backtrace

error[E0582]: binding for associated type `Output` references lifetime `'a`, which does not appear in the trait input types
  --> src/main.rs:11:32
   |
11 |     for<'a> T::Native<'a>: Not<Output = T::Native<'a>>,
   |                                ^^^^^^^^^^^^^^^^^^^^^^

For more information about this error, try `rustc --explain E0582`.

[davidli2010]

Currently I use a workaround to make it work:

trait Not {
    fn not(self) -> Self;
}

impl<T: std::ops::Not<Output = T>> Not for T {
    #[inline]
    fn not(self) -> Self {
        !self
    }
}

fn not<T: Type>(val: T::Native<'_>) -> T::Native<'_>
where
    for<'a> T::Native<'a>: Not,
{
    val.not()
}

but I think rustc should directly support for<'a> T::Native<'a>: Not<Output = T::Native<'a>> syntax.

[tgross35]

Not sure what exactly the goal is, but does naming the lifetime in the type signature let you do what is needed? Something like

use std::ops::Not;

trait Type {
    type Native<'a>
    where
        Self: 'a;
}

fn not<'a, T: Type>(val: T::Native<'a>) -> T::Native<'a>
where
    for<'b> T::Native<'b>: Not<Output = T::Native<'a>>,
{
    !val
}

fn main() {}

Also

I tried this code (playground):

You linked the playground itself, you need to do share->"permalink to the playground" if you want to link your code directly 🙂

[davidli2010]

Also

I tried this code (playground):

You linked the playground itself, you need to do share->"permalink to the playground" if you want to link your code directly 🙂

Thanks, the playground link is fixed.

[davidli2010]

Not sure what exactly the goal is, but does naming the lifetime in the type signature let you do what is needed? Something like

use std::ops::Not;

trait Type {
    type Native<'a>
    where
        Self: 'a;
}

fn not<'a, T: Type>(val: T::Native<'a>) -> T::Native<'a>
where
    for<'b> T::Native<'b>: Not<Output = T::Native<'a>>,
{
    !val
}

fn main() {}

The above code is simplified from a complex scene. Here is a more detailed example (playground):

use std::marker::PhantomData;
use std::ops::{BitAnd, Not};

pub trait Type {
    type Native<'a>
    where
        Self: 'a;
}

// T::Native data builder
pub struct DataBuilder<T: Type> {
    _marker: PhantomData<T>,
}

// A T::Native values builder
impl<T: Type> DataBuilder<T> {
    pub fn new() -> Self {
        DataBuilder {
            _marker: PhantomData,
        }
    }

    pub fn as_mut_values(&mut self) -> &mut [T::Native<'_>] {
        todo!()
    }

    pub fn build(self) -> Data<T> {
        todo!()
    }
}

// T::Native data container
pub struct Data<T: Type> {
    _marker: PhantomData<T>,
}

impl<T: Type> Data<T> {
    pub fn new() -> Self {
        Data {
            _marker: PhantomData,
        }
    }

    pub fn values(&self) -> &[T::Native<'_>] {
        todo!()
    }

    fn bitwise_op<F>(&self, rhs: &Self, op: F) -> Data<T>
    where
        for<'a> F: Fn(&'a T::Native<'a>, &'a T::Native<'a>) -> T::Native<'a>,
    {
        let mut builder = DataBuilder::new();
        let result = builder.as_mut_values();

        let left = self.values();
        let right = rhs.values();

        left.iter()
            .zip(right.iter())
            .map(|(l, r)| op(l, r))
            .zip(result.iter_mut())
            .for_each(|(res, result)| *result = res);

        builder.build()
    }

    // /// !!! failed !!!
    // ///
    // /// Performs the bitwise `NOT AND`(`!(x & y)`) operation.
    // pub fn bit_not_and(&self, rhs: &Self) -> Data<T>
    // where
    //     for<'a> &'a T::Native<'a>: BitAnd<Output = T::Native<'a>>,
    //     for<'c> T::Native<'c>: Not<Output = T::Native<'c>>,
    // {
    //     self.bitwise_op(rhs, |l, r| !(l & r))
    // }

    /// use `Reverse` as a workaround
    ///
    /// Performs the bitwise `NOT AND`(`!(x & y)`) operation.
    pub fn bit_not_and(&self, rhs: &Self) -> Data<T>
    where
        for<'a> &'a T::Native<'a>: BitAnd<Output = T::Native<'a>>,
        for<'c> T::Native<'c>: Reverse,
    {
        self.bitwise_op(rhs, |l, r| (l & r).reverse())
    }
}

pub trait Reverse {
    fn reverse(self) -> Self;
}

impl<T: Not<Output = T>> Reverse for T {
    #[inline]
    fn reverse(self) -> Self {
        !self
    }
}

fn main() {}