scastie | An interactive playground for Scala | Build Tool library

You're trying to use something from this library: https://search.maven.org/artifact/joda-time/joda-time/2.10.13/jar

You can include this library in Scastie using the following line:

You could chain the Reads using orElse.

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.

It doesn't work because Writer declares that its write method will accept an arbitrary A. What if someone decides to pass an A that is not a B to writer.write? Then it wouldn't work, so the compiler stops you from doing that.

Use a polymorphic method:

It's about type variances, you can make funPoly work by changing

Type erasure is a consequence of how generics are implemented on the JVM. It means that a runtime, you won't be able to tell the difference between e.g. a List[Int] and a List[String]; all the runtime knows is that you have a List. The knowledge of whether you're expecting [Int] or [String] is compile-time only.

In your case, you have T_SEQUENCE[T_ElemType] - so given some object of type Any, you can use isInstanceOf to check if you have an instance of some T_SEQUENCE, but there's no knowledge of what the type parameter on it is.

You could make an assumption that your method will never receive a T_SEQUENCE with the wrong type parameter, and use that to do

As suggested in the comments, Nil extends List[Nothing], thus your case IterableOnce[t] => t applies and Elem[Nil.type] =:= Nothing.