Filtering Collections with `filter`

filter is the function you use when the collection shape stays the same but only some items should survive.

For Java developers, the reliable mental model is:

• map changes every item
• filter decides which items stay
• reduce combines items into one result

If you keep those jobs distinct, collection pipelines become much easier to read.

What filter Does

filter takes:

• a predicate function
• a collection

and returns a lazy sequence containing only the items for which the predicate is truthy.

1(filter even? [1 2 3 4 5 6])
2;; => (2 4 6)

The predicate is just the rule for keeping an item.

A Production-Shaped Example

Suppose you want only billable time entries.

1(defn billable? [entry]
2  (and (:time-entry/approved? entry)
3       (not (:time-entry/internal? entry))))
4
5(defn billable-entries [entries]
6  (->> entries
7       (filter billable?)
8       (into [])))

This reads well because the rule has a clear name and the pipeline says exactly what happens.

That is the main design benefit of filter: it turns selection logic into an explicit, reusable rule.

filter Versus Java Habits

The syntax difference is minor. The more important difference is that Clojure encourages you to make the selection rule a first-class function instead of letting it disappear into loop machinery.

Predicate Quality Matters

filter itself is simple. Most of the code quality lives in the predicate you pass to it.

Good predicates:

• return a clear truthy/falsy result
• encode one coherent rule
• are easy to reuse and test

1(defn overdue? [invoice]
2  (and (= :open (:invoice/status invoice))
3       (> (:invoice/days-late invoice) 30)))

Weak predicates usually try to smuggle too much business logic into one anonymous function.

Laziness Matters Here Too

Like map, filter returns a lazy sequence.

That means:

• filtering does not necessarily happen immediately
• work is performed as the result is consumed

This is often efficient, but it matters around resources and side effects.

If you filter lines from a file inside with-open, for example, you usually need to realize the result before the reader closes.

filter, remove, and keep

These are related but not interchangeable.

This is a common source of muddy code. If the operation is “transform and maybe keep”, keep may be a better fit than forcing the logic into filter.

Pipeline Pattern: Filter Then Transform

A common and readable shape is:

1(->> invoices
2     (filter overdue?)
3     (map :invoice/id)
4     (into []))

This works well because each step has one job:

• filter chooses survivors
• map transforms survivors

Many awkward pipelines come from collapsing both concerns into one step.

Common Early Mistakes

Knowledge Check