Improvements to implicits #1918

odersky · 2017-01-31T03:50:30Z

The PR contains an optimization and a generalization of implicits

Optimization: We now avoid recomputation of companion refs in many cases
Generalization: We allow implicit call-by-name parameters

There are also some improvements to internal diagnostics regarding implicits.
There a largish test case, which explores some schemes for generic programming over ADTs.

Review by @smarter, @OlivierBlanvillain ?

OlivierBlanvillain

What would be the motivation for an enum syntax? If the goal is lighter syntax for sealed hierarchy of case classes, it looks like this would be a perfect use case for an @enum annotation implemented using scala.Meta's syntactic APIs.

I think having a bijection between Scala types and a sum of product representation (the shaped type class of this PR, or shapeless's Generic) should be enough in itself to get all the benefits of enums. For instance, if we also add a ValueOf type class to obtain values associated to literal singleton types, we compute all the values of an enumeration via implicit resolution: (enumTag can probably be computed in a similar way)

dotty-staging@dc4f84e

OlivierBlanvillain · 2017-01-31T11:24:04Z

compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala

+      "Failed Implicit"
+    case result: AmbiguousImplicits =>
+      "Ambiguous Implicit: " ~ toText(result.alt1) ~ " and " ~ toText(result.alt2)
+    case _ =>


Could we seal SearchResult instead of having a default case?

Looks like we can

No, in fact we cannot. There are too many other cases we'd have to handle. E.g. ExplainedSearchResult. Sometimes it's better not to seal.

odersky · 2017-02-02T23:41:33Z

Some current advantages of enum as a syntax:

Less verbose syntax
Gives us a robust way to find all children of a class. Even using sealed we still have problems with that because exploration can cause cycles.
Gives us an efficient way to create enums with many values.
Opens the potential to represent some enums as Java enums, which helps interop
Give us a lightweight way to hide implementation classes. E.g. We'd like Cons, Nil to be
of type List (instead of a subtype) because this helps sometimes with type inference.

Could this be done with Scala meta? I doubt it since the natural enum syntax is not currently legal Scala. Also there's a "meta discussion" to be had about Scala meta. Language workbenches are very appealing academically but often turn to nightmares in practice. Google for "The Lisp Curse" for details.

smarter · 2017-02-03T00:57:02Z

tests/run/generic/Shapes.scala

+
+  case class EnumValue[E](tag: Int)
+
+  trait shaped[SH1, SH2] extends unfolds[SH1, SH2]


What's the difference between shaped and unfolds?

xeno-by · 2017-02-04T00:55:02Z

@OlivierBlanvillain @odersky As defined in the examples, the syntax for enums cannot be implemented in scala.meta. In new-style macro annotations, we only accept annottees written using regular Scala syntax.

At the moment, we don't have plans to turn scala.meta into a language workbench. The main goal of the project is to provide syntactic and semantic API for standard Scala to be used in developer tools and macros.

xeno-by · 2017-02-04T00:51:38Z

compiler/src/dotty/tools/dotc/parsing/Parsers.scala

-                if (owner.isTypeName && !(mods is Local))
-                  syntaxError(s"${if (mods is Mutable) "`var'" else "`val'"} parameters may not be call-by-name")
-                else if (imods.hasFlags)
-                  syntaxError("implicit parameters may not be call-by-name")


Why was this prohibited in scalac?

xeno-by · 2017-02-04T00:55:53Z

tests/run/generic/Color.scala

+    def enumTag = tag
+    override def toString = name
+    registerEnumValue(this)
+  }


Can we have a named subclass of Color defined somewhere in the companion object and used here? I think that classnames of anonymous classes are quite ugly.

xeno-by · 2017-02-04T00:57:23Z

tests/run/generic/Enum.scala

+import Shapes.Singleton
+
+trait Enum {
+  def enumTag: Int


What use cases do you envision for enumTag? Back then, @densh and I planned to use tags to speed up pattern matching. Do you think that'd make sense?

xeno-by · 2017-02-04T00:57:46Z

tests/run/generic/Enum.scala

+  def enumTag: Int
+}
+
+trait FiniteEnum extends Enum


What's that?

xeno-by · 2017-02-04T00:58:21Z

tests/run/generic/Enum.scala

+  private var myValues = new Array[AnyRef](numVals)
+
+  def registerEnumValue(v: E) =
+    myValues(v.enumTag) = v


Can we somehow restrict the visibility of this method?

xeno-by · 2017-02-04T00:59:27Z

tests/run/generic/List.scala

+      new (Cons[T] `shaped` Prod[T, List0[T]]) {
+        def toShape(x: Cons[T]) = Prod(x.hd, x.tl)
+        def fromShape(p: Prod[T, List0[T]]) = new Cons(p.fst, p.snd) {}
+      }


@odersky Am I right in thinking that you'd like the XXXShape implicits to be derived by macros?

And, in general, which parts of the enum proposal do you see implementable as macros, and what you'd like to hardcode in the compiler?

@xeno-by The XXXShape implicits can be done by the compiler. The part I need from macros are the implicits in Test.scala.

xeno-by · 2017-02-04T01:00:47Z

tests/run/generic/List.scala

+    }
+}
+
+/** enum List[T] {


Is the variance modifier omitted here on purpose?

There are actually two sources, one without variance for List0, the other with variance for List1.

The previous condition for caching companionRefs contained a condition result.companionRefs.forall(implicitScopeCache.contains) which was always false because we cache types in `implicitCodeCache`, not companion refs. The new logic fixes this and does not need a second traversal because it is integrated in `iscopeRefs`.

When printing info about adding to constraints, show the hashes of the typerstate stack, so that we know where constraints are added.

The test exercises all the improvements made in previous commits of this branch.

odersky added the stat:in progress label Jan 31, 2017

odersky force-pushed the fix-implicits-generic branch from e9d324e to 2294e82 Compare January 31, 2017 05:15

OlivierBlanvillain reviewed Jan 31, 2017

View reviewed changes

This was referenced Feb 1, 2017

Union type found when inferring Array.empty #1907

Closed

Fix #1907: Improve error message #1921

Merged

smarter reviewed Feb 3, 2017

View reviewed changes

odersky force-pushed the fix-implicits-generic branch from f3145f2 to 2ce9328 Compare February 3, 2017 05:04

xeno-by reviewed Feb 4, 2017

View reviewed changes

odersky added 6 commits February 8, 2017 19:35

Allow implicit-by-name parameters

4086195

Implement SearchResult.show

269be04

Print typerstate nesting info as part of constr printing

bc06d17

When printing info about adding to constraints, show the hashes of the typerstate stack, so that we know where constraints are added.

ADT and Serialization test

fe09e0d

The test exercises all the improvements made in previous commits of this branch.

Add to test case

56d32fa

odersky force-pushed the fix-implicits-generic branch from 2ce9328 to 56d32fa Compare February 8, 2017 08:36

odersky merged commit b77c24c into scala:master Feb 8, 2017

allanrenucci deleted the fix-implicits-generic branch December 14, 2017 19:20


		case class EnumValue[E](tag: Int)

		trait shaped[SH1, SH2] extends unfolds[SH1, SH2]

Improvements to implicits #1918

Improvements to implicits #1918

Uh oh!

Conversation

odersky commented Jan 31, 2017

Uh oh!

OlivierBlanvillain left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

odersky commented Feb 2, 2017 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

xeno-by commented Feb 4, 2017

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

odersky commented Feb 2, 2017 •

edited

Loading