Opaque types are not definable at top level of REPL

[mpilquist]

Minimized code

➜  dotr -version
Starting dotty REPL...
Dotty compiler version 0.27.0-RC1 -- Copyright 2002-2020, LAMP/EPFL
scala> opaque type T = Int
1 |opaque type T = Int
  |^^^^^^
  |Illegal start of statement: no modifiers allowed here

scala> object Foo { opaque type T = Int }
// defined object Foo

[abgruszecki]

@mpilquist what semantics would you expect from top-level opaque types in the REPL?

[som-snytt]

I would expect scoped to the line:

scala> opaque type T = String ; def f: T = "hi"

similar to

scala> def f(s: String): Int = s.toInt ; def f(i: Int): Int = i+1   // ok, not local statements

I may not know whether or how a given line is wrapped.

[mpilquist]

I wanted to enter both an opaque type and a companion, which is currently prohibited, even if wrapping with an outer { /* put type and companion here */ }

[abgruszecki]

Yeah, I guess that makes sense. One may also want to copy top-level code from a file into a REPL, and we can define top-level opaque types in files.

In principle I think this should work, in practice it may boil down to how REPL encodes lines. I think right now every input corresponds to a class' body, which would imply we'd somehow need to add extra support for opaque types in class bodies.

[tgodzik]

How does REPL encode opaque type T = Int ?

Just wrap it in class REPL{ } or something like that? That seems to be fine for opaque types.

[bishabosha]

How does REPL encode opaque type T = Int ?

Just wrap it in class REPL{ } or something like that? That seems to be fine for opaque types.

it should be fine I think

scala> /*opaque*/ type T = Int
     | object T:
     |   def apply(i: Int): T = i
     | 
result of rs$line$1 after typer:
package repl$ {
  final lazy module val rs$line$1: repl$.rs$line$1$ = new repl$.rs$line$1$()
  final module class rs$line$1$() extends Object() { 
    this: repl$.rs$line$1.type =>
    type T = Int
    final lazy module val T: T$ = new T$()
    final module class T$() extends Object() { this: T.type =>
      def apply(i: Int): T = i
    }
  }
}

[dwijnand]

Yeah, I guess that makes sense. One may also want to copy top-level code from a file into a REPL, and we can define top-level opaque types in files.

In principle I think this should work, in practice it may boil down to how REPL encodes lines. I think right now every input corresponds to a class' body, which would imply we'd somehow need to add extra support for opaque types in class bodies.

Btw, this works correctly in the Scala 2 REPL, and what I mean by that is when you paste a multi-line block of code it doesn't get processed as line-prompt-line-... but as a single snippet. So bringing forward that support would deal with that use case.

[edit: actually looks like the Scala 3 REPL already does support that.]

[SethTisue]

Note that in both Scala 2 and Scala 3, the REPL allows you (because JLine 3 allows you) to press option-Return to continue the current input. (Rendering Scala 2's :paste unneeded, unless you need :paste -raw.)