Add native dot methods for arrays and hashes

New array methods: .contains(v), .index(v), .reverse(), .compact()
New hash method: .clone()
Fix: .keys() now returns keys in sorted order

Author: rubiojr

compiler/templates/runtime_core_post.go.tmpl

@@ -382,6 +382,46 @@ func rugo_array_method(arr []interface{}, method string, args ...interface{}) (i
 			result = append(result, interface{}(ch))
 		}
 		return interface{}(result), true
+
+	case "contains":
+		if len(args) < 1 {
+			panic(".contains() requires an argument")
+		}
+		target := args[0]
+		for _, v := range arr {
+			if reflect.DeepEqual(v, target) {
+				return true, true
+			}
+		}
+		return false, true
+
+	case "index":
+		if len(args) < 1 {
+			panic(".index() requires an argument")
+		}
+		target := args[0]
+		for i, v := range arr {
+			if reflect.DeepEqual(v, target) {
+				return i, true
+			}
+		}
+		return -1, true
+
+	case "reverse":
+		result := make([]interface{}, len(arr))
+		for i, v := range arr {
+			result[len(arr)-1-i] = v
+		}
+		return interface{}(result), true
+
+	case "compact":
+		result := make([]interface{}, 0, len(arr))
+		for i, v := range arr {
+			if i == 0 || !reflect.DeepEqual(v, arr[i-1]) {
+				result = append(result, v)
+			}
+		}
+		return interface{}(result), true
 	}
 	return nil, false
 }
@@ -478,6 +518,9 @@ func rugo_hash_method(m map[interface{}]interface{}, method string, args ...inte
 		for k := range m {
 			result = append(result, k)
 		}
+		sort.Slice(result, func(i, j int) bool {
+			return rugo_compare(result[i], result[j]) < 0
+		})
 		return interface{}(result), true
 
 	case "values":
@@ -500,6 +543,13 @@ func rugo_hash_method(m map[interface{}]interface{}, method string, args ...inte
 			result[k] = v
 		}
 		return interface{}(result), true
+
+	case "clone":
+		result := make(map[interface{}]interface{}, len(m))
+		for k, v := range m {
+			result[k] = v
+		}
+		return interface{}(result), true
 	}
 	return nil, false
 }

rats/core/82_array_methods_test.rugo

@@ -287,3 +287,117 @@ rats "array map then reduce chain"
   result = [1, 2, 3].map(fn(x) x * x end).reduce(0, fn(acc, x) acc + x end)
   test.assert_eq(result, 14)
 end
+
+# ============================================================
+# S. contains
+# ============================================================
+
+rats "array.contains returns true when value is present"
+  test.assert_true([1, 2, 3].contains(2))
+end
+
+rats "array.contains returns false when value is absent"
+  test.assert_false([1, 2, 3].contains(99))
+end
+
+rats "array.contains works with strings"
+  test.assert_true(["a", "b", "c"].contains("b"))
+  test.assert_false(["a", "b", "c"].contains("z"))
+end
+
+rats "array.contains on empty array returns false"
+  test.assert_false([].contains(1))
+end
+
+rats "array.contains uses deep equality"
+  test.assert_true([[1, 2], [3, 4]].contains([3, 4]))
+  test.assert_false([[1, 2], [3, 4]].contains([5, 6]))
+end
+
+# ============================================================
+# T. index
+# ============================================================
+
+rats "array.index returns index of first occurrence"
+  test.assert_eq([10, 20, 30, 20].index(20), 1)
+end
+
+rats "array.index returns -1 when not found"
+  test.assert_eq([1, 2, 3].index(99), -1)
+end
+
+rats "array.index on empty array returns -1"
+  test.assert_eq([].index(1), -1)
+end
+
+rats "array.index works with strings"
+  test.assert_eq(["a", "b", "c"].index("c"), 2)
+end
+
+rats "array.index uses deep equality"
+  test.assert_eq([[1], [2], [3]].index([2]), 1)
+end
+
+# ============================================================
+# U. reverse
+# ============================================================
+
+rats "array.reverse returns new reversed array"
+  result = [1, 2, 3].reverse()
+  test.assert_eq(result[0], 3)
+  test.assert_eq(result[1], 2)
+  test.assert_eq(result[2], 1)
+end
+
+rats "array.reverse on empty array returns empty"
+  test.assert_eq(len([].reverse()), 0)
+end
+
+rats "array.reverse does not mutate original"
+  arr = [1, 2, 3]
+  rev = arr.reverse()
+  test.assert_eq(arr[0], 1)
+  test.assert_eq(rev[0], 3)
+end
+
+rats "array.reverse on single element"
+  result = [42].reverse()
+  test.assert_eq(len(result), 1)
+  test.assert_eq(result[0], 42)
+end
+
+# ============================================================
+# V. compact
+# ============================================================
+
+rats "array.compact removes consecutive duplicates"
+  result = [1, 1, 2, 2, 2, 3, 1, 1].compact()
+  test.assert_eq(len(result), 4)
+  test.assert_eq(result[0], 1)
+  test.assert_eq(result[1], 2)
+  test.assert_eq(result[2], 3)
+  test.assert_eq(result[3], 1)
+end
+
+rats "array.compact on empty array returns empty"
+  test.assert_eq(len([].compact()), 0)
+end
+
+rats "array.compact with no consecutive duplicates"
+  result = [1, 2, 3].compact()
+  test.assert_eq(len(result), 3)
+end
+
+rats "array.compact on single element"
+  result = [42].compact()
+  test.assert_eq(len(result), 1)
+  test.assert_eq(result[0], 42)
+end
+
+rats "array.compact works with strings"
+  result = ["a", "a", "b", "b", "a"].compact()
+  test.assert_eq(len(result), 3)
+  test.assert_eq(result[0], "a")
+  test.assert_eq(result[1], "b")
+  test.assert_eq(result[2], "a")
+end

rats/core/83_hash_methods_test.rugo

@@ -175,3 +175,43 @@ rats "built-in method takes priority over hash key"
   test.assert_eq(type_of(result), "Array")
   test.assert_eq(len(result), 2)
 end
+
+# ============================================================
+# M. keys returns sorted keys
+# ============================================================
+
+rats "hash.keys returns sorted keys"
+  h = {c: 3, a: 1, b: 2}
+  keys = h.keys()
+  test.assert_eq(keys[0], "a")
+  test.assert_eq(keys[1], "b")
+  test.assert_eq(keys[2], "c")
+end
+
+# ============================================================
+# N. clone
+# ============================================================
+
+rats "hash.clone returns a shallow copy"
+  h = {a: 1, b: 2, c: 3}
+  copy = h.clone()
+  test.assert_eq(len(copy), 3)
+  test.assert_eq(copy["a"], 1)
+  test.assert_eq(copy["b"], 2)
+  test.assert_eq(copy["c"], 3)
+end
+
+rats "hash.clone does not mutate original"
+  h = {x: 10}
+  copy = h.clone()
+  copy["y"] = 20
+  test.assert_eq(len(h), 1)
+  test.assert_eq(len(copy), 2)
+end
+
+rats "hash.clone of empty hash"
+  h = {}
+  copy = h.clone()
+  test.assert_eq(len(copy), 0)
+  test.assert_eq(type_of(copy), "Hash")
+end