Syntax for polymorphic values.

    ∀[T].m[A, B[_], ...](e)

is rewritten to

    new T { def m[A, B[_], ...] = e }

In case `m` has only one *-kinded type parameter which is
is not referenced from `e`, it can be omitted:

    ∀[T].m(e)

is rewritten to

    new T { def m[A] = e }

where `A` is a fresh name.

If, in addition, the method name is `apply`, it can be omitted as well:

    ∀[T](e)

is rewritten to

    new T { def apply[A] = e }

where `A` is a fresh name.

Author: TomasMikula

src/main/scala/Extractors.scala

@@ -41,4 +41,18 @@ trait Extractors {
       case _                                                            => None
     }
   }
+  object TermForall {
+    def unapply(tree: Tree): Option[Tree] = tree match {
+      case TypeApply(Ident(TermName("$u2200")), tpe :: Nil) => Some(tpe) // ∀[F]
+      case _                                                => None
+    }
+  }
+  object PolyVal {
+    def unapply(tree: Tree): Option[(Tree, TermName, List[Tree], Tree)] = tree match {
+      case Apply(TypeApply(Select(TermForall(tpe), method), tParams), body :: Nil) => Some((tpe, method.toTermName, tParams, body))
+      case Apply(Select(TermForall(tpe), method), body :: Nil)                     => Some((tpe, method.toTermName, Nil, body))
+      case Apply(TermForall(tpe), body :: Nil)                                     => Some((tpe, nme.apply, Nil, body))
+      case _                                                                       => None
+    }
+  }
 }

src/main/scala/KindProjector.scala

@@ -128,7 +128,59 @@ class KindRewriter(plugin: Plugin, val global: Global)
     def makeTypeParamContra(name: Name, bounds: TypeBoundsTree = DefaultBounds): TypeDef =
       TypeDef(Modifiers(PARAM | CONTRAVARIANT), makeTypeName(name), Nil, bounds)
 
-    def polyLambda(tree: Tree): Tree = tree match {
+    // Given a name, e.g. A or `+A` or `A <: Foo`, build a type
+    // parameter tree using the given name, bounds, variance, etc.
+    def makeTypeParamFromName(ident: Ident): TypeDef = {
+      val decoded = NameTransformer.decode(ident.name.toString)
+      val src = s"type _X_[$decoded] = Unit"
+      sp.parse(src) match {
+        case Some(TypeDef(_, _, List(tpe), _)) => tpe.duplicate
+        case None => reporter.error(ident.pos, s"Can't parse param: ${ident.name}"); null
+      }
+    }
+
+    // Like makeTypeParam, but can be used recursively in the case of types
+    // that are themselves parameterized.
+    def makeComplexTypeParam(t: Tree): TypeDef = t match {
+      case id @ Ident(_) =>
+        makeTypeParamFromName(id)
+
+      case TypeDef(m, nm, ps, bs) =>
+        TypeDef(Modifiers(PARAM), nm, ps.map(makeComplexTypeParam), bs)
+
+      case ExistentialTypeTree(AppliedTypeTree(Ident(name), ps), _) =>
+        val tparams = ps.map(makeComplexTypeParam)
+        TypeDef(Modifiers(PARAM), makeTypeName(name), tparams, DefaultBounds)
+
+      case x =>
+        reporter.error(x.pos, "Can't parse %s (%s)" format (x, x.getClass.getName))
+        null.asInstanceOf[TypeDef]
+    }
+
+    def typeArgsToTypeParams(args: List[Tree]): List[TypeDef] = args.map {
+      case id @ Ident(_) =>
+        makeTypeParamFromName(id)
+
+      case AppliedTypeTree(Ident(Plus), Ident(name) :: Nil) =>
+        makeTypeParamCo(name)
+
+      case AppliedTypeTree(Ident(Minus), Ident(name) :: Nil) =>
+        makeTypeParamContra(name)
+
+      case AppliedTypeTree(Ident(name), ps) =>
+        val tparams = ps.map(makeComplexTypeParam)
+        TypeDef(Modifiers(PARAM), makeTypeName(name), tparams, DefaultBounds)
+
+      case ExistentialTypeTree(AppliedTypeTree(Ident(name), ps), _) =>
+        val tparams = ps.map(makeComplexTypeParam)
+        TypeDef(Modifiers(PARAM), makeTypeName(name), tparams, DefaultBounds)
+
+      case x =>
+        reporter.error(x.pos, "Can't parse %s (%s)" format (x, x.getClass.getName))
+        null.asInstanceOf[TypeDef]
+    }
+
+    def polyTerm(tree: Tree): Tree = tree match {
       case PolyLambda(methodName, (arrowType @ UnappliedType(_ :: targs)) :: Nil, Function1Tree(name, body)) =>
         val (f, g) = targs match {
           case a :: b :: Nil => (a, b)
@@ -139,41 +191,21 @@ class KindRewriter(plugin: Plugin, val global: Global)
         atPos(tree.pos.makeTransparent)(
           q"new $arrowType { def $methodName[$TParam]($name: $f[$TParam]): $g[$TParam] = $body }"
         )
+      case PolyVal(targetType, methodName, tArgs, body) =>
+        atPos(tree.pos.makeTransparent)(tArgs match {
+          case Nil =>
+            val tParam = freshTypeName("A")(currentFreshNameCreator)
+            q"new $targetType { def $methodName[$tParam] = $body }"
+          case _ =>
+            val tParams = typeArgsToTypeParams(tArgs)
+            q"new $targetType { def $methodName[..$tParams] = $body }"
+        })
       case _ => tree
     }
 
     // The transform method -- this is where the magic happens.
     override def transform(tree: Tree): Tree = {
 
-      // Given a name, e.g. A or `+A` or `A <: Foo`, build a type
-      // parameter tree using the given name, bounds, variance, etc.
-      def makeTypeParamFromName(name: Name): TypeDef = {
-        val decoded = NameTransformer.decode(name.toString)
-        val src = s"type _X_[$decoded] = Unit"
-        sp.parse(src) match {
-          case Some(TypeDef(_, _, List(tpe), _)) => tpe
-          case None => reporter.error(tree.pos, s"Can't parse param: $name"); null
-        }
-      }
-
-      // Like makeTypeParam, but can be used recursively in the case of types
-      // that are themselves parameterized.
-      def makeComplexTypeParam(t: Tree): TypeDef = t match {
-        case Ident(name) =>
-          makeTypeParamFromName(name)
-
-        case TypeDef(m, nm, ps, bs) =>
-          TypeDef(Modifiers(PARAM), nm, ps.map(makeComplexTypeParam), bs)
-
-        case ExistentialTypeTree(AppliedTypeTree(Ident(name), ps), _) =>
-          val tparams = ps.map(makeComplexTypeParam)
-          TypeDef(Modifiers(PARAM), makeTypeName(name), tparams, DefaultBounds)
-
-        case x =>
-          reporter.error(x.pos, "Can't parse %s (%s)" format (x, x.getClass.getName))
-          null.asInstanceOf[TypeDef]
-      }
-
       // Given the list a::as, this method finds the last argument in the list
       // (the "subtree") and returns that separately from the other arguments.
       // The stack is just used to enable tail recursion, and a and as are
@@ -204,28 +236,7 @@ class KindRewriter(plugin: Plugin, val global: Global)
       // Lambda[(A, B) => Function2[A, Int, B]] case.
       def handleLambda(a: Tree, as: List[Tree]): Tree = {
         val (args, subtree) = parseLambda(a, as, Nil)
-        val innerTypes = args.map {
-          case Ident(name) =>
-            makeTypeParamFromName(name)
-
-          case AppliedTypeTree(Ident(Plus), Ident(name) :: Nil) =>
-            makeTypeParamCo(name)
-
-          case AppliedTypeTree(Ident(Minus), Ident(name) :: Nil) =>
-            makeTypeParamContra(name)
-
-          case AppliedTypeTree(Ident(name), ps) =>
-            val tparams = ps.map(makeComplexTypeParam)
-            TypeDef(Modifiers(PARAM), makeTypeName(name), tparams, DefaultBounds)
-
-          case ExistentialTypeTree(AppliedTypeTree(Ident(name), ps), _) =>
-            val tparams = ps.map(makeComplexTypeParam)
-            TypeDef(Modifiers(PARAM), makeTypeName(name), tparams, DefaultBounds)
-
-          case x =>
-            reporter.error(x.pos, "Can't parse %s (%s)" format (x, x.getClass.getName))
-            null.asInstanceOf[TypeDef]
-        }
+        val innerTypes = typeArgsToTypeParams(args)
         makeTypeProjection(innerTypes, subtree)
       }
 
@@ -321,7 +332,7 @@ class KindRewriter(plugin: Plugin, val global: Global)
       // given a tree, see if it could possibly be a type lambda
       // (either placeholder syntax or lambda syntax). if so, handle
       // it, and if not, transform it in the normal way.
-      val result = polyLambda(tree match {
+      val result = polyTerm(tree match {
 
         // Lambda[A => Either[A, Int]] case.
         case AppliedTypeTree(Ident(TypeLambda1), AppliedTypeTree(target, a :: as) :: Nil) =>

src/test/scala/polylambda.scala

@@ -2,15 +2,18 @@ package d_m
 
 import org.junit.Test
 
-trait ~>[-F[_], +G[_]] {
-  def apply[A](x: F[A]): G[A]
-}
-trait ~>>[-F[_], +G[_]] {
-  def dingo[B](x: F[B]): G[B]
-}
 final case class Const[A, B](getConst: A)
 
 class PolyLambdas {
+
+  trait ~>[-F[_], +G[_]] {
+    def apply[A](x: F[A]): G[A]
+  }
+
+  trait ~>>[-F[_], +G[_]] {
+    def dingo[B](x: F[B]): G[B]
+  }
+
   type ToSelf[F[_]] = F ~> F
 
   val kf1 = Lambda[Option ~> Vector](_.toVector)

src/test/scala/polyval.scala

@@ -0,0 +1,87 @@
+package d_m
+
+import org.junit.Test
+
+class PolyVals {
+
+  trait Forall[F[_]] {
+    def apply[A]: F[A]
+  }
+
+  trait Forall2[F[_, _]] {
+    def apply[A, B]: F[A, B]
+  }
+
+  trait ForallK[F[_[_]]] {
+    def apply[G[_]]: F[G]
+  }
+
+
+  trait Semigroup[A] {
+    def combine(x: A, y: A): A
+  }
+
+  def listSemigroup[A]: Semigroup[List[A]] = new Semigroup[List[A]] {
+    def combine(x: List[A], y: List[A]): List[A] = x ++ y
+  }
+
+  trait Functor[F[_]]
+  trait Monad[F[_]] {
+    def functor: Functor[F]
+  }
+
+  // universally quantified semigroup
+  type SemigroupK[F[_]] = Forall[λ[α => Semigroup[F[α]]]]
+
+  // natural transformations
+  type ~>[F[_]   , G[_]   ] = Forall [λ[α    => F[α] => G[α]]]
+  type ≈>[F[_[_]], G[_[_]]] = ForallK[λ[α[_] => F[α] => G[α]]]
+
+  // Const functor and constructors
+  type ConstA[A] = Forall[Const[A, ?]]
+  type ConstMaker = Forall[λ[α => α => ConstA[α]]]
+  type ConstMaker2 = Forall2[λ[(α, β) => α => Const[α, β]]]
+
+  // existentials via universals
+  type Consumer[F[_], R] = Forall[λ[A => F[A] => R]]
+  type Exists[F[_]] = Forall[λ[R => Consumer[F, R] => R]]
+  def existential[F[_], A](fa: F[A]): Exists[F] = ∀[Exists[F]](_[A](fa))
+
+  @Test
+  def testSemigroupK(): Unit = {
+    val listSemigroupK = ∀[SemigroupK[List]](listSemigroup)
+    assert(listSemigroupK[Int].combine(List(1, 2), List(3, 4)) == List(1, 2, 3, 4))
+  }
+
+  @Test
+  def testNaturalTransformations(): Unit = {
+    val headOption = ∀[List ~> Option].apply[A](_.headOption)
+    val monadToFunctor1 = ∀[Monad ≈> Functor].apply[F[_]](_.functor)
+    val monadToFunctor2 = ∀[Monad ≈> Functor].apply[F[_]]((m: Monad[F]) => m.functor)
+
+    val listFunctor = new Functor[List] {}
+    val listMonad = new Monad[List] { def functor = listFunctor }
+
+    assert(headOption[Int](List(1, 2)) == Some(1))
+    assert(monadToFunctor1[List](listMonad) == listFunctor)
+    assert(monadToFunctor2[List](listMonad) == listFunctor)
+  }
+
+  @Test
+  def testConst(): Unit = {
+    val const42 = ∀[ConstA[Int]].apply[B](new Const[Int, B](42))
+    val constMaker  = ∀[ConstMaker] .apply[A]   (a => ∀[ConstA[A]].apply[B](new Const[A, B](a)))
+    val constMaker2 = ∀[ConstMaker2].apply[A, B](a =>                       new Const[A, B](a) )
+
+    assert(const42[String].getConst == 42)
+    assert(constMaker[Int](42)[String].getConst == 42)
+    assert(constMaker2[Int, String](42).getConst == 42)
+  }
+
+  @Test
+  def testExistential(): Unit = {
+    val list = existential(List("one", "two", "three"))
+    val len = ∀[Consumer[List, Int]](_.length)
+    assert(list[Int](len) == 3)
+  }
+}