docs.scala-lang | The Scala Documentation website | Build Tool library

Accessing the command-line arguments like that is no longer supported in Scala 3:

https://docs.scala-lang.org/scala3/reference/dropped-features/delayed-init.html

Under the hood, Scala pattern matching often boils down to code that's exactly like the if (notification instanceof Email) { ... } else if (notification instanceof SMS) Java code.

The particular example you give, of an abstract class Notification which isn't sealed is one where the Scala code is no better (except perhaps expressing overall intent more clearly) than the if/instanceof tree.

This is because the main benefit of pattern matching is the possibility of exhaustivity checking. With the if/instanceof approach and the example of pattern matching you present, you aren't going to be alerted that you haven't handled every case (e.g. you left off the VoiceRecording case).

By making Notification sealed (e.g. sealed abstract class Notification), the Scala compiler will ensure that no Scala code in other files (technically, compilation units, which are for all intents and purposes files) can extend Notification; since it now knows all the possible Notifications, it can then raise a compiler error if you miss a case. There's no reliable way to do this in the if/instanceof case because that's a lower level of abstraction.

The relevant section of compiled code for option-1 looks like

The documentation on trait parameters only mentions trait parameters, not trait constructors:

Scala 3 allows traits to have parameters, just like classes have parameters.

It also links to the original SIP document for reference:

For more information, see Scala SIP 25.

In the SIP-25 – trait parameters, it says [bold emphasis mine]:

In the ClassDef of traits, we still do not allow secondary constructors.

However, this restriction, is not reflected in the Syntax Summary, which does not actually distinguish between classes and traits syntactically. So, the restriction is purely one of documentation, not syntax specification.

So, to answer your question:

Why?

Because your code is syntactically valid but semantically invalid, and ScalaMeta seems to not expect this specific kind of semantic invalidity.

And why is it after line 1, which seems perfectly fine and gets accepted when I remove the rest? Does "invariant failed" mean that it's a bug in the compiler? (Many other compilers in such cases add to the message an encouragement to report it.)

It's clearly not a bug in the compiler since the exception is not thrown in the compiler, it is thrown in ScalaMeta.

Main questions:

• Are secondary (or auxiliary – IIUC the two terms I've seen used apparently interchangeably mean the same) constructors allowed in traits?

No. SIP-25 clearly disallows them.

There are actually 3 basic possibilities for lazy sequences in Scala 2.13: View, Iterator and LazyList.

View is the simplest lazy sequence with very little additional costs. It's good to use by default in general case to avoid allocations for intermediate results when working with large sequences.

It's possible to traverse the View several times (using foreach, foldLeft, toMap, etc.). Transformations (map, flatMap, filter, etc.) will be executed separately for every traversal. So care has to be applied either to avoid time-consuming transformations, or to traverse the View only once.

Iterator can be traversed only once. It's similar to Java Streams or Python generators. Most transformation methods on Iterator require that you only use the returned Iterator and discard the original object.

It's also fast like a View and supports more operations, including distinct.

LazyList is basically a real strict structure, which can be expanded automatically on the fly. LazyList memoizes all the generated elements. If you have a val with a LazyList, the memory will be allocated for all the generated elements. But if you traverse it on the fly and don't store in a val, the garbage collector can clean up the traversed elements.

Stream in Scala 2.12 was considerably slower than Views or Iterators. I'm not sure if this applies to LazyList in Scala 2.13.

So every lazy sequence has some caveat:

• View can execute transformations multiple times.
• Iterator can be consumed only once.
• LazyList can allocate the memory for all the sequence elements.

In your use case I believe, it's Iterator that's the most appropriate:

The options have for accessing tuples are Kernel.elem/2, Access.elem/2 and pattern matching. However, the Enum.sort_by/3 function does the job less verbosely than Enum.sort/2.

As user pointed out, problem can be solved by using annotation @targetName("...")

From the documentation you linked:

Primary constructor parameters with val and var are public.

E.g. (as in the example):

You can define your own reify in your project