🟠Parser.hs

Here's a comprehensive documentation for the Haskell module Parser, focusing on its functionalities

Module Documentation: Parser

The Parser module in Haskell encapsulates a collection of combinators and basic parsers designed to construct complex parsers from simpler ones. It leverages Haskell's strong typing and functional paradigms to provide a versatile and powerful parsing framework.

Interface and Functionality Overview

Data Types

• Parser a: Represents a parser with the following structure:

  • runParser: Function that takes a String and returns Maybe (a, String), where a is the parsed value and String is the remaining input.

Core Parsing Functions

Basic Parsers

• parseChar: Parses a specific character from the input.

• parseString: Sequentially parses a list of characters forming a string.

• parseUInt: Parses an unsigned integer from the input.

• parseInt: Parses a signed integer, handling optional negative signs.

• parseFloat: Parses floating-point numbers with an optional fractional part.

Combinatorial Parsers

• parseOr: Provides an alternative between two parsers; returns the result of the first successful parser.

• parseAnyChar: Parses any character from a given list of characters.

• parseAnd: Combines two parsers, sequencing their operations and aggregating their results.

• parseAndWith: Similar to parseAnd, but allows for a custom combination function to process the parsed results.

• parseMany: Applies a parser zero or more times, accumulating the results in a list.

• parseSome: Like parseMany, but requires the parser to succeed at least once.

Specialized Parsers

• parseTuple: Parses a pair of values enclosed in parentheses.

• parseTruple: Parses a triple of integers, typically used for structured data like coordinates or dimensions.

Type Class Instances

Functor, Applicative, Monad, and Alternative

• The Parser type is an instance of these fundamental Haskell type classes, enabling powerful combinatory parsing strategies:

  • Functor: Allows applying a function to the result of a parser.

  • Applicative: Facilitates sequencing of parsers while abstracting over their inputs.

  • Monad: Enables chaining of parsing operations where the output of one parser determines the next parsing step.

  • Alternative: Provides mechanisms for trying multiple parsing strategies in sequence, selecting the first successful result.

Conclusion

The Parser module forms the backbone of text parsing applications in Haskell, supporting a wide range of parsing tasks from simple token recognition to complex structure decompositions. Its design emphasizes composability and reusability, allowing for the concise and efficient definition of parsers for various data formats.

{-# HLINT ignore "Use newtype instead of data" #-}
{-# OPTIONS_GHC -Wno-unrecognised-pragmas #-}
{-# HLINT ignore "Use lambda-case" #-}
{-# OPTIONS_GHC -Wno-unused-do-bind #-}
module Parser (Parser(..), parseChar, parseOr, parseAnyChar, parseAnd,
    parseAndWith, parseMany, parseSome, parseUInt, parseInt, parseTuple,
    parseFloat, parseTruple, parseString, fmap, pure, (<*>), (<|>),
    empty, (>>=)) where

import Control.Applicative (Alternative (some, empty, (<|>), many))

data Parser a = Parser {
    runParser :: String -> Maybe (a, String)
}

instance Functor Parser where
    fmap fct parser = Parser (\str -> case runParser parser str of
        Nothing -> Nothing
        Just (a, s) -> Just (fct a, s))

instance Applicative Parser where
    pure a = Parser (\str -> Just (a, str))
    (<*>) fct parser = Parser (\str -> case runParser fct str of
        Nothing -> Nothing
        Just (b, s) -> case runParser parser s of
            Nothing -> Nothing
            Just (a, st) -> Just (b a, st))

instance Alternative Parser where
    (<|>) a b = Parser (\str -> case runParser a str of
        Nothing -> runParser b str
        x -> x)
    empty = Parser (const Nothing)

instance Monad Parser where
    (>>=) a f = Parser (\str -> case runParser a str of
        Nothing -> Nothing
        Just (b, s) -> runParser (f b) s)

parseChar :: Char -> Parser Char
parseChar a = Parser (\str -> case str of
    [] -> Nothing
    (x:s) -> case x of
        y | y == a -> Just (a, s)
            | otherwise -> Nothing)

parseOr :: Parser a -> Parser a -> Parser a
parseOr = (<|>)

parseAnyChar :: String -> Parser Char
parseAnyChar [] = Parser (const Nothing)
parseAnyChar [a] = parseChar a
parseAnyChar (a:sx) = parseOr (parseChar a) (parseAnyChar sx)

parseAnd :: Parser a -> Parser b -> Parser (a, b)
parseAnd a b = (,) <$> a <*> b

parseAndWith :: (a -> b -> c) -> Parser a -> Parser b -> Parser c
parseAndWith f a b = f <$> a <*> b

parseMany :: Parser a -> Parser [a]
parseMany = many

parseSome :: Parser a -> Parser [a]
parseSome = some

parseUInt :: Parser Int -- parse an unsigned Int
parseUInt = read <$> parseSome (parseAnyChar "0123456789")

parseInt :: Parser Int -- parse a signed Int
parseInt = (negate <$> (parseChar '-' *> parseUInt)) <|> parseUInt

parseTuple :: Parser a -> Parser (a, a) -- parse a tuple
parseTuple a = do
    parseChar '('
    b <- a
    parseChar ','
    c <- a
    parseChar ')'
    return (b, c)

parseTruple :: Parser (Int, Int, Int)
parseTruple = do
    parseChar '('
    a <- parseInt
    parseChar ','
    b <- parseInt
    parseChar ','
    c <- parseInt
    parseChar ')'
    return (a, b, c)

parseString :: String -> Parser String
parseString = foldr
      (\ a -> (<*>) ((:) <$> parseChar a))
      (Parser (\ str -> Just ([], str)))

parseFloat :: Parser Float
parseFloat = do
    wholePart <- parseInt
    parseChar '.'
    fractionalPart <- parseInt
    let fractionalDigits = length (show fractionalPart)
    return (fromIntegral wholePart +
        fromIntegral fractionalPart / 10 ^ fractionalDigits)