Add support for parenthesized functions

[fur] / parsing.py

diff --git a/parsing.py b/parsing.py
index 041f3aa..7240b52 100644 (file)
--- a/parsing.py
+++ b/parsing.py
@@ -64,14 +64,6 @@ FurNegationExpression = collections.namedtuple(
     ],
 )
 
-# TODO We don't need to wrap this type
-FurParenthesizedExpression = collections.namedtuple(
-    'FurParenthesizedExpression',
-    [
-        'internal',
-    ],
-)
-
 FurInfixExpression = collections.namedtuple(
     'FurInfixExpression',
     [
@@ -124,7 +116,7 @@ def _parenthesized_expression_parser(index, tokens):
             tokens[index].match,
         ))
 
-    return True, index, FurParenthesizedExpression(internal=internal)
+    return True, index, internal
 
 def _negation_expression_parser(index, tokens):
     failure = (False, index, None)
@@ -212,30 +204,35 @@ def _or_level_expression_parser(index, tokens):
         'or_level',
     )(index, tokens)
 
-def _comma_separated_list_parser(index, tokens):
-    start_index = index
+def _comma_separated_list_parser(subparser):
+    def result_parser(index, tokens):
+        start_index = index
+
+        items = []
 
-    expressions = []
+        success, index, item = subparser(index, tokens)
 
-    success, index, expression = _expression_parser(index, tokens)
+        if success:
+            items.append(item)
+        else:
+            return (True, start_index, ())
 
-    if success:
-        expressions.append(expression)
-    else:
-        return (True, start_index, ())
+        while success and index < len(tokens) and tokens[index].type == 'comma':
+            success = False
 
-    while success and index < len(tokens) and tokens[index].type == 'comma':
-        success = False
+            if index + 1 < len(tokens):
+                success, try_index, item = subparser(index + 1, tokens)
 
-        if index + 1 < len(tokens):
-            success, try_index, expression = _expression_parser(index + 1, tokens)
+            if success:
+                items.append(item)
+                index = try_index
 
-        if success:
-            expressions.append(expression)
-            index = try_index
+        return True, index, tuple(items)
 
-    return True, index, tuple(expressions)
+    return result_parser
 
+def _comma_separated_expression_list_parser(index, tokens):
+    return _comma_separated_list_parser(_expression_parser)(index, tokens)
 
 FurFunctionCallExpression = collections.namedtuple(
     'FurFunctionCallExpression',
@@ -264,6 +261,7 @@ FurFunctionDefinitionStatement = collections.namedtuple(
     'FurFunctionDefinitionStatement',
     [
         'name',
+        'argument_name_list',
         'statement_list',
     ],
 )
@@ -276,10 +274,16 @@ FurProgram = collections.namedtuple(
 )
 
 def _function_call_expression_parser(index, tokens):
-    # TODO Use a FurSymbolExpression for the name
+    # TODO Allow function calls as the source of the function. This requires a
+    # left-recursive parser, however.
     failure = (False, index, None)
 
-    success, index, function = _symbol_expression_parser(index, tokens)
+    # We have to be careful what expressions we add here. Otherwise expressions
+    # like "a + b()" become ambiguous to the parser.
+    success, index, function = _or_parser(
+        _symbol_expression_parser,
+        _parenthesized_expression_parser,
+    )(index, tokens)
 
     if not success:
         return failure
@@ -288,7 +292,7 @@ def _function_call_expression_parser(index, tokens):
         return failure
     index += 1
 
-    success, index, arguments = _comma_separated_list_parser(index, tokens)
+    success, index, arguments = _comma_separated_expression_list_parser(index, tokens)
 
     if not success:
         return failure
@@ -363,6 +367,11 @@ def _function_definition_statement_parser(index, tokens):
             tokens[index].line,
         ))
 
+    success, index, argument_name_list = _comma_separated_list_parser(_symbol_expression_parser)(
+        index,
+        tokens,
+    )
+
     if tokens[index].type == 'close_parenthese':
         index += 1
     else:
@@ -385,7 +394,11 @@ def _function_definition_statement_parser(index, tokens):
     else:
         return failure
 
-    return True, index, FurFunctionDefinitionStatement(name=name, statement_list=statement_list)
+    return True, index, FurFunctionDefinitionStatement(
+        name=name,
+        argument_name_list=tuple(an.value for an in argument_name_list),
+        statement_list=statement_list,
+    )
 
 def _statement_parser(index, tokens):
     _, index, _ = consume_newlines(index, tokens)