Pattern Matching для списков

program.own

@@ -205,3 +205,10 @@ println object1.arr
 println object1.arr[0][1]
 object1.arr[0][1] = "str"
 println object1.arr[0][1]
+
+println arrayRecursive([1, 2, 3, 4, 5, 6, 7])
+def arrayRecursive(arr) = match arr {
+  case [head :: tail]: "[" + head + ", " + arrayRecursive(tail) + "]"
+  case []: "[]"
+  case last: "[" + last + ", []]"
+}

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

@@ -264,25 +264,38 @@ public final class Parser {
             MatchExpression.Pattern pattern = null;
             final Token current = get(0);
             if (match(TokenType.NUMBER)) {
+                // case 0.5: 
                 pattern = new MatchExpression.ConstantPattern(
                         new NumberValue(Double.parseDouble(current.getText()))
                 );
             } else if (match(TokenType.HEX_NUMBER)) {
+                // case #FF: 
                 pattern = new MatchExpression.ConstantPattern(
                         new NumberValue(Long.parseLong(current.getText(), 16))
                 );
             } else if (match(TokenType.TEXT)) {
+                // case "text":
                 pattern = new MatchExpression.ConstantPattern(
                         new StringValue(current.getText())
                 );
             } else if (match(TokenType.WORD)) {
+                // case value: 
                 pattern = new MatchExpression.VariablePattern(current.getText());
+            } else if (match(TokenType.LBRACKET)) {
+                // case [x :: xs]:
+                final MatchExpression.ListPattern listPattern = new MatchExpression.ListPattern();
+                while (!match(TokenType.RBRACKET)) {
+                    listPattern.add(consume(TokenType.WORD).getText());
+                    match(TokenType.COLONCOLON);
+                }
+                pattern = listPattern;
             }
             
             if (pattern == null) {
                 throw new ParseException("Wrong pattern in match expression: " + current);
             }
             if (match(TokenType.IF)) {
+                // case e if e > 0:
                 pattern.optCondition = expression();
             }
             

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

@@ -1,9 +1,12 @@
 package com.annimon.ownlang.parser.ast;
 
 import com.annimon.ownlang.exceptions.PatternMatchingException;
+import com.annimon.ownlang.lib.ArrayValue;
 import com.annimon.ownlang.lib.NumberValue;
+import com.annimon.ownlang.lib.Types;
 import com.annimon.ownlang.lib.Value;
 import com.annimon.ownlang.lib.Variables;
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -48,10 +51,94 @@ public final class MatchExpression implements Expression {
                     Variables.remove(pattern.variable);
                 }
             }
+            if ((value.type() == Types.ARRAY) && (p instanceof ListPattern)) {
+                final ListPattern pattern = (ListPattern) p;
+                if (matchListPattern((ArrayValue) value, pattern)) {
+                    // Clean up variables if matched
+                    final Value result = evalResult(p.result);
+                    for (String var : pattern.parts) {
+                        Variables.remove(var);
+                    }
+                    return result;
+                }
+            }
         }
         throw new PatternMatchingException("No pattern were matched");
     }
     
+    private boolean matchListPattern(ArrayValue array, ListPattern p) {
+        final List<String> parts = p.parts;
+        final int partsSize = parts.size();
+        final int arraySize = array.size();
+        switch (partsSize) {
+            case 0: // match [] { case []: ... }
+                if ((arraySize == 0) && optMatches(p)) {
+                    return true;
+                }
+                return false;
+
+            case 1: // match arr { case [x]: x = arr ... }
+                final String variable = parts.get(0);
+                Variables.set(variable, array);
+                if (optMatches(p)) {
+                    return true;
+                }
+                Variables.remove(variable);
+                return false;
+                
+            default: { // match arr { case [...]: .. }
+                if (partsSize == arraySize) {
+                    // match [0, 1, 2] { case [a::b::c]: a=0, b=1, c=2 ... }
+                    return matchListPatternEqualsSize(p, parts, partsSize, array);
+                } else if (partsSize < arraySize) {
+                    // match [1, 2, 3] { case [head :: tail]: ... }
+                    return matchListPatternWithTail(p, parts, partsSize, array, arraySize);
+                }
+                return false;
+            }
+        }
+    } 
+
+    private boolean matchListPatternEqualsSize(ListPattern p, List<String> parts, int partsSize, ArrayValue array) {
+        // Set variables
+        for (int i = 0; i < partsSize; i++) {
+            Variables.set(parts.get(i), array.get(i));
+        }
+        if (optMatches(p)) {
+            // Clean up will be provided after evaluate result
+            return true;
+        }
+        // Clean up variables if no match
+        for (String var : parts) {
+            Variables.remove(var);
+        }
+        return false;
+    }
+    
+    private boolean matchListPatternWithTail(ListPattern p, List<String> parts, int partsSize, ArrayValue array, int arraySize) {
+        // Set element variables
+        final int lastPart = partsSize - 1;
+        for (int i = 0; i < lastPart; i++) {
+            Variables.set(parts.get(i), array.get(i));
+        }
+        // Set tail variable
+        final ArrayValue tail = new ArrayValue(arraySize - partsSize + 1);
+        for (int i = lastPart; i < arraySize; i++) {
+            tail.set(i - lastPart, array.get(i));
+        }
+        Variables.set(parts.get(lastPart), tail);
+        // Check optional condition
+        if (optMatches(p)) {
+            // Clean up will be provided after evaluate result
+            return true;
+        }
+        // Clean up variables
+        for (String var : parts) {
+            Variables.remove(var);
+        }
+        return false;
+    }
+    
     private boolean match(Value value, Value constant) {
         if (value.type() != constant.type()) return false;
         return value.equals(constant);
@@ -117,4 +204,25 @@ public final class MatchExpression implements Expression {
             return variable + ": " + result;
         }
     }
+    
+    public static class ListPattern extends Pattern {
+        public List<String> parts;
+        
+        public ListPattern() {
+            this(new ArrayList<String>());
+        }
+        
+        public ListPattern(List<String> parts) {
+            this.parts = parts;
+        }
+
+        public void add(String part) {
+            parts.add(part);
+        }
+
+        @Override
+        public String toString() {
+            return parts + ": " + result;
+        }
+    }
 }