# Chapter 13. Collections: Common Sequence Methods

Where the two previous chapters primarily focused on sequence classes, this chapter focuses on sequence methods, specifically the most commonly used sequence methods. But before digging into those recipes, there are a few important concepts to know when working with collections class methods:

• Predicates

• Anonymous functions

• Implied loops

# Predicate

A predicate is simply a method, function, or anonymous function that takes one or more input parameters and returns a `Boolean` value. For instance, the following method returns either `true` or `false`, so it’s a predicate:

````def` `isEven``(``i``:` `Int``):` `Boolean` `=`
`i` `%` `2` `==` `0````

A predicate is a simple concept, but you’ll hear the term so often when working with collection methods that it’s important to mention it.

# Anonymous Functions

The concept of an anonymous function is also important. It’s described in depth in Recipe 10.1, “Using Function Literals (Anonymous Functions)”, but as a quick example, this code shows the long form for an anonymous function that does the same work as the `isEven` method:

``(``i``:` `Int``)` `=>` `i` `%` `2` `==` `0``

Here’s the short form of the same function:

``_` `%` `2` `==` `0``

That doesn’t look like much by itself, but when it’s combined with the `filter` method on a collection, it makes for a lot of power in just a little bit of code:

```scala> val list = List.range(1, 10)
list: List[Int] = List(1, 2, 3, 4, 5, 6, 7, 8, 9)

scala> val events = list.filter(_ % 2 == 0) events: List[Int] = List(2, 4, 6, ...```

Get Scala Cookbook, 2nd Edition now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.