scala/scala3

Match type syntax does not allow writing type patterns for type members directly

Open

#13,416 opened on Aug 29, 2021

View on GitHub
 (11 comments) (3 reactions) (0 assignees)Scala (6,247 stars) (1,159 forks)batch import
area:match-typeshelp wanteditype:enhancement

Description

Minimized code

trait RDF {
  type Triple
}
object RDF {
  type Triple[R <: RDF] = R match {
    case (RDF { type Triple = t }) => t
  }
  type GetTriple[T] = RDF { type Triple = T }
}

Output

Not found: type t

Expectation

Expected to be able to extract a variable type from inside a type refinement.

This syntax limit can be worked around by introducing a "pattern type":

trait RDF {
  type Triple
}
object RDF {
  type Triple[R <: RDF] = R match {
    case GetTriple[t] => t
  }
  type GetTriple[T] = RDF { type Triple = T }
}

Why write something like that? Apparently this pattern of extracting a field using a match type can substitute for some usages of generalized type projections and is enough to port some of the libraries using type projections, e.g. https://github.com/bblfish/banana-play

Contributor guide

Tech stack
None
Domain
backend
Issue type
feature
DifficultyEstimated implementation difficulty for a new contributor, from 1 for very small changes to 5 for expert-level work.
5
Estimated timeA rough time range for an experienced contributor to investigate, implement, test, and prepare a pull request.
over 1 week
Activity statusHow available the issue appears right now: fresh, active, stale, blocked, or waiting on maintainer input.
stale
ClarityHow clearly the issue explains the expected change, acceptance criteria, and next step.
clear
Prerequisites
Scala match typesScala type refinementsScala 3 compiler internals
Newbie friendlinessA 1-100 score estimating how approachable this issue is for first-time contributors.
15
Research direction
Examine the Scala 3 compiler source code, specifically the type pattern matching in dotty.tools.dotc.typer.Inferencing or related files. Understand the current limitation that prevents direct pattern matching on type members in match types. Review the discussion in the issue comments for potential approaches. Consider implementing a solution that extends the pattern match syntax to allow capturing type members, similar to the workaround using a pattern type.