标签: scala-3

考虑以下问题：

trait AA {
    def children: List[AA]
}

trait BB {
    def children: List[BB]
}

class CC extends AA, BB {
    override def children: List[AA] & List[BB] = ???
}

当我们覆盖childrenin 时CC，被覆盖的方法是顶级方法的合并实体。因此返回类型List[AA] & List[BB]是有道理的。

我不明白的是，下面是如何编译的？

class DD extends AA, BB {
    override def children: List[AA & BB] = ???
}

List 是协变的，因此（这是证明的来源）：

List[AA & BB] <: List[AA] & List[BB]

DD只能编译如果还 List[AA] & List[BB] <: List[AA & BB]。这是真的吗？如果是这样，那么不是List[AA] & …

我希望更清楚地理解Scala 3.3.1 中 Tuple2 类的位置。

在其源代码中，可以清楚地看出该类继承了 Product2 特征。我仍然怀疑的是 Tuple2 是如何立即继承自：

• 类 T1 *: T2 *: EmptyTuple.type
• 特质可序列化

我一直无法理解这一点。

我已经阅读了相关的 Scala 文档和源代码。我可以理解这些层次结构的继承的整体设计思想，但我还没有理解更细致的点（以问题为例）

我试图让 Maven 编译 Scala 3，但我得到了奇怪的东西，比如

[INFO] --- scala-maven-plugin:4.5.4:compile (default) @ laboratory ---
[INFO] Using incremental compilation using Mixed compile order
[INFO] compiling 1 Scala source and 10 Java sources to C:\Users\ERIC\Documents\git\loom-lab\laboratory\target\classes ...
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\Scala\net\kolotyluk\loom\HelloScala.scala:<233..233>: '=' expected, but '{' found
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\java\net\kolotyluk\loom\Context.java:<332..332>: unclosed string literal
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\java\net\kolotyluk\loom\Context.java:<595..595>: unclosed string literal
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\java\net\kolotyluk\loom\Context.java:<666..744>: '}' expected but eof found.
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\java\net\kolotyluk\loom\Experiment04_PrimeThreads.java:<16902..16902>: unclosed string literal
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\java\net\kolotyluk\loom\Experiment04_PrimeThreads.java:<17176..17176>: unclosed string literal
[ERROR] C:\Users\ERIC\Documents\git\loom-lab\laboratory\src\main\java\net\kolotyluk\loom\Experiment04_PrimeThreads.java:<28863..28870>: '}' expected but eof found.
[ERROR] 7 errors found

首先，为什么.java文件也会失败？ …

设T1, T2, T3三种类型。我们还定义了该类的两个给定实例Conversion，以便编译器可以从T1toT2和从T2to进行转换T3。

下面的代码可以正常编译：

type T1
type T2
type T3

given Conversion[T1, T2] with
    override def apply(x: T1): T2 = ???

given Conversion[T2, T3] with
    override def apply(x: T2): T3 = ???

val t1: T1 = ???
val t2: T2 = t1
val t3: T3 = t2

但是当我们尝试从T1到 时会发生什么T3？编译器不会让我们：

val t3: T3 = t1
             ^^
             Found:    (t1: T1)
             Required: T3

我的问题：编译器无法本机（参见解决方法）链转换是否有特定原因？

我的解决方法 …

在许多 Scala 教程和营销材料中，我发现许多人通过混合“类型别名”和“依赖类型”来滥用术语，而实际上它们并不是同一件事。

例如，在下面的示例中，TakeAlias是依赖类型，而不是类型别名。结果会导致编译失败：

object TrueTypeAlias {

  trait Unaliased[+T] {

    def take1: List[Seq[(T, T)]]

    def take2: List[Seq[(T, T)]]

    def take3: List[Seq[(T, T)]]
  }

  trait Aliased[+T] {

    type TakeAlias = List[Seq[(T, T)]]

    def take1: TakeAlias

    def take2: TakeAlias

    def take3: TakeAlias
  }
}

/*
TrueTypeAlias.scala:16:10: covariant type T occurs in invariant position in type  = List[Seq[(T, T)]] of type TakeAlias
one error found
*/

问题是：如何实现真正的类型别名？我可以使用编译器机制/扩展来使其工作吗？

我有以下非常难看的 if 语句嵌套，其中涉及缓慢的操作 (tryFindResult和tryFindOtherResult)，我需要尽可能少地执行这些操作。line只是为了提供一些上下文，它是解析器的一部分，该解析器在某个位置 ( ) 处查看当前行 ( i)。if 语句中的每种情况都会产生副作用（增加i）。

if (cond) {
    // increase i
} else {
    val maybeResult: Option[Result] = tryFindResult(line, i)
    if (maybeResult.nonEmpty) {
        // depending on `maybeResult`, increase i
    } else {
        val (newOffset, maybeOtherResult): (Int, Option[Result2]) = tryFindOtherResult(line, i)
        if (maybeOtherResult.nonEmpty) {
            // depending on `maybeOtherResult`, increase i
        } else {
            // i = newOffset
        }
    }
}

有什么办法可以压平这个吗？据我所知，Scala 没有像 这样的内联赋值语法if (val o = …

我创建了一个微型工作系统来以最大的多核处理器利用率运行并行作业。它似乎工作正常，但在某些时候，当处理大量作业时，会出现错误（没有错误消息，只是挂起），我怀疑这是低级竞争条件。我无法确定这是否是我用来实现并行性的 cats-effect 的错误，还是 Atomic 或 TrieMap 的错误。

这是一个缩小的实现，可用于说明和测试该问题：

import cats.effect.IO
import java.util.concurrent.atomic.{AtomicBoolean, AtomicLong}
import scala.collection.concurrent.TrieMap
import cats.effect.unsafe.implicits.global
import java.util.concurrent.ConcurrentHashMap


object ThreadingError extends App:
  val jobIdsAdded = (0L until 10000L).toList
  for (_ <- jobIdsAdded.iterator) {
    ParallelJobs.addJob(() => {})
  }
  while(ParallelJobs.count.get() < 10000L) {
    print(s"${ParallelJobs.count.get()}\r")
    Thread.sleep(200)
  }

object ParallelJobs:
  private val allCores = Runtime.getRuntime.availableProcessors()
  private val availableCores = allCores - 1
  private val assignedTillJobId: AtomicLong = AtomicLong(0L)
  val jobsTrieMap: TrieMap[Long, () => Any] = TrieMap.empty[Long, () => Any]
  val jobsConcurrentHashMap: ConcurrentHashMap[Long, () …