Revert "Add Singleton upperbound to primitive type operations"

This reverts commit 3d5017a.

Author: soronpo

docs/docs/reference/metaprogramming/inline.md

@@ -462,9 +462,9 @@ match type can dispatch to the correct implementation:
 import scala.compiletime.ops._
 import scala.annotation.infix
 
-@infix type +[X <: Int & Singleton | String & Singleton, Y <: Int & Singleton | String & Singleton] = (X, Y) match {
-  case (Int & Singleton, Int & Singleton) => int.+[X, Y]
-  case (String & Singleton, String & Singleton) => string.+[X, Y]
+@infix type +[X <: Int | String, Y <: Int | String] = (X, Y) match {
+  case (Int, Int) => int.+[X, Y]
+  case (String, String) => string.+[X, Y]
 }
 
 val concat: "a" + "b" = "ab"

library/src/scala/compiletime/ops/package.scala

@@ -11,7 +11,7 @@ package object ops {
      * val eq3: "1" == "1" = true
      * ```
      */
-    @infix type ==[X <: AnyVal & Singleton, Y <: AnyVal & Singleton] <: Boolean & Singleton
+    @infix type ==[X <: AnyVal, Y <: AnyVal] <: Boolean
 
     /** Inequality comparison of two singleton types.
      * ```scala
@@ -20,7 +20,7 @@ package object ops {
      * val eq3: "1" != "1" = false
      * ```
      */
-    @infix type !=[X <: AnyVal & Singleton, Y <: AnyVal & Singleton] <: Boolean & Singleton
+    @infix type !=[X <: AnyVal, Y <: AnyVal] <: Boolean
   }
 
   object string {
@@ -29,7 +29,7 @@ package object ops {
      *  val hello: "hello " + "world" = "hello world"
      *  ```
      */
-    @infix type +[X <: String & Singleton, Y <: String & Singleton] <: String & Singleton
+    @infix type +[X <: String, Y <: String] <: String
   }
 
   object int {
@@ -38,103 +38,103 @@ package object ops {
      *  val sum: 2 + 2 = 4
      *  ```
      */
-    @infix type +[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    @infix type +[X <: Int, Y <: Int] <: Int
 
     /** Subtraction of two `Int` singleton types.
      *  ```scala
      *  val sub: 4 - 2 = 2
      *  ```
      */
-    @infix type -[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    @infix type -[X <: Int, Y <: Int] <: Int
 
     /** Multiplication of two `Int` singleton types.
      *  ```scala
      *  val mul: 4 * 2 = 8
      *  ```
      */
-    @infix type *[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    @infix type *[X <: Int, Y <: Int] <: Int
 
     /** Integer division of two `Int` singleton types.
      *  ```scala
      *  val div: 5 / 2 = 2
      *  ```
      */
-    @infix type /[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    @infix type /[X <: Int, Y <: Int] <: Int
 
     /** Remainder of the division of `X` by `Y`.
     *  ```scala
      *  val mod: 5 % 2 = 1
      *  ```
      */
-    @infix type %[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    @infix type %[X <: Int, Y <: Int] <: Int
 
     /** Less-than comparison of two `Int` singleton types.
      *  ```scala
      *  val lt1: 4 < 2 = false
      *  val lt2: 2 < 4 = true
      *  ```
      */
-    @infix type <[X <: Int & Singleton, Y <: Int & Singleton] <: Boolean & Singleton
+    @infix type <[X <: Int, Y <: Int] <: Boolean
 
     /** Greater-than comparison of two `Int` singleton types.
      *  ```scala
      *  val gt1: 4 > 2 = true
      *  val gt2: 2 > 2 = false
      *  ```
      */
-    @infix type >[X <: Int & Singleton, Y <: Int & Singleton] <: Boolean & Singleton
+    @infix type >[X <: Int, Y <: Int] <: Boolean
 
     /** Greater-or-equal comparison of two `Int` singleton types.
      *  ```scala
      *  val ge1: 4 >= 2 = true
      *  val ge2: 2 >= 3 = false
      *  ```
      */
-    @infix type >=[X <: Int & Singleton, Y <: Int & Singleton] <: Boolean & Singleton
+    @infix type >=[X <: Int, Y <: Int] <: Boolean
 
     /** Less-or-equal comparison of two `Int` singleton types.
      *  ```scala
      *  val lt1: 4 <= 2 = false
      *  val lt2: 2 <= 2 = true
      *  ```
      */
-    @infix type <=[X <: Int & Singleton, Y <: Int & Singleton] <: Boolean & Singleton
+    @infix type <=[X <: Int, Y <: Int] <: Boolean
 
     /** Absolute value of an `Int` singleton type.
      *  ```scala
      *  val abs: Abs[-1] = 1
      *  ```
      */
-    type Abs[X <: Int & Singleton] <: Int & Singleton
+    type Abs[X <: Int] <: Int
 
     /** Negation of an `Int` singleton type.
      *  ```scala
      *  val neg1: Neg[-1] = 1
      *  val neg2: Neg[1] = -1
      *  ```
      */
-    type Negate[X <: Int & Singleton] <: Int & Singleton
+    type Negate[X <: Int] <: Int
 
     /** Minimum of two `Int` singleton types.
      *  ```scala
      *  val min: Min[-1, 1] = -1
      *  ```
      */
-    type Min[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    type Min[X <: Int, Y <: Int] <: Int
 
     /** Maximum of two `Int` singleton types.
      *  ```scala
      *  val abs: Abs[-1] = 1
      *  ```
      */
-    type Max[X <: Int & Singleton, Y <: Int & Singleton] <: Int & Singleton
+    type Max[X <: Int, Y <: Int] <: Int
 
     /** String conversion of an `Int` singleton type.
      *  ```scala
      *  val abs: ToString[1] = "1"
      *  ```
      */
-    type ToString[X <: Int & Singleton] <: String & Singleton
+    type ToString[X <: Int] <: String
   }
 
   object boolean {
@@ -145,30 +145,30 @@ package object ops {
      *  val notTrue: ![true] = false
      *  ```
      */
-    type ![X <: Boolean & Singleton] <: Boolean & Singleton
+    type ![X <: Boolean] <: Boolean
 
     /** Exclusive disjunction of two `Boolean` singleton types.
      * ```scala
      * val a: true ^ true = false
      * val b: false ^ true = true
      * ```
      */
-    @infix type ^[X <: Boolean & Singleton, Y <: Boolean & Singleton] <: Boolean & Singleton
+    @infix type ^[X <: Boolean, Y <: Boolean] <: Boolean
 
     /** Conjunction of two `Boolean` singleton types.
      *  ```scala
      *  val a: true && true = true
      *  val b: false && true = false
      *  ```
      */
-    @infix type &&[X <: Boolean & Singleton, Y <: Boolean & Singleton] <: Boolean & Singleton
+    @infix type &&[X <: Boolean, Y <: Boolean] <: Boolean
 
     /** Disjunction of two `Boolean` singleton types.
      * ```scala
      * val a: true || false = true
      * val b: false || false = false
      * ```
      */
-    @infix type ||[X <: Boolean & Singleton, Y <: Boolean & Singleton] <: Boolean & Singleton
+    @infix type ||[X <: Boolean, Y <: Boolean] <: Boolean
   }
 }

project/build.properties

@@ -1 +1 @@
-sbt.version=1.3.6
+sbt.version=1.3.6

tests/neg/singleton-ops-match-type-scrutinee.scala

@@ -1,7 +1,7 @@
 import scala.compiletime.ops.int._
 
 object Test {
-  type Max2[A <: Int & Singleton, B <: Int & Singleton] <: Int & Singleton = (A < B) match {
+  type Max2[A <: Int, B <: Int] <: Int = (A < B) match {
     case true => B
     case false => A
   }

tests/neg/singleton-ops-recursive-match-type.scala

@@ -1,7 +1,7 @@
 import scala.compiletime.ops.int._
 
 object Test {
-  type GCD[A <: Int & Singleton, B <: Int & Singleton] <: Int & Singleton = B match {
+  type GCD[A <: Int, B <: Int] <: Int = B match {
     case 0 => A
     case _ => GCD[B, A % B]
   }

tests/neg/singleton-ops-type-alias.scala

@@ -1,7 +1,7 @@
 import scala.compiletime.ops.boolean._
 
 object Test {
-  type Xor[A <: Boolean & Singleton, B <: Boolean & Singleton] = (A && ![B]) || (![A] && B)
+  type Xor[A <: Boolean, B <: Boolean] = (A && ![B]) || (![A] && B)
   val t0: Xor[true, true] = false
   val t1: Xor[false, true] = true
   val t2: Xor[true, false] = false // error

tests/pos/singleton-ops-dispatch.scala

@@ -2,11 +2,11 @@ import scala.compiletime.ops._
 import scala.annotation.infix
 
 object Test {
-  @infix type +[X <: Int & Singleton | String & Singleton, Y <: Int & Singleton | String & Singleton] = (X, Y) match {
-    case (Int & Singleton, Int & Singleton) => int.+[X, Y]
-    case (String & Singleton, String & Singleton) => string.+[X, Y]
-    case (String & Singleton, Int & Singleton) => string.+[X, int.ToString[Y]]
-    case (Int & Singleton, String & Singleton) => string.+[int.ToString[X], Y]
+  @infix type +[X <: Int | String, Y <: Int | String] = (X, Y) match {
+    case (Int, Int) => int.+[X, Y]
+    case (String, String) => string.+[X, Y]
+    case (String, Int) => string.+[X, int.ToString[Y]]
+    case (Int, String) => string.+[int.ToString[X], Y]
   }
 
   val t0: "a" + 1 = "a1"