标签: scala-3

我不明白为什么这段代码不能编译并失败：

没有可用于 A 的单例值，
其中： A 是具有约束的类型变量 >: ("yo" : String) 和 <: Singleton

case class Wrapper[A <: Singleton](a: A)(using ValueOf[A])

def test[A <: Singleton](blabla: Wrapper[A]): Unit = ()

test(Wrapper("yo"))

这是预期的还是 Scala 3 中的错误？

请注意，如果我提取Wrapper("yo")然后它的工作原理：

case class Wrapper[A <: Singleton](a: A)(using ValueOf[A])

def test[A <: Singleton](blabla: Wrapper[A]): Unit = ()

val value = Wrapper("yo")
test(value)

I'm starting a Scala role in a few weeks yet I haven't written any Scala before (yes, my future employers know this), although I've written a lot of C# and Haskell. Anyway I was skimming through the Scala 3 book, and found this example:

enum Option[+T]:
  case Some(x: T)
  case None

Which apparently dusugars into:

enum Option[+T]:
  case Some(x: T) extends Option[T]
  case None       extends Option[Nothing]

My two questions are:

1. How exactly does the mechanism of this desugaring work? …

以下代码的输出只是list（没有打印数字）。

trait TC[A]:
  inline def show(value: A): Unit

object TC:
  given TC[Int] with
    inline def show(value: Int): Unit = println(value)
  given[A:TC]: TC[List[A]] with
    inline def show(value: List[A]): Unit =
      println("list")
      value.foreach(x => summon[TC[A]].show(x))

@main
def main: Unit =
  import TC._
  val value = 1 :: 2 :: 3 :: Nil
  summon[TC[List[Int]]].show(value)

如果我删除，inline那么一切都会好起来的。我是否在调用未定义的行为？

在 Scala 3 中summon似乎和旧的implicitly. 但是当我们深入研究实际例子时，我们发现情况并非如此。例如

case class A(i: Int, s: String)

val mirror    = implicitly[Mirror.Of[A]]    
type ValueOfs = Tuple.Map[mirror.MirroredElemLabels, ValueOf]
val valueOfs  = summonAll[ValueOfs]

def values(t: Tuple): Tuple = t match
  case (h: ValueOf[_]) *: t1 => h.value *: values(t1)
  case EmptyTuple => EmptyTuple

产生错误

cannot reduce inline match with  
 scrutinee:  compiletime.erasedValue[App.ValueOfs] : App.ValueOfs  
 patterns :  case _:EmptyTuple  
             case _:*:[t @ _, ts @ _]

但是替换implicitly[Mirror.Of[A]]为summon[Mirror.Of[A]]编译很好。

在这种情况下和一般情况下summonvs的微妙之处是什么implicitly？

想要这样做的特殊原因是仍然能够对来自超类的值使用模式匹配。例如，我希望case None在查看 type 的值时能够匹配Option[Throwable]，但这似乎不可能，因为Throwable不可能，而且（我想）永远不会有CanEqual实例。

假设我想使用这样的匹配类型来表示一个向量：

type V[I <: Int, N] = I match\n  case 2 => (N, N)\n  case 3 => (N, N, N)\n  case 4 => (N, N, N, N)\n

所以现在我可以使用元组声明我的向量：

  val v2: V[2, Int] = (2, 2)\n  val v3: V[3, Int] = (3, 3, 3)\n  val v4: V[4, Int] = (4, 4, 4, 4)\n

然后我可以定义一个元组矩阵和一个元组方阵：

type Mx[L <: Int, C <: Int, N] = V[L, V[C, N]]\ntype Mxq[T <: Int, N] = Mx[T, T, N]\ntype M3I = …

我无法使用 Scala 3 在 ScalaDoc 中添加包描述

/** package description */
package foo {
    /** some scaladoc comment */
    def method():A = ???
}

然后我用 sbt (1.5.3) 生成文档

sbt> doc

我没有在文件中获得包本身的描述，而只获得包内部index.html的描述。method