{"id":603,"date":"2026-10-27T15:17:59","date_gmt":"2026-10-27T07:17:59","guid":{"rendered":"http:\/\/www.tomschneiderphotography.com\/blog\/?p=603"},"modified":"2026-10-27T15:17:59","modified_gmt":"2026-10-27T07:17:59","slug":"how-to-filter-a-list-in-haskell-440e-7b30e7","status":"publish","type":"post","link":"http:\/\/www.tomschneiderphotography.com\/blog\/2026\/10\/27\/how-to-filter-a-list-in-haskell-440e-7b30e7\/","title":{"rendered":"How to filter a list in Haskell?"},"content":{"rendered":"

Hey folks, let\u2019s cut to the chase\u2014if you\u2019ve ever dabbled in functional programming, you know Haskell\u2019s not just that fancy math-y language people rave about. It\u2019s got real, usable tools, right? Like when you\u2019re 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\u2019m gonna break down how to filter a list in Haskell, but I\u2019m gonna keep it real\u2014no stuffy textbook jargon, just what actually works when you\u2019re coding and maybe juggling a stack of filter quotes at the same time. Filter<\/a><\/p>\n

<\/p>\n

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

Wait, let\u2019s make this concrete, no vague examples. Suppose I\u2019m working for my filter company, and I have a list of filter sizes\u2014like [12, 20, 24, 30, 36]<\/code>\u2014and 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 \u226524. So in Haskell, that\u2019d be filter (\u226524) [12, 20, 24, 30, 36]<\/code>. Boom. The output is [24, 30, 36]<\/code>. That\u2019s 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.<\/p>\n

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

Now, let\u2019s talk about edge cases\u2014stuff that trips up new devs (and new filter inventory managers). What if the list is empty? filter<\/code> just returns an empty list, no errors. That\u2019s like checking your filter supply bin and finding nothing\u2014you don\u2019t 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\u2019s not a number or a Boolean? Like, filtering parts that are under a certain price (wait, we didn\u2019t add price to our type, but play along)\u2014just make the predicate do the math. It works the same, because predicates are just functions that return Bool<\/code>, no limits.<\/p>\n

But hold on\u2014filter<\/code> isn\u2019t 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\u2019s say after pulling the HEPA HVAC parts, I just want their sizes, not the whole records. That\u2019s map partSize $ filter (\\p -> partType p == "HVAC" && isHEPA p) partStock<\/code>\u2014and that gives [24, 36]<\/code>. It\u2019s 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\u2019m prepping bulk filter orders\u2014pull the relevant parts, get the numbers I need, and move on to the next customer.<\/p>\n

Another thing people miss: filter<\/code> works on infinite lists too. Wait, what? Yeah, Haskell\u2019s lazy evaluation means it doesn\u2019t compute the whole list upfront. If I had an infinite list of filter sizes stepping up by 2 ([2,4,6,8,...]<\/code>) and I filtered for sizes divisible by 6, it\u2019d just give me [6,12,18,...]<\/code>\u2014no hanging the system, because it only calculates what you ask for. That\u2019s wild, but useful if you\u2019re 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.<\/p>\n

Now, let\u2019s get real\u2014what 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)<\/code>\u2014that\u2019s from the Data.List<\/code> module, so I\u2019d need to import that first. It\u2019s 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\u2019s in the standard library, same as how I use pre-built filter frames instead of welding every frame from scratch.<\/p>\n

Wait, let\u2019s 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<\/code>. filter pred list<\/code>\u2014predicate first, then list. If you swap them, like filter [12,20,24,30,36] (\u226524)<\/code>, Haskell will yell at you, because it\u2019s trying to run the number list as a function, which doesn\u2019t make sense. That\u2019s like grabbing a filter part and trying to use it as a wrench\u2014wrong tool, wrong order, doesn\u2019t work. Easy fix, just remember: function first, data second.<\/p>\n

Now, let\u2019s tie this back to my life as a filter supplier, because this isn\u2019t 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<\/code> 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\u2019t grab 12-inch residential filters instead of 24-inch commercial ones.<\/p>\n

And it\u2019s 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\u2019d have to flip through a physical catalog and call the warehouse to confirm stock\u2014now I can do it while I\u2019m on the phone with the customer. That\u2019s the power of filter<\/code>: it\u2019s 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.<\/p>\n

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

Let\u2019s wrap this up with a quick recap, so you don\u2019t have to remember every detail:<\/p>\n

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

    Look, I get it\u2014programming can feel intimidating, especially if you\u2019re used to more imperative languages where you have to write loops and track variables. But Haskell\u2019s filter<\/code> is so simple, it\u2019s like using a sieve to separate large filter parts from small ones. The sieve (predicate) catches only the stuff you want, and you\u2019re left with exactly what you need, no extra junk. That\u2019s the same vibe as filtering in Haskell\u2014clean, efficient, no hassle.<\/p>\n

    <\/p>\n

    Now, if you\u2019re 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\u2014HEPA, HVAC, residential, whatever you need), reach out. Whether you\u2019re 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\u2014just good filters and solid solutions.<\/p>\n

    Car Air Purifier<\/a> References:<\/p>\n

      \n
    1. Real World Haskell, Bryan O’Sullivan, John Goerzen, Donald Stewart<\/li>\n
    2. Haskell 2010 Language Report, Simon Marlow<\/li>\n
    3. Data.List Module Documentation, The Haskell Foundation<\/li>\n<\/ol>\n
      \n

      Cixi Beilian Electrical Appliance Co., Ltd.<\/a>
      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\/<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"

      Hey folks, let\u2019s cut to the chase\u2014if you\u2019ve ever dabbled in functional programming, you know Haskell\u2019s … How to filter a list in Haskell?<\/span>Read more<\/a><\/p>\n","protected":false},"author":325,"featured_media":603,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[566],"class_list":["post-603","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-industry","tag-filter-4670-7c81a9"],"_links":{"self":[{"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/posts\/603","targetHints":{"allow":["GET"]}}],"collection":[{"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/users\/325"}],"replies":[{"embeddable":true,"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/comments?post=603"}],"version-history":[{"count":0,"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/posts\/603\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/posts\/603"}],"wp:attachment":[{"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/media?parent=603"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/categories?post=603"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/www.tomschneiderphotography.com\/blog\/wp-json\/wp\/v2\/tags?post=603"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}