是否可将任意λ的陪域提升至Unit？Scala类型检查疑问

Great question! Let's break down why these different assignments behave the way they do, and clear up the confusion around Unit's special handling.

First: Why val a: Unit = 42 fails #

This is straightforward: in Scala, Int and Unit are both subtypes of AnyVal, but neither is a subtype of the other. The type checker enforces strict type safety here—you can't directly assign a value of type Int to a variable declared as Unit, since there's no valid subtyping relationship between them.

Why val b: Unit = { () => 42 }() works (clarifying the syntax) #

Quick note: If you literally write {42}(), that will throw an error in both Scala 2 and 3, because {42} evaluates to an Int, and Int doesn't have an apply method to call with (). I suspect you meant to write an anonymous function call, like { () => 42 }() (or the shorter (() => 42)()). That code does pass the type checker, and here's why:

1. The expression { () => 42 } creates a parameterless anonymous function of type () => Int. Calling it with () executes the function body, returning the value 42 (an Int).
2. The key here is Scala's Unit adaptation rule—a special compiler behavior for contexts where Unit is expected (like assigning to a Unit variable). When you have an expression that returns a non-Unit type in a Unit context, the compiler automatically rewrites it to:

   {
     val tempResult = [your expression] // Execute the original code
     () // Return the single instance of Unit
   }
   

   So your assignment gets transformed into executing the function (getting 42), discarding that result, and returning () instead. This isn't about subtyping—it's a deliberate language feature to let you run code for side effects in places that expect Unit.

How this differs from val f: ()->Any = { => 42 } #

This case is regular subtyping polymorphism at work. Int is a subtype of Any, so a function that returns Int is compatible with a function type that returns Any. This follows the standard Liskov substitution principle, unlike the Unit adaptation which is a compiler-specific shortcut.

Where to find this documented #

The Unit adaptation behavior is spelled out in the Scala Language Specification:

• In Scala 2, it's covered under Expression Statements (Section 6.10), which allows expressions of type Unit or AnyRef to be treated as statements (with their results discarded).
• Scala 3 expanded this rule to allow any expression to be adapted to Unit in the right context, making it more flexible while keeping the core idea intact.

You'll also find mentions of this in the official Scala Tour, particularly in sections covering the Unit type and function side effects.

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