Аргументы функций по умолчанию

program.own

@@ -212,3 +212,9 @@ def arrayRecursive(arr) = match arr {
   case []: "[]"
   case last: "[" + last + ", []]"
 }
+
+def funcWithOptionalArgs(str, count = 5, prefix = "<", suffix = ">") = prefix + (str * count) + suffix
+
+println funcWithOptionalArgs("*")
+println funcWithOptionalArgs("+", 2)
+println funcWithOptionalArgs("*", 10, "<!")

src/com/annimon/ownlang/lib/UserDefinedFunction.java

@@ -1,9 +1,10 @@
 package com.annimon.ownlang.lib;
 
 import com.annimon.ownlang.exceptions.ArgumentsMismatchException;
+import com.annimon.ownlang.parser.ast.Argument;
+import com.annimon.ownlang.parser.ast.Arguments;
 import com.annimon.ownlang.parser.ast.ReturnStatement;
 import com.annimon.ownlang.parser.ast.Statement;
-import java.util.List;
 
 /**
  *
@@ -11,33 +12,45 @@ import java.util.List;
  */
 public final class UserDefinedFunction implements Function {
     
-    private final List<String> argNames;
+    private final Arguments arguments;
     private final Statement body;
     
-    public UserDefinedFunction(List<String> argNames, Statement body) {
+    public UserDefinedFunction(Arguments arguments, Statement body) {
-        this.argNames = argNames;
+        this.arguments = arguments;
         this.body = body;
     }
     
     public int getArgsCount() {
-        return argNames.size();
+        return arguments.size();
     }
     
     public String getArgsName(int index) {
         if (index < 0 || index >= getArgsCount()) return "";
-        return argNames.get(index);
+        return arguments.get(index).getName();
     }
 
     @Override
     public Value execute(Value... values) {
         final int size = values.length;
-        if (size != getArgsCount()) throw new ArgumentsMismatchException("Arguments count mismatch");
+        final int requiredArgsCount = arguments.getRequiredArgumentsCount();
+        if (size < requiredArgsCount) {
+            throw new ArgumentsMismatchException(String.format("Arguments count mismatch. %d < %d", size, requiredArgsCount));
+        }
+        final int totalArgsCount = getArgsCount();
+        if (size > totalArgsCount) {
+            throw new ArgumentsMismatchException(String.format("Arguments count mismatch. %d > %d", size, totalArgsCount));
+        }
 
         try {
             Variables.push();
             for (int i = 0; i < size; i++) {
                 Variables.set(getArgsName(i), values[i]);
             }
+            // Optional args if exists
+            for (int i = size; i < totalArgsCount; i++) {
+                final Argument arg = arguments.get(i);
+                Variables.set(arg.getName(), arg.getValueExpr().eval());
+            }
             body.execute();
             return NumberValue.ZERO;
         } catch (ReturnStatement rt) {
@@ -49,6 +62,6 @@ public final class UserDefinedFunction implements Function {
 
     @Override
     public String toString() {
-        return String.format("function %s %s", argNames.toString(), body.toString());
+        return String.format("function %s %s", arguments.toString(), body.toString());
     }
 }

src/com/annimon/ownlang/parser/Parser.java

@@ -199,20 +199,38 @@ public final class Parser {
     }
     
     private FunctionDefineStatement functionDefine() {
-        // def name(arg1, arg2) { ... }  ||  def name(args) = expr
+        // def name(arg1, arg2 = value) { ... }  ||  def name(args) = expr
         final String name = consume(TokenType.WORD).getText();
+        final Arguments arguments = arguments();
+        final Statement body = statementBody();
+        return new FunctionDefineStatement(name, arguments, body);
+    }
+    
+    private Arguments arguments() {
+        // (arg1, arg2, arg3 = expr1, arg4 = expr2)
+        final Arguments arguments = new Arguments();
+        boolean startsOptionalArgs = false;
         consume(TokenType.LPAREN);
-        final List<String> argNames = new ArrayList<>();
         while (!match(TokenType.RPAREN)) {
-            argNames.add(consume(TokenType.WORD).getText());
+            final String name = consume(TokenType.WORD).getText();
+            if (match(TokenType.EQ)) {
+                startsOptionalArgs = true;
+                arguments.addOptional(name, variable());
+            } else if (!startsOptionalArgs) {
+                arguments.addRequired(name);
+            } else {
+                throw new ParseException("Required argument cannot be after optional");
+            }
             match(TokenType.COMMA);
         }
-        if (lookMatch(0, TokenType.EQ)) {
+        return arguments;
-            match(TokenType.EQ);
+    }
-            return new FunctionDefineStatement(name, argNames, new ReturnStatement(expression()));
+    
+    private Statement statementBody() {
+        if (match(TokenType.EQ)) {
+            return new ReturnStatement(expression());
         }
-        final Statement body = statementOrBlock();
+        return statementOrBlock();
-        return new FunctionDefineStatement(name, argNames, body);
     }
     
     private FunctionalExpression function(Expression qualifiedNameExpr) {
@@ -534,20 +552,9 @@ public final class Parser {
             return match();
         }
         if (match(TokenType.DEF)) {
-            consume(TokenType.LPAREN);
+            final Arguments arguments = arguments();
-            final List<String> argNames = new ArrayList<>();
+            final Statement statement = statementBody();
-            while (!match(TokenType.RPAREN)) {
+            return new ValueExpression(new UserDefinedFunction(arguments, statement));
-                argNames.add(consume(TokenType.WORD).getText());
-                match(TokenType.COMMA);
-            }
-            Statement statement;
-            if (lookMatch(0, TokenType.EQ)) {
-                match(TokenType.EQ);
-                statement = new ReturnStatement(expression());
-            } else {
-                statement = statementOrBlock();
-            }
-            return new ValueExpression(new UserDefinedFunction(argNames, statement));
         }
         return variable();
     }

src/com/annimon/ownlang/parser/ast/Argument.java

@@ -0,0 +1,29 @@
+package com.annimon.ownlang.parser.ast;
+
+public final class Argument {
+
+    private final String name;
+    private final Expression valueExpr;
+
+    public Argument(String name) {
+        this(name, null);
+    }
+
+    public Argument(String name, Expression valueExpr) {
+        this.name = name;
+        this.valueExpr = valueExpr;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public Expression getValueExpr() {
+        return valueExpr;
+    }
+
+    @Override
+    public String toString() {
+        return name + (valueExpr == null ? "" : " = " + valueExpr);
+    }
+}

src/com/annimon/ownlang/parser/ast/Arguments.java

@@ -0,0 +1,53 @@
+package com.annimon.ownlang.parser.ast;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public final class Arguments implements Iterable<Argument> {
+    
+    private final List<Argument> arguments;
+    private int requiredArgumentsCount;
+
+    public Arguments() {
+        arguments = new ArrayList<>();
+        requiredArgumentsCount = 0;
+    }
+    
+    public void addRequired(String name) {
+        arguments.add(new Argument(name));
+        requiredArgumentsCount++;
+    }
+    
+    public void addOptional(String name, Expression expr) {
+        arguments.add(new Argument(name, expr));
+    }
+
+    public Argument get(int index) {
+        return arguments.get(index);
+    }
+    
+    public int getRequiredArgumentsCount() {
+        return requiredArgumentsCount;
+    }
+
+    public int size() {
+        return arguments.size();
+    }
+
+    @Override
+    public Iterator<Argument> iterator() {
+        return arguments.iterator();
+    }
+
+    @Override
+    public String toString() {
+        final StringBuilder result = new StringBuilder();
+        result.append('(');
+        for (Argument arg : arguments) {
+            result.append(arg).append(", ");
+        }
+        result.append(')');
+        return result.toString();
+    }
+}

src/com/annimon/ownlang/parser/ast/FunctionDefineStatement.java

@@ -2,7 +2,6 @@ package com.annimon.ownlang.parser.ast;
 
 import com.annimon.ownlang.lib.Functions;
 import com.annimon.ownlang.lib.UserDefinedFunction;
-import java.util.List;
 
 /**
  *
@@ -11,18 +10,18 @@ import java.util.List;
 public final class FunctionDefineStatement implements Statement {
     
     public final String name;
-    public final List<String> argNames;
+    public final Arguments arguments;
     public final Statement body;
     
-    public FunctionDefineStatement(String name, List<String> argNames, Statement body) {
+    public FunctionDefineStatement(String name, Arguments arguments, Statement body) {
         this.name = name;
-        this.argNames = argNames;
+        this.arguments = arguments;
         this.body = body;
     }
 
     @Override
     public void execute() {
-        Functions.set(name, new UserDefinedFunction(argNames, body));
+        Functions.set(name, new UserDefinedFunction(arguments, body));
     }
     
     @Override
@@ -32,6 +31,6 @@ public final class FunctionDefineStatement implements Statement {
 
     @Override
     public String toString() {
-        return String.format("def %s(%s) %s", name, argNames, body);
+        return String.format("def %s%s %s", name, arguments, body);
     }
 }