A Small (Real) Example of Kleisli Arrows

This is a simple example of use of a mysterious beast called a Kleisli arrow.

I will be using Scalaz for my incantations as it comes with the necessary potions.

What is the Problem?

You have functions that take a simple type and return higher kinded types like Options or Lists, and you need to compose those functions. You might think you need to get the first result, pattern match on the it, apply it to the second function, repeat. Sounds rather cumbersome.

Kleisli FTW

The intuition is this:

a Kleisli is function composition for Monads.

Hmm, lets try again:

if you have functions that return kinds of things, like Lists, Options, etc, then you can use a Kleisli to compose those functions.

The Example

object Kleisli extends App {
  import scalaz._
  import Scalaz._

  // Some methods that take simple types
  // and return higher-kinded types
  def str(x: Int): Option[String] = Some(x.toString)
  def toInt(x: String): Option[Int] = Some(x.toInt)
  def double(x: Int): Option[Double] = Some(x * 2)

  // Lets compose those functions Ye Olde Way
  def oldSchool(i: Int) =
    for (x <- str(i);
       y <- toInt(x);
       z <- double(y))
    yield z

  // Kleisli!
  val funky = kleisli(str _) >=> (toInt _) >=> (double _)

  println(oldSchool(1)) // Some(2.0)
  println(funky(1))     // Some(2.0)

  // Lets use symbols!
  val reallyFunky = ☆(str) >=> (toInt _) >=> (double _)
}

Composition

def opt(x: Int): Option[String] = Some(x.toString)

def list(x: String) = List(x)

// a function to turn an option into a list
def optToList[T](o: Option[T]) = o.toList

// now we can compose opt and list using optToList
val multi = (kleisli(opt _) compose (optToList _)) >=> (list _)

Further reading

• Kleisli Arrow example at Cake Solutions
• Scalaz Example
• Kleili Arrow at the Haskell Wiki