What are type lambdas in Scala and what are their benefits?

by

Type lambdas are vital quite a bit of the time when you are working with higher-kinded types.

Consider a simple example of defining a monad for the right projection of Either[A, B]. The monad typeclass looks like this:

trait Monad[M[_]] {
  def point[A](a: A): M[A]
  def bind[A, B](m: M[A])(f: A => M[B]): M[B]
}

Now, Either is a type constructor of two arguments, but to implement Monad, you need to give it a type constructor of one argument. The solution to this is to use a type lambda:

class EitherMonad[A] extends Monad[({type λ[α] = Either[A, α]})#λ] {
  def point[B](b: B): Either[A, B]
  def bind[B, C](m: Either[A, B])(f: B => Either[A, C]): Either[A, C]
}

This is an example of currying in the type system – you have curried the type of Either, such that when you want to create an instance of EitherMonad, you have to specify one of the types; the other of course is supplied at the time you call point or bind.

The type lambda trick exploits the fact that an empty block in a type position creates an anonymous structural type. We then use the # syntax to get a type member.

In some cases, you may need more sophisticated type lambdas that are a pain to write out inline. Here’s an example from my code from today:

// types X and E are defined in an enclosing scope
private[iteratee] class FG[F[_[_], _], G[_]] {
  type FGA[A] = F[G, A]
  type IterateeM[A] = IterateeT[X, E, FGA, A] 
}

This class exists exclusively so that I can use a name like FG[F, G]#IterateeM to refer to the type of the IterateeT monad specialized to some transformer version of a second monad which is specialized to some third monad. When you start to stack, these kinds of constructs become very necessary. I never instantiate an FG, of course; it’s just there as a hack to let me express what I want in the type system.

More Related Contents:

  1. What is a TypeTag and how do I use it?
  2. Enforce type difference
  3. What is a higher kinded type in Scala?
  4. Scala multiple type pattern matching
  5. Why is the Aux technique required for type-level computations?
  6. Are HLists nothing more than a convoluted way of writing tuples?
  7. Turning A => M[B] into M[A => B]
  8. Static return type of Scala macros
  9. Scala type programming resources
  10. What is a Singleton Type exactly?
  11. scala f-bounded types explanation
  12. Multiple parameter closure argument type not inferred
  13. What is the differences between Int and Integer in Scala?
  14. Why “avoid method overloading”?
  15. How can I change column types in Spark SQL’s DataFrame?
  16. What is the difference between def foo = {} and def foo() = {} in Scala?
  17. Case class to map in Scala
  18. Difference between using App trait and main method in scala
  19. What does => and () => mean in Scala [duplicate]
  20. Load Scala file into interpreter to use functions?
  21. Any reason why scala does not explicitly support dependent types?
  22. Apache Spark, add an “CASE WHEN … ELSE …” calculated column to an existing DataFrame
  23. How to suppress info and success messages in sbt?
  24. Replace null values in Spark DataFrame
  25. Scala: write string to file in one statement
  26. Scala: pass Seq to var-args functions
  27. Calculate Cosine Similarity Spark Dataframe
  28. Why does Scala support shadow variables? [closed]
  29. How to wait for several Futures?
  30. Spark ML VectorAssembler returns strange output

Leave a Comment