Λ syntax for polymorphic values.

    Λ[A, B[_], ...](e) : T

is rewritten to

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

Note that explicit type `T` of the Λ-expression is required.

Author: TomasMikula

src/main/scala/Extractors.scala

@@ -41,6 +41,14 @@ trait Extractors {
       case _                                                            => None
     }
   }
+  object TermLambda {
+    private val LambdaName = newTermName("Λ")
+
+    def unapply(tree: Tree): Option[(List[Tree], Tree)] = tree match {
+      case Apply(TypeApply(Ident(name), tParams), body :: Nil) if name == LambdaName => Some((tParams, body))
+      case _                                                                         => None
+    }
+  }
   object TermNuType {
     private val NuName = newTermName("ν")
 
@@ -52,6 +60,9 @@ trait Extractors {
   object PolyVal {
     def unapply(tree: Tree): Option[(Tree, TermName, List[Tree], Tree)] = tree match {
 
+      // Λ[A, B, ...](e) : T
+      case Typed(TermLambda(tParams, body), tpe)                                   => Some((tpe, nme.apply, tParams, body))
+
       // ν[T].method[A, B, ...](e)
       case Apply(TypeApply(Select(TermNuType(tpe), method), tParams), body :: Nil) => Some((tpe, method.toTermName, tParams, body))
 

src/test/scala/polyval.scala

@@ -30,12 +30,15 @@ class PolyVals {
     def functor: Functor[F]
   }
 
+  final class Fun[A, B](val run: A => B)
+
   // universally quantified semigroup
   type SemigroupK[F[_]] = Forall[λ[α => Semigroup[F[α]]]]
 
   // natural transformations
-  type ~>[F[_]   , G[_]   ] = Forall [λ[α    => F[α] => G[α]]]
-  type ≈>[F[_[_]], G[_[_]]] = ForallK[λ[α[_] => F[α] => G[α]]]
+  type  ~>[F[_]   , G[_]   ] = Forall [λ[α      => F[α]    => G[α]]]
+  type  ≈>[F[_[_]], G[_[_]]] = ForallK[λ[α[_]   => F[α]    => G[α]]]
+  type ~~>[F[_, _], G[_, _]] = Forall2[λ[(α, β) => F[α, β] => G[α, β]]]
 
   // Const functor and constructors
   type ConstA[A] = Forall[Const[A, ?]]
@@ -61,13 +64,16 @@ class PolyVals {
     val monadToFunctor1 = ν[Monad ≈> Functor][F[_]](_.functor)
     val monadToFunctor2 = ν[Monad ≈> Functor].apply[F[_]]((m: Monad[F]) => m.functor)
 
+    val fun = Λ[A, B](new Fun(_)): Function1 ~~> Fun
+
     val listFunctor = new Functor[List] {}
     val listMonad = new Monad[List] { def functor = listFunctor }
 
     assert(headOption1[Int](List(1, 2)) == Some(1))
     assert(headOption2[Int](List(1, 2)) == Some(1))
     assert(monadToFunctor1[List](listMonad) == listFunctor)
     assert(monadToFunctor2[List](listMonad) == listFunctor)
+    assert(fun[String, Int](_.length).run("foo") == 3)
   }
 
   @Test