泛型函数中是否可以排除引用类型参数？

Great question! Unfortunately, as you've noticed, Rust doesn't support negative trait bounds for non-auto traits like Deref yet. But there are a couple of practical workarounds to exclude reference types from your generic functions.

Method 1: Compile-time assertion with std::mem::is_reference (Rust 1.75+) #

Starting from Rust 1.75, the standard library provides std::mem::is_reference — a const function that checks if a type is a reference (&T or &mut T) at compile time. Pair this with const_assert! to enforce your constraint directly:

use std::mem;

fn foo<T>(x: T) -> T {
    // Compile-time check: T must not be a reference
    const_assert!(!mem::is_reference::<T>());
    x
}

fn main() {
    foo(42); // ✅ Compiles fine
    // foo(&42); // ❌ Compile error: const assertion failed: !mem::is_reference::<&{integer}>
}

This approach is clean and gives clear error messages that directly point to the reference type issue.

Method 2: Custom trait with associated types (compatible with older Rust versions) #

If you're working with a Rust version before 1.75, you can use a custom trait with associated types to create a compile-time constraint that excludes references:

// Define a trait to validate non-reference types
trait NotAReference {
    type Validation;
}

// Default implementation for all types (marks them as valid)
impl<T: ?Sized> NotAReference for T {
    type Validation = ();
}

// Override for reference types to mark them as invalid
impl<T: ?Sized> NotAReference for &T {
    type Validation = &'static str;
}

impl<T: ?Sized> NotAReference for &mut T {
    type Validation = &'static str;
}

// Use the trait constraint to accept only non-reference types
fn foo<T>(x: T) -> T
where
    T: NotAReference<Validation = ()>,
{
    x
}

fn main() {
    foo(42); // ✅ Compiles fine
    // foo(&42); // ❌ Compile error: expected `()`, found `&str`
}

The error message here is a bit more indirect, but it effectively blocks reference types. You can adjust the Validation type to something more descriptive if you want, but () vs &'static str works reliably for the constraint.

Why your initial approach didn't work #

Rust's negative trait bounds (!Trait) are only supported for auto traits (like Send, Sync, Unpin). Since Deref is not an auto trait, you can't use !Deref as a bound. The optin_builtin_traits attribute only lets you create custom auto traits, but it doesn't retroactively make existing traits like Deref auto.

内容的提问来源于stack exchange，提问作者ljedrz