Work in Progress

We are still in the process of writing the documentation for Scala 3. You can help us to improve the documentation.

Are you searching for the Scala 2 documentation?

Scala 3 Language Reference

Context Functions - More Details

Language

Syntax

Type              ::=  ...
                    |  FunArgTypes ‘?=>’ Type
Expr              ::=  ...
                    |  FunParams ‘?=>’ Expr

Context function types associate to the right, e.g. S ?=> T ?=> U is the same as S ?=> (T ?=> U).

Implementation

Context function types are shorthands for class types that define apply methods with context parameters. Specifically, the N-ary function type

T1, ..., TN ?=> R is a shorthand for the class type ContextFunctionN[T1, ..., TN, R]. Such class types are assumed to have the following definitions, for any value of N >= 1:

package scala
trait ContextFunctionN[-T1, ..., -TN, +R]:
  def apply(using x1: T1, ..., xN: TN): R

Context function types erase to normal function types, so these classes are generated on the fly for typechecking, but not realized in actual code.

Context function literals (x1: T1, ..., xn: Tn) ?=> e map context parameters xi of types Ti to the result of evaluating the expression e. The scope of each context parameter xi is e. The parameters must have pairwise distinct names.

If the expected type of the context function literal is of the form scala.ContextFunctionN[S1, ..., Sn, R], the expected type of e is R and the type Ti of any of the parameters xi can be omitted, in which case Ti = Si is assumed. If the expected type of the context function literal is some other type, all context parameter types must be explicitly given, and the expected type of e is undefined. The type of the context function literal is scala.ContextFunctionN[S1, ...,Sn, T], where T is the widened type of e. T must be equivalent to a type which does not refer to any of the context parameters xi.

The context function literal is evaluated as the instance creation expression

new scala.ContextFunctionN[T1, ..., Tn, T]:
  def apply(using x1: T1, ..., xn: Tn): T = e

A context parameter may also be a wildcard represented by an underscore _. In that case, a fresh name for the parameter is chosen arbitrarily.

Note: The closing paragraph of the Anonymous Functions section of Scala 2.13 is subsumed by context function types and should be removed.

Context function literals (x1: T1, ..., xn: Tn) ?=> e are automatically created for any expression e whose expected type is scala.ContextFunctionN[T1, ..., Tn, R], unless e is itself a context function literal. This is analogous to the automatic insertion of scala.Function0 around expressions in by-name argument position.

Context function types generalize to N > 22 in the same way that function types do, see the corresponding documentation.

Examples

See the section on Expressiveness from Simplicitly: foundations and applications of implicit function types.

Type Checking

After desugaring no additional typing rules are required for context function types.

Contributors to this page: