How can I declare the types for this problem?

user_12950351 0
Viewed 78

I'm trying to create a simple programming language with some primitives and user defined functions.

These are the types I created:

data Type = IntT | BoolT

data Value = IntV Int | BoolV Bool | OperatorCall String [Value]

data Expr = LetE String Value | ProcedureCall String [Value]

As you can see, I've divided functions into operators (which return a value) and procedures (which don't return anything and act as expressions instead of values). A function call contains the string id of the function being called and the list of arguments being passed. Also, a program is just a list of expressions (I've omitted user defined functions here for the sake of simplicity)

My problem comes from the fact that I need to write a function that parses a function call from a string:

parseFunctionCall :: String -> ???
...

The return type of that function can be a Value (for operator calls) or an Expr (for procedure calls). This function is rather complicated and I'd prefer to avoid writing it twice, or polluting it with an Either return type. What should I do? How can I change my types so that this can be achieved cleanly? Something like this perhaps, but I don't think this is the way:

type FunctionCall = (String, [Value])

data Value = ... | OperatorCall FunctionCall

data Expr = ... | ProcedureCall FunctionCall

parseAsFunctionCall :: String -> FunctionCall
...
haskell
1 Answers

You can have the function call parser return (String, [Value]), and let the caller fix that up into whatever data structure they like best -- in your case, by applying \(s, vs) -> OperatorCall s vs if parsing a value or \(s, vs) -> ProcedureCall s vs if parsing an expression.

parseFunctionCall :: Parser (String, [Value])
parseLiteralInt :: Parser Int
parseLiteralBool :: Parser Bool
parseLet :: Parser (String, Value)
(parseFunctionCall, parseLiteralInt, parseBool, parseLet) = {- ... -}

parseValue :: Parser Value
parseValue =
    ((\(s, vs) -> OperatorCall s vs) <$> parseFunctionCall)
    <|>
    (IntV <$> parseLiteralInt)
    <|>
    (BoolV <$> parseLiteralBool)

parseExpr :: Parser Expr
    ((\(s, vs) -> ProcedureCall s vs) <$> parseFunctionCall)
    <|>
    ((\(s, v) -> Let s v) <$> parseLet)
user_7916040
Related