Hey there! Let's work through this parsing problem together—since you're new to Haskell, it's totally normal to get stuck on pattern matching for this kind of input. Let's break down what went wrong and how to fix it properly.

Why Your Initial Pattern Matching Failed #

Your pattern ['(', x, ',', y, ')', ' ', '(', r, ',', g, ',', b, ')'] only works if every number is a single digit. For example, it would match (1,2) (3,4,5) but fail completely on (10,25) (200,150,50)—since x would only capture the '1' of '10', leaving the '0' unaccounted for, which breaks the pattern match. We need a way to parse variable-length numbers, not just single characters.

Fixing Your Custom Types (Optional but Useful) #

First, let's tweak your data types a bit to fit the 0-255 range for RGB values (using Int makes more sense here than Float unless you plan to normalize them later):

-- Represent 2D coordinates (x, y) as integers
data Coords = Coord Int Int deriving (Show)
-- Represent RGB colors (r, g, b) where each value is 0-255
data Colors = Color Int Int Int deriving (Show)
-- Combine coordinates and color into a Point
data Points = Point Coords Colors deriving (Show)

If you do need Float values later, you can easily convert the Ints with fromIntegral.

Using Parsec: A Friendly Parser Combinator Library #

The best way to handle structured text parsing in Haskell is with a parser combinator library like Parsec. It's type-safe, readable, and perfect for this kind of task. Here's how to implement it:

Step 1: Install Parsec #

First, add Parsec to your project (if using Cabal, add parsec to your dependencies in package.yaml or .cabal file, or run cabal install parsec if you're working with a single file).

Step 2: Full Parsing Code #

import Text.Parsec
import Text.Parsec.String (Parser) -- Our parser works on String input

-- Parse a single integer (handles positive numbers, which fits your use case)
intParser :: Parser Int
intParser = read <$> many1 digit -- `many1 digit` captures one or more digits, then we convert to Int

-- Parse coordinates in the format (x, y)
coordParser :: Parser Coords
coordParser = do
  char '('                -- Match the opening parenthesis
  x <- intParser          -- Parse the x integer
  char ','                -- Match the comma separator
  optional space          -- Allow optional space after the comma (for flexibility)
  y <- intParser          -- Parse the y integer
  char ')'                -- Match the closing parenthesis
  return $ Coord x y      -- Wrap the values into our Coords type

-- Parse RGB colors in the format (r, g, b)
colorParser :: Parser Colors
colorParser = do
  char '('
  r <- intParser
  char ','
  optional space
  g <- intParser
  char ','
  optional space
  b <- intParser
  char ')'
  -- Optional: Add a check to ensure RGB values are 0-255
  if r >=0 && r <=255 && g >=0 && g <=255 && b >=0 && b <=255
    then return $ Color r g b
    else fail "RGB values must be between 0 and 255"

-- Parse a full Point: coordinates followed by a space, then color
pointParser :: Parser Points
pointParser = do
  coords <- coordParser
  space                   -- Match the space between coords and color
  color <- colorParser
  return $ Point coords color

-- Helper function to run the parser on a string
parsePoint :: String -> Either ParseError Points
parsePoint input = parse pointParser "" input

Step 3: Using the Parser #

To parse a single line:

-- Example usage
main :: IO ()
main = do
  let line = "(12, 34) (200, 150, 50)"
  case parsePoint line of
    Left err -> print err
    Right point -> print point
    -- Output: Point (Coord 12 34) (Color 200 150 50)

To parse an entire file line by line:

main :: IO ()
main = do
  fileContent <- readFile "your_file.txt"
  let linesList = lines fileContent
  mapM_ processLine linesList
  where
    processLine line = case parsePoint line of
      Left err -> putStrLn $ "Failed to parse line '" ++ line ++ "': " ++ show err
      Right point -> print point

Alternative: Using Regular Expressions (If You Prefer) #

If you want a simpler (but less type-safe) approach, you can use regex. Here's a quick example with the regex-tdfa library:

import Text.Regex.TDFA

parsePointRegex :: String -> Maybe Points
parsePointRegex line = case line =~ "\\(([0-9]+),([0-9]+)\\) \\(([0-9]+),([0-9]+),([0-9]+)\\)" of
  [[_, xStr, yStr, rStr, gStr, bStr]] ->
    let x = read xStr :: Int
        y = read yStr :: Int
        r = read rStr :: Int
        g = read gStr :: Int
        b = read bStr :: Int
    in if all (\v -> v >=0 && v <=255) [r,g,b]
       then Just $ Point (Coord x y) (Color r g b)
       else Nothing
  _ -> Nothing

But note that Parsec is better for catching errors early and handling edge cases (like extra spaces or invalid characters).

Key Takeaways #

• Pattern matching on individual characters only works for fixed-length input—use parser combinators for variable-length data like numbers.
• Parsec is a great tool for structured parsing in Haskell, and it plays nicely with custom data types.
• Always validate input (like checking RGB values are 0-255) to avoid invalid data in your types.

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