diff --git a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
index 18a7a88e0b24..4a413a436559 100644
--- a/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
+++ b/compiler/src/dotty/tools/backend/sjs/JSCodeGen.scala
@@ -2270,9 +2270,9 @@ class JSCodeGen()(implicit ctx: Context) {
     if (sym == defn.BoxedUnit_UNIT) {
       js.Undefined()
     } else {
-      val instance = genLoadModule(sym.owner)
+      val inst = genLoadModule(sym.owner)
       val method = encodeStaticMemberSym(sym)
-      js.Apply(instance, method, Nil)(toIRType(sym.info))
+      js.Apply(inst, method, Nil)(toIRType(sym.info))
     }
   }
 
diff --git a/compiler/src/dotty/tools/dotc/ast/Desugar.scala b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
index 493a515d1acc..695795c878db 100644
--- a/compiler/src/dotty/tools/dotc/ast/Desugar.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Desugar.scala
@@ -163,11 +163,11 @@ object desugar {
     else vdef
   }
 
-  def makeImplicitParameters(tpts: List[Tree], forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
+  def makeImplicitParameters(tpts: List[Tree], contextualFlag: FlagSet = EmptyFlags, forPrimaryConstructor: Boolean = false)(implicit ctx: Context): List[ValDef] =
     for (tpt <- tpts) yield {
        val paramFlags: FlagSet = if (forPrimaryConstructor) PrivateLocalParamAccessor else Param
        val epname = EvidenceParamName.fresh()
-       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit)
+       ValDef(epname, tpt, EmptyTree).withFlags(paramFlags | Implicit | contextualFlag)
     }
 
   /** 1. Expand context bounds to evidence params. E.g.,
@@ -197,12 +197,13 @@ object desugar {
    *      inline def f(x: Boolean): Any = (if (x) 1 else ""): Any
    */
   private def defDef(meth: DefDef, isPrimaryConstructor: Boolean = false)(implicit ctx: Context): Tree = {
-    val DefDef(name, tparams, vparamss, tpt, rhs) = meth
+    val DefDef(_, tparams, vparamss, tpt, rhs) = meth
+    val methName = normalizeName(meth, tpt).asTermName
     val mods = meth.mods
     val epbuf = new ListBuffer[ValDef]
     def desugarContextBounds(rhs: Tree): Tree = rhs match {
       case ContextBounds(tbounds, cxbounds) =>
-        epbuf ++= makeImplicitParameters(cxbounds, isPrimaryConstructor)
+        epbuf ++= makeImplicitParameters(cxbounds, forPrimaryConstructor = isPrimaryConstructor)
         tbounds
       case LambdaTypeTree(tparams, body) =>
         cpy.LambdaTypeTree(rhs)(tparams, desugarContextBounds(body))
@@ -213,7 +214,8 @@ object desugar {
       cpy.TypeDef(tparam)(rhs = desugarContextBounds(tparam.rhs))
     }
 
-    var meth1 = addEvidenceParams(cpy.DefDef(meth)(tparams = tparams1), epbuf.toList)
+    var meth1 = addEvidenceParams(
+      cpy.DefDef(meth)(name = methName, tparams = tparams1), epbuf.toList)
 
     if (meth1.mods.is(Inline))
       meth1.tpt match {
@@ -245,7 +247,7 @@ object desugar {
       case (vparam :: vparams) :: vparamss1 =>
         def defaultGetter: DefDef =
           DefDef(
-            name = DefaultGetterName(meth.name, n),
+            name = DefaultGetterName(methName, n),
             tparams = meth.tparams.map(tparam => dropContextBound(toDefParam(tparam))),
             vparamss = takeUpTo(normalizedVparamss.nestedMap(toDefParam), n),
             tpt = TypeTree(),
@@ -302,8 +304,8 @@ object desugar {
 
   /** The expansion of a class definition. See inline comments for what is involved */
   def classDef(cdef: TypeDef)(implicit ctx: Context): Tree = {
-    val className = checkNotReservedName(cdef).asTypeName
-    val impl @ Template(_, _, self, _) = cdef.rhs
+    val impl @ Template(constr0, _, self, _) = cdef.rhs
+    val className = normalizeName(cdef, impl).asTypeName
     val parents = impl.parents
     val mods = cdef.mods
     val companionMods = mods
@@ -341,6 +343,7 @@ object desugar {
     val isCaseClass  = mods.is(Case) && !mods.is(Module)
     val isCaseObject = mods.is(Case) && mods.is(Module)
     val isImplicit = mods.is(Implicit)
+    val isInstance = isImplicit && mods.mods.exists(_.isInstanceOf[Mod.Instance])
     val isEnum = mods.isEnumClass && !mods.is(Module)
     def isEnumCase = mods.isEnumCase
     val isValueClass = parents.nonEmpty && isAnyVal(parents.head)
@@ -445,7 +448,15 @@ object desugar {
       }
 
     // new C[Ts](paramss)
-    lazy val creatorExpr = New(classTypeRef, constrVparamss nestedMap refOfDef)
+    lazy val creatorExpr = {
+      val vparamss = constrVparamss match {
+        case (vparam :: _) :: _ if vparam.mods.is(Implicit) => // add a leading () to match class parameters
+          Nil :: constrVparamss
+        case _ =>
+          constrVparamss
+      }
+      New(classTypeRef, vparamss.nestedMap(refOfDef))
+    }
 
     val copiedAccessFlags = if (ctx.scala2Setting) EmptyFlags else AccessFlags
 
@@ -660,16 +671,23 @@ object desugar {
         ctx.error(ImplicitCaseClass(cdef), cdef.sourcePos)
         Nil
       }
-      else if (arity != 1) {
+      else if (arity != 1 && !isInstance) {
         ctx.error(ImplicitClassPrimaryConstructorArity(), cdef.sourcePos)
         Nil
       }
-      else
+      else {
+        val defParamss = constrVparamss match {
+          case Nil :: paramss =>
+            paramss // drop leading () that got inserted by class
+                    // TODO: drop this once we do not silently insert empty class parameters anymore
+          case paramss => paramss
+        }
         // implicit wrapper is typechecked in same scope as constructor, so
         // we can reuse the constructor parameters; no derived params are needed.
-        DefDef(className.toTermName, constrTparams, constrVparamss, classTypeRef, creatorExpr)
-          .withMods(companionMods | Synthetic | Implicit)
+        DefDef(className.toTermName, constrTparams, defParamss, classTypeRef, creatorExpr)
+          .withMods(companionMods | Synthetic | Implicit | Final)
           .withSpan(cdef.span) :: Nil
+      }
 
     val self1 = {
       val selfType = if (self.tpt.isEmpty) classTypeRef else self.tpt
@@ -713,9 +731,9 @@ object desugar {
    *    <module> final class name$ extends parents { self: name.type => body }
    */
   def moduleDef(mdef: ModuleDef)(implicit ctx: Context): Tree = {
-    val moduleName = checkNotReservedName(mdef).asTermName
     val impl = mdef.impl
     val mods = mdef.mods
+    val moduleName = normalizeName(mdef, impl).asTermName
     def isEnumCase = mods.isEnumCase
 
     def flagSourcePos(flag: FlagSet) = mods.mods.find(_.flags == flag).fold(mdef.sourcePos)(_.sourcePos)
@@ -793,19 +811,69 @@ object desugar {
       Thicket(aliasType :: companions.toList)
     }
 
-  /** The name of `mdef`, after checking that it does not redefine a Scala core class.
-   *  If it does redefine, issue an error and return a mangled name instead of the original one.
+  /** The normalized name of `mdef`. This means
+   *   1. Check that the name does not redefine a Scala core class.
+   *      If it does redefine, issue an error and return a mangled name instead of the original one.
+   *   2. If the name is missing (this can be the case for instance definitions), invent one instead.
    */
-  def checkNotReservedName(mdef: MemberDef)(implicit ctx: Context): Name = {
-    val name = mdef.name
+  def normalizeName(mdef: MemberDef, impl: Tree)(implicit ctx: Context): Name = {
+    var name = mdef.name
+    if (name.isEmpty) name = name.likeSpaced(s"${inventName(impl)}_instance".toTermName)
     if (ctx.owner == defn.ScalaPackageClass && defn.reservedScalaClassNames.contains(name.toTypeName)) {
       def kind = if (name.isTypeName) "class" else "object"
       ctx.error(em"illegal redefinition of standard $kind $name", mdef.sourcePos)
-      name.errorName
+      name = name.errorName
     }
-    else name
+    name
   }
 
+  /** Invent a name for an anonymous instance with template `impl`.
+   */
+  private def inventName(impl: Tree)(implicit ctx: Context): String = impl match {
+    case impl: Template =>
+      if (impl.parents.isEmpty)
+        impl.body.find {
+          case dd: DefDef if dd.mods.is(Extension) => true
+          case _ => false
+        } match {
+          case Some(DefDef(name, _, (vparam :: _) :: _, _, _)) =>
+            s"${name}_of_${inventTypeName(vparam.tpt)}"
+          case _ =>
+            ctx.error(i"anonymous instance must have `for` part or must define at least one extension method", impl.sourcePos)
+            nme.ERROR.toString
+        }
+      else
+        impl.parents.map(inventTypeName(_)).mkString("_")
+    case impl: Tree =>
+      inventTypeName(impl)
+  }
+
+  private class NameExtractor(followArgs: Boolean) extends UntypedTreeAccumulator[String] {
+    private def extractArgs(args: List[Tree])(implicit ctx: Context): String =
+      args.map(argNameExtractor.apply("", _)).mkString("_")
+    override def apply(x: String, tree: Tree)(implicit ctx: Context): String =
+      if (x.isEmpty)
+        tree match {
+          case Select(pre, nme.CONSTRUCTOR) => foldOver(x, pre)
+          case tree: RefTree if tree.name.isTypeName => tree.name.toString
+          case tree: TypeDef => tree.name.toString
+          case tree: AppliedTypeTree if followArgs && tree.args.nonEmpty =>
+            s"${apply(x, tree.tpt)}_${extractArgs(tree.args)}"
+          case tree: LambdaTypeTree =>
+            apply(x, tree.body)
+          case tree: Tuple =>
+            if (followArgs) extractArgs(tree.trees) else "Tuple"
+          case tree: Function if tree.args.nonEmpty =>
+            if (followArgs) s"${extractArgs(tree.args)}_to_${apply("", tree.body)}" else "Function"
+          case _ => foldOver(x, tree)
+        }
+      else x
+  }
+  private val typeNameExtractor = new NameExtractor(followArgs = true)
+  private val argNameExtractor = new NameExtractor(followArgs = false)
+
+  private def inventTypeName(tree: Tree)(implicit ctx: Context): String = typeNameExtractor("", tree)
+
   /**     val p1, ..., pN: T = E
    *  ==>
    *      makePatDef[[val p1: T1 = E]]; ...; makePatDef[[val pN: TN = E]]
@@ -960,14 +1028,11 @@ object desugar {
    *      def $anonfun(params) = body
    *      Closure($anonfun)
    */
-  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = null, isImplicit: Boolean)(implicit ctx: Context): Block = {
-    val span = params.headOption.fold(body.span)(_.span.union(body.span))
+  def makeClosure(params: List[ValDef], body: Tree, tpt: Tree = null, isContextual: Boolean)(implicit ctx: Context): Block =
     Block(
       DefDef(nme.ANON_FUN, Nil, params :: Nil, if (tpt == null) TypeTree() else tpt, body)
-        .withSpan(span)
         .withMods(synthetic | Artifact),
-      Closure(Nil, Ident(nme.ANON_FUN), if (isImplicit) ImplicitEmptyTree else EmptyTree)).withSpan(span)
-  }
+      Closure(Nil, Ident(nme.ANON_FUN), if (isContextual) ContextualEmptyTree else EmptyTree))
 
   /** If `nparams` == 1, expand partial function
    *
@@ -1020,9 +1085,9 @@ object desugar {
     Function(param :: Nil, Block(vdefs, body))
   }
 
-  def makeImplicitFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
-    val params = makeImplicitParameters(formals.map(TypeTree))
-    new FunctionWithMods(params, body, Modifiers(Implicit))
+  def makeContextualFunction(formals: List[Type], body: Tree)(implicit ctx: Context): Tree = {
+    val params = makeImplicitParameters(formals.map(TypeTree), Contextual)
+    new FunctionWithMods(params, body, Modifiers(Implicit | Contextual))
   }
 
   /** Add annotation to tree:
diff --git a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
index 0ab4a727135c..c10adfbc5cbf 100644
--- a/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
+++ b/compiler/src/dotty/tools/dotc/ast/TreeInfo.scala
@@ -330,15 +330,15 @@ trait UntypedTreeInfo extends TreeInfo[Untyped] { self: Trees.Instance[Untyped]
     functionWithUnknownParamType(tree).isDefined
 
   /** Is `tree` an implicit function or closure, possibly nested in a block? */
-  def isImplicitClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
-    case tree: FunctionWithMods => tree.mods.is(Implicit)
-    case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Implicit)
+  def isContextualClosure(tree: Tree)(implicit ctx: Context): Boolean = unsplice(tree) match {
+    case tree: FunctionWithMods => tree.mods.is(Contextual)
+    case Function((param: untpd.ValDef) :: _, _) => param.mods.is(Contextual)
     case Closure(_, meth, _) => true
-    case Block(Nil, expr) => isImplicitClosure(expr)
+    case Block(Nil, expr) => isContextualClosure(expr)
     case Block(DefDef(nme.ANON_FUN, _, params :: _, _, _) :: Nil, cl: Closure) =>
       params match {
-        case param :: _ => param.mods.is(Implicit)
-        case Nil => cl.tpt.eq(untpd.ImplicitEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
+        case param :: _ => param.mods.is(Contextual)
+        case Nil => cl.tpt.eq(untpd.ContextualEmptyTree) || defn.isImplicitFunctionType(cl.tpt.typeOpt)
       }
     case _ => false
   }
diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index d4adec6800e3..6cc697bfb5d6 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -430,6 +430,8 @@ object Trees {
   case class Apply[-T >: Untyped] private[ast] (fun: Tree[T], args: List[Tree[T]])(implicit @constructorOnly src: SourceFile)
     extends GenericApply[T] {
     type ThisTree[-T >: Untyped] = Apply[T]
+
+    def isContextual = getAttachment(untpd.WithApply).nonEmpty
   }
 
   /** fun[args] */
@@ -951,7 +953,7 @@ object Trees {
 
     @sharable val EmptyTree: Thicket = genericEmptyTree
     @sharable val EmptyValDef: ValDef = genericEmptyValDef
-    @sharable val ImplicitEmptyTree: Thicket = new EmptyTree // an empty tree marking an implicit closure
+    @sharable val ContextualEmptyTree: Thicket = new EmptyTree // an empty tree marking a contextual closure
 
     // ----- Auxiliary creation methods ------------------
 
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 0e577a5ac774..e0cddaa25f07 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -233,7 +233,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
         val previousParamRefs = if (isParamDependent) new mutable.ListBuffer[TermRef]() else null
 
         def valueParam(name: TermName, origInfo: Type): TermSymbol = {
-          val maybeImplicit = if (tp.isImplicitMethod) Implicit else EmptyFlags
+          val maybeImplicit =
+            if (tp.isContextual) Implicit | Contextual
+            else if (tp.isImplicitMethod) Implicit
+            else EmptyFlags
           val maybeErased = if (tp.isErasedMethod) Erased else EmptyFlags
 
           def makeSym(info: Type) = ctx.newSymbol(sym, name, TermParam | maybeImplicit | maybeErased, info, coord = sym.coord)
@@ -1039,9 +1042,10 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
   }
 
-  def applyOverloaded(receiver: Tree, method: TermName, args: List[Tree], targs: List[Type], expectedType: Type)(implicit ctx: Context): Tree = {
+  def applyOverloaded(receiver: Tree, method: TermName, args: List[Tree], targs: List[Type],
+                      expectedType: Type, isContextual: Boolean = false)(implicit ctx: Context): Tree = {
     val typer = ctx.typer
-    val proto = new FunProtoTyped(args, expectedType)(typer)
+    val proto = new FunProtoTyped(args, expectedType)(typer, isContextual)
     val denot = receiver.tpe.member(method)
     assert(denot.exists, i"no member $receiver . $method, members = ${receiver.tpe.decls}")
     val selected =
diff --git a/compiler/src/dotty/tools/dotc/ast/untpd.scala b/compiler/src/dotty/tools/dotc/ast/untpd.scala
index ea562d3d77cb..428c74c85960 100644
--- a/compiler/src/dotty/tools/dotc/ast/untpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/untpd.scala
@@ -68,7 +68,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     override def isType: Boolean = body.isType
   }
 
-  /** A function type with `implicit` or `erased` modifiers */
+  /** A function type with `implicit`, `erased`, or `contextual` modifiers */
   class FunctionWithMods(args: List[Tree], body: Tree, val mods: Modifiers)(implicit @constructorOnly src: SourceFile)
     extends Function(args, body)
 
@@ -149,6 +149,8 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     case class Inline()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Inline)
 
     case class Enum()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Enum)
+
+    case class Instance()(implicit @constructorOnly src: SourceFile) extends Mod(Flags.Implicit)
   }
 
   /** Modifiers and annotations for definitions
@@ -213,6 +215,7 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
     def hasFlags: Boolean = flags != EmptyFlags
     def hasAnnotations: Boolean = annotations.nonEmpty
     def hasPrivateWithin: Boolean = privateWithin != tpnme.EMPTY
+    def hasMod(cls: Class[_]) = mods.exists(_.getClass == cls)
 
     private def isEnum = is(Enum, butNot = JavaDefined)
 
@@ -269,6 +272,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
    */
   val OriginalSymbol: Property.Key[Symbol] = new Property.Key
 
+  /** Property key for contextual Apply trees of the form `fn with arg` */
+  val WithApply: Property.StickyKey[Unit] = new Property.StickyKey
+
   // ------ Creation methods for untyped only -----------------
 
   def Ident(name: Name)(implicit src: SourceFile): Ident = new Ident(name)
@@ -398,9 +404,9 @@ object untpd extends Trees.Instance[Untyped] with UntypedTreeInfo {
   def makeParameter(pname: TermName, tpe: Tree, mods: Modifiers = EmptyModifiers)(implicit ctx: Context): ValDef =
     ValDef(pname, tpe, EmptyTree).withMods(mods | Param)
 
-  def makeSyntheticParameter(n: Int = 1, tpt: Tree = null)(implicit ctx: Context): ValDef =
+  def makeSyntheticParameter(n: Int = 1, tpt: Tree = null, flags: FlagSet = EmptyFlags)(implicit ctx: Context): ValDef =
     ValDef(nme.syntheticParamName(n), if (tpt == null) TypeTree() else tpt, EmptyTree)
-      .withFlags(SyntheticTermParam)
+      .withFlags(flags | SyntheticTermParam)
 
   def lambdaAbstract(tparams: List[TypeDef], tpt: Tree)(implicit ctx: Context): Tree =
     if (tparams.isEmpty) tpt else LambdaTypeTree(tparams, tpt)
diff --git a/compiler/src/dotty/tools/dotc/config/Printers.scala b/compiler/src/dotty/tools/dotc/config/Printers.scala
index cf10ab175937..27df2dfac103 100644
--- a/compiler/src/dotty/tools/dotc/config/Printers.scala
+++ b/compiler/src/dotty/tools/dotc/config/Printers.scala
@@ -17,7 +17,7 @@ object Printers {
   val checks: Printer = noPrinter
   val config: Printer = noPrinter
   val cyclicErrors: Printer = noPrinter
-  val debug = noPrinter
+  val debug = noPrinter             // no type annotion here to force inlining
   val derive: Printer = noPrinter
   val dottydoc: Printer = noPrinter
   val exhaustivity: Printer = noPrinter
diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 30f89c5c44d1..5bd447bfb590 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -99,8 +99,8 @@ class Definitions {
    *
    *  ImplicitFunctionN traits follow this template:
    *
-   *      trait ImplicitFunctionN[T0,...,T{N-1}, R] extends Object with FunctionN[T0,...,T{N-1}, R] {
-   *        def apply(implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      trait ImplicitFunctionN[T0,...,T{N-1}, R] extends Object {
+   *        def apply with ($x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    *
    *  ErasedFunctionN traits follow this template:
@@ -111,8 +111,8 @@ class Definitions {
    *
    *  ErasedImplicitFunctionN traits follow this template:
    *
-   *      trait ErasedImplicitFunctionN[T0,...,T{N-1}, R] extends Object with ErasedFunctionN[T0,...,T{N-1}, R] {
-   *        def apply(erased implicit $x0: T0, ..., $x{N_1}: T{N-1}): R
+   *      trait ErasedImplicitFunctionN[T0,...,T{N-1}, R] extends Object {
+   *        def apply with (erased $x0: T0, ..., $x{N_1}: T{N-1}): R
    *      }
    *
    *  ErasedFunctionN and ErasedImplicitFunctionN erase to Function0.
@@ -128,13 +128,14 @@ class Definitions {
           enterTypeParam(cls, paramNamePrefix ++ "T" ++ (i + 1).toString, Contravariant, decls).typeRef
         }
         val resParamRef = enterTypeParam(cls, paramNamePrefix ++ "R", Covariant, decls).typeRef
-        val methodType = MethodType.maker(isJava = false, name.isImplicitFunction, name.isErasedFunction)
-        val parentTraits =
-          if (!name.isImplicitFunction) Nil
-          else FunctionType(arity, isErased = name.isErasedFunction).appliedTo(argParamRefs ::: resParamRef :: Nil) :: Nil
+        val methodType = MethodType.maker(
+          isJava = false,
+          isImplicit = name.isImplicitFunction,
+          isContextual = name.isImplicitFunction,
+          isErased = name.isErasedFunction)
         decls.enter(newMethod(cls, nme.apply, methodType(argParamRefs, resParamRef), Deferred))
         denot.info =
-          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: parentTraits, decls)
+          ClassInfo(ScalaPackageClass.thisType, cls, ObjectType :: Nil, decls)
       }
     }
     newClassSymbol(ScalaPackageClass, name, Trait | NoInits, completer)
@@ -388,9 +389,6 @@ class Definitions {
 
   def DottyPredefModule(implicit ctx: Context): Symbol = DottyPredefModuleRef.symbol
 
-    lazy val Predef_ImplicitConverterR: TypeRef = DottyPredefModule.requiredClass("ImplicitConverter").typeRef
-    def Predef_ImplicitConverter(implicit ctx: Context): Symbol = Predef_ImplicitConverterR.symbol
-
   lazy val DottyArraysModuleRef: TermRef = ctx.requiredModuleRef("dotty.runtime.Arrays")
   def DottyArraysModule(implicit ctx: Context): Symbol = DottyArraysModuleRef.symbol
     def newGenericArrayMethod(implicit ctx: Context): TermSymbol = DottyArraysModule.requiredMethod("newGenericArray")
@@ -591,6 +589,8 @@ class Definitions {
   def StringBuilderClass(implicit ctx: Context): ClassSymbol = StringBuilderType.symbol.asClass
   lazy val MatchErrorType: TypeRef         = ctx.requiredClassRef("scala.MatchError")
   def MatchErrorClass(implicit ctx: Context): ClassSymbol = MatchErrorType.symbol.asClass
+  lazy val ConversionType: TypeRef = ctx.requiredClass("scala.Conversion").typeRef
+  def ConversionClass(implicit ctx: Context): ClassSymbol = ConversionType.symbol.asClass
 
   lazy val StringAddType: TypeRef          = ctx.requiredClassRef("scala.runtime.StringAdd")
   def StringAddClass(implicit ctx: Context): ClassSymbol = StringAddType.symbol.asClass
@@ -860,8 +860,8 @@ class Definitions {
     sym.owner.linkedClass.typeRef
 
   object FunctionOf {
-    def apply(args: List[Type], resultType: Type, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Type =
-      FunctionType(args.length, isImplicit, isErased).appliedTo(args ::: resultType :: Nil)
+    def apply(args: List[Type], resultType: Type, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Type =
+      FunctionType(args.length, isContextual, isErased).appliedTo(args ::: resultType :: Nil)
     def unapply(ft: Type)(implicit ctx: Context): Option[(List[Type], Type, Boolean, Boolean)] = {
       val tsym = ft.typeSymbol
       if (isFunctionClass(tsym)) {
@@ -949,10 +949,10 @@ class Definitions {
 
   lazy val TupleType: Array[TypeRef] = mkArityArray("scala.Tuple", MaxTupleArity, 1)
 
-  def FunctionClass(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Symbol =
-    if (isImplicit && isErased)
+  def FunctionClass(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): Symbol =
+    if (isContextual && isErased)
       ctx.requiredClass("scala.ErasedImplicitFunction" + n.toString)
-    else if (isImplicit)
+    else if (isContextual)
       ctx.requiredClass("scala.ImplicitFunction" + n.toString)
     else if (isErased)
       ctx.requiredClass("scala.ErasedFunction" + n.toString)
@@ -964,9 +964,9 @@ class Definitions {
     lazy val Function0_applyR: TermRef = ImplementedFunctionType(0).symbol.requiredMethodRef(nme.apply)
     def Function0_apply(implicit ctx: Context): Symbol = Function0_applyR.symbol
 
-  def FunctionType(n: Int, isImplicit: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): TypeRef =
-    if (n <= MaxImplementedFunctionArity && (!isImplicit || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
-    else FunctionClass(n, isImplicit, isErased).typeRef
+  def FunctionType(n: Int, isContextual: Boolean = false, isErased: Boolean = false)(implicit ctx: Context): TypeRef =
+    if (n <= MaxImplementedFunctionArity && (!isContextual || ctx.erasedTypes) && !isErased) ImplementedFunctionType(n)
+    else FunctionClass(n, isContextual, isErased).typeRef
 
   /** If `cls` is a class in the scala package, its name, otherwise EmptyTypeName */
   def scalaClassName(cls: Symbol)(implicit ctx: Context): TypeName =
diff --git a/compiler/src/dotty/tools/dotc/core/Flags.scala b/compiler/src/dotty/tools/dotc/core/Flags.scala
index 7368d85484be..f7bad7265047 100644
--- a/compiler/src/dotty/tools/dotc/core/Flags.scala
+++ b/compiler/src/dotty/tools/dotc/core/Flags.scala
@@ -312,7 +312,6 @@ object Flags {
   final val Contravariant: FlagSet = typeFlag(21, "<contravariant>")
   final val Label: FlagSet = termFlag(21, "<label>")
 
-
   /** A trait that has only abstract methods as members
    *  and therefore can be represented by a Java interface.
    *  Warning: flag is set during regular typer pass, should be tested only after typer.
@@ -348,6 +347,9 @@ object Flags {
   /** An extension method */
   final val Extension = termFlag(28, "<extension>")
 
+  /** A contextual (with) parameter */
+  final val Contextual = commonFlag(29, "<contextual>")
+
   /** Symbol is defined by a Java class */
   final val JavaDefined: FlagSet = commonFlag(30, "<java>")
 
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index b0f3db0429aa..339d811f26d0 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/compiler/src/dotty/tools/dotc/core/StdNames.scala
@@ -483,6 +483,7 @@ object StdNames {
     val notifyAll_ : N          = "notifyAll"
     val notify_ : N             = "notify"
     val null_ : N               = "null"
+    val of: N                   = "of"
     val ofDim: N                = "ofDim"
     val opaque: N               = "opaque"
     val ordinal: N              = "ordinal"
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index 0fb8f77c217f..34a6870a4574 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -1001,13 +1001,14 @@ object SymDenotations {
     final def companionModule(implicit ctx: Context): Symbol =
       if (is(Module)) sourceModule
       else if (isOpaqueAlias) {
-        def reference(tp: Type): TermRef = tp match {
-          case TypeRef(prefix: TermRef, _) => prefix
+        def reference(tp: Type): Symbol = tp match {
+          case TypeRef(prefix: TermRef, _) => prefix.termSymbol
           case tp: HKTypeLambda => reference(tp.resType)
           case tp: AppliedType => reference(tp.tycon)
+          case tp: ErrorType => registeredCompanion.sourceModule
         }
         val TypeAlias(alias) = info
-        reference(alias).termSymbol
+        reference(alias)
       }
       else registeredCompanion.sourceModule
 
diff --git a/compiler/src/dotty/tools/dotc/core/Types.scala b/compiler/src/dotty/tools/dotc/core/Types.scala
index ff3b11f4d25c..e246bc74f358 100644
--- a/compiler/src/dotty/tools/dotc/core/Types.scala
+++ b/compiler/src/dotty/tools/dotc/core/Types.scala
@@ -72,6 +72,7 @@ object Types {
    *                       +- OrType
    *                       +- MethodOrPoly ---+-- PolyType
    *                                          +-- MethodType ---+- ImplicitMethodType
+   *                                                            +- ContextualMethodType
    *                       |                                    +- JavaMethodType
    *                       +- ClassInfo
    *                       |
@@ -334,9 +335,15 @@ object Types {
     /** Is this a MethodType which is from Java */
     def isJavaMethod: Boolean = false
 
-    /** Is this a MethodType which has implicit parameters */
+    /** Is this a MethodType which has implicit or contextual parameters */
     def isImplicitMethod: Boolean = false
 
+    /** Is this a Method or PolyType which has contextual parameters as first value parameter list? */
+    def isContextual: Boolean = false
+
+    /** Is this a Method or PolyType which has implicit parameters as first value parameter list? */
+    def isImplicit: Boolean = false
+
     /** Is this a MethodType for which the parameters will not be used */
     def isErasedMethod: Boolean = false
 
@@ -1442,7 +1449,7 @@ object Types {
     def toFunctionType(dropLast: Int = 0)(implicit ctx: Context): Type = this match {
       case mt: MethodType if !mt.isParamDependent =>
         val formals1 = if (dropLast == 0) mt.paramInfos else mt.paramInfos dropRight dropLast
-        val isImplicit = mt.isImplicitMethod && !ctx.erasedTypes
+        val isContextual = mt.isContextual && !ctx.erasedTypes
         val isErased = mt.isErasedMethod && !ctx.erasedTypes
         val result1 = mt.nonDependentResultApprox match {
           case res: MethodType => res.toFunctionType()
@@ -1450,7 +1457,7 @@ object Types {
         }
         val funType = defn.FunctionOf(
           formals1 mapConserve (_.underlyingIfRepeated(mt.isJavaMethod)),
-          result1, isImplicit, isErased)
+          result1, isContextual, isErased)
         if (mt.isResultDependent) RefinedType(funType, nme.apply, mt)
         else funType
     }
@@ -3077,15 +3084,25 @@ object Types {
     def companion: MethodTypeCompanion
 
     final override def isJavaMethod: Boolean = companion eq JavaMethodType
-    final override def isImplicitMethod: Boolean = companion.eq(ImplicitMethodType) || companion.eq(ErasedImplicitMethodType)
-    final override def isErasedMethod: Boolean = companion.eq(ErasedMethodType) || companion.eq(ErasedImplicitMethodType)
+    final override def isImplicitMethod: Boolean =
+      companion.eq(ImplicitMethodType) ||
+      companion.eq(ErasedImplicitMethodType) ||
+      isContextual
+    final override def isErasedMethod: Boolean =
+      companion.eq(ErasedMethodType) ||
+      companion.eq(ErasedImplicitMethodType) ||
+      companion.eq(ErasedContextualMethodType)
+    final override def isContextual: Boolean =
+      companion.eq(ContextualMethodType) ||
+      companion.eq(ErasedContextualMethodType)
+    final override def isImplicit = isImplicitMethod
 
     def computeSignature(implicit ctx: Context): Signature = {
       val params = if (isErasedMethod) Nil else paramInfos
       resultSignature.prepend(params, isJavaMethod)
     }
 
-    protected def prefixString: String = "MethodType"
+    protected def prefixString: String = companion.prefixString
   }
 
   final class CachedMethodType(paramNames: List[TermName])(paramInfosExp: MethodType => List[Type], resultTypeExp: MethodType => Type, val companion: MethodTypeCompanion)
@@ -3134,7 +3151,7 @@ object Types {
     def syntheticParamName(n: Int): TypeName = tpnme.syntheticTypeParamName(n)
   }
 
-  abstract class MethodTypeCompanion extends TermLambdaCompanion[MethodType] { self =>
+  abstract class MethodTypeCompanion(val prefixString: String) extends TermLambdaCompanion[MethodType] { self =>
 
     /** Produce method type from parameter symbols, with special mappings for repeated
      *  and inline parameters:
@@ -3170,23 +3187,28 @@ object Types {
     }
   }
 
-  object MethodType extends MethodTypeCompanion {
-    def maker(isJava: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false): MethodTypeCompanion = {
+  object MethodType extends MethodTypeCompanion("MethodType") {
+    def maker(isJava: Boolean = false, isImplicit: Boolean = false, isErased: Boolean = false, isContextual: Boolean = false): MethodTypeCompanion = {
       if (isJava) {
         assert(!isImplicit)
         assert(!isErased)
+        assert(!isContextual)
         JavaMethodType
       }
-      else if (isImplicit && isErased) ErasedImplicitMethodType
-      else if (isImplicit) ImplicitMethodType
-      else if (isErased) ErasedMethodType
-      else MethodType
+      else if (isContextual)
+        if (isErased) ErasedContextualMethodType else ContextualMethodType
+      else if (isImplicit)
+        if (isErased) ErasedImplicitMethodType else ImplicitMethodType
+      else
+        if (isErased) ErasedMethodType else MethodType
     }
   }
-  object JavaMethodType extends MethodTypeCompanion
-  object ImplicitMethodType extends MethodTypeCompanion
-  object ErasedMethodType extends MethodTypeCompanion
-  object ErasedImplicitMethodType extends MethodTypeCompanion
+  object JavaMethodType extends MethodTypeCompanion("JavaMethodType")
+  object ErasedMethodType extends MethodTypeCompanion("ErasedMethodType")
+  object ContextualMethodType extends MethodTypeCompanion("ContextualMethodType")
+  object ErasedContextualMethodType extends MethodTypeCompanion("ErasedContextualMethodType")
+  object ImplicitMethodType extends MethodTypeCompanion("ImplicitMethodType")
+  object ErasedImplicitMethodType extends MethodTypeCompanion("ErasedImplicitMethodType")
 
   /** A ternary extractor for MethodType */
   object MethodTpe {
@@ -3265,6 +3287,9 @@ object Types {
 
     def computeSignature(implicit ctx: Context): Signature = resultSignature
 
+    override def isContextual = resType.isContextual
+    override def isImplicit = resType.isImplicit
+
     /** Merge nested polytypes into one polytype. nested polytypes are normally not supported
      *  but can arise as temporary data structures.
      */
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
index 4f4da8d26881..9961d3b688ee 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyFormat.scala
@@ -203,6 +203,7 @@ Standard-Section: "ASTs" TopLevelStat*
                   DEFAULTparameterized                // Method with default parameters
                   STABLE                              // Method that is assumed to be stable
                   EXTENSION                           // An extension method
+                  CONTEXTUAL                          // new style implicit parameters, introduced with `with`
                   PARAMsetter                         // A setter without a body named `x_=` where `x` is pickled as a PARAM
                   Annotation
 
@@ -322,7 +323,8 @@ object TastyFormat {
   final val ERASED = 34
   final val OPAQUE = 35
   final val EXTENSION = 36
-  final val PARAMsetter = 37
+  final val CONTEXTUAL = 37
+  final val PARAMsetter = 38
 
   // Cat. 2:    tag Nat
 
@@ -427,21 +429,23 @@ object TastyFormat {
   final val TYPEREFin = 175
   final val OBJECTDEF = 176
 
-  // In binary: 101101EI
-  // I = implicit method type
-  // E = erased method type
   final val METHODtype = 180
-  final val IMPLICITMETHODtype = 181
-  final val ERASEDMETHODtype = 182
-  final val ERASEDIMPLICITMETHODtype = 183
+  final val ERASEDMETHODtype = 181
+  final val CONTEXTUALMETHODtype = 182
+  final val ERASEDCONTEXTUALMETHODtype = 183
+  final val IMPLICITMETHODtype = 184
+  final val ERASEDIMPLICITMETHODtype = 185
 
   final val MATCHtype = 190
   final val MATCHtpt = 191
 
-  def methodType(isImplicit: Boolean = false, isErased: Boolean = false): Int = {
-    val implicitOffset = if (isImplicit) 1 else 0
-    val erasedOffset = if (isErased) 2 else 0
-    METHODtype + implicitOffset + erasedOffset
+  def methodType(isContextual: Boolean, isImplicit: Boolean, isErased: Boolean): Int = {
+    val implicitOffset =
+      if (isContextual) 2
+      else if (isImplicit) 4
+      else 0
+    val erasedOffset = if (isErased) 1 else 0
+    METHODtype + erasedOffset + implicitOffset
   }
 
   final val HOLE = 255
@@ -493,6 +497,7 @@ object TastyFormat {
        | DEFAULTparameterized
        | STABLE
        | EXTENSION
+       | CONTEXTUAL
        | PARAMsetter
        | ANNOTATION
        | PRIVATEqualified
@@ -553,6 +558,7 @@ object TastyFormat {
     case DEFAULTparameterized => "DEFAULTparameterized"
     case STABLE => "STABLE"
     case EXTENSION => "EXTENSION"
+    case CONTEXTUAL => "CONTEXTUAL"
     case PARAMsetter => "PARAMsetter"
 
     case SHAREDterm => "SHAREDterm"
@@ -644,8 +650,10 @@ object TastyFormat {
     case BYNAMEtpt => "BYNAMEtpt"
     case POLYtype => "POLYtype"
     case METHODtype => "METHODtype"
-    case IMPLICITMETHODtype => "IMPLICITMETHODtype"
     case ERASEDMETHODtype => "ERASEDMETHODtype"
+    case CONTEXTUALMETHODtype => "CONTEXTUALMETHODtype"
+    case ERASEDCONTEXTUALMETHODtype => "ERASEDCONTEXTUALMETHODtype"
+    case IMPLICITMETHODtype => "IMPLICITMETHODtype"
     case ERASEDIMPLICITMETHODtype => "ERASEDIMPLICITMETHODtype"
     case TYPELAMBDAtype => "TYPELAMBDAtype"
     case LAMBDAtpt => "LAMBDAtpt"
@@ -665,8 +673,10 @@ object TastyFormat {
     case VALDEF | DEFDEF | TYPEDEF | OBJECTDEF | TYPEPARAM | PARAM | NAMEDARG | RETURN | BIND |
          SELFDEF | REFINEDtype | TERMREFin | TYPEREFin | HOLE => 1
     case RENAMED | PARAMtype => 2
-    case POLYtype | METHODtype | IMPLICITMETHODtype | ERASEDMETHODtype | ERASEDIMPLICITMETHODtype |
-         TYPELAMBDAtype => -1
+    case POLYtype | TYPELAMBDAtype |
+         METHODtype | ERASEDMETHODtype |
+         CONTEXTUALMETHODtype | ERASEDCONTEXTUALMETHODtype |
+         IMPLICITMETHODtype | ERASEDIMPLICITMETHODtype => -1
     case _ => 0
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
index c9a59577a9f3..1f9bd7f351a5 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TastyPrinter.scala
@@ -84,7 +84,10 @@ class TastyPrinter(bytes: Array[Byte])(implicit ctx: Context) {
               printName(); printTree(); printTrees()
             case RETURN | HOLE =>
               printNat(); printTrees()
-            case METHODtype | IMPLICITMETHODtype | ERASEDMETHODtype | ERASEDIMPLICITMETHODtype | POLYtype | TYPELAMBDAtype =>
+            case METHODtype | ERASEDMETHODtype |
+                 CONTEXTUALMETHODtype | ERASEDCONTEXTUALMETHODtype |
+                 IMPLICITMETHODtype | ERASEDIMPLICITMETHODtype |
+                 POLYtype | TYPELAMBDAtype =>
               printTree()
               until(end) { printName(); printTree() }
             case PARAMtype =>
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
index 48dab30dece3..e0eaa47609f9 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreePickler.scala
@@ -259,7 +259,7 @@ class TreePickler(pickler: TastyPickler) {
     case tpe: PolyType if richTypes =>
       pickleMethodic(POLYtype, tpe)
     case tpe: MethodType if richTypes =>
-      pickleMethodic(methodType(isImplicit = tpe.isImplicitMethod, isErased = tpe.isErasedMethod), tpe)
+      pickleMethodic(methodType(tpe.isContextual, tpe.isImplicitMethod, tpe.isErasedMethod), tpe)
     case tpe: ParamRef =>
       assert(pickleParamRef(tpe), s"orphan parameter reference: $tpe")
     case tpe: LazyRef =>
@@ -655,6 +655,7 @@ class TreePickler(pickler: TastyPickler) {
       if (flags is DefaultParameterized) writeByte(DEFAULTparameterized)
       if (flags is StableRealizable) writeByte(STABLE)
       if (flags is Extension) writeByte(EXTENSION)
+      if (flags is Contextual) writeByte(CONTEXTUAL)
       if (flags is ParamAccessor) writeByte(PARAMsetter)
       assert(!(flags is Label))
     } else {
diff --git a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
index 65b9a2fe55ce..fcfc77d02d46 100644
--- a/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
+++ b/compiler/src/dotty/tools/dotc/core/tasty/TreeUnpickler.scala
@@ -349,10 +349,14 @@ class TreeUnpickler(reader: TastyReader,
               readMethodic(PolyType, _.toTypeName)
             case METHODtype =>
               readMethodic(MethodType, _.toTermName)
-            case IMPLICITMETHODtype =>
-              readMethodic(ImplicitMethodType, _.toTermName)
             case ERASEDMETHODtype =>
               readMethodic(ErasedMethodType, _.toTermName)
+            case CONTEXTUALMETHODtype =>
+              readMethodic(ContextualMethodType, _.toTermName)
+            case ERASEDCONTEXTUALMETHODtype =>
+              readMethodic(ErasedContextualMethodType, _.toTermName)
+            case IMPLICITMETHODtype =>
+              readMethodic(ImplicitMethodType, _.toTermName)
             case ERASEDIMPLICITMETHODtype =>
               readMethodic(ErasedImplicitMethodType, _.toTermName)
             case TYPELAMBDAtype =>
@@ -628,6 +632,7 @@ class TreeUnpickler(reader: TastyReader,
           case DEFAULTparameterized => addFlag(DefaultParameterized)
           case STABLE => addFlag(StableRealizable)
           case EXTENSION => addFlag(Extension)
+          case CONTEXTUAL => addFlag(Contextual)
           case PARAMsetter =>
             addFlag(ParamAccessor)
           case PRIVATEqualified =>
diff --git a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
index 82abd29e4dbc..468e09204434 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Parsers.scala
@@ -364,15 +364,15 @@ object Parsers {
 
     /** Convert tree to formal parameter list
     */
-    def convertToParams(tree: Tree): List[ValDef] = tree match {
-      case Parens(t)  => convertToParam(t) :: Nil
-      case Tuple(ts)  => ts map (convertToParam(_))
-      case t          => convertToParam(t) :: Nil
+    def convertToParams(tree: Tree, mods: Modifiers): List[ValDef] = tree match {
+      case Parens(t)  => convertToParam(t, mods) :: Nil
+      case Tuple(ts)  => ts map (convertToParam(_, mods))
+      case t          => convertToParam(t, mods) :: Nil
     }
 
     /** Convert tree to formal parameter
     */
-    def convertToParam(tree: Tree, mods: Modifiers = Modifiers(), expected: String = "formal parameter"): ValDef = tree match {
+    def convertToParam(tree: Tree, mods: Modifiers, expected: String = "formal parameter"): ValDef = tree match {
       case Ident(name) =>
         makeParameter(name.asTermName, TypeTree(), mods).withSpan(tree.span)
       case Typed(Ident(name), tpt) =>
@@ -506,7 +506,8 @@ object Parsers {
       recur(top)
     }
 
-    /** operand { infixop operand} [postfixop],
+    /**   operand { infixop operand | ‘with’ (operand | ParArgumentExprs) } [postfixop],
+     *
      *  respecting rules of associativity and precedence.
      *  @param notAnOperator  a token that does not count as operator.
      *  @param maybePostfix   postfix operators are allowed.
@@ -517,23 +518,37 @@ object Parsers {
         isOperator: => Boolean = true,
         maybePostfix: Boolean = false): Tree = {
       val base = opStack
-      var top = first
-      while (isIdent && isOperator) {
-        val op = if (isType) typeIdent() else termIdent()
-        top = reduceStack(base, top, precedence(op.name), isLeftAssoc(op.name), op.name, isType)
-        opStack = OpInfo(top, op, in.offset) :: opStack
-        newLineOptWhenFollowing(canStartOperand)
-        if (maybePostfix && !canStartOperand(in.token)) {
-          val topInfo = opStack.head
-          opStack = opStack.tail
-          val od = reduceStack(base, topInfo.operand, 0, true, in.name, isType)
-          return atSpan(startOffset(od), topInfo.offset) {
-            PostfixOp(od, topInfo.operator)
+
+      def recur(top: Tree): Tree =
+        if (isIdent && isOperator) {
+          val op = if (isType) typeIdent() else termIdent()
+          val top1 = reduceStack(base, top, precedence(op.name), isLeftAssoc(op.name), op.name, isType)
+          opStack = OpInfo(top1, op, in.offset) :: opStack
+          newLineOptWhenFollowing(canStartOperand)
+          if (maybePostfix && !canStartOperand(in.token)) {
+            val topInfo = opStack.head
+            opStack = opStack.tail
+            val od = reduceStack(base, topInfo.operand, 0, true, in.name, isType)
+            atSpan(startOffset(od), topInfo.offset) {
+              PostfixOp(od, topInfo.operator)
+            }
           }
+          else recur(operand())
         }
-        top = operand()
-      }
-      reduceStack(base, top, 0, true, in.name, isType)
+        else if (in.token == WITH) {
+          val top1 = reduceStack(base, top, minInfixPrec, leftAssoc = true, nme.WITHkw, isType)
+          assert(opStack `eq` base)
+          val app = atSpan(startOffset(top1), in.offset) {
+            in.nextToken()
+            val args = if (in.token == LPAREN) parArgumentExprs() else operand() :: Nil
+            Apply(top, args)
+          }
+          app.pushAttachment(WithApply, ())
+          recur(app)
+        }
+        else reduceStack(base, top, minPrec, leftAssoc = true, in.name, isType)
+
+      recur(first)
     }
 
 /* -------- IDENTIFIERS AND LITERALS ------------------------------------------- */
@@ -755,7 +770,7 @@ object Parsers {
      */
     def toplevelTyp(): Tree = checkWildcard(typ())
 
-    /** Type        ::=  [FunArgMods] FunArgTypes `=>' Type
+    /** Type        ::=  [‘erased’] FunArgTypes (‘=>’ | ‘|=>’) Type
      *                |  HkTypeParamClause `->' Type
      *                |  InfixType
      *  FunArgTypes ::=  InfixType
@@ -764,11 +779,20 @@ object Parsers {
      */
     def typ(): Tree = {
       val start = in.offset
-      val imods = modifiers(funArgMods)
+      val imods = modifiers(BitSet(ERASED))
       def functionRest(params: List[Tree]): Tree =
-        atSpan(start, accept(ARROW)) {
+        atSpan(start, in.offset) {
+          val pmods =
+            if (in.token == CARROW) {
+              in.nextToken()
+              imods | (Contextual | Implicit)
+            }
+            else {
+              accept(ARROW)
+              imods
+            }
           val t = typ()
-          if (imods.is(Implicit) || imods.is(Erased)) new FunctionWithMods(params, t, imods)
+          if (pmods.flags.is(Implicit | Contextual | Erased)) new FunctionWithMods(params, t, pmods)
           else Function(params, t)
         }
       def funArgTypesRest(first: Tree, following: () => Tree) = {
@@ -802,7 +826,8 @@ object Parsers {
             }
             openParens.change(LPAREN, -1)
             accept(RPAREN)
-            if (imods.is(Implicit) || isValParamList || in.token == ARROW) functionRest(ts)
+            if (imods.is(Implicit) || isValParamList || in.token == ARROW || in.token == CARROW)
+              functionRest(ts)
             else {
               val ts1 =
                 for (t <- ts) yield {
@@ -833,7 +858,7 @@ object Parsers {
         else infixType()
 
       in.token match {
-        case ARROW => functionRest(t :: Nil)
+        case ARROW | CARROW => functionRest(t :: Nil)
         case MATCH => matchType(EmptyTree, t)
         case FORSOME => syntaxError(ExistentialTypesNoLongerSupported()); t
         case _ =>
@@ -1110,6 +1135,7 @@ object Parsers {
     }
 
     /** Expr              ::=  [FunArgMods] FunParams =>' Expr
+     *                      |  [‘erased’] FunParams ‘|=>’ Expr
      *                      |  Expr1
      *  FunParams         ::=  Bindings
      *                      |  id
@@ -1159,9 +1185,11 @@ object Parsers {
         finally placeholderParams = saved
 
         val t = expr1(location)
-        if (in.token == ARROW) {
+        if (in.token == ARROW || in.token == CARROW) {
           placeholderParams = Nil // don't interpret `_' to the left of `=>` as placeholder
-          wrapPlaceholders(closureRest(start, location, convertToParams(t)))
+          val impliedMods =
+            if (in.token == CARROW) Modifiers(Implicit | Contextual) else EmptyModifiers
+          wrapPlaceholders(closureRest(start, location, convertToParams(t, impliedMods)))
         }
         else if (isWildcard(t)) {
           placeholderParams = placeholderParams ::: saved
@@ -1211,7 +1239,7 @@ object Parsers {
           }
 
           val finalizer =
-            if (in.token == FINALLY) { accept(FINALLY); expr() }
+            if (in.token == FINALLY) { in.nextToken(); expr() }
             else {
               if (handler.isEmpty) warning(
                 EmptyCatchAndFinallyBlock(body),
@@ -1379,7 +1407,8 @@ object Parsers {
       }
       else ident()
 
-    /** Expr         ::= implicit id `=>' Expr
+    /** Expr         ::= FunArgMods FunParams `=>' Expr
+     *                 | [‘erased’] FunParams ‘|=>’ Expr
      *  BlockResult  ::= implicit id [`:' InfixType] `=>' Block // Scala2 only
      */
     def implicitClosure(start: Int, location: Location.Value, implicitMods: Modifiers): Tree =
@@ -1387,13 +1416,25 @@ object Parsers {
 
     def closureRest(start: Int, location: Location.Value, params: List[Tree]): Tree =
       atSpan(start, in.offset) {
-        accept(ARROW)
-        Function(params, if (location == Location.InBlock) block() else expr())
+        val params1 =
+          if (in.token == CARROW) {
+            in.nextToken()
+            params.map {
+              case param: ValDef => param.withMods(param.mods | (Implicit | Contextual))
+              case param => param
+            }
+          }
+          else {
+            accept(ARROW)
+            params
+          }
+        Function(params1, if (location == Location.InBlock) block() else expr())
       }
 
     /** PostfixExpr   ::= InfixExpr [id [nl]]
      *  InfixExpr     ::= PrefixExpr
      *                  | InfixExpr id [nl] InfixExpr
+     *                  | InfixExpr ‘with’ (InfixExpr | ParArgumentExprs)
      */
     def postfixExpr(): Tree =
       infixOps(prefixExpr(), canStartExpressionTokens, prefixExpr, maybePostfix = true)
@@ -1963,30 +2004,27 @@ object Parsers {
      */
     def typeParamClause(ownerKind: ParamOwner.Value): List[TypeDef] = inBrackets {
       def typeParam(): TypeDef = {
-        val isConcreteOwner = ownerKind == ParamOwner.Class || ownerKind == ParamOwner.Def
+        val isAbstractOwner = ownerKind == ParamOwner.Type || ownerKind == ParamOwner.TypeParam
         val start = in.offset
         val mods =
           annotsAsMods() | {
             if (ownerKind == ParamOwner.Class) Param | PrivateLocal
             else Param
           } | {
-            if (ownerKind != ParamOwner.Def)
-              if (isIdent(nme.raw.PLUS)) { in.nextToken(); Covariant }
-              else if (isIdent(nme.raw.MINUS)) { in.nextToken(); Contravariant }
-              else EmptyFlags
+            if (ownerKind == ParamOwner.Def) EmptyFlags
+            else if (isIdent(nme.raw.PLUS)) { in.nextToken(); Covariant }
+            else if (isIdent(nme.raw.MINUS)) { in.nextToken(); Contravariant }
             else EmptyFlags
           }
         atSpan(start, nameStart) {
           val name =
-            if (isConcreteOwner || in.token != USCORE) ident().toTypeName
-            else {
+            if (isAbstractOwner && in.token == USCORE) {
               in.nextToken()
               WildcardParamName.fresh().toTypeName
             }
+            else ident().toTypeName
           val hkparams = typeParamClauseOpt(ParamOwner.TypeParam)
-          val bounds =
-            if (isConcreteOwner) typeParamBounds(name)
-            else typeBounds()
+          val bounds = if (isAbstractOwner) typeBounds() else typeParamBounds(name)
           TypeDef(name, lambdaAbstract(hkparams, bounds)).withMods(mods)
         }
       }
@@ -1996,12 +2034,12 @@ object Parsers {
     def typeParamClauseOpt(ownerKind: ParamOwner.Value): List[TypeDef] =
       if (in.token == LBRACKET) typeParamClause(ownerKind) else Nil
 
-    /** ClsParamClauses   ::=  {ClsParamClause} [[nl] `(' [FunArgMods] ClsParams `)']
-     *  ClsParamClause    ::=  [nl] `(' [`erased'] [ClsParams] ')'
+    /** ClsParamClause    ::=  [nl | ‘with’] `(' [FunArgMods] [ClsParams] ')'
      *  ClsParams         ::=  ClsParam {`' ClsParam}
      *  ClsParam          ::=  {Annotation} [{Modifier} (`val' | `var') | `inline'] Param
-     *  DefParamClauses   ::=  {DefParamClause} [[nl] `(' [FunArgMods] DefParams `)']
-     *  DefParamClause    ::=  [nl] `(' [`erased'] [DefParams] ')'
+     *  DefParamClause    ::=  [nl] `(' [FunArgMods] [DefParams] ')' | InstParamClause
+     *  InstParamClause   ::=  ‘with’ (‘(’ [DefParams] ‘)’ | ContextTypes)
+     *  ContextTypes      ::=  RefinedType {`,' RefinedType}
      *  DefParams         ::=  DefParam {`,' DefParam}
      *  DefParam          ::=  {Annotation} [`inline'] Param
      *  Param             ::=  id `:' ParamType [`=' Expr]
@@ -2011,9 +2049,9 @@ object Parsers {
     def paramClause(ofClass: Boolean = false,                // owner is a class
                     ofCaseClass: Boolean = false,            // owner is a case class
                     prefix: Boolean = false,                 // clause precedes name of an extension method
-                    firstClause: Boolean = false)            // clause is the first in regular list of clauses
-                    : List[ValDef] = {
-      var impliedMods: Modifiers = EmptyModifiers
+                    firstClause: Boolean = false,            // clause is the first in regular list of clauses
+                    initialMods: Modifiers = EmptyModifiers): List[ValDef] = {
+      var impliedMods: Modifiers = initialMods
 
       def param(): ValDef = {
         val start = in.offset
@@ -2074,13 +2112,13 @@ object Parsers {
         if (in.token == RPAREN && !prefix) Nil
         else {
           def funArgMods(mods: Modifiers): Modifiers =
-            if (in.token == IMPLICIT)
+            if (in.token == IMPLICIT && !mods.is(Contextual))
               funArgMods(addMod(mods, atSpan(accept(IMPLICIT)) { Mod.Implicit() }))
             else if (in.token == ERASED)
               funArgMods(addMod(mods, atSpan(accept(ERASED)) { Mod.Erased() }))
             else mods
 
-          impliedMods = funArgMods(EmptyModifiers)
+          impliedMods = funArgMods(impliedMods)
           val clause =
             if (prefix) param() :: Nil
             else commaSeparated(() => param())
@@ -2092,25 +2130,44 @@ object Parsers {
 
     /** ClsParamClauses   ::=  {ClsParamClause}
      *  DefParamClauses   ::=  {DefParamClause}
+     *  InstParamClauses  ::=  {InstParamClause}
      *
      *  @return  The parameter definitions
      */
     def paramClauses(ofClass: Boolean = false,
-                     ofCaseClass: Boolean = false): (List[List[ValDef]]) = {
-      def recur(firstClause: Boolean): List[List[ValDef]] = {
+                     ofCaseClass: Boolean = false,
+                     ofInstance: Boolean = false): List[List[ValDef]] = {
+      def recur(firstClause: Boolean, nparams: Int): List[List[ValDef]] = {
+        val initialMods =
+          if (in.token == WITH) {
+            in.nextToken()
+            Modifiers(Contextual | Implicit)
+          }
+          else EmptyModifiers
+        val isContextual = initialMods.is(Contextual)
         newLineOptWhenFollowedBy(LPAREN)
         if (in.token == LPAREN) {
+          if (ofInstance && !isContextual)
+            syntaxError(em"parameters of instance definitions must come after `with'")
           val params = paramClause(
               ofClass = ofClass,
               ofCaseClass = ofCaseClass,
-              firstClause = firstClause)
+              firstClause = firstClause,
+              initialMods = initialMods)
           val lastClause =
-            params.nonEmpty && params.head.mods.flags.is(Implicit)
-          params :: (if (lastClause) Nil else recur(firstClause = false))
+            params.nonEmpty && params.head.mods.flags.is(Implicit, butNot = Contextual)
+          params :: (if (lastClause) Nil else recur(firstClause = false, nparams + params.length))
+        }
+        else if (isContextual) {
+          val tps = commaSeparated(refinedType)
+          var counter = nparams
+          def nextIdx = { counter += 1; counter }
+          val params = tps.map(makeSyntheticParameter(nextIdx, _, Contextual | Implicit))
+          params :: recur(firstClause = false, nparams + params.length)
         }
         else Nil
       }
-      recur(firstClause = true)
+      recur(firstClause = true, 0)
     }
 
 /* -------- DEFS ------------------------------------------- */
@@ -2382,7 +2439,8 @@ object Parsers {
 
     /** TmplDef ::=  ([`case'] ‘class’ | trait’) ClassDef
      *            |  [`case'] `object' ObjectDef
-     *            |  `enum' EnumDef
+     *            |  ‘enum’ EnumDef
+     *            |  ‘instance’ InstanceDef
      */
     def tmplDef(start: Int, mods: Modifiers): Tree = {
       in.token match {
@@ -2398,6 +2456,8 @@ object Parsers {
           objectDef(start, posMods(start, mods | Case | Module))
         case ENUM =>
           enumDef(start, mods, atSpan(in.skipToken()) { Mod.Enum() })
+        case INSTANCE =>
+          instanceDef(start, mods, atSpan(in.skipToken()) { Mod.Instance() })
         case _ =>
           syntaxErrorOrIncomplete(ExpectedStartOfTopLevelDefinition())
           EmptyTree
@@ -2493,6 +2553,40 @@ object Parsers {
       Template(constr, parents, Nil, EmptyValDef, Nil)
     }
 
+    /** InstanceDef    ::=  [id] InstanceParams InstanceBody
+     *  InstanceParams ::=  [DefTypeParamClause] {InstParamClause}
+     *  InstanceBody   ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+     *                   |  ‘of’ Type ‘=’ Expr
+     */
+    def instanceDef(start: Offset, mods: Modifiers, instanceMod: Mod) = atSpan(start, nameStart) {
+      var mods1 = addMod(mods, instanceMod)
+      val name = if (isIdent && !isIdent(nme.of)) ident() else EmptyTermName
+      val tparams = typeParamClauseOpt(ParamOwner.Def)
+      val vparamss = paramClauses(ofInstance = true)
+      val parents =
+        if (isIdent(nme.of)) {
+          in.nextToken()
+          tokenSeparated(COMMA, constrApp)
+        }
+        else Nil
+      val instDef =
+        if (in.token == EQUALS && parents.length == 1 && parents.head.isType) {
+          in.nextToken()
+          mods1 |= Final
+          DefDef(name, tparams, vparamss, parents.head, expr())
+        }
+        else {
+          newLineOptWhenFollowedBy(LBRACE)
+          val tparams1 = tparams.map(tparam => tparam.withMods(tparam.mods | PrivateLocal))
+          val vparamss1 = vparamss.map(_.map(vparam =>
+            vparam.withMods(vparam.mods &~ Param | ParamAccessor | PrivateLocal)))
+          val templ = templateBodyOpt(makeConstructor(tparams1, vparamss1), parents, Nil, isEnum = false)
+          if (tparams.isEmpty && vparamss.isEmpty) ModuleDef(name, templ)
+          else TypeDef(name.toTypeName, templ)
+        }
+      finalizeDef(instDef, mods1, start)
+    }
+
 /* -------- TEMPLATES ------------------------------------------- */
 
     /** ConstrApp         ::=  SimpleType {ParArgumentExprs}
diff --git a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
index b9afcf03aa71..c982d36e03d6 100644
--- a/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
+++ b/compiler/src/dotty/tools/dotc/parsing/Tokens.scala
@@ -112,7 +112,8 @@ abstract class TokensCommon {
   //final val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
   //final val HASH = 82;             enter(HASH, "#")
   final val AT = 83;               enter(AT, "@")
-  //final val VIEWBOUND = 84;        enter(VIEWBOUND, "<%") // TODO: deprecate
+  //final val CARROW = 84;
+  //final val VIEWBOUND = 85;        enter(VIEWBOUND, "<%") // TODO: deprecate
 
   val keywords: TokenSet
 
@@ -178,6 +179,7 @@ object Tokens extends TokensCommon {
   final val FORSOME = 61;          enter(FORSOME, "forSome") // TODO: deprecate
   final val ENUM = 62;             enter(ENUM, "enum")
   final val ERASED = 63;           enter(ERASED, "erased")
+  final val INSTANCE = 64;         enter(INSTANCE, "instance")
 
   /** special symbols */
   final val NEWLINE = 78;          enter(NEWLINE, "end of statement", "new line")
@@ -190,15 +192,16 @@ object Tokens extends TokensCommon {
   final val SUBTYPE = 80;          enter(SUBTYPE, "<:")
   final val SUPERTYPE = 81;        enter(SUPERTYPE, ">:")
   final val HASH = 82;             enter(HASH, "#")
-  final val VIEWBOUND = 84;        enter(VIEWBOUND, "<%") // TODO: deprecate
-  final val QPAREN = 85;           enter(QPAREN, "'(")
-  final val QBRACE = 86;           enter(QBRACE, "'{")
-  final val QBRACKET = 87;         enter(QBRACKET, "'[")
+  final val CARROW = 84;           enter(CARROW, "|=>")
+  final val VIEWBOUND = 85;        enter(VIEWBOUND, "<%") // TODO: deprecate
+  final val QPAREN = 86;           enter(QPAREN, "'(")
+  final val QBRACE = 87;           enter(QBRACE, "'{")
+  final val QBRACKET = 88;         enter(QBRACKET, "'[")
 
   /** XML mode */
   final val XMLSTART = 96;         enter(XMLSTART, "$XMLSTART$<") // TODO: deprecate
 
-  final val alphaKeywords: TokenSet = tokenRange(IF, ERASED)
+  final val alphaKeywords: TokenSet = tokenRange(IF, INSTANCE)
   final val symbolicKeywords: TokenSet = tokenRange(USCORE, VIEWBOUND)
   final val symbolicTokens: TokenSet = tokenRange(COMMA, VIEWBOUND)
   final val keywords: TokenSet = alphaKeywords | symbolicKeywords
@@ -221,7 +224,7 @@ object Tokens extends TokensCommon {
 
   final val templateIntroTokens: TokenSet = BitSet(CLASS, TRAIT, OBJECT, ENUM, CASECLASS, CASEOBJECT)
 
-  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE)
+  final val dclIntroTokens: TokenSet = BitSet(DEF, VAL, VAR, TYPE, INSTANCE)
 
   final val defIntroTokens: TokenSet = templateIntroTokens | dclIntroTokens
 
diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 60d9d4545488..e45ab1c4a486 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -183,8 +183,9 @@ class PlainPrinter(_ctx: Context) extends Printer {
         "<noprefix>"
       case tp: MethodType =>
         changePrec(GlobalPrec) {
+          (if (tp.isContextual) " with " else "") ~
           ("(" + (if (tp.isErasedMethod)   "erased "   else "")
-               + (if (tp.isImplicitMethod) "implicit " else "")
+               + (if (tp.isImplicitMethod && !tp.isContextual) "implicit " else "")
           ) ~ paramsText(tp) ~
           (if (tp.resultType.isInstanceOf[MethodType]) ")" else "): ") ~
           toText(tp.resultType)
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index a05b4e6cc82c..c5d338cd1553 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -125,24 +125,25 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
       else simpleNameString(tsym)
     }
 
+  protected def arrowText(contextual: Boolean): Text = if (contextual) " |=> " else " => "
+
   override def toText(tp: Type): Text = controlled {
     def toTextTuple(args: List[Type]): Text =
       "(" ~ argsText(args) ~ ")"
 
-    def toTextFunction(args: List[Type], isImplicit: Boolean, isErased: Boolean): Text =
+    def toTextFunction(args: List[Type], contextual: Boolean, isErased: Boolean): Text =
       changePrec(GlobalPrec) {
         val argStr: Text =
           if (args.length == 2 && !defn.isTupleType(args.head))
             atPrec(InfixPrec) { argText(args.head) }
           else
             toTextTuple(args.init)
-        (keywordText("erased ") provided isErased) ~ (keywordText("implicit ") provided isImplicit) ~ argStr ~ " => " ~ argText(args.last)
+        (keywordText("erased ") provided isErased) ~
+        argStr ~ arrowText(contextual) ~ argText(args.last)
       }
 
-    def toTextDependentFunction(appType: MethodType): Text = {
-      (keywordText("implicit ") provided appType.isImplicitMethod) ~
-      "(" ~ paramsText(appType) ~ ") => " ~ toText(appType.resultType)
-    }
+    def toTextDependentFunction(appType: MethodType): Text =
+      "(" ~ paramsText(appType) ~ ")" ~ arrowText(appType.isContextual) ~ toText(appType.resultType)
 
     def isInfixType(tp: Type): Boolean = tp match {
       case AppliedType(tycon, args) =>
@@ -514,10 +515,12 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         toText(id) ~ "\"" ~ Text(segments map segmentText, "") ~ "\""
       case Function(args, body) =>
         var implicitSeen: Boolean = false
+        var contextual: Boolean = false
         def argToText(arg: Tree) = arg match {
           case arg @ ValDef(name, tpt, _) =>
             val implicitText =
-              if ((arg.mods is Implicit) && !implicitSeen) { implicitSeen = true; keywordStr("implicit ") }
+              if ((arg.mods is Contextual)) { contextual = true; "" }
+              else if ((arg.mods is Implicit) && !implicitSeen) { implicitSeen = true; keywordStr("implicit ") }
               else ""
             implicitText ~ toText(name) ~ optAscription(tpt)
           case _ =>
@@ -527,9 +530,7 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
           case (arg @ ValDef(_, tpt, _)) :: Nil if tpt.isEmpty => argToText(arg)
           case _ => "(" ~ Text(args map argToText, ", ") ~ ")"
         }
-        changePrec(GlobalPrec) {
-          argsText ~ " => " ~ toText(body)
-        }
+        changePrec(GlobalPrec) { argsText ~ arrowText(contextual) ~ toText(body) }
       case InfixOp(l, op, r) =>
         val opPrec = parsing.precedence(op.name)
         changePrec(opPrec) { toText(l) ~ " " ~ toText(op) ~ " " ~ toText(r) }
diff --git a/compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala b/compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala
index 827e9d424bb2..e63ab7a09ad4 100644
--- a/compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala
+++ b/compiler/src/dotty/tools/dotc/quoted/QuoteDriver.scala
@@ -36,9 +36,9 @@ class QuoteDriver extends Driver {
 
     val clazz = classLoader.loadClass(driver.outputClassName.toString)
     val method = clazz.getMethod("apply")
-    val instance = clazz.getConstructor().newInstance()
+    val inst = clazz.getConstructor().newInstance()
 
-    method.invoke(instance).asInstanceOf[T]
+    method.invoke(inst).asInstanceOf[T]
   }
 
   def show(expr: Expr[_], settings: Toolbox.Settings): String = {
diff --git a/compiler/src/dotty/tools/dotc/transform/Erasure.scala b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
index 09276076840a..67aff2bd40e6 100644
--- a/compiler/src/dotty/tools/dotc/transform/Erasure.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Erasure.scala
@@ -501,7 +501,7 @@ object Erasure {
       val Apply(fun, args) = tree
       if (fun.symbol == defn.cbnArg)
         typedUnadapted(args.head, pt)
-      else typedExpr(fun, FunProto(args, pt)(this)) match {
+      else typedExpr(fun, FunProto(args, pt)(this, isContextual = false)) match {
         case fun1: Apply => // arguments passed in prototype were already passed
           fun1
         case fun1 =>
diff --git a/compiler/src/dotty/tools/dotc/transform/Splicer.scala b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
index 74d8f2cf7a20..638abf19e613 100644
--- a/compiler/src/dotty/tools/dotc/transform/Splicer.scala
+++ b/compiler/src/dotty/tools/dotc/transform/Splicer.scala
@@ -113,12 +113,12 @@ object Splicer {
     }
 
     protected def interpretStaticMethodCall(moduleClass: Symbol, fn: Symbol, args: => List[Object])(implicit env: Env): Object = {
-      val (instance, clazz) =
+      val (inst, clazz) =
         if (moduleClass.name.startsWith(str.REPL_SESSION_LINE)) {
           (null, loadReplLineClass(moduleClass))
         } else {
-          val instance = loadModule(moduleClass)
-          (instance, instance.getClass)
+          val inst = loadModule(moduleClass)
+          (inst, inst.getClass)
         }
 
       def getDirectName(tp: Type, name: TermName): TermName = tp.widenDealias match {
@@ -129,7 +129,7 @@ object Splicer {
 
       val name = getDirectName(fn.info.finalResultType, fn.name.asTermName)
       val method = getMethod(clazz, name, paramsSig(fn))
-      stopIfRuntimeException(method.invoke(instance, args: _*))
+      stopIfRuntimeException(method.invoke(inst, args: _*))
     }
 
     protected def interpretModuleAccess(fn: Symbol)(implicit env: Env): Object =
diff --git a/compiler/src/dotty/tools/dotc/typer/Applications.scala b/compiler/src/dotty/tools/dotc/typer/Applications.scala
index e9ffaeddb404..0a3af9b047f0 100644
--- a/compiler/src/dotty/tools/dotc/typer/Applications.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Applications.scala
@@ -763,7 +763,7 @@ trait Applications extends Compatibility { self: Typer with Dynamic =>
   def typedApply(tree: untpd.Apply, pt: Type)(implicit ctx: Context): Tree = {
 
     def realApply(implicit ctx: Context): Tree = track("realApply") {
-      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this)(argCtx(tree))
+      val originalProto = new FunProto(tree.args, IgnoredProto(pt))(this, tree.isContextual)(argCtx(tree))
       val fun1 = typedExpr(tree.fun, originalProto)
 
       // Warning: The following lines are dirty and fragile. We record that auto-tupling was demanded as
diff --git a/compiler/src/dotty/tools/dotc/typer/Checking.scala b/compiler/src/dotty/tools/dotc/typer/Checking.scala
index a195b81c86b6..4693e8fdd88c 100644
--- a/compiler/src/dotty/tools/dotc/typer/Checking.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Checking.scala
@@ -622,7 +622,7 @@ trait Checking {
       if !mt.isImplicitMethod && !sym.is(Synthetic) => // it's a conversion
         check()
       case AppliedType(tycon, _)
-      if tycon.derivesFrom(defn.Predef_ImplicitConverter) && !sym.is(Synthetic) =>
+      if tycon.derivesFrom(defn.ConversionClass) && !sym.is(Synthetic) =>
         check()
       case _ =>
     }
diff --git a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
index 9ea893283d2b..54c3a8ada151 100644
--- a/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
+++ b/compiler/src/dotty/tools/dotc/typer/EtaExpansion.scala
@@ -178,6 +178,10 @@ object EtaExpansion extends LiftImpure {
    *         { val xs = es; (x1: T1, ..., xn: Tn) => expr(x1, ..., xn) _ }
    *
    *  where `T1, ..., Tn` are the paremeter types of the expanded method.
+   *  If `expr` has a contectual function type, the arguments are passed with `with`.
+   *  E.g. for (1):
+   *
+   *      { val xs = es; (x1, ..., xn) => expr with (x1, ..., xn) }
    *
    *  Case (3) applies if the method is curried, i.e. its result type is again a method
    *  type. Case (2) applies if the expected arity of the function type `xarity` differs
@@ -206,6 +210,7 @@ object EtaExpansion extends LiftImpure {
       if (isLastApplication && mt.paramInfos.length == xarity) mt.paramInfos map (_ => TypeTree())
       else mt.paramInfos map TypeTree
     var paramFlag = Synthetic | Param
+    if (mt.isContextual) paramFlag |= Contextual
     if (mt.isImplicitMethod) paramFlag |= Implicit
     val params = (mt.paramNames, paramTypes).zipped.map((name, tpe) =>
       ValDef(name, tpe, EmptyTree).withFlags(paramFlag).withSpan(tree.span.startPos))
@@ -213,9 +218,11 @@ object EtaExpansion extends LiftImpure {
     if (mt.paramInfos.nonEmpty && mt.paramInfos.last.isRepeatedParam)
       ids = ids.init :+ repeated(ids.last)
     var body: Tree = Apply(lifted, ids)
+    if (mt.isContextual) body.pushAttachment(WithApply, ())
     if (!isLastApplication) body = PostfixOp(body, Ident(nme.WILDCARD))
     val fn =
-      if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit))
+      if (mt.isContextual) new untpd.FunctionWithMods(params, body, Modifiers(Implicit | Contextual))
+      else if (mt.isImplicitMethod) new untpd.FunctionWithMods(params, body, Modifiers(Implicit))
       else untpd.Function(params, body)
     if (defs.nonEmpty) untpd.Block(defs.toList map (untpd.TypedSplice(_)), fn) else fn
   }
diff --git a/compiler/src/dotty/tools/dotc/typer/Implicits.scala b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
index 85430730c76e..3fd7ffc62f45 100644
--- a/compiler/src/dotty/tools/dotc/typer/Implicits.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Implicits.scala
@@ -126,9 +126,9 @@ object Implicits {
               // this in Predef:
               //
               //    implicit def convertIfConforms[A, B](x: A)(implicit ev: A <:< B): B = ev(a)
-              //    implicit def convertIfConverter[A, B](x: A)(implicit ev: ImplicitConverter[A, B]): B = ev(a)
+              //    implicit def convertIfConverter[A, B](x: A)(implicit ev: Conversion[A, B]): B = ev(a)
               //
-              // (Once `<:<` inherits from `ImplicitConverter` we only need the 2nd one.)
+              // (Once `<:<` inherits from `Conversion` we only need the 2nd one.)
               // But clauses like this currently slow down implicit search a lot, because
               // they are eligible for all pairs of types, and therefore are tried too often.
               // We emulate instead these conversions directly in the search.
@@ -138,7 +138,7 @@ object Implicits {
               // We keep the old behavior under -language:Scala2.
               val isFunctionInS2 =
                 ctx.scala2Mode && tpw.derivesFrom(defn.FunctionClass(1)) && ref.symbol != defn.Predef_conforms
-              val isImplicitConverter = tpw.derivesFrom(defn.Predef_ImplicitConverter)
+              val isImplicitConversion = tpw.derivesFrom(defn.ConversionClass)
               val isConforms = // An implementation of <:< counts as a view, except that $conforms is always omitted
                   tpw.derivesFrom(defn.Predef_Conforms) && ref.symbol != defn.Predef_conforms
               val hasExtensions = resType match {
@@ -147,7 +147,7 @@ object Implicits {
                 case _ => false
               }
               val conversionKind =
-                if (isFunctionInS2 || isImplicitConverter || isConforms) Candidate.Conversion
+                if (isFunctionInS2 || isImplicitConversion || isConforms) Candidate.Conversion
                 else Candidate.None
               val extensionKind =
                 if (hasExtensions) Candidate.Extension
diff --git a/compiler/src/dotty/tools/dotc/typer/Namer.scala b/compiler/src/dotty/tools/dotc/typer/Namer.scala
index b87ae5c0cdef..aaf0f2147559 100644
--- a/compiler/src/dotty/tools/dotc/typer/Namer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Namer.scala
@@ -131,13 +131,14 @@ trait NamerContextOps { this: Context =>
       termParamss
 
   /** The method type corresponding to given parameters and result type */
-  def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type, isJava: Boolean = false)(implicit ctx: Context): Type = {
+  def methodType(typeParams: List[Symbol], valueParamss: List[List[Symbol]], resultType: Type,
+                 isJava: Boolean = false, isInstance: Boolean = false)(implicit ctx: Context): Type = {
     val monotpe =
       (valueParamss :\ resultType) { (params, resultType) =>
-        val (isImplicit, isErased) =
-          if (params.isEmpty) (false, false)
-          else (params.head is Implicit, params.head is Erased)
-        val make = MethodType.maker(isJava, isImplicit, isErased)
+        val (isImplicit, isErased, isContextual) =
+          if (params.isEmpty) (isInstance, false, false)
+          else (params.head is Implicit, params.head is Erased, params.head.is(Contextual))
+        val make = MethodType.maker(isJava = isJava, isImplicit = isImplicit, isErased = isErased, isContextual = isContextual)
         if (isJava)
           for (param <- params)
             if (param.info.isDirectRef(defn.ObjectClass)) param.info = defn.AnyType
@@ -1300,7 +1301,8 @@ class Namer { typer: Typer =>
     val termParamss = ctx.normalizeIfConstructor(vparamss.nestedMap(symbolOfTree), isConstructor)
     def wrapMethType(restpe: Type): Type = {
       instantiateDependent(restpe, typeParams, termParamss)
-      ctx.methodType(tparams map symbolOfTree, termParamss, restpe, isJava = ddef.mods is JavaDefined)
+      ctx.methodType(tparams map symbolOfTree, termParamss, restpe,
+        isJava = ddef.mods is JavaDefined, isInstance = ddef.mods.hasMod(classOf[Mod.Instance]))
     }
     if (isConstructor) {
       // set result type tree to unit, but take the current class as result type of the symbol
diff --git a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
index 8d40cbbae9aa..27f677324e7e 100644
--- a/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ProtoTypes.scala
@@ -229,7 +229,8 @@ object ProtoTypes {
    *
    *  [](args): resultType
    */
-  case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer, state: FunProtoState = new FunProtoState)(implicit ctx: Context)
+  case class FunProto(args: List[untpd.Tree], resType: Type)(typer: Typer,
+    override val isContextual: Boolean, state: FunProtoState = new FunProtoState)(implicit ctx: Context)
   extends UncachedGroundType with ApplyingProto with FunOrPolyProto {
     override def resultType(implicit ctx: Context): Type = resType
 
@@ -238,7 +239,7 @@ object ProtoTypes {
 
     def derivedFunProto(args: List[untpd.Tree] = this.args, resultType: Type, typer: Typer = this.typer): FunProto =
       if ((args eq this.args) && (resultType eq this.resultType) && (typer eq this.typer)) this
-      else new FunProto(args, resultType)(typer)
+      else new FunProto(args, resultType)(typer, isContextual)
 
     override def notApplied: Type = WildcardType
 
@@ -322,7 +323,7 @@ object ProtoTypes {
       case pt: FunProto =>
         pt
       case _ =>
-        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer)
+        state.tupled = new FunProto(untpd.Tuple(args) :: Nil, resultType)(typer, isContextual)
         tupled
     }
 
@@ -357,14 +358,14 @@ object ProtoTypes {
 
     override def withContext(newCtx: Context): ProtoType =
       if (newCtx `eq` ctx) this
-      else new FunProto(args, resType)(typer, state)(newCtx)
+      else new FunProto(args, resType)(typer, isContextual, state)(newCtx)
   }
 
   /** A prototype for expressions that appear in function position
    *
    *  [](args): resultType, where args are known to be typed
    */
-  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer)(implicit ctx: Context) extends FunProto(args, resultType)(typer)(ctx) {
+  class FunProtoTyped(args: List[tpd.Tree], resultType: Type)(typer: Typer, isContextual: Boolean)(implicit ctx: Context) extends FunProto(args, resultType)(typer, isContextual)(ctx) {
     override def typedArgs: List[tpd.Tree] = args
     override def withContext(ctx: Context): FunProtoTyped = this
   }
@@ -411,7 +412,7 @@ object ProtoTypes {
   }
 
   class UnapplyFunProto(argType: Type, typer: Typer)(implicit ctx: Context) extends FunProto(
-    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source))(ctx) :: Nil, WildcardType)(typer)
+    untpd.TypedSplice(dummyTreeOfType(argType)(ctx.source))(ctx) :: Nil, WildcardType)(typer, isContextual = false)
 
   /** A prototype for expressions [] that are type-parameterized:
    *
diff --git a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
index 0a84f1e92da0..94305da890ce 100644
--- a/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
+++ b/compiler/src/dotty/tools/dotc/typer/ReTyper.scala
@@ -123,4 +123,5 @@ class ReTyper extends Typer with ReChecking {
   override def checkCanEqual(ltp: Type, rtp: Type, span: Span)(implicit ctx: Context): Unit = ()
   override protected def addAccessorDefs(cls: Symbol, body: List[Tree])(implicit ctx: Context): List[Tree] = body
   override protected def checkEqualityEvidence(tree: tpd.Tree, pt: Type)(implicit ctx: Context): Unit = ()
+  override protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(implicit ctx: Context): Boolean = true
 }
diff --git a/compiler/src/dotty/tools/dotc/typer/Typer.scala b/compiler/src/dotty/tools/dotc/typer/Typer.scala
index 4fbeb406351d..78b2af7a44b1 100644
--- a/compiler/src/dotty/tools/dotc/typer/Typer.scala
+++ b/compiler/src/dotty/tools/dotc/typer/Typer.scala
@@ -781,26 +781,27 @@ class Typer extends Namer
 
   def typedFunctionType(tree: untpd.Function, pt: Type)(implicit ctx: Context): Tree = {
     val untpd.Function(args, body) = tree
-    val (isImplicit, isErased) = tree match {
-      case tree: untpd.FunctionWithMods =>
-        val isImplicit = tree.mods.is(Implicit)
-        var isErased = tree.mods.is(Erased)
-        if (isErased && args.isEmpty) {
-          ctx.error("An empty function cannot not be erased", tree.sourcePos)
-          isErased = false
-        }
-        (isImplicit, isErased)
-      case _ => (false, false)
+    var funFlags = tree match {
+      case tree: untpd.FunctionWithMods => tree.mods.flags
+      case _ => EmptyFlags
+    }
+    if (funFlags.is(Erased) && args.isEmpty) {
+      ctx.error("An empty function cannot not be erased", tree.sourcePos)
+      funFlags = funFlags &~ Erased
     }
 
-    val funCls = defn.FunctionClass(args.length, isImplicit, isErased)
+    val funCls = defn.FunctionClass(args.length,
+        isContextual = funFlags.is(Contextual), isErased = funFlags.is(Erased))
 
     /** Typechecks dependent function type with given parameters `params` */
     def typedDependent(params: List[ValDef])(implicit ctx: Context): Tree = {
       completeParams(params)
       val params1 = params.map(typedExpr(_).asInstanceOf[ValDef])
+      if (!funFlags.isEmpty)
+        params1.foreach(_.symbol.setFlag(funFlags))
       val resultTpt = typed(body)
-      val companion = MethodType.maker(isImplicit = isImplicit, isErased = isErased)
+      val companion = MethodType.maker(
+          isContextual = funFlags.is(Contextual), isErased = funFlags.is(Erased))
       val mt = companion.fromSymbols(params1.map(_.symbol), resultTpt.tpe)
       if (mt.isParamDependent)
         ctx.error(i"$mt is an illegal function type because it has inter-parameter dependencies", tree.sourcePos)
@@ -827,8 +828,8 @@ class Typer extends Namer
   def typedFunctionValue(tree: untpd.Function, pt: Type)(implicit ctx: Context): Tree = {
     val untpd.Function(params: List[untpd.ValDef] @unchecked, body) = tree
 
-    val isImplicit = tree match {
-      case tree: untpd.FunctionWithMods => tree.mods.is(Implicit)
+    val isContextual = tree match {
+      case tree: untpd.FunctionWithMods => tree.mods.is(Contextual)
       case _ => false
     }
 
@@ -881,7 +882,7 @@ class Typer extends Namer
       *         every parameter in `params`.
       */
     def calleeType: Type = fnBody match {
-      case Apply(expr, args) =>
+      case app @ Apply(expr, args) =>
         paramIndex = {
           for (param <- params; idx <- paramIndices(param, args))
           yield param.name -> idx
@@ -892,7 +893,7 @@ class Typer extends Namer
               expr1.tpe
             case _ =>
               val protoArgs = args map (_ withType WildcardType)
-              val callProto = FunProto(protoArgs, WildcardType)(this)
+              val callProto = FunProto(protoArgs, WildcardType)(this, isContextual = app.isContextual)
               val expr1 = typedExpr(expr, callProto)
               fnBody = cpy.Apply(fnBody)(untpd.TypedSplice(expr1), args)
               expr1.tpe
@@ -951,7 +952,7 @@ class Typer extends Namer
             else cpy.ValDef(param)(
               tpt = untpd.TypeTree(
                 inferredParamType(param, protoFormal(i)).underlyingIfRepeated(isJava = false)))
-        desugar.makeClosure(inferredParams, fnBody, resultTpt, isImplicit)
+        desugar.makeClosure(inferredParams, fnBody, resultTpt, isContextual)
       }
     typed(desugared, pt)
   }
@@ -976,9 +977,9 @@ class Typer extends Namer
                      |because it has internal parameter dependencies,
                      |position = ${tree.span}, raw type = ${mt.toString}""") // !!! DEBUG. Eventually, convert to an error?
                 }
-                else if ((tree.tpt `eq` untpd.ImplicitEmptyTree) && mt.paramNames.isEmpty)
+                else if ((tree.tpt `eq` untpd.ContextualEmptyTree) && mt.paramNames.isEmpty)
                   // Note implicitness of function in target type since there are no method parameters that indicate it.
-                  TypeTree(defn.FunctionOf(Nil, mt.resType, isImplicit = true, isErased = false))
+                  TypeTree(defn.FunctionOf(Nil, mt.resType, isContextual = true, isErased = false))
                 else
                   EmptyTree
             }
@@ -2001,11 +2002,11 @@ class Typer extends Namer
         val ifpt = defn.asImplicitFunctionType(pt)
         val result = if (ifpt.exists &&
             xtree.isTerm &&
-            !untpd.isImplicitClosure(xtree) &&
+            !untpd.isContextualClosure(xtree) &&
             !ctx.mode.is(Mode.ImplicitShadowing) &&
             !ctx.mode.is(Mode.Pattern) &&
             !ctx.isAfterTyper)
-          makeImplicitFunction(xtree, ifpt)
+          makeContextualFunction(xtree, ifpt)
         else xtree match {
           case xtree: untpd.NameTree => typedNamed(xtree, pt)
           case xtree => typedUnnamed(xtree)
@@ -2026,10 +2027,10 @@ class Typer extends Namer
     tree
   }
 
-  protected def makeImplicitFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = {
+  protected def makeContextualFunction(tree: untpd.Tree, pt: Type)(implicit ctx: Context): Tree = {
     val defn.FunctionOf(formals, _, true, _) = pt.dropDependentRefinement
-    val ifun = desugar.makeImplicitFunction(formals, tree)
-    typr.println(i"make implicit function $tree / $pt ---> $ifun")
+    val ifun = desugar.makeContextualFunction(formals, tree)
+    typr.println(i"make contextual function $tree / $pt ---> $ifun")
     typed(ifun, pt)
   }
 
@@ -2317,7 +2318,8 @@ class Typer extends Namer
               errorTree(tree, NoMatchingOverload(altDenots, pt)(err))
             def hasEmptyParams(denot: SingleDenotation) = denot.info.paramInfoss == ListOfNil
             pt match {
-              case pt: FunProto =>
+              case pt: FunProto if !pt.isContextual =>
+              	// insert apply or convert qualifier only for a regular application
                 tryInsertApplyOrImplicit(tree, pt, locked)(noMatches)
               case _ =>
                 if (altDenots exists (_.info.paramInfoss == ListOfNil))
@@ -2347,11 +2349,17 @@ class Typer extends Namer
       }
 
       def adaptToArgs(wtp: Type, pt: FunProto): Tree = wtp match {
-        case _: MethodOrPoly =>
-          if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
-            adapt(tree, pt.tupled, locked)
+        case wtp: MethodOrPoly =>
+          def methodStr = methPart(tree).symbol.showLocated
+          if (matchingApply(wtp, pt))
+            if (pt.args.lengthCompare(1) > 0 && isUnary(wtp) && ctx.canAutoTuple)
+              adapt(tree, pt.tupled, locked)
+            else
+              tree
+          else if (wtp.isContextual)
+            adaptNoArgs(wtp)  // insert arguments implicitly
           else
-            tree
+            errorTree(tree, em"Missing arguments for $methodStr")
         case _ => tryInsertApplyOrImplicit(tree, pt, locked) {
           errorTree(tree, MethodDoesNotTakeParameters(tree))
         }
@@ -2540,7 +2548,7 @@ class Typer extends Namer
     def adaptNoArgsOther(wtp: Type): Tree = {
       ctx.typeComparer.GADTused = false
       if (defn.isImplicitFunctionClass(wtp.underlyingClassRef(refinementOK = false).classSymbol) &&
-          !untpd.isImplicitClosure(tree) &&
+          !untpd.isContextualClosure(tree) &&
           !isApplyProto(pt) &&
           !ctx.mode.is(Mode.Pattern) &&
           !ctx.mode.is(Mode.ImplicitShadowing) &&
@@ -2801,6 +2809,19 @@ class Typer extends Namer
     }
   }
 
+  /** Does the "contextuality" of the method type `methType` match the one of the prototype `pt`?
+   *  This is the case if
+   *   - both are contextual, or
+   *   - neither is contextual, or
+   *   - the prototype is contextual and the method type is implicit.
+   *  The last rule is there for a transition period; it allows to mix `with` applications
+   *  with old-style implicit functions.
+   *  Overridden in `ReTyper`, where all applications are treated the same
+   */
+  protected def matchingApply(methType: MethodOrPoly, pt: FunProto)(implicit ctx: Context): Boolean =
+    methType.isContextual == pt.isContextual ||
+    methType.isImplicit && pt.isContextual // for a transition allow `with` arguments for regular implicit parameters
+
   /** Check that `tree == x: pt` is typeable. Used when checking a pattern
     * against a selector of type `pt`. This implementation accounts for
     * user-defined definitions of `==`.
diff --git a/compiler/test-resources/repl/3932 b/compiler/test-resources/repl/3932
index c8e3ae2c4c68..4a3e16000756 100644
--- a/compiler/test-resources/repl/3932
+++ b/compiler/test-resources/repl/3932
@@ -1,2 +1,2 @@
-scala> def fun[T](x: T): implicit List[T] => Int = ???
-def fun[T](x: T): implicit List[T] => Int
+scala> def fun[T](x: T): List[T] |=> Int = ???
+def fun[T](x: T): List[T] |=> Int
diff --git a/compiler/test/dotc/pos-decompilation.blacklist b/compiler/test/dotc/pos-decompilation.blacklist
index d02a16891b34..8171c6a20026 100644
--- a/compiler/test/dotc/pos-decompilation.blacklist
+++ b/compiler/test/dotc/pos-decompilation.blacklist
@@ -15,3 +15,9 @@ i4006c.scala
 
 # Decompiling RecThis as "this" is incorrect
 avoid.scala
+
+# Need to print empty tree for implicit match
+implicit-match.scala
+implicit-match-nested.scala
+implicit-match-and-inline-match.scala
+
diff --git a/compiler/test/dotc/pos-from-tasty.blacklist b/compiler/test/dotc/pos-from-tasty.blacklist
index c078f439062d..b5198d0d877a 100644
--- a/compiler/test/dotc/pos-from-tasty.blacklist
+++ b/compiler/test/dotc/pos-from-tasty.blacklist
@@ -21,7 +21,6 @@ i3050.scala
 i4006b.scala
 i4006c.scala
 
-# Need to print empty tree for implicit match
-implicit-match.scala
-implicit-match-nested.scala
-implicit-match-and-inline-match.scala
+# Not sure what's wring here
+i4203.scala
+t6278-synth-def.scala
diff --git a/compiler/test/dotc/pos-test-pickling.blacklist b/compiler/test/dotc/pos-test-pickling.blacklist
index 90cd8dbf757e..f23e94f10ff8 100644
--- a/compiler/test/dotc/pos-test-pickling.blacklist
+++ b/compiler/test/dotc/pos-test-pickling.blacklist
@@ -10,3 +10,4 @@ t3249
 t3486
 t3612.scala
 typelevel0.scala
+reference
diff --git a/compiler/test/dotc/run-test-pickling.blacklist b/compiler/test/dotc/run-test-pickling.blacklist
index 6f412a5d041a..e631ddf2873e 100644
--- a/compiler/test/dotc/run-test-pickling.blacklist
+++ b/compiler/test/dotc/run-test-pickling.blacklist
@@ -10,3 +10,5 @@ typeclass-derivation2a.scala
 typeclass-derivation3.scala
 derive-generic.scala
 deriving-interesting-prefixes.scala
+instances.scala
+instances-anonymous.scala
diff --git a/docs/docs/internals/syntax.md b/docs/docs/internals/syntax.md
index 8d16b95b48a2..b399d22cc476 100644
--- a/docs/docs/internals/syntax.md
+++ b/docs/docs/internals/syntax.md
@@ -136,7 +136,7 @@ ClassQualifier    ::=  ‘[’ id ‘]’
 
 ### Types
 ```ebnf
-Type              ::=  [FunArgMods] FunArgTypes ‘=>’ Type                       Function(ts, t)
+Type              ::=  [‘erased’] FunArgTypes (‘=>’ | ‘|=>’) Type               Function(ts, t)
                     |  HkTypeParamClause ‘=>’ Type                              TypeLambda(ps, t)
                     |  MatchType
                     |  InfixType
@@ -176,6 +176,7 @@ TypeParamBounds   ::=  TypeBounds {‘<%’ Type} {‘:’ Type}
 ### Expressions
 ```ebnf
 Expr              ::=  [FunArgMods] FunParams ‘=>’ Expr                         Function(args, expr), Function(ValDef([implicit], id, TypeTree(), EmptyTree), expr)
+                    |  [‘erased’] FunParams ‘|=>’ Expr
                     |  Expr1
 BlockResult       ::=  [FunArgMods] FunParams ‘=>’ Block
                     |  Expr1
@@ -204,6 +205,7 @@ Catches           ::=  ‘catch’ Expr
 PostfixExpr       ::=  InfixExpr [id]                                           PostfixOp(expr, op)
 InfixExpr         ::=  PrefixExpr
                     |  InfixExpr id [nl] InfixExpr                              InfixOp(expr, op, expr)
+                    |  InfixExpr ‘with’ (InfixExpr | ParArgumentExprs)
 PrefixExpr        ::=  [‘-’ | ‘+’ | ‘~’ | ‘!’] SimpleExpr                       PrefixOp(expr, op)
 SimpleExpr        ::=  ‘new’ (ConstrApp [TemplateBody] | TemplateBody)          New(constr | templ)
                     |  BlockExpr
@@ -286,8 +288,9 @@ HkTypeParamClause ::=  ‘[’ HkTypeParam {‘,’ HkTypeParam} ‘]’
 HkTypeParam       ::=  {Annotation} [‘+’ | ‘-’] (Id[HkTypeParamClause] | ‘_’)
                        TypeBounds
 
-ClsParamClauses   ::=  {ClsParamClause} [[nl] ‘(’ [FunArgMods] ClsParams ‘)’]
-ClsParamClause    ::=  [nl] ‘(’ [ClsParams] ‘)’
+ClsParamClauses   ::=  {ClsParamClause}
+ClsParamClause    ::=  [nl] ‘(’ [[FunArgMods] ClsParams] ‘)’
+                    |  ‘with’ (‘(’ ([[FunArgMods] ClsParams] ‘)’ | ContextTypes)
 ClsParams         ::=  ClsParam {‘,’ ClsParam}
 ClsParam          ::=  {Annotation}                                             ValDef(mods, id, tpe, expr) -- point of mods on val/var
                        [{Modifier} (‘val’ | ‘var’) | ‘inline’] Param
@@ -295,9 +298,11 @@ Param             ::=  id ‘:’ ParamType [‘=’ Expr]
                     |  INT
 
 DefParamClauses   ::=  {DefParamClause} [[nl] ‘(’ [FunArgMods] DefParams ‘)’]
-DefParamClause    ::=  [nl] ‘(’ [DefParams] ‘)’
+DefParamClause    ::=  [nl] ‘(’ [DefParams] ‘)’ | InstParamClause
+InstParamClause   ::=  ‘with’ (‘(’ [DefParams] ‘)’ | ContextTypes)
 DefParams         ::=  DefParam {‘,’ DefParam}
 DefParam          ::=  {Annotation} [‘inline’] Param                            ValDef(mods, id, tpe, expr) -- point of mods at id.
+ContextTypes      ::=  RefinedType {‘,’ RefinedType}
 ```
 
 ### Bindings and Imports
@@ -347,12 +352,13 @@ Def               ::=  ‘val’ PatDef
                     |  ‘var’ VarDef
                     |  ‘def’ DefDef
                     |  ‘type’ {nl} TypeDcl
+                    |  ‘instance’ {nl} InstanceDef
                     |  TmplDef
                     |  INT
 PatDef            ::=  Pattern2 {‘,’ Pattern2} [‘:’ Type] ‘=’ Expr              PatDef(_, pats, tpe?, expr)
 VarDef            ::=  PatDef
                     |  ids ‘:’ Type ‘=’ ‘_’
-DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr                               DefDef(_, name, tparams, vparamss, tpe, expr)
+DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr                      DefDef(_, name, tparams, vparamss, tpe, expr)
                     |  DefSig [nl] ‘{’ Block ‘}’                                DefDef(_, name, tparams, vparamss, tpe, Block)
                     |  ‘this’ DefParamClause DefParamClauses                    DefDef(_, <init>, Nil, vparamss, EmptyTree, expr | Block)
                        (‘=’ ConstrExpr | [nl] ConstrBlock)
@@ -360,11 +366,16 @@ DefDef            ::=  DefSig [(‘:’ | ‘<:’) Type] ‘=’ Expr
 TmplDef           ::=  ([‘case’] ‘class’ | ‘trait’) ClassDef
                     |  [‘case’] ‘object’ ObjectDef
                     |  ‘enum’ EnumDef
+                    |  ‘witness’ WitnessDef
 ClassDef          ::=  id ClassConstr [Template]                                ClassDef(mods, name, tparams, templ)
 ClassConstr       ::=  [ClsTypeParamClause] [ConstrMods] ClsParamClauses        with DefDef(_, <init>, Nil, vparamss, EmptyTree, EmptyTree) as first stat
 ConstrMods        ::=  {Annotation} [AccessModifier]
 ObjectDef         ::=  id [Template]                                            ModuleDef(mods, name, template)  // no constructor
 EnumDef           ::=  id ClassConstr InheritClauses EnumBody                   EnumDef(mods, name, tparams, template)
+InstanceDef       ::=  [id] InstanceParams InstanceBody
+InstanceParams    ::=  [DefTypeParamClause] {InstParamClause}
+InstanceBody      ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+                    |  ‘of’ Type ‘=’ Expr
 Template          ::=  InheritClauses [TemplateBody]                            Template(constr, parents, self, stats)
 InheritClauses    ::=  [‘extends’ ConstrApps] [‘derives’ QualId {‘,’ QualId}]
 ConstrApps        ::=  ConstrApp {‘with’ ConstrApp}
diff --git a/docs/docs/reference/changed-features/implicit-conversions-spec.md b/docs/docs/reference/changed-features/implicit-conversions-spec.md
index d1bf918421bb..408bd68328a5 100644
--- a/docs/docs/reference/changed-features/implicit-conversions-spec.md
+++ b/docs/docs/reference/changed-features/implicit-conversions-spec.md
@@ -9,16 +9,17 @@ An implicit conversion, or _view_, from type `S` to type `T` is
 defined by either:
 
 - An `implicit def` which has type `S => T` or `(=> S) => T`
-- An implicit value which has type `ImplicitConverter[S, T]`
+- An implicit value which has type `Conversion[S, T]`
 
-The standard library defines an abstract class `ImplicitConverter`:
+The standard library defines an abstract class `Conversion`:
 
 ```scala
-abstract class ImplicitConverter[-T, +U] extends Function1[T, U]
+package scala
+@java.lang.FunctionalInterface
+abstract class Conversion[-T, +U] extends Function1[T, U]
 ```
 
-Function literals are automatically converted to `ImplicitConverter`
-values.
+Function literals are automatically converted to `Conversion` values.
 
 Views are applied in three situations:
 
@@ -60,14 +61,14 @@ val x: String = 0 // Compiles in Scala2 (uses `conv1`),
 
 In Scala 2, implicit values of a function type would be considered as
 potential views. In Scala 3, these implicit value need to have type
-`ImplicitConverter`:
+`Conversion`:
 
 ```scala
 // Scala 2:
 def foo(x: Int)(implicit conv: Int => String): String = x
 
 // Becomes with Scala 3:
-def foo(x: Int)(implicit conv: ImplicitConverter[Int, String]): String = x
+def foo(x: Int)(implicit conv: Conversion[Int, String]): String = x
 
 // Call site is unchanged:
 foo(4)(_.toString)
@@ -76,7 +77,7 @@ foo(4)(_.toString)
 implicit val myConverter: Int => String = _.toString
 
 // Becomes with Scala 3:
-implicit val myConverter: ImplicitConverter[Int, String] = _.toString
+implicit val myConverter: Conversion[Int, String] = _.toString
 ```
 
 Note that implicit conversions are also  affected by the [changes to
@@ -85,7 +86,7 @@ Scala 3.
 
 ## Motivation for the changes
 
-The introduction of `ImplicitConverter` in Scala 3 and the decision to
+The introduction of `Conversion` in Scala 3 and the decision to
 restrict implicit values of this type to be considered as potential
 views comes from the desire to remove surprising behavior from the
 language:
@@ -101,12 +102,12 @@ This snippet contains a type error. The right hand side of `val x`
 does not conform to type `String`. In Scala 2, the compiler will use
 `m` as an implicit conversion from `Int` to `String`, whereas Scala 3
 will report a type error, because Map isn't an instance of
-`ImplicitConverter`.
+`Conversion`.
 
 ## Migration path
 
 Implicit values that are used as views should see their type changed
-to `ImplicitConverter`.
+to `Conversion`.
 
 For the migration of implicit conversions that are affected by the
 changes to implicit resolution, refer to the [Changes in Implicit
diff --git a/docs/docs/reference/changed-features/implicit-conversions.md b/docs/docs/reference/changed-features/implicit-conversions.md
index 67bccc4933d6..ade6c13187d9 100644
--- a/docs/docs/reference/changed-features/implicit-conversions.md
+++ b/docs/docs/reference/changed-features/implicit-conversions.md
@@ -19,7 +19,7 @@ case).
 This conversion can be either:
 
 1. An `implicit def` of type `T => S` or `(=> T) => S`
-1. An implicit value of type `ImplicitConverter[T, S]`
+1. An implicit value of type `scala.Conversion[T, S]`
 
 Defining an implicit conversion will emit a warning unless the import
 `scala.language.implicitConversions` is in scope, or the flag
@@ -37,14 +37,14 @@ implicit def int2Integer(x: Int): java.lang.Integer =
   x.asInstanceOf[java.lang.Integer]
 ```
 
-The second example shows how to use `ImplicitConverter` to define an
+The second example shows how to use `Conversion` to define an
 `Ordering` for an arbitrary type, given existing `Ordering`s for other
 types:
 
 ```scala
 import scala.language.implicitConversions
 implicit def ordT[T, S](
-  implicit conv: ImplicitConverter[T, S],
+  implicit conv: Conversion[T, S],
            ordS: Ordering[S]
   ): Ordering[T] = {
   // `ordS` compares values of type `S`, but we can convert from `T` to `S`
@@ -54,7 +54,7 @@ implicit def ordT[T, S](
 class A(val x: Int) // The type for which we want an `Ordering`
 
 // Convert `A` to a type for which an `Ordering` is available:
-implicit val AToInt: ImplicitConverter[A, Int] = _.x
+implicit val AToInt: Conversion[A, Int] = _.x
 
 implicitly[Ordering[Int]] // Ok, exists in the standard library
 implicitly[Ordering[A]] // Ok, will use the implicit conversion from
diff --git a/docs/docs/reference/instances/context-params.md b/docs/docs/reference/instances/context-params.md
new file mode 100644
index 000000000000..ef58b3d82ece
--- /dev/null
+++ b/docs/docs/reference/instances/context-params.md
@@ -0,0 +1,89 @@
+---
+layout: doc-page
+title: "Context Parameters and Arguments"
+---
+
+Context parameters are the name of a new syntax for implicit parameters that aligns definition and call syntax. Parameter definitions
+and method  arguments both follow a `with` connective. On the definition side, the old syntax
+```scala
+def f(a: A)(implicit b: B)
+```
+is now expressed as
+```scala
+def f(a: A) with (b: B)
+```
+or, leaving out the parameter name,
+```scala
+def f(a: A) with B
+```
+Implicit parameters defined with the new syntax are also called _context parameters_.
+They come with a matching syntax for applications: explicit arguments for context parameters are also given after a `with`.
+
+The following example shows shows three methods that each have a context parameter for `Ord[T]`.
+```scala
+def maximum[T](xs: List[T]) with Ord[T]: T =
+  xs.reduceLeft((x, y) => if (x < y) y else x)
+
+def descending[T] with (asc: Ord[T]): Ord[T] = new Ord[T] {
+  def (x: T) compareTo (y: T) = asc.compareTo(y)(x)
+}
+
+def minimum[T](xs: List[T]) with Ord[T] =
+  maximum(xs) with descending
+```
+The `minimum` method's right hand side passes `descending` as an explicit argument to `maximum(xs)`.
+But usually, explicit arguments for context parameters are be left out. For instance,
+given `xs: List[Int]`, the following calls are all possible (and they all normalize to the last one:)
+```scala
+maximum(xs)
+maximum(xs) with descending
+maximum(xs) with (descending with IntOrd)
+```
+Arguments for context parameters must be given using the `with` syntax. So the expression `maximum(xs)(descending)` would give a type error.
+
+The `with` connective is treated like an infix operator with the same precedence as other operators that start with a letter. The expression following a `with` may also be an argument list consisting of several implicit arguments separated by commas. If a tuple should be passed as a single implicit argument (probably an uncommon case), it has to be put in a pair of extra parentheses:
+```scala
+def f with (x: A, y: B)
+f with (a, b)
+
+def g with (xy: (A, B))
+g with ((a, b))
+```
+Unlike existing implicit parameters, context parameters can be freely mixed with normal parameter lists.
+A context parameter may be followed by a normal parameter and _vice versa_. There can be several context parameter
+lists in a definition. Example:
+```scala
+def f with (u: Universe) (x: u.T) with Context = ...
+
+instance global for Universe { type T = String ... }
+instance ctx for Context { ... }
+```
+Then the following calls are all valid (and normalize to the last one)
+```scala
+f("abc")
+(f with global)("abc")
+f("abc") with ctx
+(f with global)("abc") with ctx
+```
+Context parameters may be given either as a normal parameter list `(...)`
+or as a sequence of types. To distinguish the two, a leading `(` always indicates a parameter list.
+
+## Summoning an Instance
+
+A method `summon` in `Predef` creates an implicit instance value for a given type, analogously to what `implicitly[T]` did. The only difference between the two is that
+`summon` takes a context parameter, where `implicitly` took an old-style implicit parameter:
+```scala
+def summon[T] with (x: T) = x
+```
+
+## Syntax
+
+Here is the new syntax of parameters and arguments seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
+```
+ClsParamClause    ::=  ...
+                    |  ‘with’ (‘(’ [ClsParams] ‘)’ | ContextTypes)
+DefParamClause    ::=  ...
+                    |  InstParamClause
+InfixExpr         ::=  ...
+                    |  InfixExpr ‘with’ (InfixExpr | ParArgumentExprs)
+```
diff --git a/docs/docs/reference/instances/discussion/context-params.md b/docs/docs/reference/instances/discussion/context-params.md
new file mode 100644
index 000000000000..afd6992ef5f0
--- /dev/null
+++ b/docs/docs/reference/instances/discussion/context-params.md
@@ -0,0 +1,121 @@
+---
+layout: doc-page
+title: "Context Parameters and Arguments"
+---
+
+This page presents new syntax for defining implicit parameters that aligns definition and call syntax. In both cases, the implicit parameter or argument now follows a `with` connective.
+On the definition side, the old syntax
+```scala
+def f(a: A)(implicit b: B)
+```
+is now expressed as
+```scala
+def f(a: A) with (b: B)
+```
+Implicit parameters defined with the new syntax are also called _context parameters_.
+They come with a matching syntax for applications: explicit arguments for context parameters are also given after a `with`.
+
+The following example shows shows three methods that each have a context parameter for `Ord[T]`.
+```scala
+def maximum[T](xs: List[T]) with (cmp: Ord[T]): T =
+  xs.reduceLeft((x, y) => if (x < y) y else x)
+
+def descending[T] with (asc: Ord[T]): Ord[T] = new Ord[T] {
+  def (x: T) compareTo (y: T) = asc.compareTo(y)(x)
+}
+
+def minimum[T](xs: List[T]) with (cmp: Ord[T]) =
+  maximum(xs) with descending
+```
+The `minimum` method's right hand side defines the explicit argument `descending`.
+Explicit arguments for context parameters can be left out. For instance,
+given `xs: List[Int]`, the following calls are all possible (and they all normalize to the last one:)
+```scala
+maximum(xs)
+maximum(xs) with descending
+maximum(xs) with (descending with IntOrd)
+```
+Arguments for context parameters must be given using the `with` syntax. So the expression `maximum(xs)(descending)` would give a type error.
+
+The `with` connective is treated like an infix operator with the same precedence as other operators that start with a letter. The expression following a `with` may also be an argument list consisting of several implicit arguments separated by commas. If a tuple should be passed as a single implicit argument (probably an uncommon case), it has to be put in a pair of extra parentheses:
+```scala
+def f with (x: A, y: B)
+f with (a, b)
+
+def g with (xy: (A, B))
+g with ((a, b))
+```
+
+## Implicit Function Types and Closures
+
+Implicit function types are expressed using the new reserved operator `|=>`. Examples:
+```scala
+Context |=> T
+A |=> B |=> T
+(A, B) |=> T
+(x: A, y: B) |=> T
+```
+The `|=>` syntax was chosen for its resemblance with a turnstile symbol `|-` which signifies context dependencies.
+
+The old syntax `implicit A => B` is no longer available.
+Implicit function types are applied using `with`:
+```scala
+val f: A |=> B
+val a: A
+f with a    // OK
+f(a)        // error: `f` does not take parameters
+```
+Since application of regular function types and implicit function types different, implicit function types are no longer subtypes of regular function types.
+
+The `|=>` syntax can also be used for closures. It turns the parameter bindings into implicit
+parameters and makes the closure's type an implicit function type
+```scala
+case class Context(value: String)
+val f1: Context |=> String  =  ctx |=> ctx.value
+val f2: Context |=> String  =  (ctx: Context) |=> ctx.value
+val f3: (A, B) |=> T        =  (a: A, b: B) |=> t
+```
+The old syntax `implicit (a: A) => B` now creates a closure of a regular function type `A => B` instead of an implicit function type `A |=> B`. This matches the types of implicit closures in Scala 2.x.
+
+## Example
+
+Implementing postconditions via `ensuring`:
+```scala
+object PostConditions {
+  opaque type WrappedResult[T] = T
+
+  private instance WrappedResult {
+    def apply[T](x: T): WrappedResult[T] = x
+    def (x: WrappedResult[T]) unwrap[T]: T = x
+  }
+
+  def result[T] with (wrapped: WrappedResult[T]): T = wrapped.unwrap
+
+  instance {
+    def (x: T) ensuring[T] (condition: WrappedResult[T] |=> Boolean): T = {
+      assert(condition with WrappedResult(x))
+      x
+    }
+  }
+}
+
+object Test {
+  import PostConditions._
+  val s = List(1, 2, 3).sum.ensuring(result == 6)
+}
+```
+## Syntax
+
+Here is the new syntax of parameters, arguments, and implicit function types seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
+```
+ClsParamClause    ::=  ...
+                    |  ‘with’ ‘(’ [ClsParams] ‘)’
+DefParamClause    ::=  ...
+                    |  ‘with’ ‘(’ [DefParams] ‘)’
+Type              ::=  ...
+                    |  [‘erased’] FunArgTypes ‘|=>’ Type
+Expr              ::=  ...
+                    |  [‘erased’] FunParams ‘|=>’ Expr
+InfixExpr         ::=  ...
+                    |  InfixExpr ‘with’ (InfixExpr | ParArgumentExprs)
+```
diff --git a/docs/docs/reference/instances/discussion/discussion.md b/docs/docs/reference/instances/discussion/discussion.md
new file mode 100644
index 000000000000..ba38f004aa92
--- /dev/null
+++ b/docs/docs/reference/instances/discussion/discussion.md
@@ -0,0 +1,52 @@
+---
+layout: doc-page
+title: "Discussion"
+---
+
+## Summary
+
+The instance proposal consists of two main parts:
+
+ - Define a new [high-level syntax for instance definitions](./instance-defs.html) that works out better the intent underlying implicit definitions.
+ - Define a [new syntax for implicit parameters](./context-params.html) that aligns formal parameters and arguments.
+ - Define [abstract and alias instances](./replacing-implicits.html) and replace all existing usages of `implicit` in the language.
+
+
+## Migration
+
+New and old syntax would co-exist initially. Rewrite rules could rewrite old syntax to new automatically. This is trivial in the case of implicit parameters and implicit function types. It is a bit more involved in the case of implicit definitions, since more extensive pattern matching is required to recognize a definition that can be rewritten to a instance.
+
+To make gradual change possible, we allow the new `with` application syntax also for
+old style implicit parameters.
+
+One tricky question concerns context bounds. During the migration period, should they map to old style implicit parameters or new style context parameters? Mapping them to context parameters could break things in difficult to diagnose ways since then an explicit argument for a context bound would be treated as a type error, or, in the worst case, would be constructed as an argument for an `apply` of the result of method with the
+context bound. Also, it would remove context bounds from the common subset that is
+treated the same in Scala 2 and 3. We therefore opt to map context bounds to old style implicit parameters for the time being. In the future, migrating context bounds implies a three-step process:
+
+ - Step 1: Deprecate passing arguments to evidence parameters defined by context bounds
+   directly. All such parameters should be passed with `with`.
+ - Step 2: Remove ability to pass context bound arguments directly.
+ - Step 3: Map context bounds to context parameters.
+
+The third part (replacing existing implicits) should be adopted well after the first two parts are implemented. Alias and abstract instances could be introduced together with the other instance definitions, but could also come later.
+
+## Discussion
+
+This is a rather sweeping proposal, which will affect most Scala code. Here are some supporting arguments and a summary of alternatives that were considered.
+
+The instance definition syntax makes the definition of implicit instances clearer and more concise. People have repeatedly asked for specific "typeclass syntax" in Scala. I believe that instance definitions together with extension methods address this ask quite well.
+
+Probably the most far reaching and contentious changes affect implicit parameters. There might be resistance to change, because the existing scheme seems to work "well enough". However, I believe there is a price to pay for the status quo. The need to write `.apply` occasionally to force implicit arguments is already bad. Worse is the fact that implicits always have to come last, which makes useful program patterns much more cumbersome than before and makes the language less regular.
+
+Two alternatives to the proposed syntax changes for implicit parameters were considered:
+
+ 1. Leave `implicit` parameters as they are. This suffers from the problems stated
+   in the [motivation section](./motivation.md).
+ 2. Leave the syntax of `implicit` parameters but institute two changes: First, applications
+   of implicit parameters must be via the pseudo method `.explicitly(...)`. Second, there can be more than one implicit parameter list and implicit parameters may precede explicit ones. This fixes most of the discussed problems, but at the expense of a bulky explicit application syntax. Bulk can be a problem, for instance when the programmer tries to
+   construct an extensive explicit argument tree to figure out what went wrong with a missing
+   implicit. Another issue is that migration from old to new scheme would be tricky and
+   would likely take multiple language versions.
+
+A contentious point is whether we want abstract and alias instances. As an alternative, one would could also keep the current syntax for implicit vals and defs, which can express the same concepts. The main advantage to introduce abstract and alias instances is that it would
+allow us to drop implicit definitions altogether.
\ No newline at end of file
diff --git a/docs/docs/reference/instances/discussion/instance-defs.md b/docs/docs/reference/instances/discussion/instance-defs.md
new file mode 100644
index 000000000000..d0968ad03144
--- /dev/null
+++ b/docs/docs/reference/instances/discussion/instance-defs.md
@@ -0,0 +1,186 @@
+---
+layout: doc-page
+title: "Instance Definitions"
+---
+
+Instance definitions provide a concise and uniform syntax for defining implicit values. Example:
+
+```scala
+trait Ord[T] {
+  def (x: T) compareTo (y: T): Int
+  def (x: T) < (y: T) = x.compareTo(y) < 0
+  def (x: T) > (y: T) = x.compareTo(y) > 0
+}
+
+instance IntOrd of Ord[Int] {
+  def (x: Int) compareTo (y: Int) =
+    if (x < y) -1 else if (x > y) +1 else 0
+}
+
+instance ListOrd[T: Ord] of Ord[List[T]] {
+  def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+    case (Nil, Nil) => 0
+    case (Nil, _) => -1
+    case (_, Nil) => +1
+    case (x :: xs1, y :: ys1) =>
+      val fst = x.compareTo(y)
+      if (fst != 0) fst else xs1.compareTo(ys1)
+  }
+}
+```
+
+Instance can be seen as shorthands for what is currently expressed as implicit definitions. The instance definitions above could also have been formulated as implicits as follows:
+```scala
+implicit object IntOrd extends Ord[Int] {
+  def (x: Int) compareTo (y: Int) =
+    if (x < y) -1 else if (x > y) +1 else 0
+}
+
+class ListOrd[T: Ord] extends Ord[List[T]] {
+  def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+    case (Nil, Nil) => 0
+    case (Nil, _) => -1
+    case (_, Nil) => +1
+    case (x :: xs1, y :: ys1) =>
+      val fst = x.compareTo(y)
+      if (fst != 0) fst else xs1.compareTo(ys1)
+  }
+}
+implicit def ListOrd[T: Ord]: Ord[List[T]] = new ListOrd[T]
+```
+In fact, a plausible compilation strategy would map the instance definitions given above to exactly these implicit definitions.
+
+Implicit definitions are kept for the moment but should be be deprecated eventually. As we will see, the only kind of implicit definitions that cannot be directly emulated by instance definitions are implicit conversions.
+
+Why prefer instance over implicit definitions? Their definitions are shorter, more uniform, and they focus on intent rather than mechanism: I.e. we define an _instance of_ a type, instead of an _implicit object_ that happens to _extend_ a type. Likewise, the `ListOrd` instance is shorter and clearer than the class/implicit def combo that emulates it. Arguably, `implicit` was always a misnomer. An `implicit object` is every bit as explicit as a plain object, it's just that the former is eligible as a synthesized (implicit) argument to an _implicit parameter_. So, "implicit" makes sense as an adjective for arguments and at a stretch for parameters, but not so much for the other kinds of definitions.
+
+## Instances for Extension Methods
+
+Instances can also be defined without an `of` clause. A typical application is to use a instance to package some extension methods. Examples:
+
+```scala
+instance StringOps {
+  def (xs: Seq[String]) longestStrings: Seq[String] = {
+    val maxLength = xs.map(_.length).max
+    xs.filter(_.length == maxLength)
+  }
+}
+
+instance ListOps {
+  def (xs: List[T]) second[T] = xs.tail.head
+}
+```
+Instances like these translate to `implicit` objects without an extends clause.
+
+## Anonymous Instances
+
+The name of an instance definition can be left out. Examples:
+```scala
+instance of Ord[Int] { ... }
+instance [T: Ord] of Ord[List[T]] { ... }
+
+instance {
+  def (xs: List[T]) second[T] = xs.tail.head
+}
+```
+If the name of an instance is missing, the compiler will synthesize a name from
+the type in the of clause, or, if that is missing, from the first defined
+extension method. Details remain to be specified.
+
+## Conditional Instances
+
+An instance definition can depend on another instance being defined. For instance:
+```scala
+trait Convertible[From, To] {
+  def convert(x: From): To
+}
+
+instance [From, To] with (c: Convertible[From, To]) of Convertible[List[From], List[To]] {
+  def convert(x: List[From]): List[To] = x.map(c.convert)
+}
+```
+
+The `with` clause instance defines required instances. The instance of `Convertible[List[From], List[To]]` above is defined only if an instance of `Convertible[From, To]` exists.
+`with` clauses translate to implicit parameters of implicit methods. Here is the expansion of the anonymous instance above in terms of a class and an implicit method (the example demonstrates well the reduction in boilerplate afforded by instance syntax):
+```scala
+class Convertible_List_List_instance[From, To](implicit c: Convertible[From, To])
+extends Convertible[List[From], List[To]] {
+  def convert (x: List[From]): List[To] = x.map(c.convert)
+}
+implicit def Convertible_List_List_instance[From, To](implicit c: Convertible[From, To])
+  : Convertible[List[From], List[To]] =
+  new Convertible_List_List_instance[From, To]
+```
+Context bounds in instance definitions also translate to implicit parameters, and therefore they can be represented alternatively as with clauses. For instance, here is an equivalent definition of the `ListOrd` instance:
+```scala
+instance ListOrd[T] with (ord: Ord[T]) of List[Ord[T]] { ... }
+```
+An underscore ‘_’ can be used as the name of a required instance, if that instance does not
+need to be referred to directly. For instance, the last `ListOrd` instance could also have been written like this:
+```scala
+instance ListOrd[T] with (_: Ord[T]) of List[Ord[T]] { ... }
+```
+
+**Design note:** An alternative to the underscore syntax would be to allow the `name:` part to be left out entirely. I.e. it would then be `instance ListOrd[T] with (Ord[T]) of ...`. I am not yet sure which is preferable.
+
+
+## Typeclass Instances
+
+Here are some examples of standard typeclass instances:
+
+Semigroups and monoids:
+
+```scala
+trait SemiGroup[T] {
+  def (x: T) combine (y: T): T
+}
+trait Monoid[T] extends SemiGroup[T] {
+  def unit: T
+}
+
+instance of Monoid[String] {
+  def (x: String) combine (y: String): String = x.concat(y)
+  def unit: String = ""
+}
+
+def sum[T: Monoid](xs: List[T]): T =
+    xs.foldLeft(summon[Monoid[T]].unit)(_.combine(_))
+```
+Functors and monads:
+```scala
+trait Functor[F[_]] {
+  def (x: F[A]) map[A, B] (f: A => B): F[B]
+}
+
+trait Monad[F[_]] extends Functor[F] {
+  def (x: F[A]) flatMap[A, B] (f: A => F[B]): F[B]
+  def (x: F[A]) map[A, B] (f: A => B) = x.flatMap(f `andThen` pure)
+
+  def pure[A](x: A): F[A]
+}
+
+instance ListMonad of Monad[List] {
+  def (xs: List[A]) flatMap[A, B] (f: A => List[B]): List[B] =
+    xs.flatMap(f)
+  def pure[A](x: A): List[A] =
+    List(x)
+}
+
+instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
+  def (r: Ctx => A) flatMap[A, B] (f: A => Ctx => B): Ctx => B =
+    ctx => f(r(ctx))(ctx)
+  def pure[A](x: A): Ctx => A =
+    ctx => x
+}
+```
+
+## Syntax
+
+Here is the new syntax of instance definitions, seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
+```
+TmplDef          ::=  ...
+                  |  ‘instance’ InstanceDef
+InstanceDef      ::=  [id] InstanceParams [‘of’ ConstrApps] [TemplateBody]
+InstanceParams   ::=  [DefTypeParamClause] {‘with’ ‘(’ [DefParams] ‘)}
+```
+The identifier `id` can be omitted only if either the `of` part or the template body is present. If the `of` part is missing, the template body must define at least one extension method.
\ No newline at end of file
diff --git a/docs/docs/reference/instances/discussion/motivation.md b/docs/docs/reference/instances/discussion/motivation.md
new file mode 100644
index 000000000000..8df60ed25258
--- /dev/null
+++ b/docs/docs/reference/instances/discussion/motivation.md
@@ -0,0 +1,45 @@
+---
+layout: doc-page
+title: "Motivation"
+---
+
+### Critique
+
+Scala's implicits are its most distinguished feature. They are _the_ fundamental way to abstract over context. They represent a single concept with an extremely varied number of use cases, among them: implementing type classes, establishing context, dependency injection, expressing capabilities, computing new types and proving relationships between them.
+
+At the same time, implicits are also a controversial feature. I believe there are several reasons for this.
+
+_First_, being very powerful, implicits are easily over-used and mis-used. This observation holds in almost all cases when we talk about _implicit conversions_, which, even though conceptually different, share the same syntax with other implicit definitions. For instance,
+regarding the two definitions
+
+    implicit def i1(implicit x: T): C[T] = ...
+    implicit def i2(x: T): C[T] = ...
+
+the first of these is a conditional implicit _value_, the second an implicit _conversion_. Conditional implicit values are a cornerstone for expressing type classes, whereas most applications of implicit conversions have turned out to be of dubious value. The problem is that many newcomers to the language start with defining implicit conversions since they are easy to understand and seem powerful and convenient. Scala 3 will put under a language flag both definitions and applications of "undisciplined" implicit conversions between types defined elsewhere. This is a useful step to push back against overuse of implicit conversions. But the problem remains that syntactically, conversions and values just look too similar for comfort.
+
+_Second_, implicits pose challenges for tooling. The set of available implicits depends on context, so command completion has to take context into account. This is feasible in an IDE but docs like ScalaDoc that are based static web pages can only provide an approximation. Another problem is that failed implicit searches often give very unspecific error messages, in particular if some deeply recursive implicit search has failed. The dotty compiler implements some improvements in this case, but further progress would be desirable.
+
+_Third_, the syntax of implicit definitions might be a bit too minimal. It consists of a single modifier, `implicit`, that can be attached to a large number of language constructs. A problem with this for newcomers is that it often conveys mechanism better than intent. For instance, a typeclass instance is an implicit object or val if unconditional and an implicit def with implicit parameters if conditional. This describes precisely what the implicit definitions translate to -- just drop the `implicit` modifier, and that's it! But the cues that define intent are rather indirect and can be easily misread, as demonstrated by the definitions of `i1` and `i2` above.
+
+_Fourth_, the syntax of implicit parameters has also some shortcomings. It starts with the position of `implicit` as a pseudo-modifier that applies to a whole parameter section instead of a single parameter. This represents an irregular case wrt to the rest of Scala's syntax. Furthermore, while implicit _parameters_ are designated specifically, arguments are not. Passing an argument to an implicit parameter looks like a regular application `f(arg)`. This is problematic because it means there can be confusion regarding what parameter gets instantiated in a call. For instance, in
+```scala
+def currentMap(implicit ctx: Context): Map[String, Int]
+```
+one cannot write `currentMap("abc")` since the string "abc" is taken as explicit argument to the implicit `ctx` parameter. One has to write `currentMap.apply("abc")` instead, which is awkward and irregular. For the same reason, a method definition can only have one implicit parameter section and it must always come last. This restriction not only reduces orthogonality, but also prevents some useful program constructs, such as a method with a regular parameter whose type depends on an implicit value. Finally, it's also a bit annoying that implicit parameters must have a name, even though in many cases that name is never referenced.
+
+None of the shortcomings is fatal, after all implicits are very widely used, and many libraries and applications rely on them. But together, they make code using implicits more cumbersome and less clear than it could be.
+
+Can implicit function types help? Implicit function types allow to abstract over implicit parameterization. They are a key part of the program to make as many aspects of methods as possible first class. Implicit function types can avoid much of the repetition in programs that use implicits widely. But they do not directly address the issues mentioned here.
+
+### Alternative Design
+
+`implicit` is a modifier that gets attached to various constructs. I.e. we talk about implicit vals, defs, objects, parameters, or arguments. This conveys mechanism rather than intent. What _is_ the intent that we want to convey? Ultimately it's "trade types for terms". The programmer specifies a type and the compiler fills in the term matching that type automatically. So the concept we are after would serve to express definitions that provide the canonical _instances_ for certain types.
+
+The next sections elaborate such an alternative design. It consists of three proposals:
+
+ - A proposal to replace implicit _definitions_ by [instance definitions](./instance-defs.html).
+ - A proposal for a [new syntax](./context-params.html) of implicit _parameters_ and their _arguments_.
+ - A proposal to [replace all remaining usages](./replacing-implicits.html) of `implicit` in the language.
+
+The first two proposals are independent of each other. The last one would work only if the first two are adopted.
+A [discussion page](./discussion.html) summarizes and evaluates the proposal.
diff --git a/docs/docs/reference/instances/discussion/replacing-implicits.md b/docs/docs/reference/instances/discussion/replacing-implicits.md
new file mode 100644
index 000000000000..514379d2e75b
--- /dev/null
+++ b/docs/docs/reference/instances/discussion/replacing-implicits.md
@@ -0,0 +1,111 @@
+---
+layout: doc-page
+title: "Replacing Implicits"
+---
+
+The previous two pages proposed high-level syntax for implicit definitions and a new syntax for implicit parameters.
+
+This addresses all the issues mentioned in the [Motivation](./motivation.md), but it leaves us with two related constructs: new style instance definitions and context parameters and traditional implicits. This page discusses what would be needed to get rid of `implicit` entirely.
+
+## Abstract and Alias Instances
+
+Instance definitions can be abstract.
+As an example of an abstract instance, consider the following fragment that's derived from Scala's Tasty extractor framework:
+```scala
+trait TastyAPI {
+  type Symbol
+  trait SymDeco {
+    def (sym: Symbol) name: Name
+    def (sym: Symbol) tpe: Type
+  }
+  instance symDeco: SymDeco
+}
+```
+Here, `symDeco` is available as a instance of the `SymDeco` trait but its actual implementation
+is deferred to subclasses of the `TastyAPI` trait.
+
+An example of an alias instance would be an implementation of `symDeco` in terms of some internal compiler structure:
+```scala
+trait TastyImpl extends TastyAPI {
+  instance symDeco: SymDeco = compilerSymOps
+}
+```
+Note that the result type of an abstract or alias instance is introduced with a colon instead of an `of`. This seems more natural since it evokes the similarity to implicit parameters, whose type is also given following a `:`. It also avoids the syntactic ambiguity with an instance definition of a class that does not add any new definitions. I.e.
+```scala
+instance a of C   // concrete instance of class C, no definitions added
+instance b: C     // abstract instance of class C
+```
+Further examples of alias instances:
+```scala
+instance ctx = outer.ctx
+instance ctx: Context = outer.ctx
+instance byNameCtx with (): Context = outer.ctx
+instance f[T]: C[T] = new C[T]
+instance g with (ctx: Context): D = new D(ctx)
+```
+As another example, if one had already defined classes `IntOrd` and `ListOrd`, instances for them could be defined as follows:
+```scala
+class IntOrd extends Ord[Int] { ... }
+class ListOrd[T: Ord] extends Ord[List[T]] { ... }
+
+instance intOrd: Ord[Int] = new IntOrd
+instance listOrd[T: Ord]: Ord[List[T]] = new ListOrd[T]
+```
+The result type of a alias instance is mandatory unless the instance definition
+occurs as a statement in a block and lacks any type or value parameters. This corresponds to the same restriction for implicit vals in Dotty.
+
+Abstract instances are equivalent to abstract implicit defs. Alias instances are equivalent to implicit defs if they are parameterized or to implicit vals otherwise. For instance, the instances defined so far in this section are equivalent to:
+```scala
+implicit def symDeco: SymDeco
+implicit val symDeco: SymDeco = compilerSymOps
+
+implicit val ctx = outer.ctx
+implicit val ctx: Context = outer.ctx
+implicit def byNameCtx: Ctx = outer.ctx
+implicit def f[T]: C[T] = new C[T]
+implicit def g(implicit ctx: Context): D = new D(ctx)
+
+implicit val intOrd: Ord[Int] = new IntOrd
+implicit def listOrd(implicit ev: Ord[T]): Ord[List[T]] = new ListOrd[T]
+```
+The `lazy` modifier is applicable to unparameterized alias instances. If present, the resulting implicit val is lazy. For instance,
+```scala
+lazy instance intOrd2: Ord[Int] = new IntOrd
+```
+would be equivalent to
+```scala
+lazy implicit val intOrd2: Ord[Int] = new IntOrd
+```
+
+## Implicit Conversions and Classes
+
+The only use cases that are not yet covered by the proposal are implicit conversions and implicit classes. We do not propose to use `instance` in place of `implicit` for these, since that would bring back the uncomfortable similarity between implicit conversions and parameterized implicit aliases. However, there is a way to drop implicit conversions entirely. Scala 3 already [defines](https://github.com/lampepfl/dotty/pull/2065) a class `Conversion` whose instances are available as implicit conversions.
+```scala
+  abstract class Conversion[-T, +U] extends Function1[T, U]
+```
+One can define all implicit conversions as instances of this class. E.g.
+```scala
+instance StringToToken of Conversion[String, Token] {
+  def apply(str: String): Token = new KeyWord(str)
+}
+```
+The fact that this syntax is more verbose than simple implicit defs could be a welcome side effect since it might dampen any over-enthusiasm for defining implicit conversions.
+
+That leaves implicit classes. Most use cases of implicit classes are probably already covered by extension methods. For the others, one could always fall back to a pair of a regular class and an `Conversion` instance. It would be good to do a survey to find out how many classes would be affected.
+
+## Summoning an Instance
+
+Besides `implicit`, there is also `implicitly`, a method defined in `Predef` that computes an implicit value for a given type. A possible replacement could be `instanceOf`. Or, keeping with common usage, one could introduce the name `summon` for this operation. So `summon[T]` summons an instance of `T`, in the same way as `implicitly[T]` did. The definition of `summon` is straightforward:
+```scala
+def summon[T] with (x: T) = x
+```
+
+## Syntax
+
+The syntax changes for this page are summarized as follows:
+```
+InstanceDef     ::=  ...
+                  |  id InstanceParams ‘:’ Type ‘=’ Expr
+                  |  id ‘=’ Expr
+```
+In addition, the `implicit` modifier is removed together with all [productions]((http://dotty.epfl.ch/docs/internals/syntax.html) that reference it.
diff --git a/docs/docs/reference/instances/implicit-function-types-spec.md b/docs/docs/reference/instances/implicit-function-types-spec.md
new file mode 100644
index 000000000000..80f50964e586
--- /dev/null
+++ b/docs/docs/reference/instances/implicit-function-types-spec.md
@@ -0,0 +1,88 @@
+---
+layout: doc-page
+title: "Implicit Function Types - More Details"
+---
+
+Initial implementation in (#1775)[https://github.com/lampepfl/dotty/pull/1775].
+
+## Syntax
+
+    Type              ::=  ...
+                        |  FunArgTypes `|=>' Type
+    Expr              ::=  ...
+                        |  FunParams `|=>' Expr
+
+Implicit function types associate to the right, e.g.
+`S |=> T => U` is the same as `S => (T => U)`.
+
+## Implementation
+
+Implicit function types are shorthands for class types that define `apply`
+methods with implicit parameters. Specifically, the `N`-ary function type
+`T1, ..., TN => R` is a shorthand for the class type
+`ImplicitFunctionN[T1 , ... , TN, R]`. Such class types are assumed to have
+the following definitions, for any value of `N >= 1`:
+```scala
+package scala
+trait ImplicitFunctionN[-T1 , ... , -TN, +R] {
+  def apply with (x1: T1 , ... , xN: TN): R
+}
+```
+Implicit function types erase to normal function types, so these classes are
+generated on the fly for typechecking, but not realized in actual code.
+
+Anonymous implicit function values `(x1: T1, ..., xn: Tn) |=> e` map
+implicit parameters `xi` of types `Ti` to a result given by expression `e`.
+The scope of each implicit parameter `xi` is `e`. Implicit parameters must
+have pairwise distinct names.
+
+If the expected type of the anonymous implicit function is of the form
+`scala.ImplicitFunctionN[S1, ..., Sn, R]`, the expected type of `e` is `R` and
+the type `Ti` of any of the parameters `xi` can be omitted, in which case `Ti
+= Si` is assumed. If the expected type of the anonymous implicit function is
+some other type, all implicit parameter types must be explicitly given, and
+the expected type of `e` is undefined. The type of the anonymous implicit
+function is `scala.ImplicitFunctionN[S1, ...,Sn, T]`, where `T` is the widened
+type of `e`. `T` must be equivalent to a type which does not refer to any of
+the implicit parameters `xi`.
+
+The anonymous implicit function is evaluated as the instance creation
+expression:
+
+    new scala.ImplicitFunctionN[T1, ..., Tn, T] {
+      def apply with (x1: T1, ..., xn: Tn): T = e
+    }
+
+In the case of a single untyped implicit parameter, `(x) |=> e` can be
+abbreviated to `x |=> e`.
+
+A implicit parameter may also be a wildcard represented by an underscore `_`. In
+that case, a fresh name for the parameter is chosen arbitrarily.
+
+Note: The closing paragraph of the [Anonymous Functions section](https://www
+.scala-lang.org/files/archive/spec/2.12/06-expressions.html#anonymous-
+functions) of the Scala 2.12 is subsumed by implicit function types and should
+be removed.
+
+Anonymous implicit functions `(x1: T1, ..., xn: Tn) |=> e` are
+automatically inserted around any expression `e` whose expected type is
+`scala.ImplicitFunctionN[T1, ..., Tn, R]`, unless `e` is
+itself a function literal. This is analogous to the automatic
+insertion of `scala.Function0` around expressions in by-name argument position.
+
+Implicit functions generalize to `N > 22` in the same way that functions do,
+see [the corresponding
+documentation](https://dotty.epfl.ch/docs/reference/dropped-features/limit22.html).
+
+## Examples
+
+See the section on Expressiveness from [Simplicitly: foundations and
+applications of implicit function
+types](https://dl.acm.org/citation.cfm?id=3158130). I've extracted it in [this
+Gist](https://gist.github.com/OlivierBlanvillain/234d3927fe9e9c6fba074b53a7bd9
+592), it might easier to access than the pdf.
+
+### Type Checking
+
+After desugaring no additional typing rules are required for implicit function
+types.
diff --git a/docs/docs/reference/new-types/implicit-function-types.md b/docs/docs/reference/instances/implicit-function-types.md
similarity index 51%
rename from docs/docs/reference/new-types/implicit-function-types.md
rename to docs/docs/reference/instances/implicit-function-types.md
index e3b956ecbf46..4474711990bd 100644
--- a/docs/docs/reference/new-types/implicit-function-types.md
+++ b/docs/docs/reference/instances/implicit-function-types.md
@@ -1,38 +1,44 @@
 ---
 layout: doc-page
-title: "Implicit Function Types"
+title: "Implicit Function Types and Closures"
 ---
 
-An implicit function type describes functions with implicit parameters. Example:
+An implicit function type describes functions with implicit (context) parameters. Example:
 
-    type Contextual[T] = implicit Context => T
+    type Contextual[T] = Context |=> T
 
-A value of implicit function type is applied to implicit arguments, in
-the same way a method with implicit parameters is applied. For instance:
+A value of implicit function type is applied to context arguments, in
+the same way a method with context parameters is applied. For instance:
 
     implicit val ctx: Context = ...
 
     def f(x: Int): Contextual[Int] = ...
 
-    f(2)    // is expanded to f(2)(ctx)
+    f(2) with ctx   // explicit argument
+    f(2)            // argument left implicit
 
 Conversely, if the expected type of an expression `E` is an implicit
-function type `implicit (T_1, ..., T_n) => U` and `E` is not already an
+function type `(T_1, ..., T_n) |=> U` and `E` is not already an
 implicit function value, `E` is converted to an implicit function value
 by rewriting to
 
-    implicit (x_1: T1, ..., x_n: Tn) => E
+    (x_1: T1, ..., x_n: Tn) |=> E
 
-where the names `x_1`, ..., `x_n` are arbitrary. For example, continuing
-with the previous definitions,
+where the names `x_1`, ..., `x_n` are arbitrary. Implicit closures are written
+with a `|=>` connective instead of `=>` for normal closures. They differ from normal closures in two ways:
+
+ 1. Their parameters are implicit context parameters
+ 2. Their types are implicit function types.
+
+For example, continuing with the previous definitions,
 
     def g(arg: Contextual[Int]) = ...
 
-    g(22)      // is expanded to g { implicit ctx => 22 }
+    g(22)      // is expanded to g(ctx |=> 22)
 
-    g(f(2))    // is expanded to g { implicit ctx => f(2)(ctx) }
+    g(f(2))    // is expanded to g(ctx |=> f(2) with ctx)
 
-    g(implicit ctx => f(22)(ctx)) // is left as it is
+    g(ctx |=> f(22) with ctx) // is left as it is
 
 Implicit function types have considerable expressive power. For
 instance, here is how they can support the "builder pattern", where
@@ -70,36 +76,37 @@ Then, the `table`, `row` and `cell` constructor methods can be defined
 in terms of implicit function types to avoid the plumbing boilerplate
 that would otherwise be necessary.
 
-    def table(init: implicit Table => Unit) = {
-      implicit val t = new Table
+    def table(init: Table |=> Unit) = {
+      instance t of Table
       init
       t
     }
 
-    def row(init: implicit Row => Unit)(implicit t: Table) = {
-      implicit val r = new Row
+    def row(init: Row |=> Unit) with (t: Table) = {
+      instance r of Row
       init
       t.add(r)
     }
 
-    def cell(str: String)(implicit r: Row) =
+    def cell(str: String) with (r: Row) =
       r.add(new Cell(str))
 
 With that setup, the table construction code above compiles and expands to:
 
-    table { implicit $t: Table =>
-      row { implicit $r: Row =>
-        cell("top left")($r)
-        cell("top right")($r)
-      }($t)
-      row { implicit $r: Row =>
-        cell("bottom left")($r)
-        cell("bottom right")($r)
-      }($t)
+    table { $t: Table |=>
+      row { $r: Row |=>
+        cell("top left") with $r
+        cell("top right") with $r
+      } with $t
+      row { $r: Row |=>
+        cell("bottom left") with $r
+        cell("bottom right") with $r
+      } with $t
     }
 
 ### Reference
 
-For more info, see the [blog article](https://www.scala-lang.org/blog/2016/12/07/implicit-function-types.html).
+For more info, see the [blog article](https://www.scala-lang.org/blog/2016/12/07/implicit-function-types.html),
+(which uses a different syntax that has been superseded).
 
 [More details](./implicit-function-types-spec.html)
diff --git a/docs/docs/reference/instances/instance-defs.md b/docs/docs/reference/instances/instance-defs.md
new file mode 100644
index 000000000000..17436a508ca6
--- /dev/null
+++ b/docs/docs/reference/instances/instance-defs.md
@@ -0,0 +1,195 @@
+---
+layout: doc-page
+title: "Instance Definitions"
+---
+
+Instance definitions provide a concise and uniform syntax for defining implicit values. Example:
+
+```scala
+trait Ord[T] {
+  def (x: T) compareTo (y: T): Int
+  def (x: T) < (y: T) = x.compareTo(y) < 0
+  def (x: T) > (y: T) = x.compareTo(y) > 0
+}
+
+instance IntOrd of Ord[Int] {
+  def (x: Int) compareTo (y: Int) =
+    if (x < y) -1 else if (x > y) +1 else 0
+}
+
+instance ListOrd[T: Ord] of Ord[List[T]] {
+  def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+    case (Nil, Nil) => 0
+    case (Nil, _) => -1
+    case (_, Nil) => +1
+    case (x :: xs1, y :: ys1) =>
+      val fst = x.compareTo(y)
+      if (fst != 0) fst else xs1.compareTo(ys1)
+  }
+}
+```
+Instance definitions can be seen as shorthands for what is currently expressed with implicit object and method definitions.
+For instance, the definition of instance `IntOrd` above defines an implicit value of type `Ord[Int]`. It is hence equivalent
+to the following implicit object definition:
+```scala
+implicit object IntOrd extends Ord[Int] {
+  def (x: Int) compareTo (y: Int) =
+    if (x < y) -1 else if (x > y) +1 else 0
+}
+```
+The definition of instance `ListOrd` defines an ordering for `List[T]` provided there is an ordering for type `T`. With existing
+implicits, this could be expressed as a pair of a class and an implicit method:
+```scala
+class ListOrd[T: Ord] extends Ord[List[T]] {
+  def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+    case (Nil, Nil) => 0
+    case (Nil, _) => -1
+    case (_, Nil) => +1
+    case (x :: xs1, y :: ys1) =>
+      val fst = x.compareTo(y)
+      if (fst != 0) fst else xs1.compareTo(ys1)
+  }
+}
+implicit def ListOrd[T: Ord]: Ord[List[T]] = new ListOrd[T]
+```
+## Instances for Extension Methods
+
+Instances can also be defined without an `of` clause. A typical application is to use a instance to package some extension methods. Examples:
+
+```scala
+instance StringOps {
+  def (xs: Seq[String]) longestStrings: Seq[String] = {
+    val maxLength = xs.map(_.length).max
+    xs.filter(_.length == maxLength)
+  }
+}
+
+instance ListOps {
+  def (xs: List[T]) second[T] = xs.tail.head
+}
+```
+## Anonymous Instances
+
+The name of an instance definition can be left out. Examples:
+```scala
+instance of Ord[Int] { ... }
+instance [T: Ord] of Ord[List[T]] { ... }
+
+instance {
+  def (xs: List[T]) second[T] = xs.tail.head
+}
+```
+If the name of an instance is missing, the compiler will synthesize a name from
+the type in the of clause, or, if that is missing, from the first defined
+extension method.
+
+## Conditional Instances
+
+An instance definition can depend on another instance being defined. Example:
+```scala
+trait Conversion[-From, +To] {
+  def apply(x: From): To
+}
+
+instance [S, T] with (c: Conversion[S, T]) of Conversion[List[S], List[T]] {
+  def convert(x: List[From]): List[To] = x.map(c.apply)
+}
+```
+This defines an implicit conversion from `List[S]` to `List[T]` provided there is an implicit conversion from `S` to `T`.
+The `with` clause instance defines required instances. The instance of `Conversion[List[From], List[To]]` above is defined only if an instance of `Conversion[From, To]` exists.
+
+Context bounds in instance definitions also translate to implicit parameters, and therefore they can be represented alternatively as with clauses. For instance, here is an equivalent definition of the `ListOrd` instance:
+```scala
+instance ListOrd[T] with (ord: Ord[T]) of List[Ord[T]] { ... }
+```
+The name of a parameter in a `with` clause can also be left out, as shown in the following variant of `ListOrd`:
+```scala
+instance ListOrd[T] with Ord[T] of List[Ord[T]] { ... }
+```
+As usual one can then infer to implicit parameter only indirectly, by passing it as implicit argument to another function.
+
+## Typeclass Instances
+
+Instance definitions allow a concise and natural expression of typeclasses.
+Here are some examples of standard typeclass instances:
+
+Semigroups and monoids:
+
+```scala
+trait SemiGroup[T] {
+  def (x: T) combine (y: T): T
+}
+trait Monoid[T] extends SemiGroup[T] {
+  def unit: T
+}
+object Monoid {
+  def apply[T] = implicitly[Monoid[T]]
+}
+
+instance of Monoid[String] {
+  def (x: String) combine (y: String): String = x.concat(y)
+  def unit: String = ""
+}
+
+def sum[T: Monoid](xs: List[T]): T =
+    xs.foldLeft(Monoid[T].unit)(_.combine(_))
+```
+Functors and monads:
+```scala
+trait Functor[F[_]] {
+  def (x: F[A]) map[A, B] (f: A => B): F[B]
+}
+
+trait Monad[F[_]] extends Functor[F] {
+  def (x: F[A]) flatMap[A, B] (f: A => F[B]): F[B]
+  def (x: F[A]) map[A, B] (f: A => B) = x.flatMap(f `andThen` pure)
+
+  def pure[A](x: A): F[A]
+}
+
+instance ListMonad of Monad[List] {
+  def (xs: List[A]) flatMap[A, B] (f: A => List[B]): List[B] =
+    xs.flatMap(f)
+  def pure[A](x: A): List[A] =
+    List(x)
+}
+
+instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
+  def (r: Ctx => A) flatMap[A, B] (f: A => Ctx => B): Ctx => B =
+    ctx => f(r(ctx))(ctx)
+  def pure[A](x: A): Ctx => A =
+    ctx => x
+}
+```
+## Alias Instances
+
+An alias instance creates an instance that is equal to some expression. E.g.,
+```
+instance ctx of ExecutionContext = currentThreadPool().context
+```
+Here, we create an instance `ctx` of type `ExecutionContext` that resolves to the
+right hand side `currentThreadPool().context`. Each time an instance of `ExecutionContext`
+is demanded, the result of evaluating the right-hand side expression is returned. The instance definition is equivalent to the following implicit definition:
+```
+final implicit def ctx: ExecutionContext = currentThreadPool().context
+```
+Alias instances may be anonymous, e.g.
+```
+instance of Position = enclosingTree.position
+```
+An alias instance can have type and context parameters just like any other instance definition, but it can only implement a single type.
+
+## Syntax
+
+Here is the new syntax of instance definitions, seen as a delta from the [standard context free syntax of Scala 3](http://dotty.epfl.ch/docs/internals/syntax.html).
+```
+TmplDef          ::=  ...
+                  |  ‘instance’ InstanceDef
+InstanceDef      ::=  [id] InstanceParams InstanceBody
+InstanceParams   ::=  [DefTypeParamClause] {InstParamClause}
+InstParamClause  ::=  ‘with’ (‘(’ [DefParams] ‘)’ | ContextTypes)
+InstanceBody     ::=  [‘of’ ConstrApp {‘,’ ConstrApp }] [TemplateBody]
+                   |  ‘of’ Type ‘=’ Expr
+ContextTypes     ::=  RefinedType {‘,’ RefinedType}
+```
+The identifier `id` can be omitted only if either the `of` part or the template body is present. If the `of` part is missing, the template body must define at least one extension method.
diff --git a/docs/docs/reference/instances/replacing-implicits.md b/docs/docs/reference/instances/replacing-implicits.md
new file mode 100644
index 000000000000..93bf50c1b75f
--- /dev/null
+++ b/docs/docs/reference/instances/replacing-implicits.md
@@ -0,0 +1,70 @@
+---
+layout: doc-page
+title: "Replacing Implicits"
+---
+
+The previous pages describe a new, high-level syntax for implicit definitions, parameters, function literals, and function types. With the exception of context parameters
+
+These idioms can by-and-large be mapped to existing implicits. The only exception concerns context parameters which give genuinely more freedom in the way parameters can be organized. The new idioms are preferable to existing implicits since they are both more concise and better behaved. The better expressiveness comes at a price, however, since it leaves us with two related constructs: new style instance definitions and context parameters and traditional implicits. This page discusses what would be needed to get rid of `implicit` entirely.
+
+The contents of this page are more tentative than the ones of the previous pages. The concepts described in the previous pages are useful independently whether the changes on this page are adopted.
+
+The current Dotty implementation implements the new concepts described on this page (alias instances and the summon method), but it does not remove any of the old-style implicit constructs. It cannot do this since support
+for old-style implicits is an essential part of the common language subset of Scala 2 and Scala 3.0. Any deprecation and subsequent removal of these constructs would have to come later, in a version following 3.0. The `implicit` modifier can be removed from the language at the end of this development, if it happens.
+
+## Alias Instances
+
+An alias instance creates an instance that is equal to some expression.
+```
+instance ctx of ExecutionContext = currentThreadPool().context
+```
+Here, we create an instance `ctx` of type `ExecutionContext` that resolves to the
+right hand side `currentThreadPool().context`. Each time an instance of `ExecutionContext`
+is demanded, the result of evaluating the right-hand side expression is returned. The instance definition is equivalent to the following implicit definition:
+```
+final implicit def ctx: ExecutionContext = currentThreadPool().context
+```
+Alias instances may be anonymous, e.g.
+```
+instance of Position = enclosingTree.position
+```
+An alias instance can have type and context parameters just like any other instance definition, but it can only implement a single type.
+
+## Replaced: Implicit Conversions
+
+Implicit conversions using the `implicit def` syntax are no longer needed, since they
+can be expressed as instances of the `scala.Conversion` class: This class is defined in package `scala` as follows:
+```scala
+abstract class Conversion[-T, +U] extends (T => U)
+```
+For example, here is an implicit conversion from `String` to `Token`:
+```scala
+instance of Conversion[String, Token] {
+  def apply(str: String): Token = new KeyWord(str)
+}
+```
+The fact that this syntax is more verbose than simple implicit defs could be a welcome side effect since it might dampen any over-enthusiasm for defining implicit conversions.
+
+## Dropped: Implicit Classes
+
+Most use cases of implicit classes are already covered by extension methods. For the others, one can always fall back to a pair of a regular class and a `Conversion` instance.
+
+## Summoning an Instance
+
+Besides `implicit`, there is also `implicitly`, a method defined in `Predef` that computes an implicit value for a given type. We propose to rename this operation to `summon`. So `summon[T]` summons an instance of `T`, in the same way as `implicitly[T]` did. The definition of `summon` is straightforward:
+```scala
+def summon[T] with (x: T) = x
+```
+
+## Syntax
+
+The syntax changes for this page are summarized as follows:
+```
+InstanceBody     ::=  ...
+                   |  ‘of’ Type ‘=’ Expr
+```
+In addition, the `implicit` modifier is removed together with all [productions]((http://dotty.epfl.ch/docs/internals/syntax.html) that reference it.
+
+## Further Reading
+
+Here is the [original proposal](./discussion/motivation.html) that makes the case for the changes described in these pages.
diff --git a/docs/docs/reference/new-types/match-types.md b/docs/docs/reference/new-types/match-types.md
index 03fa5b4b677e..b36df5d69fcc 100644
--- a/docs/docs/reference/new-types/match-types.md
+++ b/docs/docs/reference/new-types/match-types.md
@@ -86,7 +86,7 @@ Using `can-reduce`, we can now define match type reduction proper in the `reduce
 ```
 if
 ```
-    Match(S, C1, ..., Cn)  can-reduce  i, T
+  Match(S, C1, ..., Cn)  can-reduce  i, T
 ```
 and, for `j` in `1..i-1`: `C_j` is disjoint from `C_i`, or else `S` cannot possibly match `C_j`.
 See the section on overlapping patterns for an elaboration of "disjoint" and "cannot possibly match".
diff --git a/docs/sidebar.yml b/docs/sidebar.yml
index 92e368b80b0c..3fcec6950d26 100644
--- a/docs/sidebar.yml
+++ b/docs/sidebar.yml
@@ -29,8 +29,6 @@ sidebar:
               url: docs/reference/new-types/type-lambdas.html
             - title: Match types
               url: docs/reference/new-types/match-types.html
-            - title: Implicit Function Types
-              url: docs/reference/new-types/implicit-function-types.html
             - title: Dependent Function Types
               url: docs/reference/new-types/dependent-function-types.html
         - title: Enums
@@ -69,7 +67,20 @@ sidebar:
               url: docs/reference/other-new-features/erased-terms.html
             - title: Kind Polymorphism
               url: docs/reference/other-new-features/kind-polymorphism.html
-        - title: Changed Features
+        - title: New Implicits
+            - title: Instance Definitions
+              url: docs/reference/instances/instance-defs.html
+            - title: Context Parameters
+              url: docs/reference/instances/context-params.html
+            - title: Implicit Function Types
+              url: docs/reference/instances/implicit-function-types.html
+            - title: Implicit Conversions
+              url: docs/reference/instances/implicit-conversions.html
+            - title: Replacing Implicits
+              url: docs/reference/instances/replacing-implicits.html
+            - title: Discussion
+              url: docs/reference/instances/discussion.html
+        - title: Other Changed Features
           subsection:
             - title: Volatile Lazy Vals
               url: docs/reference/changed-features/lazy-vals.html
diff --git a/language-server/test/dotty/tools/languageserver/util/CodeTester.scala b/language-server/test/dotty/tools/languageserver/util/CodeTester.scala
index 53167188be9c..20bf80a3d543 100644
--- a/language-server/test/dotty/tools/languageserver/util/CodeTester.scala
+++ b/language-server/test/dotty/tools/languageserver/util/CodeTester.scala
@@ -237,7 +237,7 @@ class CodeTester(projects: List[Project]) {
 
   private def doAction(action: Action): this.type = {
     try {
-      action.execute()(testServer, testServer.client, positions)
+      action.execute() with (testServer, testServer.client, positions)
     } catch {
       case ex: AssertionError =>
         val sourcesStr =
@@ -252,7 +252,7 @@ class CodeTester(projects: List[Project]) {
             |
             |$sourcesStr
             |
-            |while executing action: ${action.show(positions)}
+            |while executing action: ${action.show with positions}
             |
           """.stripMargin
         val assertionError = new AssertionError(msg + ex.getMessage)
diff --git a/language-server/test/dotty/tools/languageserver/util/PositionContext.scala b/language-server/test/dotty/tools/languageserver/util/PositionContext.scala
index 45b97c886078..1697e68eb2d1 100644
--- a/language-server/test/dotty/tools/languageserver/util/PositionContext.scala
+++ b/language-server/test/dotty/tools/languageserver/util/PositionContext.scala
@@ -24,5 +24,5 @@ class PositionContext(positionMap: Map[CodeMarker, (TestFile, Int, Int)]) {
 }
 
 object PositionContext {
-  type PosCtx[T] = implicit PositionContext => T
+  type PosCtx[T] = PositionContext |=> T
 }
diff --git a/language-server/test/dotty/tools/languageserver/util/actions/Action.scala b/language-server/test/dotty/tools/languageserver/util/actions/Action.scala
index 746d9c4c01d4..209960902d91 100644
--- a/language-server/test/dotty/tools/languageserver/util/actions/Action.scala
+++ b/language-server/test/dotty/tools/languageserver/util/actions/Action.scala
@@ -11,7 +11,7 @@ import PositionContext._
  * definition, etc.)
  */
 trait Action {
-  type Exec[T] = implicit (TestServer, TestClient, PositionContext) => T
+  type Exec[T] = (TestServer, TestClient, PositionContext) |=> T
 
   /** Execute the action. */
   def execute(): Exec[Unit]
diff --git a/library/src/dotty/DottyPredef.scala b/library/src/dotty/DottyPredef.scala
index 0a1276e1958e..0bdd5719c39d 100644
--- a/library/src/dotty/DottyPredef.scala
+++ b/library/src/dotty/DottyPredef.scala
@@ -4,25 +4,6 @@ import scala.forceInline
 
 object DottyPredef {
 
-  /** A class for implicit values that can serve as implicit conversions
-   *  The implicit resolution algorithm will act as if there existed
-   *  the additional implicit definition:
-   *
-   *    def $implicitConversion[T, U](x: T)(c: ImplicitConverter[T, U]): U = c(x)
-   *
-   *  However, the presence of this definition would slow down implicit search since
-   *  its outermost type matches any pair of types. Therefore, implicit search
-   *  contains a special case in `Implicits#discardForView` which emulates the
-   *  conversion in a more efficient way.
-   *
-   *  Note that this is a SAM class - function literals are automatically converted
-   *  to `ImplicitConverter` values.
-   *
-   *  Also note that in bootstrapped dotty, `Predef.<:<` should inherit from
-   *  `ImplicitConverter`. This would cut the number of special cases in
-   *  `discardForView` from two to one.
-   */
-  abstract class ImplicitConverter[-T, +U] extends Function1[T, U]
 
   @forceInline final def assert(assertion: => Boolean, message: => Any): Unit = {
     if (!assertion)
@@ -55,4 +36,6 @@ object DottyPredef {
    * @group utilities
    */
   @forceInline def valueOf[T](implicit vt: ValueOf[T]): T = vt.value
+
+  @forceInline def summon[T](implicit x: T) = x
 }
diff --git a/library/src/scala/Conversion.scala b/library/src/scala/Conversion.scala
new file mode 100644
index 000000000000..fd7aa0b4b01f
--- /dev/null
+++ b/library/src/scala/Conversion.scala
@@ -0,0 +1,22 @@
+package scala
+
+/** A class for implicit values that can serve as implicit conversions
+*  The implicit resolution algorithm will act as if there existed
+*  the additional implicit definition:
+*
+*    def $implicitConversion[T, U](x: T)(c: Conversion[T, U]): U = c(x)
+*
+*  However, the presence of this definition would slow down implicit search since
+*  its outermost type matches any pair of types. Therefore, implicit search
+*  contains a special case in `Implicits#discardForView` which emulates the
+*  conversion in a more efficient way.
+*
+*  Note that this is a SAM class - function literals are automatically converted
+*  to the `Conversion` values.
+*
+*  Also note that in bootstrapped dotty, `Predef.<:<` should inherit from
+*  `Conversion`. This would cut the number of special cases in `discardForView`
+*  from two to one.
+*/
+@java.lang.FunctionalInterface
+abstract class Conversion[-T, +U] extends Function1[T, U]
diff --git a/tests/disabled/run/xml-interpolation-3/Test_2.scala b/tests/disabled/run/xml-interpolation-3/Test_2.scala
new file mode 100644
index 000000000000..9a3d8d64161b
--- /dev/null
+++ b/tests/disabled/run/xml-interpolation-3/Test_2.scala
@@ -0,0 +1,11 @@
+import XmlQuote._
+
+object Test {
+  def main(args: Array[String]): Unit = {
+
+    assert(xml"Hello Allan!" == Xml("Hello Allan!", Nil))
+
+    val name = new Object{}
+    assert(xml"Hello $name!" == Xml("Hello ??!", List(name)))
+  }
+}
diff --git a/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala b/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala
new file mode 100644
index 000000000000..f99da7d01204
--- /dev/null
+++ b/tests/disabled/run/xml-interpolation-3/XmlQuote_1.scala
@@ -0,0 +1,19 @@
+import scala.quoted._
+import scala.tasty.Tasty
+
+import scala.language.implicitConversions
+
+case class Xml(parts: String, args: List[Any])
+
+object XmlQuote {
+
+  implicit object SCOps {
+    inline def xml(this inline ctx: StringContext)(args: => Any*): Xml =
+      ~XmlQuote.impl(ctx, '(args))
+  }
+
+  def impl(receiver: StringContext, args: Expr[Seq[Any]]): Expr[Xml] = {
+    val string = receiver.parts.mkString("??")
+    '(new Xml(~string.toExpr, (~args).toList))
+  }
+}
diff --git a/tests/neg-custom-args/impl-conv/A.scala b/tests/neg-custom-args/impl-conv/A.scala
index 6d6e8cb30d4b..6a2de9e6dac4 100644
--- a/tests/neg-custom-args/impl-conv/A.scala
+++ b/tests/neg-custom-args/impl-conv/A.scala
@@ -3,7 +3,7 @@ package implConv
 object A {
 
   implicit def s2i(x: String): Int = Integer.parseInt(x) // error: feature
-  implicit val i2s: ImplicitConverter[Int, String] = _.toString // error: feature
+  implicit val i2s: Conversion[Int, String] = _.toString // error: feature
 
   implicit class Foo(x: String) {
     def foo = x.length
diff --git a/tests/neg/contextual-params.scala b/tests/neg/contextual-params.scala
new file mode 100644
index 000000000000..2d44284955d0
--- /dev/null
+++ b/tests/neg/contextual-params.scala
@@ -0,0 +1,22 @@
+object Test {
+
+  case class C(x: Int)
+
+  def f(x: Int) with (c: C) = x + c.x
+
+  def g(x: Int) with (c: C) (y: Int) = x + c.x + y
+
+  implicit object C extends C(11)
+
+  f(1)
+  f(1) with C
+  f with 2  // error
+  f(1)(C)   // error
+
+  g(1)(2) // OK
+  (g(1) with C)(2) // OK
+  g(1) with 2 // error
+  g(1) with C with 2 // error
+  g(1)(C)(2) // error
+  g(1)(C) with 2 // error
+}
\ No newline at end of file
diff --git a/tests/neg/i2006.scala b/tests/neg/i2006.scala
index f1b48b011384..7142da89619a 100644
--- a/tests/neg/i2006.scala
+++ b/tests/neg/i2006.scala
@@ -4,7 +4,7 @@ object Test {
   inline def bar(f: ImplicitFunction1[Int, Int]) = f // error
 
   def main(args: Array[String]) = {
-    foo(implicit thisTransaction => 43)
-    bar(implicit thisTransaction => 44)
+    foo(thisTransaction |=> 43)
+    bar(thisTransaction |=> 44)
   }
 }
diff --git a/tests/neg/i2146.scala b/tests/neg/i2146.scala
index 13ecf1e7b680..32be8734efde 100644
--- a/tests/neg/i2146.scala
+++ b/tests/neg/i2146.scala
@@ -2,7 +2,7 @@ object Test {
   case class A()
   case class B()
 
-  def foo[A, B]: implicit A => implicit B => Int = { implicit b: B =>
-    42 // error: found Int, required: implicit A => implicit B => Int
+  def foo[A, B]: A |=> B |=> Int = { b: B |=>
+    42 // error: found Int, required: A |=> B |=> Int
   }
 }
diff --git a/tests/neg/i2512.scala b/tests/neg/i2512.scala
index 077072478316..2efccfb7472c 100644
--- a/tests/neg/i2512.scala
+++ b/tests/neg/i2512.scala
@@ -1,8 +1,8 @@
 
-object Test {
+class Test {
 
-  def foo0(): implicit Int => Int = ???
-  val foo01: implicit (String, Int) => Int = ???
+  def foo0(): implicit Int => Int = ???     // error
+  val foo01: implicit (String, Int) => Int = ???  // error
 
   def foo1(f: Int => implicit Int): Int = ??? // error
   def foo2(): implicit Int = ??? // error
diff --git a/tests/neg/i2514.scala b/tests/neg/i2514.scala
index 35bc840ccb3f..c05c4b434f42 100644
--- a/tests/neg/i2514.scala
+++ b/tests/neg/i2514.scala
@@ -1,7 +1,7 @@
 object Foo {
   def foo(): Int = {
     val f: implicit Int => Int = (implicit x: Int) => 2 * x // error // error
-    f(2)
+    f with 2
   }
 
   val f = (implicit x: Int) => x // error // error
diff --git a/tests/neg/i2514a.scala b/tests/neg/i2514a.scala
index 8a8263666e87..59c954f31a25 100644
--- a/tests/neg/i2514a.scala
+++ b/tests/neg/i2514a.scala
@@ -1,10 +1,10 @@
 object Foo {
   def foo(): Int = {
-    val f: implicit Int => Int = implicit (x: Int) => 2 * x
-    f(2)
+    val f: Int |=> Int = (x: Int) |=> 2 * x
+    f with 2
   }
 
   val f = implicit (x: Int) => x
 
-  (implicit (x: Int) => x): (implicit Int => Int) // error: no implicit argument found
+  ((x: Int) |=> x): (Int |=> Int) // error: no implicit argument found
 }
diff --git a/tests/neg/i2642.scala b/tests/neg/i2642.scala
index fce66d13b527..bb52d06c0c3e 100644
--- a/tests/neg/i2642.scala
+++ b/tests/neg/i2642.scala
@@ -1,10 +1,10 @@
 object Foo {
-  type X = implicit () => Int // now ok, used to be: implicit function needs parameters
+  type X = () |=> Int // now ok, used to be: implicit function needs parameters
   def ff: X = () // error: found: Unit, expected: Int
 
   type Y = erased () => Int // error: empty function may not be erased
   def gg: Y = () // error: found: Unit, expected: Y
 
-  type Z = erased implicit () => Int // error: empty function may not be erased
+  type Z = erased () |=> Int // error: empty function may not be erased
   def hh: Z = () // error: found: Unit, expected: Int
 }
diff --git a/tests/neg/i2960.scala b/tests/neg/i2960.scala
index 3a423612cb19..a134d3721350 100644
--- a/tests/neg/i2960.scala
+++ b/tests/neg/i2960.scala
@@ -22,9 +22,9 @@ class Tag(val name: String,
         this
     }
 
-    def apply[U](f: implicit Tag => U)(implicit t: Tag = null): this.type = {
+    def apply[U](f: Tag |=> U)(implicit t: Tag = null): this.type = {
         if(t != null) t.children += this
-        f(this)
+        f with this
         this
     }
 }
diff --git a/tests/neg/i4196.scala b/tests/neg/i4196.scala
index 8a80807a3d5c..1eea1e565d15 100644
--- a/tests/neg/i4196.scala
+++ b/tests/neg/i4196.scala
@@ -1,6 +1,6 @@
 object Test {
   @annotation.tailrec
-  def foo(i: implicit Unit => Int): implicit Unit => Int =
+  def foo(i: Unit |=> Int): Unit |=> Int =
     if (i == 0)
       0
     else
diff --git a/tests/neg/i4611a.scala b/tests/neg/i4611a.scala
index 0bcdd1c33ceb..31a210ad63fa 100644
--- a/tests/neg/i4611a.scala
+++ b/tests/neg/i4611a.scala
@@ -1,6 +1,6 @@
 // Don't qualify as SAM type because result type is an implicit function type
 trait Foo {
-  def foo(x: Int): implicit Int => Int
+  def foo(x: Int): Int |=> Int
 }
 
 trait Bar[T] {
@@ -12,7 +12,7 @@ class Test {
     def foo(x: Int) = 1
   }
 
-  val good2 = new Bar[implicit Int => Int] {
+  val good2 = new Bar[Int |=> Int] {
     def bar(x: Int) = 1
   }
 
diff --git a/tests/neg/i4611b.scala b/tests/neg/i4611b.scala
index 6e5f1b8a3017..dc53e0fd74cb 100644
--- a/tests/neg/i4611b.scala
+++ b/tests/neg/i4611b.scala
@@ -3,7 +3,7 @@ import scala.concurrent.Future
 class Response
 class Request
 object Request {
-  type To[T] = implicit Request => T
+  type To[T] = Request |=> T
 }
 
 // Don't qualify as SAM type because result type is an implicit function type
diff --git a/tests/neg/implicit-shadowing.scala b/tests/neg/implicit-shadowing.scala
index 310925ae4911..f263b3f81761 100644
--- a/tests/neg/implicit-shadowing.scala
+++ b/tests/neg/implicit-shadowing.scala
@@ -20,8 +20,8 @@ object Test {
     }
   }
 
-  def h[T]: implicit C1[T] => Unit = {
-    def g[U]: implicit C2[U] => Unit = {
+  def h[T]: C1[T] |=> Unit = {
+    def g[U]: C2[U] |=> Unit = {
       implicitly[C1[T]]    // OK: no shadowing for evidence parameters
       implicitly[C2[U]]
     }
diff --git a/tests/new/test.scala b/tests/new/test.scala
index 5d2bc0ff5211..3e568da314df 100644
--- a/tests/new/test.scala
+++ b/tests/new/test.scala
@@ -2,11 +2,17 @@ trait T {
   object O
 }
 
+object Test0 {
+  trait A[T]
+  instance a[T] of A[T]
+
+  class B[T]
+  instance b[T] of B[T]
+}
+
 class C extends T
 
 object Test {
-
   val c = new C
   c.O
-
 }
diff --git a/tests/pos/Orderings.scala b/tests/pos/Orderings.scala
index 24c89cd7b147..ec5aa60a745b 100644
--- a/tests/pos/Orderings.scala
+++ b/tests/pos/Orderings.scala
@@ -15,6 +15,6 @@ object Orderings {
       else ev.less(xs.head, ys.head)
   }
 
-  def isLess[T]: T => T => implicit Ord[T] => Boolean =
+  def isLess[T]: T => T => Ord[T] |=> Boolean =
     x => y => implicitly[Ord[T]].less(x, y)
 }
diff --git a/tests/pos/assumeIn.scala b/tests/pos/assumeIn.scala
new file mode 100644
index 000000000000..6c367f826b2c
--- /dev/null
+++ b/tests/pos/assumeIn.scala
@@ -0,0 +1,27 @@
+object Test {
+  import scala.compiletime.constValue
+
+  class Context {
+    inline def assumeIn[T](op: => Context |=> T) = {
+      instance of Context = this
+      op
+    }
+  }
+
+  def ctx: Context = new Context
+  def g with Context = ()
+  ctx.assumeIn(g)
+
+/* The last three statements shoudl generate the following code:
+
+    def ctx: Test.Context = new Test.Context()
+    def g(implicit x$1: Test.Context): Unit = ()
+    {
+      val Context_this: Test.Context = Test.ctx
+      {
+        implicit def ctx: Test.Context = Context_this
+        Test.g(ctx)
+      }
+    }
+*/
+}
diff --git a/tests/pos/case-getters.scala b/tests/pos/case-getters.scala
index e79267c7e9c0..dc6476e10674 100644
--- a/tests/pos/case-getters.scala
+++ b/tests/pos/case-getters.scala
@@ -1,8 +1,8 @@
-case class Foo(x: 1, y: implicit Int => Int)
+case class Foo(x: 1, y: Int |=> Int)
 object Test {
-  val f = Foo(1, implicit (i: Int) => i)
+  val f = Foo(1, (i: Int) |=> i)
   val fx1: 1 = f.x
   val fx2: 1 = f._1
-  val fy1: Int = f.y(1)
-  val fy2: Int = f._2(1)
+  val fy1: Int = f.y with 1
+  val fy2: Int = f._2 with 1
 }
diff --git a/tests/pos/depfuntype.scala b/tests/pos/depfuntype.scala
index b132b843c240..c31978af8536 100644
--- a/tests/pos/depfuntype.scala
+++ b/tests/pos/depfuntype.scala
@@ -19,15 +19,15 @@ object Test {
   // Reproduced here because the one from DottyPredef is lacking a parameter dependency of the return type `ev.type`
   inline final def implicitly[T](implicit ev: T): ev.type = ev
 
-  type IDF = implicit (x: C) => x.M
+  type IDF = (x: C) |=> x.M
 
   implicit val ic: C = ???
 
   val ifun: IDF = implicitly[C].m
 
-  val u = ifun(c)
+  val u = ifun with c
   val u1: Int = u
 
-  val v = ifun(d)
+  val v = ifun with d
   val v1: d.M = v
 }
diff --git a/tests/pos/eff-compose.scala b/tests/pos/eff-compose.scala
index a1931bab47b6..80e43b70d199 100644
--- a/tests/pos/eff-compose.scala
+++ b/tests/pos/eff-compose.scala
@@ -5,7 +5,7 @@ object Test {
   // Type X => Y
   abstract class Fun[-X, Y] {
     type Eff <: Effect
-    def apply(x: X): implicit Eff => Y
+    def apply(x: X): Eff |=> Y
   }
 
   // Type X -> Y
@@ -13,7 +13,7 @@ object Test {
 
   // def map(f: A => B)(xs: List[A]): List[B]
   def map[A, B, E <: Effect](f: Fun[A, B] { type Eff = E})(xs: List[A])
-    : implicit E => List[B] =
+    : E |=> List[B] =
     xs.map(f.apply)
 
   // def mapFn[A, B]: (A => B) -> List[A] -> List[B]
@@ -31,19 +31,19 @@ object Test {
       def apply(f: Fun[A, B] { type Eff = E}) =
         new Fun[List[A], List[B]] {
           type Eff = E
-          def apply(xs: List[A]): implicit Eff => List[B] =
+          def apply(xs: List[A]): Eff |=> List[B] =
             map(f)(xs)
         }
     }
 
-  implicit def combine[E1 <: Effect, E2 <: Effect](implicit x: E1, y: E2): E1 & E2 = ???
+  implicit def combine[E1 <: Effect, E2 <: Effect] with (x: E1, y: E2): E1 & E2 = ???
 
   // def compose(f: A => B)(g: B => C)(x: A): C
   def compose[A, B, C, E1 <: Effect, E2 <: Effect]
     (f: Fun[A, B] { type Eff = E1})
     (g: Fun[B, C] { type Eff = E2})
     (x: A):
-    implicit E1 & E2 => C = g(f(x))
+    E1 & E2 |=> C = g(f(x))
 
   // def composeFn: (A => B) -> (B => C) -> A -> C
   def composeFn[A, B, C, E1 <: Effect, E2 <: Effect]:
diff --git a/tests/pos/ho-implicits.scala b/tests/pos/ho-implicits.scala
index de3874f47c5a..4dbb2a2e47a3 100644
--- a/tests/pos/ho-implicits.scala
+++ b/tests/pos/ho-implicits.scala
@@ -1,9 +1,9 @@
 object Test2 {
 
-  implicit def __1: implicit Int => String = s"implicit: ${implicitly[Int]}"
+  implicit def __1: Int |=> String = s"implicit: ${implicitly[Int]}"
   implicit def __2: Int = 42
 
-  def f: implicit String => Int = implicitly[String].length
+  def f: String |=> Int = implicitly[String].length
 
   f: Int
 }
\ No newline at end of file
diff --git a/tests/pos/i2146.scala b/tests/pos/i2146.scala
index 8bb08de86e58..674094e9914b 100644
--- a/tests/pos/i2146.scala
+++ b/tests/pos/i2146.scala
@@ -2,12 +2,12 @@ object Test {
   case class A()
   case class B()
 
-  def simple[A]: implicit A => A = implicitly[A]
+  def simple[A]: A |=> A = implicitly[A]
 
-  def foo[A, B]: implicit A => implicit B => (A, B) =
+  def foo[A, B]: A |=> B |=> (A, B) =
     (implicitly[A], implicitly[B])
 
-  def bar[A, B]: implicit A => implicit B => (A, B) = { implicit a: A =>
+  def bar[A, B]: A |=> B |=> (A, B) = { a: A |=>
     (implicitly[A], implicitly[B])
   }
 
@@ -16,17 +16,17 @@ object Test {
 
   def main(args: Array[String]) = {
     println(foo[A, B])
-    println(foo[A, B](a))
-    println(foo(a)(b))
-    val s: implicit A => A = simple[A]
+    println(foo[A, B] with a)
+    println(foo with a with b)
+    val s: A |=> A = simple[A]
     println(s)
-    val x0: implicit A => implicit B => (A, B) = foo[A, B]
+    val x0: A |=> B |=> (A, B) = foo[A, B]
     println(x0)
-    val x1: implicit B => (A, B) = foo[A, B]
+    val x1: B |=> (A, B) = foo[A, B]
     println(x1)
 
     println(bar[A, B])
-    println(bar[A, B](a))
-    println(bar(a)(b))
+    println(bar[A, B] with a)
+    println(bar with a with b)
   }
 }
diff --git a/tests/pos/i2278.scala b/tests/pos/i2278.scala
index 0e4b7feb0c9e..13b7d9dddc7c 100644
--- a/tests/pos/i2278.scala
+++ b/tests/pos/i2278.scala
@@ -4,7 +4,7 @@ object Fluent {
   }
   trait CC[T]
 
-  type Context[Alg[x[_]] <: Foo[x], E] = implicit Alg[CC] => CC[E]
+  type Context[Alg[x[_]] <: Foo[x], E] = Alg[CC] |=> CC[E]
 
   def meth1[T]() : Context[Foo, T] = {
     implicitly[Foo[CC]].meth1()
diff --git a/tests/pos/i2671.scala b/tests/pos/i2671.scala
index de942b4f9799..90ec7c91bb9e 100644
--- a/tests/pos/i2671.scala
+++ b/tests/pos/i2671.scala
@@ -1,10 +1,10 @@
 object Foo {
 
-  def map[E](f: implicit E => Int): (implicit E => Int) = ???
+  def map[E](f: E |=> Int): (E |=> Int) = ???
 
   implicit def i: Int = ???
 
-  def f: implicit Int => Int = ???
+  def f: Int |=> Int = ???
 
   val a: Int = map(f)
 
diff --git a/tests/pos/i2749.scala b/tests/pos/i2749.scala
index 5d4972421ebb..0897f8a386e0 100644
--- a/tests/pos/i2749.scala
+++ b/tests/pos/i2749.scala
@@ -1,23 +1,23 @@
 object Test {
-  val f: implicit (implicit Int => Char) => Boolean = ???
+  val f: (Int |=> Char) |=> Boolean = ???
   implicit val n: Int = 3
-  implicit val g: implicit Int => Char = ???
+  implicit val g: Int |=> Char = ???
 
   f : Boolean
 }
 
 object Test2 {
-  val f: implicit (implicit Int => Char) => Boolean = ???
+  val f: (Int |=> Char) |=> Boolean = ???
   implicit val s: String = null
-  implicit val g: implicit Int => implicit String => Char = ???
+  implicit val g: Int |=> String |=> Char = ???
 
   f : Boolean
 }
 
 object Test3 {
-  val f: implicit (implicit Int => implicit String => Char) => Boolean = ???
+  val f: (Int |=> String |=> Char) |=> Boolean = ???
   implicit val n: Int = 3
-  implicit val g: implicit Int => Char = ???
+  implicit val g: Int |=> Char = ???
 
   f : Boolean
 }
diff --git a/tests/pos/i3692.scala b/tests/pos/i3692.scala
index 8fe924cfc462..2911f548f56f 100644
--- a/tests/pos/i3692.scala
+++ b/tests/pos/i3692.scala
@@ -6,9 +6,9 @@ object Main {
   //val b: Int => Int = a
 
   def main(args: Array[String]): Unit = {
-    val choose: implicit (c: C) => Set[Int] = Set.empty
-    val b0: (C) => Set[Int] = choose
-    val b1: (c: C) => Set[Int] = choose
+    val choose: (c: C) |=> Set[Int] = Set.empty
+    val b0: (C) => Set[Int] = choose with _
+    val b1: (c: C) => Set[Int] = choose with _
     def applyF(f: (c: C) => Set[Int]) = f(new C{type T=Int})
     //applyF(choose)
   }
diff --git a/tests/pos/i4125.scala b/tests/pos/i4125.scala
index 9ef034ba27b8..61310f14b246 100644
--- a/tests/pos/i4125.scala
+++ b/tests/pos/i4125.scala
@@ -1,4 +1,4 @@
 object Test {
   def foo: (erased (x: Int, y: Int) => Int) = erased (x, y) => 1
-  def bar: (erased implicit (x: Int, y: Int) => Int) = erased implicit (x, y) => 1
+  def bar: (erased (x: Int, y: Int) |=> Int) = erased (x, y) |=> 1
 }
diff --git a/tests/pos/i4196.scala b/tests/pos/i4196.scala
index 24662df97962..e880f01cd7a4 100644
--- a/tests/pos/i4196.scala
+++ b/tests/pos/i4196.scala
@@ -1,6 +1,6 @@
 object Test {
   @annotation.tailrec
-  def foo(i: implicit Unit => Int): implicit Unit => Int =
+  def foo(i: Unit |=> Int): Unit |=> Int =
     if (i == 0)
       0
     else
diff --git a/tests/pos/i4203.scala b/tests/pos/i4203.scala
index 3549237bff2a..3c75e7dee3df 100644
--- a/tests/pos/i4203.scala
+++ b/tests/pos/i4203.scala
@@ -1,7 +1,7 @@
 case class Box[Z](unbox: Z)
 
 object Test {
-  def foo(b: Box[implicit Int => Int]): Int = b match {
+  def foo(b: Box[Int |=> Int]): Int = b match {
     case Box(f) =>
       implicit val i: Int = 1
       f
diff --git a/tests/pos/i4725.scala b/tests/pos/i4725.scala
index f242915918b0..46a9a7ecaee8 100644
--- a/tests/pos/i4725.scala
+++ b/tests/pos/i4725.scala
@@ -1,8 +1,8 @@
 object Test1 {
   trait T[A]
 
-  def foo[S[_], A](implicit ev: implicit T[A] => T[S[A]]): Unit = ()
-  implicit def bar[A : T]: T[List[A]] = ???
+  def foo[S[_], A] with (ev: T[A] |=> T[S[A]]): Unit = ()
+  implicit def bar[A] with (ev: T[A]): T[List[A]] = ???
 
   foo[List, Int]
 }
@@ -11,8 +11,8 @@ object Test2 {
   trait T
   trait S
 
-  def foo(implicit ev: implicit T => S): Unit = ()
-  implicit def bar(implicit ev: T): S = ???
+  def foo with (ev: T |=> S): Unit = ()
+  implicit def bar with (ev: T): S = ???
 
   foo
 }
diff --git a/tests/pos/i4753.scala b/tests/pos/i4753.scala
index c8f7038f04ea..bc83d980a6b6 100644
--- a/tests/pos/i4753.scala
+++ b/tests/pos/i4753.scala
@@ -1,13 +1,13 @@
 class A
 
 trait Foo {
-  def foo: implicit A => Int
+  def foo: A |=> Int
 }
 
 class Test {
-  new FooI{}
+  println(new FooI{})
 }
 
 class FooI extends Foo {
-  def foo: implicit A => Int = 3
+  def foo: A |=> Int = 3
 }
\ No newline at end of file
diff --git a/tests/pos/i4753b.scala b/tests/pos/i4753b.scala
index 407bb9b1c83c..606986f2ddbc 100644
--- a/tests/pos/i4753b.scala
+++ b/tests/pos/i4753b.scala
@@ -1,7 +1,7 @@
 class Foo1 {
-  def foo: implicit String => Int = 1
+  def foo: String |=> Int = 1
 }
 
 class Foo2 extends Foo1 {
-  override def foo: implicit String => Int = 2
+  override def foo: String |=> Int = 2
 }
diff --git a/tests/pos/implicit-dep.scala b/tests/pos/implicit-dep.scala
index 778048f7acee..f6fe80cc43c1 100644
--- a/tests/pos/implicit-dep.scala
+++ b/tests/pos/implicit-dep.scala
@@ -5,5 +5,5 @@ trait HasT {
 object Test {
 
 
-  def foo: implicit Int => implicit (g: HasT) => g.T = ???
+  def foo: Int |=> (g: HasT) |=> g.T = ???
 }
diff --git a/tests/pos/implicitFuns.scala b/tests/pos/implicitFuns.scala
index 41c57e2a018e..555acf7310d0 100644
--- a/tests/pos/implicitFuns.scala
+++ b/tests/pos/implicitFuns.scala
@@ -10,7 +10,7 @@ class ConfManagement(papers: List[Paper], realScore: Map[Paper, Int]) extends Ap
   private def hasConflict(ps1: Set[Person], ps2: Iterable[Person]) =
     ps2.exists(ps1 contains _)
 
-  type Viewable[T] = implicit Viewers => T
+  type Viewable[T] = Viewers |=> T
 
   def vs: Viewable[Viewers] = implicitly
 
@@ -52,7 +52,7 @@ object Orderings extends App {
       x => y => x < y
   }
 
-  implicit def __2[T]: implicit Ord[T] => Ord[List[T]] = new Ord[List[T]] {
+  implicit def __2[T]: Ord[T] |=> Ord[List[T]] = new Ord[List[T]] {
     def less: List[T] => List[T] => Boolean =
       xs => ys =>
         if ys.isEmpty then false
@@ -61,7 +61,7 @@ object Orderings extends App {
         else isLess(xs.head)(ys.head)
   }
 
-  def isLess[T]: T => T => implicit Ord[T] => Boolean =
+  def isLess[T]: T => T => Ord[T] |=> Boolean =
     x => y => implicitly[Ord[T]].less(x)(y)
 
   println(isLess(Nil)(List(1, 2, 3)))
diff --git a/tests/pos/inline-apply.scala b/tests/pos/inline-apply.scala
index 6cdfe3b3ccb2..60c024af2227 100644
--- a/tests/pos/inline-apply.scala
+++ b/tests/pos/inline-apply.scala
@@ -3,9 +3,9 @@ class Context
 object Test {
 
   def transform()(implicit ctx: Context) = {
-    inline def withLocalOwner[T](op: Context => T) = op(ctx)
+    inline def withLocalOwner[T](op: Context |=> T) = op with ctx
 
-    withLocalOwner { implicit ctx => }
+    withLocalOwner { ctx |=> () }
 
   }
 }
diff --git a/tests/pos/opaque-groups-params.scala b/tests/pos/opaque-groups-params.scala
index 7c3de6b146be..e5f19d5f095f 100644
--- a/tests/pos/opaque-groups-params.scala
+++ b/tests/pos/opaque-groups-params.scala
@@ -4,7 +4,7 @@ package object groups {
   }
 
   object Semigroup {
-    def instance[A](f: (A, A) => A): Semigroup[A] =
+    def inst[A](f: (A, A) => A): Semigroup[A] =
       new Semigroup[A] {
         def combine(x: A, y: A): A = f(x, y)
       }
@@ -37,7 +37,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[First[A]] = ga // error: overriding
     def unwrap[G[_], A](gfa: G[First[A]]): G[A] = gfa
     implicit def firstSemigroup[A]: Semigroup[First[A]] =
-      Semigroup.instance((x, y) => x)
+      Semigroup.inst((x, y) => x)
   }
 
   opaque type Last[A] = A
@@ -45,6 +45,6 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[Last[A]] = ga // error: overriding
     def unwrap[G[_], A](gfa: G[Last[A]]): G[A] = gfa
     implicit def lastSemigroup[A]: Semigroup[Last[A]] =
-      Semigroup.instance((x, y) => y)
+      Semigroup.inst((x, y) => y)
   }
 }
\ No newline at end of file
diff --git a/tests/pos/opaque-groups.scala b/tests/pos/opaque-groups.scala
index 547c1747c4cc..bc6e81fe01ad 100644
--- a/tests/pos/opaque-groups.scala
+++ b/tests/pos/opaque-groups.scala
@@ -4,7 +4,7 @@ package object groups {
   }
 
   object Semigroup {
-    def instance[A](f: (A, A) => A): Semigroup[A] =
+    def inst[A](f: (A, A) => A): Semigroup[A] =
       new Semigroup[A] {
         def combine(x: A, y: A): A = f(x, y)
       }
@@ -36,7 +36,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[First[A]] = ga
     def unwrap[G[_], A](gfa: G[First[A]]): G[A] = gfa
     implicit def firstSemigroup[A]: Semigroup[First[A]] =
-      Semigroup.instance((x, y) => x)
+      Semigroup.inst((x, y) => x)
   }
 
   opaque type Last[A] = A
@@ -45,7 +45,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[Last[A]] = ga
     def unwrap[G[_], A](gfa: G[Last[A]]): G[A] = gfa
     implicit def lastSemigroup[A]: Semigroup[Last[A]] =
-      Semigroup.instance((x, y) => y)
+      Semigroup.inst((x, y) => y)
   }
 
   opaque type Min[A] = A
@@ -54,7 +54,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[Min[A]] = ga
     def unwrap[G[_], A](gfa: G[Min[A]]): G[A] = gfa
     implicit def minSemigroup[A](implicit o: Ordering[A]): Semigroup[Min[A]] =
-      Semigroup.instance(o.min)
+      Semigroup.inst(o.min)
   }
 
   opaque type Max[A] = A
@@ -63,7 +63,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[Max[A]] = ga
     def unwrap[G[_], A](gfa: G[Max[A]]): G[A] = gfa
     implicit def maxSemigroup[A](implicit o: Ordering[A]): Semigroup[Max[A]] =
-      Semigroup.instance(o.max)
+      Semigroup.inst(o.max)
   }
 
   opaque type Plus[A] = A
@@ -72,7 +72,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[Plus[A]] = ga
     def unwrap[G[_], A](gfa: G[Plus[A]]): G[A] = gfa
     implicit def plusSemigroup[A](implicit n: Numeric[A]): Semigroup[Plus[A]] =
-      Semigroup.instance(n.plus)
+      Semigroup.inst(n.plus)
   }
 
   opaque type Times[A] = A
@@ -81,7 +81,7 @@ package object groups {
     def wraps[G[_], A](ga: G[A]): G[Times[A]] = ga
     def unwrap[G[_], A](gfa: G[Times[A]]): G[A] = gfa
     implicit def timesSemigroup[A](implicit n: Numeric[A]): Semigroup[Times[A]] =
-      Semigroup.instance(n.times)
+      Semigroup.inst(n.times)
   }
 
   opaque type Reversed[A] = A
diff --git a/tests/pos/phantom-Evidence.scala b/tests/pos/phantom-Evidence.scala
index 732d9795d571..37ce544dfbcf 100644
--- a/tests/pos/phantom-Evidence.scala
+++ b/tests/pos/phantom-Evidence.scala
@@ -15,9 +15,9 @@ object WithNormalState {
   }
 
   def run() = {
-    val instance = Instance.newInstance()
-    instance.getOnInstance // inferred phantom evidence parameter =::= is erased
-    instance.getOnInstance.getOffInstance.getOnInstance.getOffInstance // all inferred phantom evidence parameters =::= are erased
+    val inst = Instance.newInstance()
+    inst.getOnInstance // inferred phantom evidence parameter =::= is erased
+    inst.getOnInstance.getOffInstance.getOnInstance.getOffInstance // all inferred phantom evidence parameters =::= are erased
   }
 
 }
diff --git a/tests/pos/reference/instances.scala b/tests/pos/reference/instances.scala
new file mode 100644
index 000000000000..3618b5a257a9
--- /dev/null
+++ b/tests/pos/reference/instances.scala
@@ -0,0 +1,284 @@
+class Common {
+
+  trait Ord[T] {
+    def (x: T) compareTo (y: T): Int
+    def (x: T) < (y: T) = x.compareTo(y) < 0
+    def (x: T) > (y: T) = x.compareTo(y) > 0
+  }
+
+  trait Convertible[From, To] {
+    def (x: From) convert: To
+  }
+
+  trait SemiGroup[T] {
+    def (x: T) combine (y: T): T
+  }
+
+  trait Monoid[T] extends SemiGroup[T] {
+    def unit: T
+  }
+
+  trait Functor[F[_]] {
+    def (x: F[A]) map[A, B] (f: A => B): F[B]
+  }
+
+  trait Monad[F[_]] extends Functor[F] {
+    def (x: F[A]) flatMap[A, B] (f: A => F[B]): F[B]
+    def (x: F[A]) map[A, B] (f: A => B) = x.flatMap(f `andThen` pure)
+
+    def pure[A](x: A): F[A]
+  }
+}
+
+object Instances extends Common {
+
+  instance IntOrd of Ord[Int] {
+    def (x: Int) compareTo (y: Int) =
+      if (x < y) -1 else if (x > y) +1 else 0
+  }
+
+  instance ListOrd[T] with Ord[T] of Ord[List[T]] {
+    def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+      case (Nil, Nil) => 0
+      case (Nil, _) => -1
+      case (_, Nil) => +1
+      case (x :: xs1, y :: ys1) =>
+        val fst = x.compareTo(y)
+        if (fst != 0) fst else xs1.compareTo(ys1)
+    }
+  }
+
+  instance StringOps {
+    def (xs: Seq[String]) longestStrings: Seq[String] = {
+      val maxLength = xs.map(_.length).max
+      xs.filter(_.length == maxLength)
+    }
+  }
+
+  instance ListOps {
+    def (xs: List[T]) second[T] = xs.tail.head
+  }
+
+  instance ListMonad of Monad[List] {
+    def (xs: List[A]) flatMap[A, B] (f: A => List[B]): List[B] =
+      xs.flatMap(f)
+    def pure[A](x: A): List[A] =
+      List(x)
+  }
+
+  instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
+    def (r: Ctx => A) flatMap[A, B] (f: A => Ctx => B): Ctx => B =
+      ctx => f(r(ctx))(ctx)
+    def pure[A](x: A): Ctx => A =
+      ctx => x
+  }
+
+  def maximum[T](xs: List[T]) with Ord[T]: T =
+    xs.reduceLeft((x, y) => if (x < y) y else x)
+
+  def descending[T] with (asc: Ord[T]): Ord[T] = new Ord[T] {
+    def (x: T) compareTo (y: T) = asc.compareTo(y)(x)
+  }
+
+  def minimum[T](xs: List[T]) with Ord[T] =
+    maximum(xs) with descending
+
+  def test(): Unit = {
+    val xs = List(1, 2, 3)
+    println(maximum(xs))
+    println(maximum(xs) with descending)
+    println(maximum(xs) with (descending with IntOrd))
+    println(minimum(xs))
+  }
+
+  case class Context(value: String)
+  val c0: Context |=> String = ctx |=> ctx.value
+  val c1: (Context |=> String) = (ctx: Context) |=> ctx.value
+
+  class A
+  class B
+  val ab: (x: A, y: B) |=> Int = (a: A, b: B) |=> 22
+
+  trait TastyAPI {
+    type Symbol
+    trait SymDeco {
+      def (sym: Symbol) name: String
+    }
+    def symDeco: SymDeco
+    instance of SymDeco = symDeco
+  }
+  object TastyImpl extends TastyAPI {
+    type Symbol = String
+    val symDeco = new SymDeco {
+      def (sym: Symbol) name = sym
+    }
+  }
+
+  class D[T]
+
+  class C with (ctx: Context) {
+    def f() = {
+      locally {
+        instance of Context = this.ctx
+        println(summon[Context].value)
+      }
+      locally {
+        lazy val ctx1 = this.ctx
+        instance of Context = ctx1
+        println(summon[Context].value)
+      }
+      locally {
+        instance d[T] of D[T]
+        println(summon[D[Int]])
+      }
+      locally {
+        instance with Context of D[Int]
+        println(summon[D[Int]])
+      }
+    }
+  }
+
+  class Token(str: String)
+
+  instance StringToToken of Conversion[String, Token] {
+    def apply(str: String): Token = new Token(str)
+  }
+
+  val x: Token = "if"
+}
+
+object PostConditions {
+  opaque type WrappedResult[T] = T
+
+  private instance WrappedResult {
+    def apply[T](x: T): WrappedResult[T] = x
+    def (x: WrappedResult[T]) unwrap[T]: T = x
+  }
+
+  def result[T] with (wrapped: WrappedResult[T]): T = wrapped.unwrap
+
+  instance {
+    def (x: T) ensuring[T] (condition: WrappedResult[T] |=> Boolean): T = {
+      assert(condition with WrappedResult(x))
+      x
+    }
+  }
+}
+
+object AnonymousInstances extends Common {
+  instance of Ord[Int] {
+    def (x: Int) compareTo (y: Int) =
+      if (x < y) -1 else if (x > y) +1 else 0
+  }
+
+  instance [T: Ord] of Ord[List[T]] {
+    def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+      case (Nil, Nil) => 0
+      case (Nil, _) => -1
+      case (_, Nil) => +1
+      case (x :: xs1, y :: ys1) =>
+        val fst = x.compareTo(y)
+        if (fst != 0) fst else xs1.compareTo(ys1)
+    }
+  }
+
+  instance {
+    def (xs: Seq[String]) longestStrings: Seq[String] = {
+      val maxLength = xs.map(_.length).max
+      xs.filter(_.length == maxLength)
+    }
+  }
+
+  instance {
+    def (xs: List[T]) second[T] = xs.tail.head
+  }
+
+  instance [From, To] with (c: Convertible[From, To]) of Convertible[List[From], List[To]] {
+    def (x: List[From]) convert: List[To] = x.map(c.convert)
+  }
+
+  instance of Monoid[String] {
+    def (x: String) combine (y: String): String = x.concat(y)
+    def unit: String = ""
+  }
+
+  def sum[T: Monoid](xs: List[T]): T =
+      xs.foldLeft(summon[Monoid[T]].unit)(_.combine(_))
+}
+
+object Implicits extends Common {
+  implicit object IntOrd extends Ord[Int] {
+    def (x: Int) compareTo (y: Int) =
+      if (x < y) -1 else if (x > y) +1 else 0
+  }
+
+  class ListOrd[T: Ord] extends Ord[List[T]] {
+    def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+      case (Nil, Nil) => 0
+      case (Nil, _) => -1
+      case (_, Nil) => +1
+      case (x :: xs1, y :: ys1) =>
+        val fst = x.compareTo(y)
+        if (fst != 0) fst else xs1.compareTo(ys1)
+    }
+  }
+  implicit def ListOrd[T: Ord]: Ord[List[T]] = new ListOrd[T]
+
+  class Convertible_List_List_instance[From, To](implicit c: Convertible[From, To])
+  extends Convertible[List[From], List[To]] {
+    def (x: List[From]) convert: List[To] = x.map(c.convert)
+  }
+  implicit def Convertible_List_List_instance[From, To](implicit c: Convertible[From, To])
+    : Convertible[List[From], List[To]] =
+    new Convertible_List_List_instance[From, To]
+
+  def maximum[T](xs: List[T])
+                (implicit cmp: Ord[T]): T =
+    xs.reduceLeft((x, y) => if (x < y) y else x)
+
+  def descending[T](implicit asc: Ord[T]): Ord[T] = new Ord[T] {
+    def (x: T) compareTo (y: T) = asc.compareTo(y)(x)
+  }
+
+  def minimum[T](xs: List[T])(implicit cmp: Ord[T]) =
+    maximum(xs)(descending)
+}
+
+object Test extends App {
+  Instances.test()
+  import PostConditions._
+  val s = List(1, 2, 3).sum
+  s.ensuring(result == 6)
+}
+
+object Completions {
+
+  class Future[T]
+  class HttpResponse
+  class StatusCode
+
+  // The argument "magnet" type
+  enum CompletionArg {
+    case Error(s: String)
+    case Response(f: Future[HttpResponse])
+    case Status(code: Future[StatusCode])
+  }
+  import CompletionArg._
+
+  def complete[T](arg: CompletionArg) = arg match {
+    case Error(s) => ???
+    case Response(f) => ???
+    case Status(code) => ???
+  }
+
+  // conversions defining the possible arguments to pass to `complete`
+  instance stringArg of Conversion[String, CompletionArg] {
+    def apply(s: String) = CompletionArg.Error(s)
+  }
+  instance responseArg of Conversion[Future[HttpResponse], CompletionArg] {
+    def apply(f: Future[HttpResponse]) = CompletionArg.Response(f)
+  }
+  instance statusArg of Conversion[Future[StatusCode], CompletionArg] {
+    def apply(code: Future[StatusCode]) = CompletionArg.Status(code)
+  }
+}
\ No newline at end of file
diff --git a/tests/pos/t7753.scala b/tests/pos/t7753.scala
index 80e2f1c66742..8ff8f19d3f65 100644
--- a/tests/pos/t7753.scala
+++ b/tests/pos/t7753.scala
@@ -3,31 +3,31 @@ import scala.language.{ higherKinds, implicitConversions }
 trait Foo { type Out }
 
 trait SI {
-  val instance: Foo
+  val inst: Foo
   type Out
 }
 
 object Test {
   def test: Unit = {
-    def indirect(si: SI)(v: si.instance.Out) = v
+    def indirect(si: SI)(v: si.inst.Out) = v
 
     val foo: Foo { type Out = Int } = ???
-    def conv(i: Foo): SI { type Out = i.Out; val instance: i.type } = ???
+    def conv(i: Foo): SI { type Out = i.Out; val inst: i.type } = ???
 
     val converted = conv(foo)
 
-    val v1: Int = indirect(converted)(23)  // Okay (after refining the return type `instance` in the return type of `conv`)
+    val v1: Int = indirect(converted)(23)  // Okay (after refining the return type `inst` in the return type of `conv`)
     /*
-    indirect(converted){(v: converted.instance.Out)converted.instance.Out}(
+    indirect(converted){(v: converted.inst.Out)converted.inst.Out}(
       23{Int(23)}
-    ){converted.instance.Out};
+    ){converted.inst.Out};
     */
 
     val v2: Int = indirect(conv(foo))(23)  // Used to fail as follows:
     /*
     indirect(
-        conv(foo){si.SI{type Out = foo.Out; val instance: si.Test.<refinement>.type}}
-    ){(v: si.instance.Out)si.instance.Out}(
+        conv(foo){si.SI{type Out = foo.Out; val inst: si.Test.<refinement>.type}}
+    ){(v: si.inst.Out)si.inst.Out}(
       23{<error>}
     ){<error>};
     */
diff --git a/tests/pos/typeclass-encoding.scala b/tests/pos/typeclass-encoding.scala
index 12ae16e208a6..981da1008b00 100644
--- a/tests/pos/typeclass-encoding.scala
+++ b/tests/pos/typeclass-encoding.scala
@@ -19,7 +19,7 @@
       }
 
       def sum[T: Monoid](xs: List[T]): T =
-        (instance[T, Monoid].unit /: xs)(_ `add` _)
+        (inst[T, Monoid].unit /: xs)(_ `add` _)
 
 */
 object runtime {
@@ -37,7 +37,7 @@ object runtime {
 
   class CompanionOf[T] { type StaticPart[_] }
 
-  def instance[From, To <: TypeClass](
+  def inst[From, To <: TypeClass](
       implicit ev1: Implementation[From] { type Implemented = To },
       ev2: CompanionOf[To]): Implementation[From] { type Implemented = To } & ev2.StaticPart[From] =
     ev1.asInstanceOf  // can we avoid the cast?
@@ -85,7 +85,7 @@ object semiGroups {
   }
 
   def sum[T](xs: List[T])(implicit $ev: Implementation[T] { type Implemented = Monoid } ) = {
-    (instance[T, Monoid].unit /: xs)((x, y) => inject(x) `add` y)
-    (instance[T, Monoid].unit /: xs)((x, y) => x `add` y)  // fails in scalac and previous dotc.
+    (inst[T, Monoid].unit /: xs)((x, y) => inject(x) `add` y)
+    (inst[T, Monoid].unit /: xs)((x, y) => x `add` y)  // fails in scalac and previous dotc.
   }
 }
diff --git a/tests/run/builder.scala b/tests/run/builder.scala
index d09e9f2c8895..436b14ed421f 100644
--- a/tests/run/builder.scala
+++ b/tests/run/builder.scala
@@ -16,13 +16,13 @@ case class Cell(elem: String)
 
 object Test {
 
-  def table(init: implicit Table => Unit) = {
+  def table(init: Table |=> Unit) = {
     implicit val t = new Table
     init
     t
   }
 
-  def row(init: implicit Row => Unit)(implicit t: Table) = {
+  def row(init: Row |=> Unit)(implicit t: Table) = {
     implicit val r = new Row
     init
     t.add(r)
diff --git a/tests/run/config.scala b/tests/run/config.scala
index e85d7bc8ba5a..7d30001be36c 100644
--- a/tests/run/config.scala
+++ b/tests/run/config.scala
@@ -29,13 +29,13 @@ object Imperative {
     ).onError(None)
 
   def main(args: Array[String]) = {
-    println(readPerson(Config("John Doe", 20)))
-    println(readPerson(Config("Incognito", 99)))
+    println(readPerson with Config("John Doe", 20))
+    println(readPerson with Config("Incognito", 99))
   }
 }
 
 object Configs {
-  type Configured[T] = implicit Config => T
+  type Configured[T] = Config |=> T
   def config: Configured[Config] = implicitly[Config]
 }
 
@@ -47,7 +47,7 @@ object Exceptions {
     private[Exceptions] def throwE() = throw new E
   }
 
-  type Possibly[T] = implicit CanThrow => T
+  type Possibly[T] = CanThrow |=> T
 
   def require(p: Boolean)(implicit ct: CanThrow): Unit =
     if (!p) ct.throwE()
@@ -56,7 +56,7 @@ object Exceptions {
 
   class OnError[T](op: Possibly[T]) {
     def onError(fallback: => T): T =
-      try op(new CanThrow)
+      try op with (new CanThrow)
       catch { case ex: E => fallback }
   }
 }
@@ -85,8 +85,8 @@ object Test extends App {
   val config1 = Config("John Doe", 20)
   val config2 = Config("Incognito", 99)
 
-  println(readPerson(config1))
-  println(readPerson(config2))
+  println(readPerson with config1)
+  println(readPerson with config2)
 }
 
 object OptionTest extends App {
diff --git a/tests/run/eff-dependent.scala b/tests/run/eff-dependent.scala
index 0e86494b1165..5ecfe0a08c8a 100644
--- a/tests/run/eff-dependent.scala
+++ b/tests/run/eff-dependent.scala
@@ -5,7 +5,7 @@ object Test extends App {
   // Type X => Y
   abstract class Fun[-X, +Y] {
     type Eff <: Effect
-    def apply(x: X): implicit Eff => Y
+    def apply(x: X): Eff |=> Y
   }
 
   class CanThrow extends Effect
@@ -18,18 +18,18 @@ object Test extends App {
   implicit val ci: CanIO = new CanIO
 
   // def map(f: A => B)(xs: List[A]): List[B]
-  def map[A, B](f: Fun[A, B])(xs: List[A]): implicit f.Eff => List[B] =
+  def map[A, B](f: Fun[A, B])(xs: List[A]): f.Eff |=> List[B] =
     xs.map(f.apply)
 
   // def mapFn[A, B]: (A => B) -> List[A] -> List[B]
-  def mapFn[A, B]: (f: Fun[A, B]) => List[A] => implicit f.Eff => List[B] =
+  def mapFn[A, B]: (f: Fun[A, B]) => List[A] => f.Eff |=> List[B] =
     f => xs => map(f)(xs)
 
   // def compose(f: A => B)(g: B => C)(x: A): C
-  def compose[A, B, C](f: Fun[A, B])(g: Fun[B, C])(x: A): implicit f.Eff => implicit g.Eff => C = g(f(x))
+  def compose[A, B, C](f: Fun[A, B])(g: Fun[B, C])(x: A): f.Eff |=> g.Eff |=> C = g(f(x))
 
   // def composeFn: (A => B) -> (B => C) -> A -> C
-  def composeFn[A, B, C]: (f: Fun[A, B]) => (g: Fun[B, C]) => A => implicit f.Eff => implicit g.Eff => C =
+  def composeFn[A, B, C]: (f: Fun[A, B]) => (g: Fun[B, C]) => A => f.Eff |=> g.Eff |=> C =
     f => g => x => compose(f)(g)(x)
 
   assert(mapFn(i2s)(List(1, 2, 3)).mkString == "123")
diff --git a/tests/run/erased-23.check b/tests/run/erased-23.check
index efbbe4dddf06..aac6a431ff8a 100644
--- a/tests/run/erased-23.check
+++ b/tests/run/erased-23.check
@@ -1,2 +1 @@
 lambda1
-lambda2
diff --git a/tests/run/erased-23.scala b/tests/run/erased-23.scala
index 8545a7bf8384..e61a0ad4a981 100644
--- a/tests/run/erased-23.scala
+++ b/tests/run/erased-23.scala
@@ -1,22 +1,13 @@
 object Test {
 
   def main(args: Array[String]): Unit = {
-    fun { implicit erased (x: Int) =>
+    fun { erased (x: Int) |=>
       println("lambda1")
       "abc"
     }
-
-    fun2 { erased implicit (x: Int) =>
-      println("lambda2")
-      "abc"
-    }
-  }
-
-  def fun(f: implicit erased Int => String): String = {
-    f(35)
   }
 
-  def fun2(f: erased implicit Int => String): String = {
-    f(36)
+  def fun(f: erased Int |=> String): String = {
+    f with 35
   }
 }
diff --git a/tests/run/i2642.scala b/tests/run/i2642.scala
index 6349f2e10d65..d0f4bcaf0b00 100644
--- a/tests/run/i2642.scala
+++ b/tests/run/i2642.scala
@@ -1,7 +1,7 @@
 // Tests nullary implicit function types
 object Test extends App {
   class I
-  type X = implicit () => Int
+  type X = () |=> Int
   def ff: X = 2
   assert(ff == 2)
 }
diff --git a/tests/run/i2939.scala b/tests/run/i2939.scala
index a9fa9ee22962..1e2937617bde 100644
--- a/tests/run/i2939.scala
+++ b/tests/run/i2939.scala
@@ -7,8 +7,8 @@ class Tag(val name: String, val buffer: Buffer[Tag] = ArrayBuffer()) {
 	    s"${" " * n}</$name>"
 	}
 
-	def apply[U](f: implicit Tag => U)(implicit tag: Tag = null): this.type = {
-		f(this)
+	def apply[U](f: Tag |=> U)(implicit tag: Tag = null): this.type = {
+		f with this
 		if(tag != null) tag.buffer += this
 		this
 	}
diff --git a/tests/run/i3448.scala b/tests/run/i3448.scala
index a856d8e2357b..6905c1cbcdbf 100644
--- a/tests/run/i3448.scala
+++ b/tests/run/i3448.scala
@@ -1,13 +1,13 @@
 object Test extends App {
 
   case class C(x: Int)
-  type IF[T] = implicit C => T
+  type IF[T] = C |=> T
 
   val x: IF[Int] = implicitly[C].x
 
-  val xs0: List[IF[Int]] = List(implicit _ => x)
+  val xs0: List[IF[Int]] = List(_ |=> x)
   val xs: List[IF[Int]] = List(x)
   val ys: IF[List[Int]] = xs.map(x => x)
-  val zs = ys(C(22))
+  val zs = ys with C(22)
   assert(zs == List(22))
 }
diff --git a/tests/run/implicit-shortcut-bridge.scala b/tests/run/implicit-shortcut-bridge.scala
index 97c168bd3c05..7ad474ea507f 100644
--- a/tests/run/implicit-shortcut-bridge.scala
+++ b/tests/run/implicit-shortcut-bridge.scala
@@ -1,17 +1,17 @@
 abstract class A[T] {
   def foo: T
 }
-class B extends A[implicit Int => Int] {
+class B extends A[Int |=> Int] {
   // No bridge needed for foo$direct
-  def foo: implicit Int => Int = 1
+  def foo: Int |=> Int = 1
 }
 
-abstract class X[T] extends A[implicit T => T] {
-  def foo: implicit T => T
+abstract class X[T] extends A[T |=> T] {
+  def foo: T |=> T
 }
 
 class Y extends X[Int] {
-  def foo: implicit Int => Int = 1
+  def foo: Int |=> Int = 1
 }
 
 object Test {
diff --git a/tests/run/implicitFunctionXXL.scala b/tests/run/implicitFunctionXXL.scala
index 9d1d4ff37ecd..7c3093890e00 100644
--- a/tests/run/implicitFunctionXXL.scala
+++ b/tests/run/implicitFunctionXXL.scala
@@ -5,7 +5,7 @@ object Test {
     implicit val intWorld: Int = 42
     implicit val strWorld: String = "Hello "
 
-    val i1 = (implicit (x1: Int,
+    val i1 = (         (x1: Int,
                         x2: String,
                         x3: Int,
                         x4: Int,
@@ -30,7 +30,7 @@ object Test {
                         x23: Int,
                         x24: Int,
                         x25: Int,
-                        x26: Int) => x2 + x1)
+                        x26: Int) |=> x2 + x1)
 
     println(i1)
   }
diff --git a/tests/run/implicitFuns.scala b/tests/run/implicitFuns.scala
index 496fba0d387c..30893ed544c9 100644
--- a/tests/run/implicitFuns.scala
+++ b/tests/run/implicitFuns.scala
@@ -3,44 +3,44 @@ object Test {
 
     implicit val world: String = "world!"
 
-    val i1 = (implicit (s: String) => s.length > 2)
-    val i2 = {implicit (s: String) => s.length > 2}
+    val i1 = ((s: String) |=> s.length > 2)
+    val i2 = {(s: String) |=> s.length > 2}
 
     assert(i1)
     assert(i2)
 
-    val x: implicit String => Boolean = { implicit (s: String) => s.length > 2 }
+    val x: String |=> Boolean = { (s: String) |=> s.length > 2 }
 
-    val xx: implicit (String, Int) => Int = implicit (x: String, y: Int) => x.length + y
+    val xx: (String, Int) |=> Int = (x: String, y: Int) |=> x.length + y
 
-    val y: String => Boolean = x
+    val y: String => Boolean = x with _
 
     object nested {
       implicit val empty: String = ""
       assert(!x)
     }
 
-    val yy: (String, Int) => Any = xx
+    val yy: (String, Int) => Any = xx with (_, _)
 
-    val z1: implicit String => Boolean = implicitly[String].length >= 2
+    val z1: String |=> Boolean = implicitly[String].length >= 2
     assert(z1)
 
-    type StringlyBool = implicit String => Boolean
+    type StringlyBool = String |=> Boolean
 
     val z2: StringlyBool = implicitly[String].length >= 2
     assert(z2)
 
-    type Stringly[T] = implicit String => T
+    type Stringly[T] = String |=> T
 
     val z3: Stringly[Boolean] = implicitly[String].length >= 2
     assert(z3)
 
-    type GenericImplicit[X] = implicit X => Boolean
+    type GenericImplicit[X] = X |=> Boolean
 
     val z4: GenericImplicit[String] = implicitly[String].length >= 2
     assert(z4)
 
-    val b = x("hello")
+    val b = x with "hello"
 
     val b1: Boolean = b
 
@@ -48,7 +48,7 @@ object Test {
 
     val bi1: Boolean = bi
 
-    val c = xx("hh", 22)
+    val c = xx with ("hh", 22)
 
     val c1: Int = c
 
@@ -56,7 +56,7 @@ object Test {
 
     def foo(s: String): Stringly[Int] = 42
 
-    (if ("".isEmpty) foo("") else foo("")).apply("")
+    (if ("".isEmpty) foo("") else foo("")).apply with ""
   }
 }
 
@@ -76,16 +76,16 @@ object Contextual {
   val Source = new Key[String]
   val Options = new Key[List[String]]
 
-  type Ctx[T] = implicit Context => T
+  type Ctx[T] = Context |=> T
 
   def ctx: Ctx[Context] = implicitly[Context]
 
   def compile(s: String): Ctx[Boolean] =
-    runOn(new java.io.File(s))(ctx.withBinding(Source, s)) >= 0
+    (runOn(new java.io.File(s)) with ctx.withBinding(Source, s)) >= 0
 
   def runOn(f: java.io.File): Ctx[Int] = {
     val options = List("-verbose", "-explaintypes")
-    process(f).apply(ctx.withBinding(Options, options))
+    process(f).apply with ctx.withBinding(Options, options)
   }
 
   def process(f: java.io.File): Ctx[Int] =
@@ -151,7 +151,7 @@ object TransactionalExplicit {
 }
 
 object Transactional {
-  type Transactional[T] = implicit Transaction => T
+  type Transactional[T] = Transaction |=> T
 
   def transaction[T](op: Transactional[T]) = {
     implicit val trans: Transaction = new Transaction
@@ -216,7 +216,7 @@ object TransactionalExpansion {
 }
 
 object TransactionalAbstracted {
-  type Transactional[T] = implicit Transaction => T
+  type Transactional[T] = Transaction |=> T
 
   trait TransOps {
     def thisTransaction: Transactional[Transaction]
diff --git a/tests/run/implicitFuns2.scala b/tests/run/implicitFuns2.scala
index 56b815a716f0..8f59819015a9 100644
--- a/tests/run/implicitFuns2.scala
+++ b/tests/run/implicitFuns2.scala
@@ -2,27 +2,27 @@ class A
 class B
 
 trait Foo {
-  def foo: implicit A => implicit B => Int
+  def foo: A |=> B |=> Int
 }
 
 class Foo1 extends Foo {
-  def foo: implicit A => implicit B => Int = 1
+  def foo: A |=> B |=> Int = 1
 }
 
 class Foo2 extends Foo1 {
-  override def foo: implicit A => implicit B => Int = 2
+  override def foo: A |=> B |=> Int = 2
 }
 
 trait Foo3 extends Foo {
-  override def foo: implicit A => implicit B => Int = 3
+  override def foo: A |=> B |=> Int = 3
 }
 
 class Bar[T] {
-  def bar: implicit A => T = null.asInstanceOf[T]
+  def bar: A |=> T = null.asInstanceOf[T]
 }
 
-class Bar1 extends Bar[implicit B => Int] {
-  override def bar: implicit A => implicit B => Int = 1
+class Bar1 extends Bar[B |=> Int] {
+  override def bar: A |=> B |=> Int = 1
 }
 
 object Test {
diff --git a/tests/run/implicitShortcut/Base_1.scala b/tests/run/implicitShortcut/Base_1.scala
index 1c6c663aa6ed..bbba570bcf38 100644
--- a/tests/run/implicitShortcut/Base_1.scala
+++ b/tests/run/implicitShortcut/Base_1.scala
@@ -3,6 +3,6 @@ package implicitShortcut
 class C
 abstract class Base[T] {
 
-  def foo(x: T): implicit C => T = x
+  def foo(x: T): C |=> T = x
 
 }
\ No newline at end of file
diff --git a/tests/run/implicitShortcut/Derived_2.scala b/tests/run/implicitShortcut/Derived_2.scala
index f983cc38b1db..b66bfcc17c02 100644
--- a/tests/run/implicitShortcut/Derived_2.scala
+++ b/tests/run/implicitShortcut/Derived_2.scala
@@ -1,5 +1,5 @@
 package implicitShortcut
 
 class Derived extends Base[Int] {
-  override def foo(x: Int): implicit C => Int = 42
+  override def foo(x: Int): C |=> Int = 42
 }
\ No newline at end of file
diff --git a/tests/run/instances-anonymous.check b/tests/run/instances-anonymous.check
new file mode 100644
index 000000000000..a754cb78f072
--- /dev/null
+++ b/tests/run/instances-anonymous.check
@@ -0,0 +1,5 @@
+12.566370614359172
+hihelloworld
+-2147483648
+3
+List(2)
diff --git a/tests/run/instances-anonymous.scala b/tests/run/instances-anonymous.scala
new file mode 100644
index 000000000000..a4b29bdcb9b8
--- /dev/null
+++ b/tests/run/instances-anonymous.scala
@@ -0,0 +1,125 @@
+object Test extends App {
+
+  implicit object O {
+    def (x: Int) em: Boolean = x > 0
+  }
+
+  assert(1.em == O.em(1))
+
+  case class Circle(x: Double, y: Double, radius: Double)
+
+  instance {
+    def (c: Circle) circumference: Double = c.radius * math.Pi * 2
+  }
+
+  val circle = new Circle(1, 1, 2.0)
+
+  println(circle.circumference)
+
+  instance {
+    def (xs: Seq[String]) longestStrings: Seq[String] = {
+      val maxLength = xs.map(_.length).max
+      xs.filter(_.length == maxLength)
+    }
+  }
+  val names = List("hi", "hello", "world")
+  assert(names.longestStrings == List("hello", "world"))
+
+  instance {
+    def (xs: Seq[T]) second[T] = xs.tail.head
+  }
+
+  assert(names.longestStrings.second == "world")
+
+  instance {
+    def (xs: List[List[T]]) flattened[T] = xs.foldLeft[List[T]](Nil)(_ ++ _)
+  }
+
+  assert(List(names, List("!")).flattened == names :+ "!")
+  assert(Nil.flattened == Nil)
+
+  trait SemiGroup[T] {
+    def (x: T) combine (y: T): T
+  }
+  trait Monoid[T] extends SemiGroup[T] {
+    def unit: T
+  }
+
+  // An instance declaration:
+  instance of Monoid[String] {
+    def (x: String) combine (y: String): String = x.concat(y)
+    def unit: String = ""
+  }
+
+  // Abstracting over a typeclass with a context bound:
+  def sum[T: Monoid](xs: List[T]): T =
+    xs.foldLeft(implicitly[Monoid[T]].unit)(_.combine(_))
+
+  println(sum(names))
+
+  trait Ord[T] {
+    def (x: T) compareTo (y: T): Int
+    def (x: T) < (y: T) = x.compareTo(y) < 0
+    def (x: T) > (y: T) = x.compareTo(y) > 0
+    val minimum: T
+  }
+
+  instance of Ord[Int] {
+    def (x: Int) compareTo (y: Int) =
+      if (x < y) -1 else if (x > y) +1 else 0
+    val minimum = Int.MinValue
+  }
+
+  instance [T: Ord] of Ord[List[T]] {
+    def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+      case (Nil, Nil) => 0
+      case (Nil, _) => -1
+      case (_, Nil) => +1
+      case (x :: xs1, y :: ys1) =>
+        val fst = x.compareTo(y)
+        if (fst != 0) fst else xs1.compareTo(ys1)
+    }
+    val minimum: List[T] = Nil
+  }
+
+  def max[T: Ord](x: T, y: T): T = if (x < y) y else x
+
+  def max[T: Ord](xs: List[T]): T = (implicitly[Ord[T]].minimum /: xs)(max(_, _))
+
+  println(max(List[Int]()))
+  println(max(List(1, 2, 3)))
+
+  println(max(List(1, 2, 3), List(2)))
+
+  trait Functor[F[_]] {
+    def (x: F[A]) map[A, B] (f: A => B): F[B]
+  }
+
+  trait Monad[F[_]] extends Functor[F] {
+    def (x: F[A]) flatMap[A, B] (f: A => F[B]): F[B]
+    def (x: F[A]) map[A, B] (f: A => B) = x.flatMap(f `andThen` pure)
+
+    def pure[A](x: A): F[A]
+  }
+
+  instance of Monad[List] {
+    def (xs: List[A]) flatMap[A, B] (f: A => List[B]): List[B] =
+      xs.flatMap(f)
+    def pure[A](x: A): List[A] =
+      List(x)
+  }
+
+  instance [Ctx] of Monad[[X] => Ctx => X] {
+    def (r: Ctx => A) flatMap[A, B] (f: A => Ctx => B): Ctx => B =
+      ctx => f(r(ctx))(ctx)
+    def pure[A](x: A): Ctx => A =
+      ctx => x
+  }
+
+  def mappAll[F[_]: Monad, T](x: T, fs: List[T => T]): F[T] =
+    fs.foldLeft(implicitly[Monad[F]].pure(x))((x: F[T], f: T => T) =>
+      if (true) implicitly[Monad[F]].map(x)(f)
+      else if (true) x.map(f)
+      else x.map[T, T](f)
+    )
+}
diff --git a/tests/run/instances.check b/tests/run/instances.check
new file mode 100644
index 000000000000..5cd13ae2676a
--- /dev/null
+++ b/tests/run/instances.check
@@ -0,0 +1,4 @@
+hihelloworld
+-2147483648
+3
+List(2)
diff --git a/tests/run/instances.scala b/tests/run/instances.scala
new file mode 100644
index 000000000000..c971238330f2
--- /dev/null
+++ b/tests/run/instances.scala
@@ -0,0 +1,133 @@
+object Test extends App {
+
+  implicit object O {
+    def (x: Int) em: Boolean = x > 0
+  }
+
+  assert(1.em == O.em(1))
+
+  case class Circle(x: Double, y: Double, radius: Double)
+
+  instance CircleOps {
+    def (c: Circle) circumference: Double = c.radius * math.Pi * 2
+  }
+
+  val circle = new Circle(1, 1, 2.0)
+
+  assert(circle.circumference == CircleOps.circumference(circle))
+
+  instance StringOps {
+    def (xs: Seq[String]) longestStrings: Seq[String] = {
+      val maxLength = xs.map(_.length).max
+      xs.filter(_.length == maxLength)
+    }
+  }
+  val names = List("hi", "hello", "world")
+  assert(names.longestStrings == List("hello", "world"))
+
+  instance SeqOps {
+    def (xs: Seq[T]) second[T] = xs.tail.head
+  }
+
+  assert(names.longestStrings.second == "world")
+
+  instance ListListOps {
+    def (xs: List[List[T]]) flattened[T] = xs.foldLeft[List[T]](Nil)(_ ++ _)
+  }
+
+  // A right associative op
+  instance Prepend {
+    def (x: T) ::[T] (xs: Seq[T]) = x +: xs
+  }
+  val ss: Seq[Int] = List(1, 2, 3)
+  val ss1 = 0 :: ss
+  assert(ss1 == List(0, 1, 2, 3))
+
+  assert(List(names, List("!")).flattened == names :+ "!")
+  assert(Nil.flattened == Nil)
+
+  trait SemiGroup[T] {
+    def (x: T) combine (y: T): T
+  }
+  trait Monoid[T] extends SemiGroup[T] {
+    def unit: T
+  }
+
+  // An instance declaration:
+  instance StringMonoid of Monoid[String] {
+    def (x: String) combine (y: String): String = x.concat(y)
+    def unit: String = ""
+  }
+
+  // Abstracting over a typeclass with a context bound:
+  def sum[T: Monoid](xs: List[T]): T =
+    xs.foldLeft(implicitly[Monoid[T]].unit)(_.combine(_))
+
+  println(sum(names))
+
+  trait Ord[T] {
+    def (x: T) compareTo (y: T): Int
+    def (x: T) < (y: T) = x.compareTo(y) < 0
+    def (x: T) > (y: T) = x.compareTo(y) > 0
+    val minimum: T
+  }
+
+  instance of Ord[Int] {
+    def (x: Int) compareTo (y: Int) =
+      if (x < y) -1 else if (x > y) +1 else 0
+    val minimum = Int.MinValue
+  }
+
+  instance ListOrd[T: Ord] of Ord[List[T]] {
+    def (xs: List[T]) compareTo (ys: List[T]): Int = (xs, ys) match {
+      case (Nil, Nil) => 0
+      case (Nil, _) => -1
+      case (_, Nil) => +1
+      case (x :: xs1, y :: ys1) =>
+        val fst = x.compareTo(y)
+        if (fst != 0) fst else xs1.compareTo(ys1)
+    }
+    val minimum: List[T] = Nil
+  }
+
+  def max[T: Ord](x: T, y: T): T = if (x < y) y else x
+
+  def max[T: Ord](xs: List[T]): T = (implicitly[Ord[T]].minimum /: xs)(max(_, _))
+
+  println(max(List[Int]()))
+  println(max(List(1, 2, 3)))
+
+  println(max(List(1, 2, 3), List(2)))
+
+  trait Functor[F[_]] {
+    def (x: F[A]) map[A, B] (f: A => B): F[B]
+  }
+
+  trait Monad[F[_]] extends Functor[F] {
+    def (x: F[A]) flatMap[A, B] (f: A => F[B]): F[B]
+    def (x: F[A]) map[A, B] (f: A => B) = x.flatMap(f `andThen` pure)
+
+    def pure[A](x: A): F[A]
+  }
+
+  instance ListMonad of Monad[List] {
+    def (xs: List[A]) flatMap[A, B] (f: A => List[B]): List[B] =
+      xs.flatMap(f)
+    def pure[A](x: A): List[A] =
+      List(x)
+  }
+
+  instance ReaderMonad[Ctx] of Monad[[X] => Ctx => X] {
+    def (r: Ctx => A) flatMap[A, B] (f: A => Ctx => B): Ctx => B =
+      ctx => f(r(ctx))(ctx)
+    def pure[A](x: A): Ctx => A =
+      ctx => x
+  }
+
+  def mappAll[F[_]: Monad, T](x: T, fs: List[T => T]): F[T] =
+    fs.foldLeft(implicitly[Monad[F]].pure(x))((x: F[T], f: T => T) =>
+      if (true) implicitly[Monad[F]].map(x)(f)
+      else if (true) x.map(f)
+      else x.map[T, T](f)
+    )
+}
\ No newline at end of file
diff --git a/tests/run/returning.scala b/tests/run/returning.scala
index f0af05e2ba14..28d65ed7056d 100644
--- a/tests/run/returning.scala
+++ b/tests/run/returning.scala
@@ -14,9 +14,9 @@ object NonLocalReturns {
   def throwReturn[T](result: T)(implicit returner: ReturnThrowable[T]): Nothing =
     returner.throwReturn(result)
 
-  def returning[T](op: implicit ReturnThrowable[T] => T): T = {
+  def returning[T](op: ReturnThrowable[T] |=> T): T = {
     val returner = new ReturnThrowable[T]
-    try op(returner)
+    try op with returner
     catch {
       case ex: ReturnThrowable[_] =>
        if (ex `eq` returner) ex.result.asInstanceOf[T] else throw ex
diff --git a/tests/run/t6111.scala b/tests/run/t6111.scala
index 6f0164833794..915c23b446fe 100644
--- a/tests/run/t6111.scala
+++ b/tests/run/t6111.scala
@@ -4,7 +4,7 @@
 // along with the real fix: an extractor pattern with 1 sub-pattern should type check for all extractors
 // that return Option[T], whatever T (even if it's a tuple)
 object Foo {
-  def unapply[S, T](scrutinee: S)(implicit witness: FooHasType[S, T]): Option[T] = scrutinee match {
+  def unapply[S, T](scrutinee: S)(implicit evidence: FooHasType[S, T]): Option[T] = scrutinee match {
     case i: Int => Some((i, i).asInstanceOf[T])
   }
 }
diff --git a/tests/run/t8280.scala b/tests/run/t8280.scala
index 7578e0417ff4..8d77e735ef70 100644
--- a/tests/run/t8280.scala
+++ b/tests/run/t8280.scala
@@ -74,14 +74,14 @@ object Moop3 {
       // Dotty deviation. This fails for Dotty with ambiguity error for similar reasons as ob1.
   }
   object ob2 {
-    implicit val f1: ImplicitConverter[Int, String]  = _ => "Int"
+    implicit val f1: Conversion[Int, String]  = _ => "Int"
     implicit def f2(x: Long): String = "Long"
 
     println(5: String)
   }
   object ob3 {
-    implicit val f1: ImplicitConverter[Int, String]  = _ => "Int"
-    implicit val f2: ImplicitConverter[Long, String] = _ => "Long"
+    implicit val f1: Conversion[Int, String]  = _ => "Int"
+    implicit val f2: Conversion[Long, String] = _ => "Long"
 
     println((5: Int): String)
     // println(5: String)  // error: ambiguity, since both f1 and f2 are applicable to 5.
diff --git a/tests/run/tagless.check b/tests/run/tagless.check
new file mode 100644
index 000000000000..b397f0d211d5
--- /dev/null
+++ b/tests/run/tagless.check
@@ -0,0 +1,20 @@
+5
+(8 + (-(1 + 2)))
+5
+(7 + (-1 * 2))
+35
+7 * (8 + (-(1 + 2)))
+tf1Tree = Node(Add,WrappedArray(Node(Lit,WrappedArray(Leaf(8))), Node(Neg,WrappedArray(Node(Add,WrappedArray(Node(Lit,WrappedArray(Leaf(1))), Node(Lit,WrappedArray(Leaf(2)))))))))
+tfm1Tree = Node(Add,WrappedArray(Node(Lit,WrappedArray(Leaf(7))), Node(Neg,WrappedArray(Node(Mult,WrappedArray(Node(Lit,WrappedArray(Leaf(1))), Node(Lit,WrappedArray(Leaf(2)))))))))
+2
+Not a number: "X"
+5
+(8 + (-(1 + 2)))
+Node(Add,WrappedArray(Node(Lit,WrappedArray(Leaf(8))), Node(Neg,WrappedArray(Node(Add,WrappedArray(Node(Lit,WrappedArray(Leaf(1))), Node(Lit,WrappedArray(Leaf(2)))))))))
+5
+(8 + (-(1 + 2)))
+(8 + ((-1) + (-2)))
+(8 + ((-1) + (-2)))
+(8 + ((-1) + (-2)))
+(7 + 1 * (-2))
+7 * (8 + ((-1) + (-2)))
diff --git a/tests/run/tagless.scala b/tests/run/tagless.scala
new file mode 100644
index 000000000000..d59b091b39bb
--- /dev/null
+++ b/tests/run/tagless.scala
@@ -0,0 +1,251 @@
+// A rewrite of Olivier Blanvillain's [adaptation](https://gist.github.com/OlivierBlanvillain/48bb5c66dbb0557da50465809564ee80)
+// of Oleg Kislyov's [lecture notes](http://okmij.org/ftp/tagless-final/course/lecture.pdf)
+// on tagless final interpreters.
+// Main win: Replace Either by an "algebraic effect" using an implicit function type.
+object Test extends App {
+
+  // Explicit ADT
+  enum IExp {
+    case Lit(i: Int)
+    case Neg(e: IExp)
+    case Add(l: IExp, r: IExp)
+  }
+
+  val fe: IExp = {
+    import IExp._
+    Add(Lit(8), Neg(Add(Lit(1), Lit(2))))
+  }
+
+  // Base trait for type classes
+  trait Exp[T] {
+    def lit(i: Int): T
+    def neg(t: T): T
+    def add(l: T, r: T): T
+  }
+
+  // An example tree
+  def tf0[T] with (e: Exp[T]): T =
+    e.add(e.lit(8), e.neg(e.add(e.lit(1), e.lit(2))))
+
+  // Typeclass-style Exp syntax
+  object ExpSyntax {
+    def lit[T](i: Int)     with (e: Exp[T]): T = e.lit(i)
+    def neg[T](t: T)       with (e: Exp[T]): T = e.neg(t)
+    def add[T](l: T, r: T) with (e: Exp[T]): T = e.add(l, r)
+  }
+  import ExpSyntax._ // It's safe to always have these in scope
+
+  // Another tree
+  def tf1[T] with Exp[T]: T =
+    add(lit(8), neg(add(lit(1), lit(2))))
+
+  // Base operations as typeclasses
+  instance of Exp[Int] {
+    def lit(i: Int): Int = i
+    def neg(t: Int): Int = -t
+    def add(l: Int, r: Int): Int = l + r
+  }
+
+  instance of Exp[String] {
+    def lit(i: Int): String = i.toString
+    def neg(t: String): String = s"(-$t)"
+    def add(l: String, r: String): String = s"($l + $r)"
+  }
+
+  println(tf1[Int])
+  println(tf1[String])
+
+  // Added case in algebra: *
+  trait Mult[T] {
+    def mul(l: T, r: T): T
+  }
+  object MultSyntax {
+    def mul[T](l: T, r: T) with (e: Mult[T]): T = e.mul(l, r)
+  }
+  import MultSyntax._
+
+  def tfm1[T: Exp : Mult] = add(lit(7), neg(mul(lit(1), lit(2))))
+  def tfm2[T: Exp : Mult] = mul(lit(7), tf1)
+
+  instance of Mult[Int] {
+    def mul(l: Int, r: Int): Int = l * r
+  }
+
+  instance of Mult[String] {
+    def mul(l: String, r: String): String = s"$l * $r"
+  }
+
+  println(tfm1[Int])
+  println(tfm1[String])
+  println(tfm2[Int])
+  println(tfm2[String])
+
+  // Added operation: serialization
+  enum Tree {
+    case Leaf(s: String)
+    case Node(s: String, ts: Tree*)
+  }
+  import Tree._
+
+  instance of Exp[Tree], Mult[Tree] {
+    def lit(i: Int): Tree = Node("Lit", Leaf(i.toString))
+    def neg(t: Tree): Tree = Node("Neg", t)
+    def add(l: Tree, r: Tree): Tree = Node("Add", l , r)
+    def mul(l: Tree, r: Tree): Tree = Node("Mult", l , r)
+  }
+
+  val tf1Tree = tf1[Tree]
+  val tfm1Tree = tfm1[Tree]
+
+  println(s"tf1Tree = $tf1Tree")
+  println(s"tfm1Tree = $tfm1Tree")
+
+  // CanThrow infrastructure
+  // At some point this will be supported in language and stdlib
+  class CanThrow private ()
+
+  object CanThrow {
+    private class Exc(msg: String) extends Exception(msg)
+    def _throw(msg: String) with CanThrow: Nothing = throw new Exc(msg)
+    def _try[T](op: CanThrow |=> T)(handler: String => T): T = {
+      instance of CanThrow
+      try op
+      catch {
+        case ex: Exception => handler(ex.getMessage)
+      }
+    }
+  }
+  import CanThrow._
+
+  type Maybe[T] = CanThrow |=> T
+
+  def show[T](op: Maybe[T]): Unit =
+    println(_try(op.toString)(identity))
+
+  def assertEquals[T](op1: Maybe[T], op2: Maybe[T]): Unit =
+    _try {
+      val x1 = op1
+      val x2 = op2
+      assert(x1 == x2, "$x1 != $x2")
+    } {
+      msg => assert(false, s"thrown: $msg")
+    }
+
+  // Added operation: deserialization
+  def readInt(str: String): Maybe[Int] =
+    _try(str.toInt)(_ => _throw(s"""Not a number: "$str""""))
+
+  show(readInt("2"))
+  show(readInt("X"))
+
+  def fromTree[T](t: Tree) with Exp[T]: Maybe[T] = t match {
+    case Node("Lit", Leaf(n)) => lit(readInt(n))
+    case Node("Neg", t) => neg(fromTree(t))
+    case Node("Add", l , r) => add(fromTree(l), fromTree(r))
+    case _ => _throw(s"Invalid tree $t")
+  }
+
+  show(fromTree[Int](tf1Tree))
+  show(fromTree[String](tf1Tree))
+  show(fromTree[Tree](tf1Tree))
+
+  trait Wrapped {
+    def value[T] with Exp[T]: T
+  }
+
+  instance of Exp[Wrapped] {
+    def lit(i: Int) = new Wrapped {
+      def value[T] with (e: Exp[T]): T = e.lit(i)
+    }
+    def neg(t: Wrapped) = new Wrapped {
+      def value[T] with (e: Exp[T]): T = e.neg(t.value)
+    }
+    def add(l: Wrapped, r: Wrapped) = new Wrapped {
+      def value[T] with (e: Exp[T]): T = e.add(l.value, r.value)
+    }
+  }
+
+  show {
+    val t = fromTree[Wrapped](tf1Tree)
+    s"${t.value[Int]}\n${t.value[String]}"
+
+  }
+  def fromTreeExt[T](recur: => Tree => Maybe[T]) with Exp[T]: Tree => Maybe[T] = {
+    case Node("Lit", Leaf(n)) => lit(readInt(n))
+    case Node("Neg", t) => neg(recur(t))
+    case Node("Add", l , r) => add(recur(l), recur(r))
+    case t => _throw(s"Invalid tree $t")
+  }
+
+  def fix[A](f: (=> A) => A): A = f(fix(f))
+
+  def fromTree2[T: Exp](t: Tree): Maybe[T] = fix(fromTreeExt[T])(t)
+
+  def fromTreeExt2[T](recur: => Tree => Maybe[T]) with Exp[T], Mult[T]: Tree => Maybe[T] = {
+    case Node("Mult", l , r) => mul(recur(l), recur(r))
+    case t => fromTreeExt(recur)(t)
+  }
+
+  def fromTree3[T: Exp : Mult](t: Tree): Maybe[T] = fix(fromTreeExt2[T])(t)
+
+  assertEquals(fromTree[String](tf1[Tree]), tf1[String])
+  assertEquals(fromTree2[String](tf1[Tree]), tf1[String])
+  assertEquals(fromTree3[String](tf1[Tree]), tf1[String])
+  assertEquals(fromTree3[String](tfm1[Tree]), tfm1[String])
+
+  // Added operation: negation pushdown
+  enum NCtx { case Pos, Neg }
+
+  instance [T] with (e: Exp[T]) of Exp[NCtx => T] {
+    import NCtx._
+    def lit(i: Int) = {
+      case Pos => e.lit(i)
+      case Neg => e.neg(e.lit(i))
+    }
+    def neg(x: NCtx => T): NCtx => T = {
+     case Pos => x(Neg)
+     case Neg => x(Pos)
+    }
+    def add(l: NCtx => T, r: NCtx => T): NCtx => T =
+      c => e.add(l(c), r(c))
+  }
+
+  println(tf1[NCtx => String](NCtx.Pos))
+
+  def pushNeg[T](e: NCtx => T): T = e(NCtx.Pos)
+  println(pushNeg(tf1[NCtx => String]))
+  println(pushNeg(pushNeg(pushNeg(tf1))): String)
+
+  instance [T] with (e: Mult[T]) of Mult[NCtx => T] {
+    import NCtx._
+    def mul(l: NCtx => T, r: NCtx => T): NCtx => T = {
+      case Pos => e.mul(l(Pos), r(Pos))
+      case Neg => e.mul(l(Pos), r(Neg))
+    }
+  }
+
+  println(pushNeg(tfm1[NCtx => String]))
+  println(pushNeg(tfm2[NCtx => String]))
+
+  import IExp._
+
+  // Going from type class encoding to ADT encoding
+  instance initialize of Exp[IExp] {
+    def lit(i: Int): IExp = Lit(i)
+    def neg(t: IExp): IExp = Neg(t)
+    def add(l: IExp, r: IExp): IExp = Add(l, r)
+  }
+
+  // Going from ADT encoding to type class encoding
+  def finalize[T](i: IExp) with (e: Exp[T]): T = i match {
+    case Lit(l) => e.lit(l)
+    case Neg(n) => e.neg(finalize[T](n))
+    case Add(l, r) => e.add(finalize[T](l), finalize[T](r))
+  }
+
+  // Abstracting over multiple typeclasses
+  type Ring[T] = Exp[T] |=> Mult[T] |=> T
+
+  def tfm1a[T]: Ring[T] = add(lit(7), neg(mul(lit(1), lit(2))))
+  def tfm2a[T]: Ring[T] = mul(lit(7), tf1)
+}
\ No newline at end of file
diff --git a/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala b/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala
index 51b1eeced766..afc84c7e67d3 100644
--- a/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala
+++ b/tests/run/tasty-getfile-implicit-fun-context/Macro_1.scala
@@ -3,7 +3,7 @@ import scala.tasty.Reflection
 
 object SourceFiles {
 
-  type Macro[X] = implicit Reflection => Expr[X]
+  type Macro[X] = Reflection |=> Expr[X]
   def tastyContext(implicit ctx: Reflection): Reflection = ctx
 
   implicit inline def getThisFile: String =
diff --git a/tests/run/tasty-implicit-fun-context-2/Macro_1.scala b/tests/run/tasty-implicit-fun-context-2/Macro_1.scala
index 38778a12a183..170080aab25b 100644
--- a/tests/run/tasty-implicit-fun-context-2/Macro_1.scala
+++ b/tests/run/tasty-implicit-fun-context-2/Macro_1.scala
@@ -3,14 +3,13 @@ import scala.tasty.Reflection
 
 object Foo {
 
-  type Macro[X] = implicit Reflection => Expr[X]
-  type Tastier[X] = implicit Reflection => X
+  type Macro[X] = Reflection |=> Expr[X]
+  type Tastier[X] = Reflection |=> X
 
   implicit inline def foo: String =
     ~fooImpl
 
-  def fooImpl(implicit reflect: Reflection): implicit Reflection => Tastier[implicit Reflection => Macro[String]] = {
+  def fooImpl(implicit reflect: Reflection): Reflection |=> Tastier[Reflection |=> Macro[String]] = {
     '("abc")
   }
-
 }
diff --git a/tests/run/try.scala b/tests/run/try.scala
index 785f0153a7a5..b22e334346fc 100644
--- a/tests/run/try.scala
+++ b/tests/run/try.scala
@@ -38,11 +38,11 @@ object Test extends AnyRef with App {
     Console.println(x + n);
   }
 
-  var instance: AnyRef = null;
+  var inst: AnyRef = null;
 
   def try4 = {
-    if (instance == null) {
-      instance = try {
+    if (inst == null) {
+      inst = try {
         "" //new String();
       } catch {
         case _: Throwable =>