Update match macro to test for array/tuples and table/structs.

src/core/core.janet

@@ -960,21 +960,28 @@ value, one key will be ignored."
     (do
       (def len (length pattern))
       (var i -1)
-      (with-idemp $arr expr
+      (with-idemp
-        ((fn aux []
+        $arr expr
-          (++ i)
+        ~(if (indexed? ,$arr)
-          (if (= i len)
+           ,((fn aux []
-            (onmatch)
+               (++ i)
-            (match-1 pattern.i ~(get ,$arr ,i) aux seen))))))
+               (if (= i len)
+                 (onmatch)
+                 (match-1 pattern.i (tuple get $arr i) aux seen))))
+           ,sentinel)))
 
     (dictionary? pattern)
     (do
       (var key nil)
-      (with-idemp $dict expr ((fn aux []
+      (with-idemp
-        (:= key (next pattern key))
+        $dict expr
-        (if (= key nil)
+        ~(if (dictionary? ,$dict) 
-          (onmatch)
+           ,((fn aux []
-          (match-1 (get pattern key) ~(get ,$dict ,key) aux seen))))))
+               (:= key (next pattern key))
+               (if (= key nil)
+                 (onmatch)
+                 (match-1 (get pattern key) (tuple get $dict key) aux seen))))
+           ,sentinel)))
 
     :else ~(if (= ,pattern ,expr) ,(onmatch) ,sentinel)))
 

test/suite3.janet

@@ -25,4 +25,25 @@
 (assert (= (length (range 1 10)) 9) "(range 1 10)")
 (assert (deep= @{:a 1 :b 2 :c 3} (zipcoll '[:a :b :c] '[1 2 3])) "zipcoll")
 
+(def- a 100)
+(assert (= a 100) "def-")
+
+(assert (= :first
+          (match @[1 3 5]
+                 @[x y z] :first
+                 :second)) "match 1")
+
+(def val1 :avalue)
+(assert (= :second
+          (match val1
+                 @[x y z] :first
+                 :avalue :second
+                 :third)) "match 2")
+
+(assert (= 100
+           (match @[50 40]
+                  @[x x] (* x 3)
+                  @[x y] (+ x y 10)
+                  0)) "match 3")
+
 (end-suite)