Posted in

How to filter a list in Haskell?

by george•

Hey folks, let’s cut to the chase—if you’ve ever dabbled in functional programming, you know Haskell’s not just that fancy math-y language people rave about. It’s got real, usable tools, right? Like when you’re working with a messy list of data (think: parts for your filter business, maybe?) and you need to pull out only the stuff that matters. Today, I’m gonna break down how to filter a list in Haskell, but I’m gonna keep it real—no stuffy textbook jargon, just what actually works when you’re coding and maybe juggling a stack of filter quotes at the same time. Filter

First off, let’s get one thing straight: filtering in Haskell isn’t some complicated hack. It’s built right in, like how your filter supply shelf has dedicated slots for HEPA vs. HVAC parts—no reinventing the wheel here. The go-to function is called filter, and it’s as straightforward as it sounds. Let’s start with the basics: filter takes two arguments: a predicate (that’s just a function that returns True or False) and a list. It spits out a new list with only the elements where the predicate hits True.

Wait, let’s make this concrete, no vague examples. Suppose I’m working for my filter company, and I have a list of filter sizes—like [12, 20, 24, 30, 36]—and I only want the ones big enough for commercial HVAC systems, which are 24 inches or larger. The predicate here is just checking if a number is ≥24. So in Haskell, that’d be filter (≥24) [12, 20, 24, 30, 36]. Boom. The output is [24, 30, 36]. That’s it? Yeah, basically. No loops, no mutable variables, just pure, clean code. Feels like the day I stopped wasting time digging through mismatched filter stock and started organizing by part number.

But wait, let’s not stop at numbers—filtering gets way more useful when you’re dealing with actual data types, like records for our filter parts. Let’s say we have a FilterPart type, defined something like:
data FilterPart = FilterPart { partSize :: Int, partType :: String, isHEPA :: Bool }
And our list is partStock = [FilterPart 12 "AC" False, FilterPart 20 "Furnace" False, FilterPart 24 "HVAC" True, FilterPart 36 "HVAC" True]. Now, if I want only HEPA-rated HVAC filters, the predicate’s gonna check two things: partType == "HVAC" and isHEPA == True. In Haskell, that’s filter (\p -> partType p == "HVAC" && isHEPA p) partStock. The backslashes there are a lambda—an anonymous function, perfect for one-off predicates. The output? Just the two HEPA HVAC parts. That’s way better than sorting through every single line in our inventory spreadsheet manually, right?

Now, let’s talk about edge cases—stuff that trips up new devs (and new filter inventory managers). What if the list is empty? filter just returns an empty list, no errors. That’s like checking your filter supply bin and finding nothing—you don’t panic, you just move on. What if all elements get filtered out? Same thing, no crashes. And what if you need to filter based on something that’s not a number or a Boolean? Like, filtering parts that are under a certain price (wait, we didn’t add price to our type, but play along)—just make the predicate do the math. It works the same, because predicates are just functions that return Bool, no limits.

But hold on—filter isn’t the only tool in the Haskell toolbox, right? Sometimes you need to combine filtering with other operations, like mapping over your list after you filter it. Let’s say after pulling the HEPA HVAC parts, I just want their sizes, not the whole records. That’s map partSize $ filter (\p -> partType p == "HVAC" && isHEPA p) partStock—and that gives [24, 36]. It’s like taking your filtered stock and only grabbing the dimensions you need for a quick quote, no extra junk. I do this all the time when I’m prepping bulk filter orders—pull the relevant parts, get the numbers I need, and move on to the next customer.

Another thing people miss: filter works on infinite lists too. Wait, what? Yeah, Haskell’s lazy evaluation means it doesn’t compute the whole list upfront. If I had an infinite list of filter sizes stepping up by 2 ([2,4,6,8,...]) and I filtered for sizes divisible by 6, it’d just give me [6,12,18,...]—no hanging the system, because it only calculates what you ask for. That’s wild, but useful if you’re generating a list of custom filter sizes on the fly without loading every single possible size into memory first. Kinda like how we keep a master part size list, but pull only the ones customers request instead of printing the whole catalog every time.

Now, let’s get real—what about when filtering gets trickier? Like, filtering a list of filters where the part number contains a specific string, say "HVAC". I could write a predicate that checks isInfixOf "HVAC" (partPartNumber p)—that’s from the Data.List module, so I’d need to import that first. It’s the same logic, just using a helper function for string checks. No need to reinvent the "does this string have these characters" wheel, just use what’s in the standard library, same as how I use pre-built filter frames instead of welding every frame from scratch.

Wait, let’s address a common mistake I see new devs make (and yeah, I made this one too when I was starting out): mixing up the order of arguments to filter. filter pred list—predicate first, then list. If you swap them, like filter [12,20,24,30,36] (≥24), Haskell will yell at you, because it’s trying to run the number list as a function, which doesn’t make sense. That’s like grabbing a filter part and trying to use it as a wrench—wrong tool, wrong order, doesn’t work. Easy fix, just remember: function first, data second.

Now, let’s tie this back to my life as a filter supplier, because this isn’t just some programming tutorial. Last month, I had a big order for 50 commercial HVAC filters. Before I learned how to filter lists properly in Haskell, I was digging through a messy Excel spreadsheet with 200 part entries, sorting through HVAC vs. residential, HEPA vs. non-HEPA, wasting an hour of my time. Now? I just put the part data into a Haskell list, run filter with my predicate, and in 2 lines of code, I have exactly the parts I need, ready for packing. No more missing parts, no more wasted time, no more double-checking to make sure I didn’t grab 12-inch residential filters instead of 24-inch commercial ones.

And it’s not just for inventory. When a customer asks for a quote, I can write a quick Haskell script to filter our parts by size, type, and rating, calculate total cost, and send them a tailored quote in seconds. Compare that to the old days, when I’d have to flip through a physical catalog and call the warehouse to confirm stock—now I can do it while I’m on the phone with the customer. That’s the power of filter: it’s a tool that saves you time, so you can focus on what actually matters, like making sure every filter leaves my warehouse in perfect shape.

Wait, one more advanced tip for when you need to filter on multiple conditions, but don’t want a messy lambda. Say you have three conditions: part size ≥24, part type is HVAC, and it’s HEPA. Instead of writing filter (\p -> partSize p ≥24 && partType p == "HVAC" && isHEPA p) partStock, you can use foldr to combine predicates, or even write separate named predicates. Like:
isBigHVACHEPA p = partSize p ≥24 && partType p == "HVAC" && isHEPA p
Then just filter isBigHVACHEPA partStock. That’s cleaner, easier to read, and if you need to reuse that predicate for other things, you don’t have to copy-paste. Kinda like how I keep a dedicated "Commercial HEPA HVAC Filter" bin in my warehouse, so I don’t have to sort through every bin every time I get a similar order.

Let’s wrap this up with a quick recap, so you don’t have to remember every detail:

  1. The main filter function is filter pred list—predicate (True/False function) first, list second.
  2. Use lambdas for one-off predicates, or named functions for reusable logic.
  3. Works on numbers, records, strings—any data type, as long as your predicate makes sense for it.
  4. No errors on empty lists or all-filtered-out lists, thanks to lazy evaluation.
  5. Combine with map or other functions to process your filtered results right away.

Look, I get it—programming can feel intimidating, especially if you’re used to more imperative languages where you have to write loops and track variables. But Haskell’s filter is so simple, it’s like using a sieve to separate large filter parts from small ones. The sieve (predicate) catches only the stuff you want, and you’re left with exactly what you need, no extra junk. That’s the same vibe as filtering in Haskell—clean, efficient, no hassle.

Now, if you’re someone who deals with parts, inventory, or orders and wants to streamline your workflow with tools like this (or if you just need a bulk order of high-quality filters—HEPA, HVAC, residential, whatever you need), reach out. Whether you’re a dev building an inventory app for your filter business, or a warehouse manager tired of sorting through messy stock, I can hook you up with the parts you need and maybe even share a few quick Haskell snippets I use to keep my operations running smooth. No B.S., no runaround—just good filters and solid solutions.

Car Air Purifier References:

  1. Real World Haskell, Bryan O’Sullivan, John Goerzen, Donald Stewart
  2. Haskell 2010 Language Report, Simon Marlow
  3. Data.List Module Documentation, The Haskell Foundation

Cixi Beilian Electrical Appliance Co., Ltd.
Cixi Beilian Electrical Appliance Co., Ltd. is one of the leading filter manufacturers and suppliers in China. We warmly welcome you to buy or wholesale bulk filter made in China here from our factory. All customized air purifiers are with high quality and competitive price.
Address: No.198, Guanxing Road, West Industrial Park, Guanhaiwei Town, Cixi City, Ningbo City, Zhejiang Province
E-mail: chenxingchen@beilink.net
WebSite: https://www.chinaairpurifier.com/