Various tweaks

Author: odersky

docs/_docs/reference/experimental/named-tuples.md

@@ -38,9 +38,9 @@ This follows since a regular tuple `(T_1, ..., T_n)` is treated as a subtype of
 ```scala
 val x: (String, Int) = Bob           // error: type mismatch
 ```
-One can convert a named tuple to an unnamed tuple with the `dropNames` method, so the following works:
+One can convert a named tuple to an unnamed tuple with the `toTuple` method, so the following works:
 ```scala
-val x: (String, Int) = Bob.dropNames // ok
+val x: (String, Int) = Bob.toTuple // ok
 ```
 Note that conformance rules for named tuples are analogous to the rules for named parameters. One can assign parameters by position to a named parameter list.
 ```scala

library/src/scala/NamedTuple.scala

@@ -8,7 +8,7 @@ object NamedTuple:
   opaque type AnyNamedTuple = Any
   opaque type NamedTuple[N <: Tuple, +V <: Tuple] >: V <: AnyNamedTuple = V
 
-  def apply[N <: Tuple, V <: Tuple](x: V) = x
+  def apply[N <: Tuple, V <: Tuple](x: V): NamedTuple[N, V] = x
 
   def unapply[N <: Tuple, V <: Tuple](x: NamedTuple[N, V]): Some[V] = Some(x)
 

library/src/scala/Tuple.scala

@@ -354,7 +354,6 @@ object Tuple:
     /** A boolean indicating whether there is an element in the type `X` of `x`
      *  that matches type `Y`.
      */
-
     inline def containsType[Y] = constValue[Contains[X, Y]]
 
     /* Note: It would be nice to add the following two extension methods:

tests/neg/named-tuples.check

@@ -21,80 +21,87 @@
    |                         Required: (String, Int)
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:19:20 ------------------------------------------------------
-19 |  val _: NameOnly = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:19:25 ------------------------------------------------------
+19 |  val _: (String, Int) = (name = "", age = 0) // error
+   |                         ^^^^^^^^^^^^^^^^^^^^
+   |                         Found:    (name : String, age : Int)
+   |                         Required: (String, Int)
+   |
+   | longer explanation available when compiling with `-explain`
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:20:20 ------------------------------------------------------
+20 |  val _: NameOnly = person // error
    |                    ^^^^^^
    |                    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:20:18 ------------------------------------------------------
-20 |  val _: Person = nameOnly // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:21:18 ------------------------------------------------------
+21 |  val _: Person = nameOnly // error
    |                  ^^^^^^^^
    |                  Found:    (Test.nameOnly : (name : String))
    |                  Required: Test.Person
    |
    | longer explanation available when compiling with `-explain`
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:22:36 ------------------------------------------------------
-22 |  val _: (age: Int, name: String) = person // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:23:36 ------------------------------------------------------
+23 |  val _: (age: Int, name: String) = person // error
    |                                    ^^^^^^
    |                                    Found:    (Test.person : (name : String, age : Int))
    |                                    Required: (age : Int, name : String)
    |
    | longer explanation available when compiling with `-explain`
--- Error: tests/neg/named-tuples.scala:24:17 ---------------------------------------------------------------------------
-24 |  val (name = x, agee = y) = person // error
+-- Error: tests/neg/named-tuples.scala:25:17 ---------------------------------------------------------------------------
+25 |  val (name = x, agee = y) = person // error
    |                 ^^^^^^^^
    |                 No element named `agee` is defined in selector type (name : String, age : Int)
--- Error: tests/neg/named-tuples.scala:27:10 ---------------------------------------------------------------------------
-27 |    case (name = n, age = a) => () // error // error
+-- Error: tests/neg/named-tuples.scala:28:10 ---------------------------------------------------------------------------
+28 |    case (name = n, age = a) => () // error // error
    |          ^^^^^^^^
    |          No element named `name` is defined in selector type (String, Int)
--- Error: tests/neg/named-tuples.scala:27:20 ---------------------------------------------------------------------------
-27 |    case (name = n, age = a) => () // error // error
+-- Error: tests/neg/named-tuples.scala:28:20 ---------------------------------------------------------------------------
+28 |    case (name = n, age = a) => () // error // error
    |                    ^^^^^^^
    |                    No element named `age` is defined in selector type (String, Int)
--- [E172] Type Error: tests/neg/named-tuples.scala:29:27 ---------------------------------------------------------------
-29 |  val pp = person ++ (1, 2)  // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:30:27 ---------------------------------------------------------------
+30 |  val pp = person ++ (1, 2)  // error
    |                           ^
    |            Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), Tuple] =:= (true : Boolean).
--- [E172] Type Error: tests/neg/named-tuples.scala:32:18 ---------------------------------------------------------------
-32 |  person ++ (1, 2) match // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:33:18 ---------------------------------------------------------------
+33 |  person ++ (1, 2) match // error
    |                  ^
    |            Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), Tuple] =:= (true : Boolean).
--- Error: tests/neg/named-tuples.scala:35:17 ---------------------------------------------------------------------------
-35 |  val bad = ("", age = 10) // error
+-- Error: tests/neg/named-tuples.scala:36:17 ---------------------------------------------------------------------------
+36 |  val bad = ("", age = 10) // error
    |                 ^^^^^^^^
    |                 Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:38:20 ---------------------------------------------------------------------------
-38 |    case (name = n, age) => () // error
+-- Error: tests/neg/named-tuples.scala:39:20 ---------------------------------------------------------------------------
+39 |    case (name = n, age) => () // error
    |                    ^^^
    |                    Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:39:16 ---------------------------------------------------------------------------
-39 |    case (name, age = a) => () // error
+-- Error: tests/neg/named-tuples.scala:40:16 ---------------------------------------------------------------------------
+40 |    case (name, age = a) => () // error
    |                ^^^^^^^
    |                Illegal combination of named and unnamed tuple elements
--- Error: tests/neg/named-tuples.scala:42:10 ---------------------------------------------------------------------------
-42 |    case (age = x) => // error
+-- Error: tests/neg/named-tuples.scala:43:10 ---------------------------------------------------------------------------
+43 |    case (age = x) => // error
    |          ^^^^^^^
    |          No element named `age` is defined in selector type Tuple
--- [E172] Type Error: tests/neg/named-tuples.scala:44:27 ---------------------------------------------------------------
-44 |  val p2 = person ++ person // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:45:27 ---------------------------------------------------------------
+45 |  val p2 = person ++ person // error
    |                           ^
    |Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), (("name" : String), ("age" : String))] =:= (true : Boolean).
--- [E172] Type Error: tests/neg/named-tuples.scala:45:43 ---------------------------------------------------------------
-45 |  val p3 = person ++ (first = 11, age = 33) // error
+-- [E172] Type Error: tests/neg/named-tuples.scala:46:43 ---------------------------------------------------------------
+46 |  val p3 = person ++ (first = 11, age = 33) // error
    |                                           ^
    |Cannot prove that Tuple.Disjoint[(("name" : String), ("age" : String)), (("first" : String), ("age" : String))] =:= (true : Boolean).
--- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:47:22 ------------------------------------------------------
-47 |  val p5 = person.zip(first = 11, age = 33) // error
+-- [E007] Type Mismatch Error: tests/neg/named-tuples.scala:48:22 ------------------------------------------------------
+48 |  val p5 = person.zip(first = 11, age = 33) // error
    |                      ^^^^^^^^^^^^^^^^^^^^
    |                      Found:    (first : Int, age : Int)
    |                      Required: NamedTuple.NamedTuple[(("name" : String), ("age" : String)), Tuple]
    |
    | longer explanation available when compiling with `-explain`
--- Warning: tests/neg/named-tuples.scala:24:29 -------------------------------------------------------------------------
-24 |  val (name = x, agee = y) = person // error
+-- Warning: tests/neg/named-tuples.scala:25:29 -------------------------------------------------------------------------
+25 |  val (name = x, agee = y) = person // error
    |                             ^^^^^^
    |pattern's type (String, Int) is more specialized than the right hand side expression's type (name : String, age : Int)
    |

tests/neg/named-tuples.scala

@@ -16,6 +16,7 @@ import language.experimental.namedTuples
   val nameOnly = (name = "Louis")
 
   val y: (String, Int) = person // error
+  val _: (String, Int) = (name = "", age = 0) // error
   val _: NameOnly = person // error
   val _: Person = nameOnly // error
 

tests/run/named-tuples.check

@@ -7,3 +7,4 @@ no match
 Bob is younger than Bill
 Bob is younger than Lucy
 Bill is younger than Lucy
+(((Lausanne,Pully),Preverenges),((1003,1009),1028))

tests/run/named-tuples.scala

@@ -1,5 +1,5 @@
 import language.experimental.namedTuples
-import NamedTuple.toTuple
+import NamedTuple.*
 
 type Person = (name: String, age: Int)
 val bob = (name = "Bob", age = 33): (name: String, age: Int)
@@ -9,8 +9,8 @@ type Uni = (uni: Double)
 val uni = (uni = 1.0)
 val _: Uni = uni
 
-type AddressInfo = (city: String, zip: Int)
-val addr = (city = "Lausanne", zip = 1003)
+type AddressInfo = (city: String, zipCode: Int)
+val addr = (city = "Lausanne", zipCode = 1003)
 val _: AddressInfo = addr
 
 type CombinedInfo = NamedTuple.Concat[Person, AddressInfo]
@@ -95,5 +95,13 @@ val _: CombinedInfo = bob ++ addr
       val x: Person = bob1 // bob1 still has type Person with the unswapped elements
     case _ => assert(false)
 
+  val addr2 = (city = "Pully", zipCode = 1009)
+  val addr3 = addr.zip(addr2)
+  val addr4 = addr3.zip("Preverenges", 1028)
+  println(addr4)
+
+
+
+