Pure function types -> and ?->

 1. Allow `->` and `?->` and function operators, treated like `=>` and `?=>`. 2. under -Ycc treat `->` and `?->` as immutable function types, whereas `A => B` is an alias of `{*} A -> B` and `A ?=> B` is an alias of `{*} A ?-> B`. Closures are unaffected, we still use `=>` for all closures where they are pure or not.

Author: odersky

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

@@ -70,13 +70,13 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
  case class InterpolatedString(id: TermName, segments: List[Tree])(implicit @constructorOnly src: SourceFile)
  extends TermTree
 
- /** A function type */
+ /** A function type or closure */
  case class Function(args: List[Tree], body: Tree)(implicit @constructorOnly src: SourceFile) extends Tree {
  override def isTerm: Boolean = body.isTerm
  override def isType: Boolean = body.isType
  }
 
- /** A function type with `implicit`, `erased`, or `given` modifiers */
+ /** A function type or closure with `implicit`, `erased`, or `given` modifiers */
  class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers)(implicit @constructorOnly src: SourceFile)
  extends Function(args, body)
 
@@ -217,6 +217,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
  case class Transparent()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Transparent)
 
  case class Infix()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Infix)
+
+ case class Impure()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Impure)
  }
 
  /** Modifiers and annotations for definitions

compiler/src/dotty/tools/dotc/core/Definitions.scala

@@ -1381,6 +1381,10 @@ class Definitions {
  */
  def isFunctionClass(cls: Symbol): Boolean = scalaClassName(cls).isFunction
 
+ /** Is a function class, or an impure function type alias */
+ def isFunctionSymbol(sym: Symbol): Boolean =
+ sym.isType && (sym.owner eq ScalaPackageClass) && sym.name.isFunction
+
  /** Is a function class where
  * - FunctionN for N >= 0 and N != XXL
  */

compiler/src/dotty/tools/dotc/core/Flags.scala

@@ -314,8 +314,8 @@ object Flags {
  /** A Scala 2x super accessor / an unpickled Scala 2.x class */
  val (SuperParamAliasOrScala2x @ _, SuperParamAlias @ _, Scala2x @ _) = newFlags(26, "<super-param-alias>", "<scala-2.x>")
 
- /** A parameter with a default value */
- val (_, HasDefault @ _, _) = newFlags(27, "<hasdefault>")
+ /** A parameter with a default value / an impure untpd.Function type */
+ val (_, HasDefault @ _, Impure @ _) = newFlags(27, "<hasdefault>", "<{*}>")
 
  /** An extension method, or a collective extension instance */
  val (Extension @ _, ExtensionMethod @ _, _) = newFlags(28, "<extension>")

compiler/src/dotty/tools/dotc/core/NameOps.scala

@@ -227,17 +227,14 @@ object NameOps {
  */
  def isPlainFunction: Boolean = functionArity >= 0
 
- /** Is an context function name, i.e one of ContextFunctionN or ErasedContextFunctionN for N >= 0
- */
- def isContextFunction: Boolean =
+ /** Is a function name that contains `mustHave` as a substring */
+ private def isSpecificFunction(mustHave: String): Boolean =
  val suffixStart = functionSuffixStart
- isFunctionPrefix(suffixStart, mustHave = "Context") && funArity(suffixStart) >= 0
+ isFunctionPrefix(suffixStart, mustHave) && funArity(suffixStart) >= 0
 
- /** Is an erased function name, i.e. one of ErasedFunctionN, ErasedContextFunctionN for N >= 0
- */
- def isErasedFunction: Boolean =
- val suffixStart = functionSuffixStart
- isFunctionPrefix(suffixStart, mustHave = "Erased") && funArity(suffixStart) >= 0
+ def isContextFunction: Boolean = isSpecificFunction("Context")
+ def isErasedFunction: Boolean = isSpecificFunction("Erased")
+ def isImpureFunction: Boolean = isSpecificFunction("Impure")
 
  /** Is a synthetic function name, i.e. one of
  * - FunctionN for N > 22

compiler/src/dotty/tools/dotc/core/StdNames.scala

@@ -741,6 +741,8 @@ object StdNames {
  val XOR : N = "^"
  val ZAND : N = "&&"
  val ZOR : N = "||"
+ val PUREARROW: N = "->"
+ val PURECTXARROW: N = "?->"
 
  // unary operators
  val UNARY_PREFIX: N = "unary_"

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -183,7 +183,7 @@ object Types {
  case _ => false
  }
 
- /** Is this type a (possibly refined or applied or aliased) type reference
+ /** Is this type a (possibly refined, applied, aliased or annotated) type reference
  * to the given type symbol?
  * @sym The symbol to compare to. It must be a class symbol or abstract type.
  * It makes no sense for it to be an alias type because isRef would always
@@ -204,9 +204,7 @@ object Types {
  case this1: TypeVar =>
  this1.instanceOpt.isRef(sym, skipRefined)
  case this1: AnnotatedType =>
- this1 match
- case CapturingType(_, _, _) => false
- case _ => this1.parent.isRef(sym, skipRefined)
+ this1.parent.isRef(sym, skipRefined)
  case _ => false
  }
 

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

@@ -1363,47 +1363,56 @@ object Parsers {
  * | InfixType
  * | CaptureSet Type
  * FunType ::= (MonoFunType | PolyFunType)
- * MonoFunType ::= FunTypeArgs (‘=>’ | ‘?=>’) Type
- * PolyFunType ::= HKTypeParamClause '=>' Type
+ * MonoFunType ::= FunTypeArgs (‘=>’ | ‘?=>’ | ‘->’ | ‘?->’ ) Type
+ * PolyFunType ::= HKTypeParamClause ('=>' | ‘->’_) Type
  * FunTypeArgs ::= InfixType
  * | `(' [ [ ‘[using]’ ‘['erased'] FunArgType {`,' FunArgType } ] `)'
  * | '(' [ ‘[using]’ ‘['erased'] TypedFunParam {',' TypedFunParam } ')'
  * CaptureSet ::= `{` CaptureRef {`,` CaptureRef} `}`
  * CaptureRef ::= Ident
  */
- def typ(): Tree = {
+ def typ(): Tree =
  val start = in.offset
  var imods = Modifiers()
  def functionRest(params: List[Tree]): Tree =
  val paramSpan = Span(start, in.lastOffset)
  atSpan(start, in.offset) {
- if in.token == TLARROW then
+ var token = in.token
+ if in.isIdent(nme.PUREARROW) then
+ token = ARROW
+ else if in.isIdent(nme.PURECTXARROW) then
+ token = CTXARROW
+ else if token == TLARROW then
  if !imods.flags.isEmpty || params.isEmpty then
  syntaxError(em"illegal parameter list for type lambda", start)
- in.token = ARROW
- else
- for case ValDef(_, tpt: ByNameTypeTree, _) <- params do
- syntaxError(em"parameter of type lambda may not be call-by-name", tpt.span)
- in.nextToken()
- return TermLambdaTypeTree(params.asInstanceOf[List[ValDef]], typ())
+ token = ARROW
+ else if ctx.settings.Ycc.value then
+ // `=>` means impure function under -Ycc whereas `->` is a regular function.
+ // Without -Ycc they both mean regular function.
+ imods |= Impure
 
- if in.token == CTXARROW then
+ if token == CTXARROW then
  in.nextToken()
  imods |= Given
+ else if token == ARROW || token == TLARROW then
+ in.nextToken()
  else
  accept(ARROW)
- val t = typ()
 
- if imods.isOneOf(Given | Erased) then
+ val resultType = typ()
+ if token == TLARROW then
+ for case ValDef(_, tpt: ByNameTypeTree, _) <- params do
+ syntaxError(em"parameter of type lambda may not be call-by-name", tpt.span)
+ TermLambdaTypeTree(params.asInstanceOf[List[ValDef]], resultType)
+ else if imods.isOneOf(Given | Erased | Impure) then
  if imods.is(Given) && params.isEmpty then
  syntaxError("context function types require at least one parameter", paramSpan)
- new FunctionWithMods(params, t, imods)
+ FunctionWithMods(params, resultType, imods)
  else if !ctx.settings.YkindProjector.isDefault then
- val (newParams :+ newT, tparams) = replaceKindProjectorPlaceholders(params :+ t)
-
- lambdaAbstract(tparams, Function(newParams, newT))
+ val (newParams :+ newResultType, tparams) = replaceKindProjectorPlaceholders(params :+ resultType)
+ lambdaAbstract(tparams, Function(newParams, newResultType))
  else
- Function(params, t)
+ Function(params, resultType)
  }
  def funTypeArgsRest(first: Tree, following: () => Tree) = {
  val buf = new ListBuffer[Tree] += first
@@ -1461,7 +1470,7 @@ object Parsers {
  val tparams = typeParamClause(ParamOwner.TypeParam)
  if (in.token == TLARROW)
  atSpan(start, in.skipToken())(LambdaTypeTree(tparams, toplevelTyp()))
- else if (in.token == ARROW) {
+ else if (in.token == ARROW || in.isIdent(nme.PUREARROW)) {
  val arrowOffset = in.skipToken()
  val body = toplevelTyp()
  atSpan(start, arrowOffset) {
@@ -1482,16 +1491,18 @@ object Parsers {
  else if (in.token == INDENT) enclosed(INDENT, typ())
  else infixType()
 
- in.token match {
+ in.token match
  case ARROW | CTXARROW => functionRest(t :: Nil)
  case MATCH => matchType(t)
  case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
  case _ =>
- if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
- syntaxError(ErasedTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
- t
- }
- }
+ if isIdent(nme.PUREARROW) || isIdent(nme.PURECTXARROW) then
+ functionRest(t :: Nil)
+ else
+ if (imods.is(Erased) && !t.isInstanceOf[FunctionWithMods])
+ syntaxError(ErasedTypesCanOnlyBeFunctionTypes(), implicitKwPos(start))
+ t
+ end typ
 
  private def makeKindProjectorTypeDef(name: TypeName): TypeDef = {
  val isVarianceAnnotated = name.startsWith("+") || name.startsWith("-")
@@ -1549,7 +1560,7 @@ object Parsers {
  def infixTypeRest(t: Tree): Tree =
  infixOps(t, canStartInfixTypeTokens, refinedTypeFn, Location.ElseWhere,
  isType = true,
- isOperator = !followingIsVararg())
+ isOperator = !followingIsVararg() && !isIdent(nme.PUREARROW) && !isIdent(nme.PURECTXARROW))
 
  /** RefinedType ::= WithType {[nl] Refinement}
  */

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

@@ -138,14 +138,14 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  else simpleNameString(tsym)
  }
 
- private def arrow(isGiven: Boolean): String =
- if isGiven then "?=>" else "=>"
+ private def arrow(isGiven: Boolean, isPure: Boolean): String =
+ (if isGiven then "?" else "") + (if isPure then "->" else "=>")
 
  override def toText(tp: Type): Text = controlled {
  def toTextTuple(args: List[Type]): Text =
  "(" ~ argsText(args) ~ ")"
 
- def toTextFunction(args: List[Type], isGiven: Boolean, isErased: Boolean): Text =
+ def toTextFunction(args: List[Type], isGiven: Boolean, isErased: Boolean, isPure: Boolean): Text =
  changePrec(GlobalPrec) {
  val argStr: Text =
  if args.length == 2
@@ -158,26 +158,26 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  ~ keywordText("erased ").provided(isErased)
  ~ argsText(args.init)
  ~ ")"
- argStr ~ " " ~ arrow(isGiven) ~ " " ~ argText(args.last)
+ argStr ~ " " ~ arrow(isGiven, isPure) ~ " " ~ argText(args.last)
  }
 
- def toTextMethodAsFunction(info: Type): Text = info match
+ def toTextMethodAsFunction(info: Type, isPure: Boolean): Text = info match
  case info: MethodType =>
  changePrec(GlobalPrec) {
  "("
  ~ keywordText("erased ").provided(info.isErasedMethod)
  ~ paramsText(info)
  ~ ") "
- ~ arrow(info.isImplicitMethod)
+ ~ arrow(info.isImplicitMethod, isPure)
  ~ " "
- ~ toTextMethodAsFunction(info.resultType)
+ ~ toTextMethodAsFunction(info.resultType, isPure)
  }
  case info: PolyType =>
  changePrec(GlobalPrec) {
  "["
  ~ paramsText(info)
  ~ "] => "
- ~ toTextMethodAsFunction(info.resultType)
+ ~ toTextMethodAsFunction(info.resultType, isPure)
  }
  case _ =>
  toText(info)
@@ -216,9 +216,11 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
 
  def appliedText(tp: Type): Text = tp match
  case tp @ AppliedType(tycon, args) =>
- val cls = tycon.typeSymbol
+ val tsym = tycon.typeSymbol
  if tycon.isRepeatedParam then toTextLocal(args.head) ~ "*"
- else if defn.isFunctionClass(cls) then toTextFunction(args, cls.name.isContextFunction, cls.name.isErasedFunction)
+ else if defn.isFunctionSymbol(tsym) then
+ toTextFunction(args, tsym.name.isContextFunction, tsym.name.isErasedFunction,
+ isPure = ctx.settings.Ycc.value && !tsym.name.isImpureFunction)
  else if tp.tupleArity >= 2 && !printDebug then toTextTuple(tp.tupleElementTypes)
  else if isInfixType(tp) then
  val l :: r :: Nil = args
@@ -245,7 +247,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  // don't eta contract if the application would be printed specially
  toText(tycon)
  case tp: RefinedType if defn.isFunctionOrPolyType(tp) && !printDebug =>
- toTextMethodAsFunction(tp.refinedInfo)
+ toTextMethodAsFunction(tp.refinedInfo,
+ isPure = ctx.settings.Ycc.value && !tp.typeSymbol.name.isImpureFunction)
  case tp: TypeRef =>
  if (tp.symbol.isAnonymousClass && !showUniqueIds)
  toText(tp.info)
@@ -261,7 +264,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  case tp: ClassInfo =>
  if tp.cls.derivesFrom(defn.PolyFunctionClass) then
  tp.member(nme.apply).info match
- case info: PolyType => return toTextMethodAsFunction(info)
+ case info: PolyType => return toTextMethodAsFunction(info, isPure = false)
  case _ =>
  toTextParents(tp.parents) ~~ "{...}"
  case JavaArrayType(elemtp) =>
@@ -529,7 +532,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  changePrec(OrTypePrec) { toText(args(0)) ~ " | " ~ atPrec(OrTypePrec + 1) { toText(args(1)) } }
  else if (tpt.symbol == defn.andType && args.length == 2)
  changePrec(AndTypePrec) { toText(args(0)) ~ " & " ~ atPrec(AndTypePrec + 1) { toText(args(1)) } }
- else if defn.isFunctionClass(tpt.symbol)
+ else if defn.isFunctionSymbol(tpt.symbol)
  && tpt.isInstanceOf[TypeTree] && tree.hasType && !printDebug
  then changePrec(GlobalPrec) { toText(tree.typeOpt) }
  else args match
@@ -657,7 +660,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
  ~ Text(args.map(argToText), ", ")
  ~ ")"
  }
- argsText ~ " " ~ arrow(isGiven) ~ " " ~ toText(body)
+ val isPure =
+ ctx.settings.Ycc.value
+ && tree.match
+ case tree: FunctionWithMods => !tree.mods.is(Impure)
+ case _ => true
+ argsText ~ " " ~ arrow(isGiven, isPure) ~ " " ~ toText(body)
  case PolyFunction(targs, body) =>
  val targsText = "[" ~ Text(targs.map((arg: Tree) => toText(arg)), ", ") ~ "]"
  changePrec(GlobalPrec) {

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

@@ -1238,7 +1238,8 @@ class Typer extends Namer
  val numArgs = args.length
  val isContextual = funFlags.is(Given)
  val isErased = funFlags.is(Erased)
- val funCls = defn.FunctionSymbol(numArgs, isContextual, isErased)
+ val isImpure = funFlags.is(Impure)
+ val funSym = defn.FunctionSymbol(numArgs, isContextual, isErased, isImpure)
 
  /** If `app` is a function type with arguments that are all erased classes,
  * turn it into an erased function type.
@@ -1248,7 +1249,7 @@ class Typer extends Namer
  if !isErased
  && numArgs > 0
  && args.indexWhere(!_.tpe.isErasedClass) == numArgs =>
- val tycon1 = TypeTree(defn.FunctionSymbol(numArgs, isContextual, isErased = true).typeRef)
+ val tycon1 = TypeTree(defn.FunctionSymbol(numArgs, isContextual, true, isImpure).typeRef)
  .withSpan(tycon.span)
  assignType(cpy.AppliedTypeTree(app)(tycon1, args), tycon1, args)
  case _ =>
@@ -1275,7 +1276,7 @@ class Typer extends Namer
  report.error(i"$mt is an illegal function type because it has inter-parameter dependencies", tree.srcPos)
  val resTpt = TypeTree(mt.nonDependentResultApprox).withSpan(body.span)
  val typeArgs = appDef.termParamss.head.map(_.tpt) :+ resTpt
- val tycon = TypeTree(funCls.typeRef)
+ val tycon = TypeTree(funSym.typeRef)
  val core = propagateErased(AppliedTypeTree(tycon, typeArgs))
  RefinedTypeTree(core, List(appDef), ctx.owner.asClass)
  end typedDependent
@@ -1286,7 +1287,7 @@ class Typer extends Namer
  using ctx.fresh.setOwner(newRefinedClassSymbol(tree.span)).setNewScope)
  case _ =>
  propagateErased(
- typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funCls.typeRef), args :+ body), pt))
+ typed(cpy.AppliedTypeTree(tree)(untpd.TypeTree(funSym.typeRef), args :+ body), pt))
  }
  }
 

tests/neg-custom-args/capt-wf.scala

@@ -8,7 +8,7 @@ def test(c: Cap, other: String): Unit =
  val x2: {other} C = ??? // error: cs is empty
  val s1 = () => "abc"
  val x3: {s1} C = ??? // error: cs is empty
- val x3a: () => String = s1
+ val x3a: () -> String = s1
  val s2 = () => if x1 == null then "" else "abc"
  val x4: {s2} C = ??? // OK
  val x5: {c, c} C = ??? // error: redundant
@@ -26,8 +26,8 @@ def test(c: Cap, other: String): Unit =
  val y1: {e1} String = ??? // error cs is empty
  val y2: {o1} String = ??? // error cs is empty
 
- lazy val ev: (Int => Boolean) = (n: Int) =>
- lazy val od: (Int => Boolean) = (n: Int) =>
+ lazy val ev: (Int -> Boolean) = (n: Int) =>
+ lazy val od: (Int -> Boolean) = (n: Int) =>
  if n == 1 then true else ev(n - 1)
  if n == 0 then true else od(n - 1)
  val y3: {ev} String = ??? // error cs is empty