Implement parameter dependent case classes #8073
Labels
Comments
odersky
added a commit
to dotty-staging/dotty
that referenced
this issue
Jan 22, 2020
This avoids the crash but intorduces an implementation restriction. I have opened scala#8073, which suggests a full implementation of parameter dependent case classes so that the restriction can be dropped.
odersky
added a commit
to dotty-staging/dotty
that referenced
this issue
Jan 22, 2020
This avoids the crash but intorduces an implementation restriction. I have opened scala#8073, which suggests a full implementation of parameter dependent case classes so that the restriction can be dropped.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 3, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 3, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 3, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 4, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 5, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 5, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Oct 5, 2024
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
to dotty-staging/dotty
that referenced
this issue
Feb 14, 2025
This lets us write:
trait A:
type B
case class CC(a: A, b: a.B)
Pattern matching works but isn't dependent yet:
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
(for my usecase this isn't a problem, I'm working on a type constraint API
which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors `_N`, making
it dependent is a bit tricky, currently we generate:
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
So the type of `_2` is not obviously related to the type of `_1`, we probably
need to change what we generate into:
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
But this can be done in a separate PR.
Fixes scala#8073.
smarter
added a commit
that referenced
this issue
Feb 19, 2025
This lets us write:
```scala
trait A:
type B
case class CC(a: A, b: a.B)
```
Pattern matching works but isn't dependent yet:
```scala
x match
case CC(a, b) =>
val a1: A = a
// Dependent pattern matching is not currently supported
// val b1: a1.B = b
val b1 = b // Type is CC#a.B
```
(for my usecase this isn't a problem, I'm working on a type constraint
API which lets me write things like `case class CC(a: Int, b: Int
GreaterThan[a.type])`)
Because case class pattern matching relies on the product selectors
`_N`, making it dependent is a bit tricky, currently we generate:
```scala
case class CC(a: A, b: a.B):
def _1: A = a
def _2: a.B = b
```
So the type of `_2` is not obviously related to the type of `_1`, we
probably need to change what we generate into:
```scala
case class CC(a: A, b: a.B):
@uncheckedStable def _1: a.type = a
def _2: _1.B = b
```
But this can be done in a separate PR.
Fixes #8073.
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
minimized example
From #8069:
It would be great if we could lift the implementation restriction and admit case classes (and enum cases) with parameter dependencies.
To get there, we need a systematic study where we have to do the right substitutions.
One immediate problem, which caused #8069 is that
fromProductdoes not work as given since itcasts to unsubstituted parameter types. E.g. for class
Test2, fromProduct would contain code like this:where the
aina.Bis unbound.I suspect there will also be other problems with pattern matching, and maybe elsewhere. So it will require a focussed effort to get there. But the benefits (dependent ADTs) would be potentially very significant!
The text was updated successfully, but these errors were encountered: