Merge origin/mlin/wdl-1.2-stdlib - add values() function

Resolved conflicts in tests/test_5stdlib.py:
- Kept all test_keys() tests including struct support and version gating
- Added test_values() function for WDL 1.2 values() implementation
- Both functions now properly tested

Author: mlin

WDL/StdLib.py

@@ -151,6 +151,7 @@ def sep(sep: Value.String, iterable: Value.Array) -> Value.String:
         if self.wdl_version not in ["draft-2", "1.0", "1.1"]:
             # WDL 1.2+ functions
             self.contains = _Contains()
+            self.values = _Values()
 
     def _read(self, parse: Callable[[str], Value.Base]) -> Callable[[Value.File], Value.Base]:
         "generate read_* function implementation based on parse"
@@ -1129,6 +1130,31 @@ def _call_eager(self, expr: "Expr.Apply", arguments: List[Value.Base]) -> Value.
             raise Error.EvalError(expr, f"keys() received unexpected argument type: {type(arg)}")
 
 
+class _Values(EagerFunction):
+    # Array[Y] values(Map[P, Y])
+    # Returns an array of values from a Map
+
+    def infer_type(self, expr: "Expr.Apply") -> Type.Base:
+        if len(expr.arguments) != 1:
+            raise Error.WrongArity(expr, 1)
+        arg0ty = expr.arguments[0].type
+        if not isinstance(arg0ty, Type.Map) or (expr._check_quant and arg0ty.optional):
+            raise Error.StaticTypeMismatch(
+                expr.arguments[0], Type.Map((Type.Any(), Type.Any())), arg0ty
+            )
+        # For Map[P, Y], return Array[Y]
+        return Type.Array(arg0ty.item_type[1].copy())
+
+    def _call_eager(self, expr: "Expr.Apply", arguments: List[Value.Base]) -> Value.Base:
+        assert isinstance(arguments[0], Value.Map)
+        mapty = arguments[0].type
+        assert isinstance(mapty, Type.Map)
+        # Return the values (p[1]) from the map
+        return Value.Array(
+            mapty.item_type[1], [p[1].coerce(mapty.item_type[1]) for p in arguments[0].value], expr
+        )
+
+
 class _AsPairs(EagerFunction):
     def infer_type(self, expr: "Expr.Apply") -> Type.Base:
         if len(expr.arguments) != 1:

tests/test_5stdlib.py

@@ -2072,6 +2072,108 @@ def test_keys(self):
         # that may be hit during coercion from read_json, though it's hard to isolate in testing.
         # The runtime error path (unexpected argument type) should be prevented by static type checking.
 
+    def test_values(self):
+        """Test the values() function from WDL 1.2"""
+
+        # Basic functionality with different value types
+        outputs = self._test_task(R"""
+        version 1.2
+        task test_values {
+            input {
+                Map[String, Int] m1 = {"a": 1, "b": 2, "c": 3}
+                Map[Int, String] m2 = {1: "one", 2: "two"}
+                Map[String, Pair[Int, Int]] m3 = {
+                    "a": (1, 2),
+                    "b": (3, 4)
+                }
+            }
+            command {}
+            output {
+                Array[Int] v1 = values(m1)
+                Array[String] v2 = values(m2)
+                Array[Pair[Int, Int]] v3 = values(m3)
+                Array[Boolean] v4 = values({})
+            }
+        }
+        """)
+        self.assertEqual(outputs["v1"], [1, 2, 3])
+        self.assertEqual(outputs["v2"], ["one", "two"])
+        self.assertEqual(outputs["v3"], [{"left": 1, "right": 2}, {"left": 3, "right": 4}])
+        self.assertEqual(outputs["v4"], [])
+
+        # Complex nested types
+        outputs = self._test_task(R"""
+        version 1.2
+        task test_values_complex {
+            input {
+                Map[String, Array[Int]] nested = {
+                    "x": [1, 2],
+                    "y": [3, 4, 5]
+                }
+            }
+            command {}
+            output {
+                Array[Array[Int]] vals = values(nested)
+            }
+        }
+        """)
+        self.assertEqual(outputs["vals"], [[1, 2], [3, 4, 5]])
+
+        # Error: wrong arity (too few arguments)
+        self._test_task(R"""
+        version 1.2
+        task bad {
+            command {}
+            output {
+                Array[Int] x = values()
+            }
+        }
+        """, expected_exception=WDL.Error.WrongArity)
+
+        # Error: wrong arity (too many arguments)
+        self._test_task(R"""
+        version 1.2
+        task bad {
+            command {}
+            output {
+                Array[Int] x = values({"a": 1}, {"b": 2})
+            }
+        }
+        """, expected_exception=WDL.Error.WrongArity)
+
+        # Error: not available in WDL 1.1
+        self._test_task(R"""
+        version 1.1
+        task bad {
+            command {}
+            output {
+                Array[Int] x = values({"a": 1})
+            }
+        }
+        """, expected_exception=WDL.Error.NoSuchFunction)
+
+        # Error: not available in WDL 1.0
+        self._test_task(R"""
+        version 1.0
+        task bad {
+            command {}
+            output {
+                Array[Int] x = values({"a": 1})
+            }
+        }
+        """, expected_exception=WDL.Error.NoSuchFunction)
+
+        # Error: first argument not a map
+        self._test_task(R"""
+        version 1.2
+        task bad {
+            command {}
+            output {
+                Array[Int] x = values([1, 2, 3])
+            }
+        }
+        """, expected_exception=WDL.Error.StaticTypeMismatch)
+
     def test_map_pairs(self):
         outputs = self._test_task(R"""
         version development