What are Scala Type Classes?

When we refactor code how can we be confident that we don't break anything?

3 of the most important things that allow us to refactor fearlessly are:

Side effect free - or pure - expressions
Statically typed expressions
Tests

In this article we will solely focus on the aspect of side effects and strictly speaking on how to identify them. Being able to identify side effects in our programs clearly is the precondition for eliminating them.

Why avoid side effects?

Continue reading →

Have you ever wanted to try out PureScript but were lacking a good way to get started?

If you

Have some prior functional programming knowledge - maybe you know Haskell,Elm,F#,or Scala,etc.
Want to solve a small task with PureScript
And want to get started quickly

This post is for you!

In this post we will walk through setting up and implementing a small exemplary PureScript application from scratch.

Continue reading →

In this article I would like to present a minimal implementation of a music data type and everything that is needed to turn that into audible sound from an Elm application.

We will see how to transcribe an existing composition - an excerpt from Chick Corea's Children's Songs No. 6 - and listen to the result right here,embedded in this article.

From a music data type to performance

My colleague Jonas recently pointed out the presentation Making Algorithmic Music by Donya Quick to me. Donya Quick shows how she uses the Haskell library Euterpea to produce algorithmic music.

It got me really excited about the idea of porting this to Elm and to be able to use this in web applications.

In the following we will see the core data types and algorithms from Euterpea ported to Elm. To focus on the core concepts the implementation is stripped down to the minimum that is required to transcribe and perform an existing polyphonic piece of music (for a single instrument).

Continue reading →

This post is about how to implement well structured,and purely functional command line applications in Scala using PureApp.

PureApp originated in an experiment while refactoring out some glue code of an interactive command line application. At the same time it was inspired by the Elm Architecture Pattern,and scalaz's SafeApp,as well as scalm.

To show the really cool things we can do with PureApp,we will implement a self-contained example application from scratch.

This application translates texts from and into different languages. And it provides basic user interactions via the command line.

The complete source code is compiled with tut. Every output (displayed as code comments) is generated by tut.
Continue reading →

In this post we will see how applicatives can be used for validation in Scala. It is an elegant approach. Especially when compared to an object-oriented way.

Usually when we have operations that can fail,we have them return types like Option or Try. We sequence operations and once there is an error the computation is short circuited and the result is a None or a Failure.

Applicatives allow us to compose independent operations and evaluate each one. Even if an intermediate evaluation fails. This allows us to collect error messages instead of returning only the first error that occurred.

A classic example where this is useful is the validation of user input. We would like to return a list of all invalid inputs rather than aborting the evaluation after the first error.

Scala Cats provides a type that does exactly that. So let's dive into some code and see how it works.

Continue reading →

After some initial struggles,the chapter Functional Parsers from the great book Programming in Haskell by Graham Hutton,where a basic parser library is built from scratch,significantly helped me to finally understand the core ideas of parser combinators and how to apply them to other programming languages other than Haskell as well.

While I recently revisited the material and started to port the examples to Scala I wasn't able to define a proper monad instance for the type Parser[A].

The type Parser[A] alias was defined like this:

type Parser[A] = String =>Option[(A,String)] // defined type alias Parser

To test the monad laws with discipline I had to provide an instance of Eq[Parser[A]]. Because Parser[A] is a function,equality could only be approximated by showing degrees of function equivalence,which is not a trivial task.

Also the implementation of tailRecM was challenging. (I couldn't figure it out.)

Using existing abstractions

Continue reading →

Most config libraries use a stringly typed approach.

Some handle runtime failures due to invalid configuration schemas by leveraging data types like Option or Result to represent missing values or errors. This allows us to handle these failures by either providing default values or by providing decent error messages.

This is a good strategy that we should definitely stick to.

However,the problem with default values is that we might not even notice if the configuration is broken. This could potentially fail in production. In any case an error e.g. due to a misspelled config property will be observable at runtime at the earliest.

Wouldn't it be a great user experience (for us developers) if the compiler told us if the configuration schema is invalid? Even better,imagine we could access the configuration data in a strongly typed way like any other data structure,and with autocompletion.

Moreover,what if we didn't have to write any glue code,not even when the configuration schema changes?

This can be done with the costs of an initial setup that won't take more than probably around 5 minutes.

Continue reading →

In this post I will look at a practical example where the combined application (through monad transformers) of the state monad and the either monad can be very useful.

I won't go into much theory,but instead demonstrate the problem and then slowly build it up to resolve it.

You don't have to be completely familiar with all the concepts as the examples will be easy to follow. Here is a very brief overview:

Continue reading →

If your API overflows with Boolean parameters,this is usually a bad smell.

Consider the following function call for example:

toContactInfoList(csv,true,true)

When looking at this snippet of code it is not very clear what kind of effect the two Boolean parameters will have exactly. In fact,we would probably be without a clue.

We have to inspect the documentation or at least the parameter names of the function declaration to get a better idea. But still,this doesn't solve all of our problems.

The more Boolean parameters there are,the easier it will be for the caller to mix them up. We have to be very careful.

Moreover,functions with Boolean parameters must have conditional logic like if or case statements inside. With a growing number of conditional statements,the number of possible execution paths will grow exponentially. It will become more difficult to reason about the implementation code.

Can we do better?

Sure we can. Lambdas and combinators come to the rescue and I'm going to show this with a simple example,a refactoring of the function from above.

This post is based on a great article by John A De Goes,Destroy All Ifs — A Perspective from Functional Programming.

I'm going to take John's ideas that he backed up with PureScript examples and present how the same thing can be elegantly achieved in Scala.

Continue reading →

I'm currently working on an sbt plugin that generates Scala case classes at compile time to model JSON API responses for easy deserialization especially with the Scala play-json library.

The plugin makes it possible to access JSON documents in a statically typed way including auto-completion. It takes a sample JSON document as input (either from a file or a URL) and generates Scala types that can be used to read data with the same structure.

Let's look at a basic example,an app that prints the current Bitcoin price to the console.

Continue reading →

What are Scala type classes, what kind of problem do they solve and how are they implemented?

In a nut shell, type classes provide polymorphism without using subtyping, but in a completely type safe way.

Type classes represent some common functionality that can be applied to values of many different types. Moreover, we don't have to change existing types in order to extend them with the new functionality.

In this post I will describe 5 simple steps for encoding a type class in Scala in an idiomatic way.

A problem and a specific solution

Let's first look at a problem and its specific solution.

Consider a type ShoppingCart:

type ProductId = String
type Quantity = Int

case class ShoppingCart(items: Map[ProductId, Quantity])

Assume we have to implement a function that merges a list of ShoppingCart into a single instance that contains all the product items from all the carts with their quantities summed up.

One way to do this is to implement a fold over the list of shopping carts:

def merge(list: List[ShoppingCart]): ShoppingCart = {
    val emptyCart = ShoppingCart(Map())
    list.fold(emptyCart)(combineTwoShoppingCarts)
}

To make this work we need a function to combine two shopping carts:

def combineTwoShoppingCarts(sc1: ShoppingCart, sc2: ShoppingCart): ShoppingCart = {
    ShoppingCart(combineItems(sc1.items, sc2.items))
}

We are delegating the work to a function that takes two lists of product IDs with their quantities and merges them into one:

  def combineItems(m1: Map[ProductId, Quantity], m2: Map[ProductId, Quantity])
  : Map[ProductId, Quantity] = {
    (m1.keys ++ m2.keys)
      .toList
      .distinct
      .map(id => (id, m1.getOrElse(id, 0) + m2.getOrElse(id, 0)))
      .toMap
  }

It's not the most efficient solution, but it works:

scala> val carts = List(
    ShoppingCart(Map("p0001" -> 1, "p0002" -> 3)),
    ShoppingCart(Map("p0001" -> 4, "p0004" -> 6)))

scala> merge(carts)
ShoppingCart(Map(p0001 -> 5, p0002 -> 3, p0004 -> 6))

The generalized solution

Let's find a common pattern.

There are two concepts that appear several times as demonstrated in the image below:

A value that represents a neutral or empty element (marked in green)
A function that combines two elements (marked in pink)

alt text

The empty value and the combine function are used with three different types:

Quantity (which expands to Int)
- Empty value: 0
- Combine function: +
Map[ProductId, Quantity]
- Empty value: Map()
- Combine function: combineItems
ShoppingCart
- Empty value: ShoppingCart(Map())
- Combine function: combineTwoShoppingCarts

Type class encoding in 5 simple steps

Let's encode the common concepts in a custom type class that we will call Combinable.

Here are the steps to create a type class and instances.

Some of the steps are optional, as they only provide syntactic sugar.

1. Define a parameterised trait

First we define a parameterised trait with the empty value and the combine function:

trait Combinable[A] {
  def empty: A
  def combine(a: A, b: A): A
}

2. Define a companion object with an apply method (optional)

object Combinable {
  def apply[A](implicit comb: Combinable[A]): Combinable[A] = comb
}

The apply method gives us syntactic sugar, when we want to use an instance of the Combinable type class.

Note the implicit parameter. In order to obtain an instance of the type class, the instance has to be defined somewhere within the scope, annotated with implicit. (Find out more on implicit here.)

E.g. if an implicit instance for Int is defined, we can get the empty value like this:

scala> Combinable[Int].empty
res0: Int = 0

3. Define a factory method (optional)

Within the companion object we can define a factory method which reduces much of the boiler-plate code when creating Combinable instances.

def instance[A](emptyValue: A, combineFunc: (A, A) => A): Combinable[A] = {
  new Combinable[A] {
    def combine(a: A, b: A): A = combineFunc(a,b)
    def empty: A = emptyValue
  }
}

4. Define globally visible type class instances

Also within the companion object, we define all the instances that should be globally visible and mark them with implicit.

In our case we need instances for Int and Map.

Here is the definition of Combinable[Int]:

implicit val intCombinableInstance: Combinable[Int] = 
  Combinable.instance(0, _ + _)

This is the instance for Map:

implicit def mapCombinableInstance[A,B](implicit b: Combinable[B])
: Combinable[Map[A, B]] = {
  def merge(map1: Map[A, B], map2: Map[A, B]): Map[A, B] = {
    (map1.keys ++ map2.keys)
      .toList
      .distinct
      .map(a => (a, b.combine(
        map1.getOrElse(a, b.empty),
        map2.getOrElse(a, b.empty))))
      .toMap
  }
  Combinable.instance(Map(), merge)

To create an instance of Combinable[Map[A, B]] we have to use an implicit function.

The reason is that there is a constraint on the type B. B itself has to be a Combinable. So we have to pass an implicit parameter of type Combinable[B].

Type safety

The compiler will figure out if there is an implicit value of Combinable[B] in scope. If not, the code won't compile.

E.g. this will work since we have a Combinable[Int]:

scala> Combinable[Map[String, Int]].empty
res0: Map[String,Int] = Map()

But this won't compile unless we define a Combinable instance for Boolean:

scala> Combinable[Map[String, Boolean]].empty
<console>:16: error: could not find implicit value for parameter comb: Combinable[Map[String,Boolean]]
       Combinable[Map[String, Boolean]].empty
                 ^

Recursive resolution

The compiler can even recursively resolve instances:

scala> Combinable[Map[Int, Map[Int, Map[Int, Int]]]].empty
res0: Map[Int,Map[Int,Map[Int,Int]]] = Map()

5. Define locally visible type class instances

No we can define an instance for our ShoppingCart type. This can be done within the companion object of ShoppingCart or elsewhere:

implicit val shoppingCartCombinableInstance: Combinable[ShoppingCart] = {
  Combinable.instance(
    ShoppingCart(
      Map()),
      (m1, m2) => ShoppingCart(Combinable[Map[ProductId, Quantity]].combine(m1.items, m2.items)))
}

Back to the problem

We can now retrieve an empty shopping cart or combine two shopping carts. However, we still have to implement the fold to combine a list of shopping carts.

The nice thing is that we can now do that for every instance of the Combinable type class by defining a non-abstract method within the trait:

trait Combinable[A] {
  // ...
  def combineAll(list: List[A]) = list.fold(empty)(combine)
}

Now we can call this method like this:

scala> Combinable[ShoppingCart].combineAll(carts)
res0: ShoppingCart = ShoppingCart(Map(p0001 -> 5, p0002 -> 3, p0004 -> 6))

Monoids

It turns out that there already exists a type class like Combinable called Monoid.

The concept of monoids is simple yet powerful and goes way beyond what we've discussed here. E.g. monoids are the building blocks of much more advanced types and they are extensively used in data processing.

Conclusion

We have seen that with the help of type classes we can reduce the code that is specific to a particular problem by a great deal.

We have also seen:

Type classes offer general solutions to specific problems
Type classes provide polymorphism without subtyping
Existing types can be extended with new functionality without changing their internals
Programming with type classes is completely type safe
Type classes are encoded with traits and implicits
Cats and scalaz provide a lot of implementations of very useful type classes

There are 5 simple steps to create a type class:

Define a parameterised trait
Define a companion object with an apply method (optional)
Define a factory method (optional)
Define globally visible type class instances
Define locally visible type class instances

If you want to practice, here are two exercises:

Take the code from this post and define Combinable instances for String, Boolean, and List (or any other type that seems appropriate).
Implement a type class Printable which prints a String representation of a value to the console.

And have fun! 🙂

Leif Battermann

Functional Programming Fu

Identify Side Effects And Refactor Fearlessly

Why avoid side effects?

PureScript Case Study And Guide For Newcomers

Elm And The Algorithm Of Music

From a music data type to performance

Interactive Command Line Applications In Scala –Well Structured And Purely Functional

How To Use Applicatives For Validation In Scala And Save Much Work

Parsers in Scala built upon existing abstractions

Using existing abstractions

Strongly Typed Configuration Access With Code Generation

Error and state handling with monad transformers in Scala

Use lambdas and combinators to improve your API

Modelling API Responses With sbt-json –Print Current Bitcoin Price

Leif Battermann

Functional Programming Fu

What are Scala Type Classes?

A problem and a specific solution

The generalized solution

Type class encoding in 5 simple steps

1. Define a parameterised trait

2. Define a companion object with an apply method (optional)

3. Define a factory method (optional)

4. Define globally visible type class instances

Type safety

Recursive resolution

5. Define locally visible type class instances

Back to the problem

Monoids

Conclusion