Make named tuples an experimental feature

Author: odersky

compiler/src/dotty/tools/dotc/config/Feature.scala

@@ -33,6 +33,7 @@ object Feature:
   val pureFunctions = experimental("pureFunctions")
   val captureChecking = experimental("captureChecking")
   val into = experimental("into")
+  val namedTuples = experimental("namedTuples")
 
   val globalOnlyImports: Set[TermName] = Set(pureFunctions, captureChecking)
 

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

@@ -635,7 +635,7 @@ object Parsers {
       else leading :: Nil
 
     def maybeNamed(op: () => Tree): () => Tree = () =>
-      if isIdent && in.lookahead.token == EQUALS then
+      if isIdent && in.lookahead.token == EQUALS && in.featureEnabled(Feature.namedTuples) then
         atSpan(in.offset):
           val name = ident()
           in.nextToken()
@@ -2024,7 +2024,7 @@ object Parsers {
 
       if namedOK && isIdent && in.lookahead.token == EQUALS then
         commaSeparated(() => namedArgType())
-      else if tupleOK && isIdent && in.lookahead.isColon then
+      else if tupleOK && isIdent && in.lookahead.isColon && in.featureEnabled(Feature.namedTuples) then
         commaSeparated(() => namedElem())
       else
         commaSeparated(() => argType())

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -710,7 +710,7 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
       val nameIdx = tupleElems.indexWhere:
         case defn.NamedTupleElem(name, _) => name == selName
         case _ => false
-      if nameIdx >= 0 then
+      if nameIdx >= 0 && Feature.enabled(Feature.namedTuples) then
         typed(
           untpd.Apply(
             untpd.Select(untpd.TypedSplice(qual), nme.apply),

compiler/test/dotc/pos-test-pickling.blacklist

@@ -61,6 +61,7 @@ i17149.scala
 tuple-fold.scala
 mt-redux-norm.perspective.scala
 i18211.scala
+named-tuples1.scala
 
 # Opaque type
 i5720.scala

library/src/scala/Tuple.scala

@@ -241,8 +241,10 @@ object Tuple {
    */
   type Union[T <: Tuple] = Fold[T, Nothing, [x, y] =>> x | y]
 
+  @experimental
   opaque type NamedValue[name <: String & Singleton, A] >: A = A
 
+  @experimental
   object NamedValue:
     def apply[S <: String & Singleton, A](name: S, x: A): NamedValue[name.type, A] = x
     def extract[S <: String & Singleton]: NameExtractor[S] = NameExtractor[S]()

library/src/scala/runtime/stdLibPatches/language.scala

@@ -91,6 +91,13 @@ object language:
     @compileTimeOnly("`into` can only be used at compile time in import statements")
     object into
 
+    /** Experimental support for named tuples.
+     *
+     *  @see [[https://dotty.epfl.ch/docs/reference/experimental/into-modifier]]
+     */
+    @compileTimeOnly("`namedTuples` can only be used at compile time in import statements")
+    object namedTuples
+
     /** Was needed to add support for relaxed imports of extension methods.
       * The language import is no longer needed as this is now a standard feature since SIP was accepted.
       * @see [[http://dotty.epfl.ch/docs/reference/contextual/extension-methods]]

tests/pos/i7247.scala renamed to tests/neg/i7247.scala

@@ -1,28 +1,28 @@
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:12:25 ------------------------------------------------------
-12 |  val y: (String, Int) = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:13:25 ------------------------------------------------------
+13 |  val y: (String, Int) = person // error
    |                         ^^^^^^
-   |                         Found:    (person : (name: String, age: Int))
+   |                         Found:    (Test.person : (name: String, age: Int))
    |                         Required: (String, Int)
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:13:20 ------------------------------------------------------
-13 |  val _: NameOnly = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:14:20 ------------------------------------------------------
+14 |  val _: NameOnly = person // error
    |                    ^^^^^^
-   |                    Found:    (person : (name: String, age: Int))
-   |                    Required: NameOnly
+   |                    Found:    (Test.person : (name: String, age: Int))
+   |                    Required: Test.NameOnly
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:14:18 ------------------------------------------------------
-14 |  val _: Person = nameOnly // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:15:18 ------------------------------------------------------
+15 |  val _: Person = nameOnly // error
    |                  ^^^^^^^^
-   |                  Found:    (nameOnly : (name: String))
-   |                  Required: Person
+   |                  Found:    (Test.nameOnly : (name: String))
+   |                  Required: Test.Person
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:16:36 ------------------------------------------------------
-16 |  val _: (age: Int, name: String) = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:17:36 ------------------------------------------------------
+17 |  val _: (age: Int, name: String) = person // error
    |                                    ^^^^^^
-   |                                    Found:    (person : (name: String, age: Int))
+   |                                    Found:    (Test.person : (name: String, age: Int))
    |                                    Required: (age: Int, name: String)
    |
    | longer explanation available when compiling with `-explain`

tests/neg/named-tuples.check

@@ -1,14 +1,15 @@
+import annotation.experimental
+import language.experimental.namedTuples
 
-type Person = (name: String, age: Int)
-val person = (name = "Bob", age = 33): (name: String, age: Int)
+@experimental object Test:
 
-type NameOnly = (name: String)
+  type Person = (name: String, age: Int)
+  val person = (name = "Bob", age = 33): (name: String, age: Int)
 
-val nameOnly = (name = "Louis")
+  type NameOnly = (name: String)
 
+  val nameOnly = (name = "Louis")
 
-
-def Test =
   val y: (String, Int) = person // error
   val _: NameOnly = person // error
   val _: Person = nameOnly // error

tests/neg/named-tuples.scala

@@ -0,0 +1,14 @@
+import annotation.experimental
+import language.experimental.namedTuples
+import NamedTuple.dropNames
+
+@main def Test =
+  val bob = (name = "Bob", age = 33): (name: String, age: Int)
+  val persons = List(
+    bob,
+    (name = "Bill", age = 40),
+    (name = "Lucy", age = 45)
+  )
+  val ages = persons.map(_.age)
+    // pickling failure: matchtype is reduced after pickling, unreduced before.
+  assert(ages.sum == 118)

tests/pos/named-tuples.check

@@ -97,7 +97,15 @@ val experimentalDefinitionInLibrary = Set(
   "scala.Tuple$.Helpers$",
   "scala.Tuple$.Helpers$.ReverseImpl",
   "scala.Tuple$.Reverse",
-  "scala.runtime.Tuples$.reverse"
+  "scala.runtime.Tuples$.reverse",
+
+  // New feature: named tuples
+  "scala.NamedTuple",
+  "scala.NamedTuple$",
+  "scala.Tuple$.NamedValue",
+  "scala.Tuple$.NamedValue$",
+
+
 )
 
 

tests/pos/named-tuples.scala

@@ -4,3 +4,6 @@ Bob
 (Bob,33,Lausanne,1003)
 33
 no match
+Bob is younger than Bill
+Bob is younger than Lucy
+Bill is younger than Lucy

tests/pos/named-tuples1.scala

@@ -1,3 +1,5 @@
+import annotation.experimental
+import language.experimental.namedTuples
 import NamedTuple.dropNames
 
 type Person = (name: String, age: Int)
@@ -40,4 +42,42 @@ val _: CombinedInfo = bob ++ addr
   assert(ageOf((name = "anon", age = 22)) == 22)
   assert(ageOf(("anon", 11)) == 11)
 
+  val persons = List(
+    bob,
+    (name = "Bill", age = 40),
+    (name = "Lucy", age = 45)
+  )
+  for
+    p <- persons
+    q <- persons
+    if p.age < q.age
+  do
+    println(s"${p.name} is younger than ${q.name}")
+
+  //persons.select(_.age, _.name)
+  //persons.join(addresses).withCommon(_.name)
+
+  def minMax(elems: Int*): (min: Int, max: Int) =
+    var min = elems(0)
+    var max = elems(0)
+    for elem <- elems do
+      if elem < min then min = elem
+      if elem > max then max = elem
+    (min = min, max = max)
+
+  val mm = minMax(1, 3, 400, -3, 10)
+  assert(mm.min == -3)
+  assert(mm.max == 400)
+
+  val name1 = bob(0).value
+  val age1 = bob(1).value
+
+// should the .value above be inferred or maybe tuple indexing should strip names?
+// But then we could not do this:
+
+  def swap[A, B](x: (A, B)): (B, A) = (x(1), x(0))
+
+  val bobS = swap(bob)
+  val _: (age: Int, name: String) = bobS
+