Haskell中如何通过数据类型直接限制车牌字段的格式约束？

Great question! #

Haskell’s type system shines here—we absolutely can encode these constraints directly into data types, making invalid states unrepresentable instead of relying solely on runtime checks in a single constructor. This aligns perfectly with Haskell’s philosophy of using types to enforce correctness. Let’s walk through a cleaner, more idiomatic approach:

Step 1: Define Constrained Subtypes

Instead of using raw Int or String for fields with rules, we’ll create newtype wrappers with "smart constructors"—functions that only return valid instances of the type. We’ll hide the actual newtype constructors from external code, so users can only create valid values through these smart functions.

import Data.Char (isAlphaNum)
import Data.Maybe (Maybe(..))

-- Locality is already perfect as a sum type
data Locality = N | S | E | W | C deriving (Show, Eq)

-- District: 1-20
newtype District = District Int deriving (Show, Eq)
mkDistrict :: Int -> Maybe District
mkDistrict d
  | d >= 1 && d <= 20 = Just (District d)
  | otherwise = Nothing

-- Month: 1-12
newtype Month = Month Int deriving (Show, Eq)
mkMonth :: Int -> Maybe Month
mkMonth m
  | m >= 1 && m <= 12 = Just (Month m)
  | otherwise = Nothing

-- Year: >=2020 and <= current year (fixed your original inverted condition)
currentYear :: Int
currentYear = 2020

newtype Year = Year Int deriving (Show, Eq)
mkYear :: Int -> Maybe Year
mkYear y
  | y >= 2020 && y <= currentYear = Just (Year y)
  | otherwise = Nothing

-- Random sequence: 3-character alphanumeric string
newtype RandomSequence = RandomSequence String deriving (Show, Eq)
mkRandomSequence :: String -> Maybe RandomSequence
mkRandomSequence s
  | length s == 3 && all isAlphaNum s = Just (RandomSequence s)
  | otherwise = Nothing

Step 2: Define the Reg Type with Constrained Fields

Now our NewReg variant uses these constrained subtypes instead of raw values. This means you literally can’t create a NewReg with an invalid district, month, or random sequence—because those fields can only hold valid values to begin with.

data Reg = OldReg { code :: String } 
         | NewReg { loc :: Locality
                  , district :: District
                  , month :: Month
                  , year :: Year
                  , random :: RandomSequence
                  } deriving (Show, Eq)

Step 3: Simplify the Constructor Function

With the subtype constraints handled, createNewReg becomes a simple sequence of validating each input and assembling the result (using do notation for clean Maybe chaining):

createNewReg :: Locality -> Int -> Int -> Int -> String -> Maybe Reg
createNewReg l d m y r = do
  validDistrict <- mkDistrict d
  validMonth <- mkMonth m
  validYear <- mkYear y
  validRandom <- mkRandomSequence r
  return $ NewReg l validDistrict validMonth validYear validRandom

Bonus: Enforce Old Plate Constraints Too

We can extend this pattern to OldReg to ensure it’s always a 5-character alphanumeric string:

newtype OldPlateCode = OldPlateCode String deriving (Show, Eq)
mkOldPlateCode :: String -> Maybe OldPlateCode
mkOldPlateCode s
  | length s == 5 && all isAlphaNum s = Just (OldPlateCode s)
  | otherwise = Nothing

-- Update Reg to use the constrained type
data Reg = OldReg { code :: OldPlateCode } 
         | NewReg { loc :: Locality
                  , district :: District
                  , month :: Month
                  , year :: Year
                  , random :: RandomSequence
                  } deriving (Show, Eq)

createOldReg :: String -> Maybe Reg
createOldReg s = OldReg <$> mkOldPlateCode s

Why This Is More Haskell-Idiomatic #

1. Invalid States Are Unrepresentable: No one can accidentally create a District with value 0 or a RandomSequence with 4 characters—those values can’t exist in the type system.
2. Modularity: Each constraint is encapsulated in its own newtype and smart constructor, making code easier to test and maintain.
3. Clearer Intent: The type signature of NewReg immediately tells you exactly what kind of values it accepts, without needing to read comments or constructor logic.

For even more strictness (e.g., compile-time enforcement of numeric ranges), you could use GADTs or type-level numbers, but the newtype + smart constructor pattern strikes the best balance between simplicity and safety for most use cases.

内容的提问来源于stack exchange，提问作者C. Begley