parser_standalone.hs

#!/usr/bin/env runhaskell
{-# LANGUAGE FlexibleInstances #-}

-- Standalone parser that can be run with: runhaskell parser.hs
-- This file is for quick testing and does not require compilation.

import Data.Char (isDigit, isAlpha, isAlphaNum, isSpace)
import Data.List (intercalate)

-- AST Data Types

data Expr
  = Number Int
  | BinOp Op Expr Expr
  | Var String
  deriving (Show, Eq)

data Op = Add | Sub | Mul | Div
  deriving (Show, Eq)

data KVPair = KVPair String String
  deriving (Show, Eq)

-- Tokenizer

data Token
  = TNum Int
  | TOp Char
  | TVar String
  | TLParen
  | TRParen
  | TEq
  | EOF
  deriving (Show, Eq)

tokenize :: String -> [Token]
tokenize [] = [EOF]
tokenize (c:cs)
  | isSpace c = tokenize cs
  | isDigit c = 
      let (num, rest) = span isDigit (c:cs)
      in TNum (read num) : tokenize rest
  | isAlpha c =
      let (var, rest) = span isAlphaNum (c:cs)
      in TVar var : tokenize rest
  | c == '+' || c == '-' || c == '*' || c == '/' = TOp c : tokenize cs
  | c == '(' = TLParen : tokenize cs
  | c == ')' = TRParen : tokenize cs
  | c == '=' = TEq : tokenize cs
  | otherwise = tokenize cs

-- Parser for Arithmetic Expressions (with operator precedence)

parseExpr :: [Token] -> (Expr, [Token])
parseExpr tokens = parseAddSub tokens

parseAddSub :: [Token] -> (Expr, [Token])
parseAddSub tokens =
  let (left, rest) = parseMulDiv tokens
  in parseAddSub' left rest

parseAddSub' :: Expr -> [Token] -> (Expr, [Token])
parseAddSub' left (TOp '+' : rest) =
  let (right, rest') = parseMulDiv rest
  in parseAddSub' (BinOp Add left right) rest'
parseAddSub' left (TOp '-' : rest) =
  let (right, rest') = parseMulDiv rest
  in parseAddSub' (BinOp Sub left right) rest'
parseAddSub' left rest = (left, rest)

parseMulDiv :: [Token] -> (Expr, [Token])
parseMulDiv tokens =
  let (left, rest) = parsePrimary tokens
  in parseMulDiv' left rest

parseMulDiv' :: Expr -> [Token] -> (Expr, [Token])
parseMulDiv' left (TOp '*' : rest) =
  let (right, rest') = parsePrimary rest
  in parseMulDiv' (BinOp Mul left right) rest'
parseMulDiv' left (TOp '/' : rest) =
  let (right, rest') = parsePrimary rest
  in parseMulDiv' (BinOp Div left right) rest'
parseMulDiv' left rest = (left, rest)

parsePrimary :: [Token] -> (Expr, [Token])
parsePrimary (TNum n : rest) = (Number n, rest)
parsePrimary (TVar v : rest) = (Var v, rest)
parsePrimary (TLParen : rest) =
  let (expr, rest') = parseExpr rest
  in case rest' of
    (TRParen : rest'') -> (expr, rest'')
    _ -> error "Expected closing parenthesis"
parsePrimary _ = error "Expected a number, variable, or opening parenthesis"

-- Parser for Key-Value Pairs

parseKVPair :: [Token] -> (KVPair, [Token])
parseKVPair (TVar key : TEq : TVar value : rest) = (KVPair key value, rest)
parseKVPair (TVar key : TEq : TNum num : rest) = (KVPair key (show num), rest)
parseKVPair _ = error "Invalid key-value pair format (expected: key = value)"

-- Evaluator for Arithmetic Expressions

evalExpr :: Expr -> Int
evalExpr (Number n) = n
evalExpr (Var _) = error "Variable evaluation not supported"
evalExpr (BinOp op left right) =
  let l = evalExpr left
      r = evalExpr right
  in case op of
    Add -> l + r
    Sub -> l - r
    Mul -> l * r
    Div -> if r == 0 then error "Division by zero" else l `div` r

-- Token Formatter

formatTokens :: [Token] -> String
formatTokens tokens = "[" ++ intercalate ", " (map show tokens) ++ "]"

-- Main

main :: IO ()
main = do
  putStrLn ""
  putStrLn "Welcome to Tiny Parser!"
  putStrLn ""
  putStrLn "Arithmetic Expression Parser"
  putStrLn ""

  let expr1 = "1 + 5 * 4"
  putStrLn $ "Input: " ++ expr1
  putStrLn $ "Tokens: " ++ formatTokens (tokenize expr1)
  let (ast, _) = parseExpr (tokenize expr1)
  putStrLn $ "AST: " ++ show ast
  putStrLn $ "Result: " ++ show (evalExpr ast)
  putStrLn ""

  let expr2 = "(7 + 9) * 3"
  putStrLn $ "Input: " ++ expr2
  putStrLn $ "Tokens: " ++ formatTokens (tokenize expr2)
  let (ast2, _) = parseExpr (tokenize expr2)
  putStrLn $ "AST: " ++ show ast2
  putStrLn $ "Result: " ++ show (evalExpr ast2)
  putStrLn ""

  putStrLn "Key-Value Pair Parser"
  putStrLn ""

  let kv1 = "name = bob"
  putStrLn $ "Input: " ++ kv1
  putStrLn $ "Tokens: " ++ formatTokens (tokenize kv1)
  let (kvpair, _) = parseKVPair (tokenize kv1)
  putStrLn $ "Parsed: " ++ show kvpair
  putStrLn ""

  let kv2 = "age = 45"
  putStrLn $ "Input: " ++ kv2
  putStrLn $ "Tokens: " ++ formatTokens (tokenize kv2)
  let (kvpair2, _) = parseKVPair (tokenize kv2)
  putStrLn $ "Parsed: " ++ show kvpair2