Scala中如何让方法静态接受除Future外的所有类型？

Great question! Since you're dealing with Future and type-safe caching (I'm assuming Scala here, given the context), we can use compile-time type constraints to statically block Future from being passed to your getCachedOrElsePut method. Let's break down how to do this for both Scala 3 and Scala 2, since syntax differs between versions.

Scala 3: Using Built-in Not Type #

Scala 3 introduces the Not type, which makes excluding specific types straightforward. We can add a context bound that ensures our type T is not a subtype of Future:

import scala.concurrent.Future

def getCachedOrElsePut[T](key: String, defaultValue: => T)(using T <:< Not[Future[?]]): T = {
  // Step 1: Check cache for existing value
  val cachedValue = Option.empty[T] // Replace with your actual cache lookup logic
  
  cachedValue.getOrElse {
    // Step 2: Compute default value if cache miss
    val freshValue = defaultValue
    // Step 3: Store fresh value in cache
    // cache.put(key, freshValue)
    freshValue
  }
}

How it works: #

The using T <:< Not[Future[?]] clause tells the compiler to verify that T cannot be assigned to Future[_] at compile time. If you try to pass a Future (e.g., getCachedOrElsePut("myKey", Future.successful(42))), you'll get a clear compile error:

Cannot prove that Future[Int] <:< Not[Future[?]]

Scala 2: Custom Implicit Evidence #

Scala 2 doesn't have a built-in Not type, but we can create a custom implicit constraint to reject Future types:

import scala.concurrent.Future
import scala.language.implicitConversions

// Helper trait to mark allowed types
sealed trait NotFuture[T]
object NotFuture {
  // Provide an implicit instance for ALL non-Future types
  implicit def allowNonFuture[T]: NotFuture[T] = new NotFuture[T] {}
  
  // Create conflicting implicits for Future types to trigger a compile error
  implicit def rejectFuture1[T]: NotFuture[Future[T]] = null
  implicit def rejectFuture2[T]: NotFuture[Future[T]] = null
}

def getCachedOrElsePut[T](key: String, defaultValue: => T)(implicit ev: NotFuture[T]): T = {
  // Same cache logic as above
  val cachedValue = Option.empty[T] // Replace with your cache lookup
  
  cachedValue.getOrElse {
    val freshValue = defaultValue
    // cache.put(key, freshValue)
    freshValue
  }
}

How it works: #

• For non-Future types, the compiler finds exactly one implicit instance (allowNonFuture[T]), so the method compiles.
• For Future types, the compiler finds two conflicting implicits (rejectFuture1 and rejectFuture2), which triggers an ambiguous implicit error—effectively blocking Future from being used.

Key Benefit #

Both approaches enforce the constraint at compile time, not runtime. This means you catch invalid Future inputs early, before your code even runs, which is far safer than checking types dynamically.

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