如何借助Haskell标准库重构这类冗余代码？

Absolutely! Haskell’s standard library is built with abstraction in mind, so there are plenty of battle-tested, standard ways to eliminate redundant code. Let’s walk through the most useful approaches you can apply right now without any external dependencies:

1. Abstract repeated logic with higher-order functions #

The single biggest source of redundancy in Haskell code is repeated traversal, transformation, or filtering of data structures. The Data.List module (and other standard modules) are packed with higher-order functions that let you replace hand-written recursive loops with concise, reusable calls.

For example, if you’ve got multiple functions that iterate over lists to apply different operations:

-- Redundant: separate recursive functions for each operation
addOneToAll :: [Int] -> [Int]
addOneToAll [] = []
addOneToAll (x:xs) = (x + 1) : addOneToAll xs

multiplyByTwoToAll :: [Int] -> [Int]
multiplyByTwoToAll [] = []
multiplyByTwoToAll (x:xs) = (x * 2) : multiplyByTwoToAll xs

You can refactor this entirely using map:

-- Refactored: reuse the standard map function
addOneToAll = map (+1)
multiplyByTwoToAll = map (*2)

Other go-tos here include filter for conditional filtering, foldl/foldr for accumulating values, and traverse (from Data.Traversable) for effectful traversals.

2. Use type classes to unify similar operations #

If you find yourself writing identical logic for different types (e.g., checking if a value is "empty", serializing to a string), type classes let you define a single interface that works across multiple types—no more copy-pasted functions.

For example, instead of writing separate "isEmpty" checks for different types:

-- Redundant: duplicate isEmpty logic
isEmptyString :: String -> Bool
isEmptyString = null

isEmptyList :: [a] -> Bool
isEmptyList = null

isEmptyMaybe :: Maybe a -> Bool
isEmptyMaybe Nothing = True
isEmptyMaybe _ = False

You can either:

• Reuse existing standard type classes (like checking == mempty for Monoid instances, or using isNothing for Maybe, null for lists)
• Define your own lightweight type class if needed:

-- Refactored: single interface for all empty-checkable types
class Emptyable a where
  isEmpty :: a -> Bool

instance Emptyable String where isEmpty = null
instance Emptyable [a] where isEmpty = null
instance Emptyable (Maybe a) where isEmpty = (== Nothing)

3. Consolidate pattern matching branches #

Redundant pattern matching often happens when you write separate functions to extract values from different data constructors, or handle similar cases across functions. Instead, extract shared logic into helper functions or consolidate branches.

Take this example with a custom data type:

data Animal = Dog String | Cat String | Bird String

-- Redundant: separate name extractors for each animal
getDogName :: Animal -> Maybe String
getDogName (Dog name) = Just name
getDogName _ = Nothing

getCatName :: Animal -> Maybe String
getCatName (Cat name) = Just name
getCatName _ = Nothing

You can replace these with a single, reusable extractor:

-- Refactored: single function to get any animal's name
getAnimalName :: Animal -> Maybe String
getAnimalName (Dog name) = Just name
getAnimalName (Cat name) = Just name
getAnimalName (Bird name) = Just name

Or if you need more flexibility, write a helper that takes a constructor matcher:

extractName :: (Animal -> Maybe String) -> Animal -> Maybe String
extractName matcher animal = matcher animal

-- Usage: extractName (\(Dog n) -> Just n; _ -> Nothing) myDog

4. Leverage record syntax for data access #

If you’re writing manual accessor functions for every field in a data type, you’re wasting effort. Haskell’s record syntax automatically generates accessor functions and lets you update fields without repeating the entire constructor.

Instead of this:

-- Redundant: manual accessors for each field
data User = User String Int String -- name, age, email

getUserName :: User -> String
getUserName (User name _ _) = name

getUserAge :: User -> Int
getUserAge (User _ age _) = age

Use record syntax to get accessors for free:

-- Refactored: auto-generated accessors (userName, userAge, userEmail)
data User = User 
  { userName :: String
  , userAge :: Int
  , userEmail :: String 
  }

5. Eliminate null/error checking redundancy with Maybe/Either #

Repetitive null checks or error handling can be replaced with Maybe (for optional values) or Either (for error messages) combined with standard functions like fmap, >>=, or traverse.

For example:

-- Redundant: duplicate Maybe unwrapping
getUserEmail :: Maybe User -> Maybe String
getUserEmail Nothing = Nothing
getUserEmail (Just user) = Just (userEmail user)

getUserNameLength :: Maybe User -> Maybe Int
getUserNameLength Nothing = Nothing
getUserNameLength (Just user) = Just (length (userName user))

Refactor using fmap to lift operations into the Maybe context:

-- Refactored: reuse fmap to avoid unwrapping boilerplate
getUserEmail = fmap userEmail
getUserNameLength = fmap (length . userName)

6. Use Monoid/Semigroup for reusable combination logic #

If you’re writing code that repeatedly combines values (e.g., concatenating strings, merging lists, accumulating numbers), the Monoid and Semigroup type classes provide a standard way to handle these operations without duplication.

Instead of:

-- Redundant: duplicate concatenation logic
concatThreeStrings :: String -> String -> String -> String
concatThreeStrings a b c = a ++ b ++ c

concatThreeLists :: [a] -> [a] -> [a]
concatThreeLists a b c = a ++ b ++ c

Use the generic <> (from Semigroup) and mconcat (from Monoid) functions:

-- Refactored: works for any Monoid instance (Strings, lists, numbers, etc.)
concatThree :: Monoid m => m -> m -> m -> m
concatThree a b c = a <> b <> c

-- Or even more concise:
concatThree a b c = mconcat [a, b, c]

The key here is to look for patterns in your redundant code—repeated loops, identical type-specific logic, or boilerplate data access—and match them to the abstractions provided by Haskell’s standard library. Over time, this not only eliminates redundancy but makes your code more maintainable and idiomatic.

内容的提问来源于stack exchange，提问作者Zazaeil