[WIP] Context Bounds for Polymorphic Functions #21643

KacperFKorban · 2024-09-25T08:12:58Z

Implement the #6 point form SIP-64 i.e.

6. Context Bounds for Polymorphic Functions

Currently, context bounds can be used in methods, but not in function types or function literals. It would be nice propose to drop this irregularity and allow context bounds also in these places. Example:

type Comparer = [X: Ord] => (x: X, y: X) => Boolean
val less: Comparer = [X: Ord as ord] => (x: X, y: X) =>
  ord.compare(x, y) < 0

The expansion of such context bounds is analogous to the expansion in method types, except that instead of adding a using clause in a method, we insert a context function type.

For instance, the type and val definitions above would expand to

type Comparer = [X] => (x: X, y: X) => Ord[X] ?=> Boolean
val less: Comparer = [X] => (x: X, y: X) => (ord: Ord[X]) ?=>
  ord.compare(x, y) < 0

The expansion of using clauses does look inside alias types. For instance,
here is a variation of the previous example that uses a parameterized type alias:

type Cmp[X] = (x: X, y: X) => Ord[X] ?=> Boolean
type Comparer2 = [X: Ord] => Cmp[X]

The expansion of the right hand side of Comparer2 expands the Cmp[X] alias
and then inserts the context function at the same place as what's done for Comparer.

Open questions:

Should [X: Ord] => Cmp[X] be accepted as a correct poly function, since it eventually will have term parameters?

Currently missing:

Support for following type aliases when expanding context bounds

…ture

KacperFKorban · 2024-09-27T13:24:40Z

@odersky Could you take a look and see if there is something fundamentally wrong with this approach?

On a slightly different note:
What is the motivation for following aliases? I'm not sure how exactly it should work and how to fit it nicely into the current design, which does most of the transformations in desugaring. Should it only expand aliases and not other type parameters or match types?
Should we for example be able to represent the following declaration in TASTY?
type Comparer3[F[_]] = [X: Ord] => (x: X, y: X) => F[Boolean]

compiler/src/dotty/tools/dotc/typer/Typer.scala

odersky · 2024-09-30T18:23:13Z

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1717,7 +1717,11 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer
          typedFunctionType(desugar.makeFunctionWithValDefs(tree, pt), pt)
        else
          val funSym = defn.FunctionSymbol(numArgs, isContextual, isImpure)
-          val result = typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt)
+          val args1 = args.mapConserve {
+            case cb: untpd.ContextBoundTypeTree => typed(cb)


I think that won't do anything since args1 gets typed below as a list of untyped type trees. So typing it here beforehand should be redundant.

odersky · 2024-09-30T18:23:46Z

compiler/src/dotty/tools/dotc/typer/Typer.scala

@@ -1926,8 +1930,10 @@ class Typer(@constructorOnly nestingLevel: Int = 0) extends Namer

  def typedPolyFunction(tree: untpd.PolyFunction, pt: Type)(using Context): Tree =
    val tree1 = desugar.normalizePolyFunction(tree)
-    if (ctx.mode is Mode.Type) typed(desugar.makePolyFunctionType(tree1), pt)
-    else typedPolyFunctionValue(tree1, pt)
+    val tree2 = if Feature.enabled(Feature.modularity) then desugar.expandPolyFunctionContextBounds(tree1)


maybe roll expandPolyFunctionContextBounds into normalizePolyFunction?

odersky · 2024-09-30T18:26:17Z

tests/pos/contextbounds-for-poly-functions.scala

+
+val less8 = [X: {Ord, Show as show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0
+
+val less9 = [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y) < 0


We should have tests that compare these polyfunction values with their expected types. E.g.

val _: [X: {Ord as ord, Show}] => (x: X, y: X) => Boolean = less7

Also we should have use aliases in some parts of these types and see whether it still works.

odersky · 2024-09-30T18:27:29Z

compiler/src/dotty/tools/dotc/ast/Desugar.scala

+  /** Desugar [T_1 : B_1, ..., T_N : B_N] => (P_1, ..., P_M) => R
+   *  Into    [T_1, ..., T_N] => (P_1, ..., P_M) => (B_1, ..., B_N) ?=> R
+   */
+  def expandPolyFunctionContextBounds(tree: PolyFunction)(using Context): PolyFunction =


I was wondering whether we could re-use some of the code that desugars context bounds in methods. But maybe not. In any case, need to check that all applicable cases there are also present here.

odersky · 2024-09-30T18:29:27Z

About aliases:

type Cmp[X] = (x: X, y: X) => Ord[X] ?=> Boolean
type Comparer2 = [X: Ord] => Cmp[X]

The tricky part is, say you have

val f =  [X; Ord] => (x: X, y: X) => Ord[X] ?=> true

Does f: Comparer2 hold?

odersky · 2024-09-30T20:04:08Z

Also, we don't need to put this modularity anymore since SIP 64 got accepted.

KacperFKorban · 2024-10-01T14:12:16Z

@odersky I'm not entirely sure that I understand your aliases example.
Do you mean that we need some normalization mechanism to eliminate redundant context functions? Or not generate them when they are unnecessary?

e.g.

[X: Ord] => (x: X, y: X) => Ord[X] ?=> Boolean
===>(desugar)
[X] => (x: X, y: X) => ?=> Ord[X] => Ord[X] ?=> Boolean
===>(normalize)
[X] => (x: X, y: X) => => Ord[X] ?=> Boolean

odersky · 2024-10-01T14:42:25Z

Well, does f: Comparer2 hold or not? I guess it depends how Comparer2 is expanded. I believe it should hold.

KacperFKorban · 2024-10-01T14:58:05Z

It doesn't hold now. I'll try moving the expansion later, to be able to use some type info then.

…ns to reuse some of the existing context bound expansion

…poly functions

…gant

KacperFKorban added 7 commits September 24, 2024 10:18

Implement basic version of desugaring context bounds for poly functions

d653f5a

Handle named context bounds in poly function context bound desugaring

4060cf2

Correctly-ish desugar poly function context bounds in function types

1c36605

Fix pickling issue

44af0d6

Hide context bounds expansion for poly functions under modularity fea…

054251e

…ture

Small cleanup

571ae8d

Add more test cases

8b72b1e

odersky reviewed Sep 30, 2024

View reviewed changes

KacperFKorban added 3 commits October 2, 2024 17:23

Change the implementation of context bound expansion for poly functio…

458fd29

…ns to reuse some of the existing context bound expansion

Add support for some type aliases, when expanding context bounds for …

42d914e

…poly functions

Make the expandion of context bounds for poly types slightly more ele…

980213b

…gant

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

[WIP] Context Bounds for Polymorphic Functions #21643

[WIP] Context Bounds for Polymorphic Functions #21643

KacperFKorban commented Sep 25, 2024 •

edited

Loading

KacperFKorban commented Sep 27, 2024

odersky Sep 30, 2024

odersky Sep 30, 2024

odersky Sep 30, 2024

odersky Sep 30, 2024

odersky commented Sep 30, 2024

odersky commented Sep 30, 2024

KacperFKorban commented Oct 1, 2024

odersky commented Oct 1, 2024

KacperFKorban commented Oct 1, 2024


		val less8 = [X: {Ord, Show as show}] => (x: X, y: X) => summon[Ord[X]].compare(x, y) < 0

		val less9 = [X: {Ord as ord, Show as show}] => (x: X, y: X) => ord.compare(x, y) < 0

[WIP] Context Bounds for Polymorphic Functions #21643

Are you sure you want to change the base?

[WIP] Context Bounds for Polymorphic Functions #21643

Conversation

KacperFKorban commented Sep 25, 2024 • edited Loading

6. Context Bounds for Polymorphic Functions

KacperFKorban commented Sep 27, 2024

odersky Sep 30, 2024

Choose a reason for hiding this comment

odersky Sep 30, 2024

Choose a reason for hiding this comment

odersky Sep 30, 2024

Choose a reason for hiding this comment

odersky Sep 30, 2024

Choose a reason for hiding this comment

odersky commented Sep 30, 2024

odersky commented Sep 30, 2024

KacperFKorban commented Oct 1, 2024

odersky commented Oct 1, 2024

KacperFKorban commented Oct 1, 2024

KacperFKorban commented Sep 25, 2024 •

edited

Loading