Dotty

[cquiroz]

Scala 3 port

This PR adds support for scala3 while still cross compiling to scala 2.13.
It is a fairly complex PR due to the structure of spire and its extensive use of techniques such as macros and typeclass based syntax that need to be changed for scala 3

The aim is to have a cross compiled version with no or minimal changes to the API and keep a reasonable performance
The mark of success will be passing all (or most tests) while the API remains mostly unchanged.
While this is totally usable we may need to do some further refinements after this is merged

General changes:

• do/while constructs were converted to while
• Implicits need type ascription
• Some number conversions need to be explicit
• Remove or rewrite the macros

API changes

In general we want clients not needing to change their code at all, however
in some cases it was unavoidable:

• the method Dist.given clashes with the given keyword, it was renamed to given_
• the class DistIterator has a next member that clashes with a next method. The field has renamed to _next
• UnboundSyntax seems to be bogus and it is not used anywhere in spire. It was marked as deprecated in scala 2 and removed in scala 3
• It is not in this PR yet but we should change all the empty paren methods to no-parens

Syntax changes

spire contains a fairly large set of syntaxis to allow a variety of operations. These use macros and needed to be rewritten.

As part of the process I changed them to be mostly extension methods.
However this changes the priorities as seen here:
scala/scala3#8740

I discovered this late in the process as it only has effects in some cases where all syntax is
imported and there are multiple implementations of the same operator.

I propose to test the approach in this PR but could be reverted if necessary

Macros

Spire includes a fair amount of macros many of them fairly complex.
As a first approximation I applied this policy about macros:

Only port macros that are strictly necessary to keep the semantics not the ones related to performance:

Under that criteria the action for each macro is as follow:

• Checked: This is likely the most complicated macro. It can take an arbitrary expression and check if any of
  the int/long operations would cause an overflow. It is hard to replace this with a non macro as it is supposed
  to operate with any arbitrary expression.
  In a first run Checked.tryOrReturn was removed as it can't be expressed as a quasiquote and in general it
  is hard to reason about when used
  Uses of tryOrReturn have been rewritten with the general form of

try {
  Checked.checked(a)
} catch {
  case _: ArithmeticException => return b
}

• PackMacro: This are fairly simple thus were converted using scala3 inline. Note that part of
  Pack is now shared with the macros being scala version specific

• Machinist: They are no longer used in scala 3. All calls that previously used machinist now are just regular typeclasses calls

• cFor: A base implementation was done at https://github.com/bishabosha/spire-scala3 and it was used
  as the basis for the port. See https://github.com/bishabosha/spire-scala3/blob/develop/src/main/scala/spire/syntax/macros/cforMacros.scala
  Note a cFor test is not passing thus a bit of work is still needed but it doesn't affect other uses

• Fpf: This class contains several macros which have not been ported and it remains scala 2.x only.
  I couldn't find it used anywhere except in test thus impact should be limited.
  Still it could be ported later as the macros are not very complicated.

• Auto: This is left as 2.x only

• Literals: Literals are specified as failing at compilation time thus a macro was needed. The current one was ported to scala 3 and the old versions kept for scala 2.
  NOTE: radix literals are not tested and not yet ported

Scalafmt

Ideally we'd update scalafmt to 3.0.0 but that would produce an even larger PR, thus I propose it is done in a later stage

Performance

Note that performance will not be the same as in scala 2. This is in part because scala 3 doesn't
support specialization and due to the replacement of some macros.

Some quick benchmarking shows no important difference for code not using specialization

Keeping the same level of performance is a non goal of this PR but could be improved later

[armanbilge]

Can we bump to 3.1.0? 😅

[armanbilge]

I'm very sorry if I asked before and forgot :( did all of these imports really have to change? I feel surprised, and it seems concerning.

[cquiroz]

In the original PR there were some clashes due to the way priorities are set using implicit conversions compared to extension methods. That forced the change but in principle all could be reverted

[armanbilge]

Yeah, if you don't mind I'm currently working on reducing the diff for these. Instead of asking a question every time, I figure I better just try reverting :)

[armanbilge]

Sorry if I forgot, what are unbound syntax?

[cquiroz]

It is a set of conversions classes like:
https://github.com/typelevel/spire/blob/main/core/src/main/scala/spire/syntax/Ops.scala#L549

final class ActionUnboundOps[G: ({ type F[A] = Action[_, A] })#F](lhs: G) {
  def |+|(rhs: G): G = macro Ops.binopWithScalar[G, G]
  def |-|(rhs: G): G = macro Ops.binopWithScalar[G, G]
  def inverse(): G = macro Ops.unopWithScalar[G]
}

These are not used anywhere and IMHO are bogus especially because lhs is G. IMHO they are just a mistake that compiles because it goes through the macro and they are never expanted

[armanbilge]

I don't really understand but that's fine it can go away 😆

[armanbilge]

we can remove this?

[cquiroz]

This change was needed as there is b function in implicits as indicated here:
scala/scala3#13602

It can be fixed renaming the b param

[armanbilge]

Yup I caught that one.

[armanbilge]

I'm 👍 after we merge #1079.

[cquiroz]

Added a few small fixes and updated scala to 3.1.0

[armanbilge]

👍 when green!

[vasilmkd]

Let's go! 🎉

[SethTisue]

👏👏👏

[som-snytt]

congrats! it's fun to watch people undertake daredevil stunts.