Question

I am surfing through Scala for the Impatient, but unfortunately it assumes previous Java experience and an understanding of how [T] is used here:

object Iterables {
   def filter[T](unfiltered: Iterable[T], predicate: T => Boolean): Iterable[T] = {...}
   def find[T](iterable: Iterable[T], predicate: T => Boolean): T = {...}
}

The syntax for every instance of [T] and T is quite confusing here. What significance does it have when it’s listed directly after the function name, such as filter[T]. I understand in the parameters list, we’re looking for an Iterable of type T. But if T is a type, what does predicate: T => Boolean mean?

Answer 1

Type Parametric Methods

A method in scala can accept one or more type parameters, just like a class, object or trait does.

In this case it means that the same method can be called for a type T which can vary from call to call, but that have to be consistent within the definition.

Let’s use for example

def filter[T](unfiltered: Iterable[T], predicate: T => Boolean): Iterable[T]

The method expects you to pass:
– an Iterable of Ts (unfiltered)
– a function that transforms a T to a Boolean (predicate)
and the result will be another Iterable of Ts.

The method will then iterate on the unfiltered object and for each element apply the predicate, to decide if it must be filtered or not.

The resulting Iterable only contains the elements satisfying the predicate (i.e. those t for whom predicate(t) returns true)

You can call filter for any type T, with the constraint that it must be consistent fo all parameters and the result type.

examples

//filtered is List(2,3)
val filtered: Iterable[Int] = filter(List(1, 2, 3), (i: Int) => i > 1) 

//filtered is List("b", "abc")
val filtered: Iterable[String] = filter(List("a", "b", "abc"), (s: String) => s contains "b") 

//filtered is List(Some(1), Some(2))
val filtered: Iterable[Option[Int]] = filter(List(Some(1), Some(2), None), (op: Option[Int]) => op.isDefined)


//you can't call this because T is not the same everywhere it's used
val filtered: Iterable[Int] = filter(List(1, 2, 3), (op: Option[Int]) => op.isDefined)

//this will get you
<console>:12: error: type mismatch;
 found   : Option[Int] => Boolean
 required: Int => Boolean
           val filtered: Iterable[Int] = filter(List(1, 2, 3), (op: Option[Int]) => op.isDefined) 

                                                                             ^