hydra-python 0.17.4__tar.gz → 0.17.6__tar.gz

{hydra_python-0.17.4 → hydra_python-0.17.6}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: hydra-python
-Version: 0.17.4
+Version: 0.17.6
 Summary: Python support for Hydra
 Project-URL: Homepage, https://github.com/CategoricalData/hydra
 Project-URL: Repository, https://github.com/CategoricalData/hydra
@@ -9,7 +9,7 @@ License: Apache-2.0
 License-File: LICENSE
 License-File: NOTICE
 Requires-Python: >=3.12
-Requires-Dist: hydra-kernel==0.17.4
+Requires-Dist: hydra-kernel==0.17.6
 Description-Content-Type: text/markdown
 
 # Hydra-Python
@@ -398,7 +398,7 @@ of kwargs + explicit `field()`.
 ```python
 @hydra_element(my_module, type_=T.function(T.int32(), T.string()))
 def show_number(x):
-    return Strings.show_int32(x)
+    return Strings.print_int32(x)
 ```
 
 Idiomatic Python metadata mechanism. Risk: users may expect the

{hydra_python-0.17.4 → hydra_python-0.17.6}/README.md

@@ -384,7 +384,7 @@ of kwargs + explicit `field()`.
 ```python
 @hydra_element(my_module, type_=T.function(T.int32(), T.string()))
 def show_number(x):
-    return Strings.show_int32(x)
+    return Strings.print_int32(x)
 ```
 
 Idiomatic Python metadata mechanism. Risk: users may expect the

{hydra_python-0.17.4 → hydra_python-0.17.6}/build/main/digest.json

@@ -1,20 +1,20 @@
 {
   "digestFormatVersion": 2,
   "moduleFormatVersion": 1,
-  "generator": "2c0ecf5e44272577",
+  "generator": "3fcbb2c3eed9a625",
   "generation": {
-    "generatorId": "2c0ecf5e44272577",
+    "generatorId": "3fcbb2c3eed9a625",
     "mode": "published",
     "host": "python",
-    "hydraVersion": "0.17.3",
-    "revision": "39f38e98ce",
-    "timestamp": "2026-08-10T00:06:14Z"},
-  "selfHash": "979ad9fa2784665ae8639c0a37ac80ed296d12c8524c0766c21cd7a8802e2965",
-  "dependencyHashes": [{"key": "hydra-kernel", "value": "2af6a4dff2fbf02f4859ca5f0c222c44c9ab9ce5345d26abcf7c6e39f90b5bcb"}],
+    "hydraVersion": "0.17.5",
+    "revision": "b0b667ab7e",
+    "timestamp": "2026-08-30T21:12:52Z"},
+  "selfHash": "9d63be6fefd1f95d501eb1ca75f52604f6b5ef6a37d02fe79ac24ae4608433e9",
+  "dependencyHashes": [{"key": "hydra-kernel", "value": "21db6cd59e90695a747e6be08ce6759422f84c88efd511d09ecd00fae34e4c7a"}],
   "inputs": [
     {
       "key": "hydra.python.coder",
-      "value": {"kind": "other", "hash": "33c5deb31968c9c0d41834301852b38d617cdcf7453d0115b75e693c8683401a"}},
+      "value": {"kind": "other", "hash": "0f6f038ef11ca726af501d1483716d1d5adff54e3c03e9a1f2cb61875260f4f7"}},
     {
       "key": "hydra.python.environment",
       "value": {"kind": "other", "hash": "663b02271ddd4a6ad9ab8a2bdc152a64802a675a59280909f605d6dedcc4017e"}},
@@ -23,22 +23,22 @@
       "value": {"kind": "other", "hash": "78fb867a1d0fa6654f46f5d9fd72c2c5607d2934b7c7fbd5f5d830786b4ad91e"}},
     {
       "key": "hydra.python.names",
-      "value": {"kind": "other", "hash": "87bfa00de69547fcb4a14b69a56be98d3f612dcd52b76063153365c375ce91e4"}},
+      "value": {"kind": "other", "hash": "5bc2e53c63d41de79877fbe331aada2c7f43175b09d4245b7ac61cf8261b0ca3"}},
     {
       "key": "hydra.python.pyproject",
       "value": {"kind": "other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2"}},
     {
       "key": "hydra.python.serde",
-      "value": {"kind": "other", "hash": "9285fa0296e940da1de51a53465598455c46404851aefc2ce15220fc6ee7efc6"}},
+      "value": {"kind": "other", "hash": "8d35f12f8ef3aa33db2064a266d6c97a31e2c8675a6f77005cdb011b01597b8a"}},
     {
       "key": "hydra.python.syntax",
       "value": {"kind": "other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19"}},
     {
       "key": "hydra.python.testing",
-      "value": {"kind": "other", "hash": "a40b949c594c81f8925ba423a89e46964b2b1475d44a486aa07c792c2c7f807b"}},
+      "value": {"kind": "other", "hash": "52629d9f9aba82fbae03c9250b42d962eea9b2cdfde77c02466282ab95c51b5b"}},
     {
       "key": "hydra.python.utils",
-      "value": {"kind": "other", "hash": "b026355e1174d4573e14ee1a932a17e1d28cef3559f2f85a330d279b543598a3"}},
+      "value": {"kind": "other", "hash": "dee99428120e9ed4b418ca438480434cc967a13ac1d918385d9fb2b1d76afeb7"}},
     {
       "key": "jsonContent:hydra/dsl/python/environment.json",
       "value": {"kind": "other", "hash": "684965cea67ad57d492b50f408c6575f679b073c5de5e76826fb0941da86ec21"}},
@@ -53,31 +53,31 @@
       "value": {"kind": "other", "hash": "7a3b84d522c420db0db03a77f9e54635b33544f73eb49ed67cdc3a4d5dac04ae"}},
     {
       "key": "jsonContent:hydra/python/coder.json",
-      "value": {"kind": "other", "hash": "ec4263eccf7a8dd826d44cea6aa4fc112cf7a6eda6c4d1ffd54cda0387e60729"}},
+      "value": {"kind": "other", "hash": "ebc4bdd1c21d9af2f90f408414d22313b1d1c2750f6c792c2ebed8ea9793336e"}},
     {
       "key": "jsonContent:hydra/python/environment.json",
-      "value": {"kind": "other", "hash": "889380dd3664c763437475b2e5146b38f865f4a20a308332633a33a4d038fce1"}},
+      "value": {"kind": "other", "hash": "27b358d874d0de0b7cd8b2ded9194c6ae0ac30069f26eb6d658e768ff9414825"}},
     {
       "key": "jsonContent:hydra/python/language.json",
-      "value": {"kind": "other", "hash": "221e68d68030945db181fdd079be4ff619cb4cd1ad5d4b72b4e70f2aa1bd5230"}},
+      "value": {"kind": "other", "hash": "f5f154079126771b9af2a4df8e53a4e9c75bb44ee3f154f4f0ce762744785b88"}},
     {
       "key": "jsonContent:hydra/python/names.json",
-      "value": {"kind": "other", "hash": "7af58464067c990f8acdeb9399a217ee8b345e712927619b163eb18a1fd18a4a"}},
+      "value": {"kind": "other", "hash": "6997d344c45c2a774b8e5d354f67c06358a7f06c91317d6100b25573cb11b7ab"}},
     {
       "key": "jsonContent:hydra/python/pyproject.json",
-      "value": {"kind": "other", "hash": "c94de46f1615e6e82d2f706d01ef04293373f6241a9a42882bb394d51b4f7f53"}},
+      "value": {"kind": "other", "hash": "eacea3b3d38c4890c693a012d3cd71f02e96c25c131cef8a0aa90a30442f8a7f"}},
     {
       "key": "jsonContent:hydra/python/serde.json",
-      "value": {"kind": "other", "hash": "648d34f63d2336972d5e0a59d4871332a07bd35c88eb38c28236e16a7fd48601"}},
+      "value": {"kind": "other", "hash": "1428720f350e9f76ab293116b4ebf7d384d8e78dc6b62f5220d3ef30c26f9585"}},
     {
       "key": "jsonContent:hydra/python/syntax.json",
-      "value": {"kind": "other", "hash": "8dc3a26ac927fa338b273c9deee6317906977a2deec4c2df1e44ff0bbe0a64cd"}},
+      "value": {"kind": "other", "hash": "a6ddfec03413c23fd3830501c58eb4350b046b6b654faa51f49ffe9aab5b995c"}},
     {
       "key": "jsonContent:hydra/python/testing.json",
-      "value": {"kind": "other", "hash": "9c75b534004194396935b1dd3331bae4d8d5cbb31c3959fa3794dda00960c09a"}},
+      "value": {"kind": "other", "hash": "eb35348cdf17021c1480d2b3ec001d4e5326f7d5b934325cb7294553d2ff64d2"}},
     {
       "key": "jsonContent:hydra/python/utils.json",
-      "value": {"kind": "other", "hash": "9fe5863fa3b3fb7b87b97041336ac5ff947f69e9bc7a8c2667f0bfc217bed724"}},
+      "value": {"kind": "other", "hash": "cae0b4fac77fdae05b5592f671b9c58f84d3374f94acbe3d49f27962096d1a5e"}},
     {
       "key": "jsonContent:manifest.json",
       "value": {"kind": "other", "hash": "3f94b521766d042381d7bee84596308ea4e35c7e8fb45f8fd8338a8dbe27a0ac"}}],
@@ -96,7 +96,7 @@
       "value": {"kind": "targetFile", "hash": "3fed9996a3f875a53675b6c8620884949adf7d155b0e68cacfba9007d5d07b29"}},
     {
       "key": "hydra/python/coder.py",
-      "value": {"kind": "targetFile", "hash": "5dc0e92942be490ab049f187918a038b39c40ded8975445966c626eae6f32753"}},
+      "value": {"kind": "targetFile", "hash": "d7e39526e1f7802a5af9d6ea57596766be03b9e16505095c57597f8903683461"}},
     {
       "key": "hydra/python/environment.py",
       "value": {"kind": "targetFile", "hash": "1036eb9d285ba3e98c85095820f2e77900334340c9f0223fd4dfd6b3e847f4df"}},
@@ -105,19 +105,19 @@
       "value": {"kind": "targetFile", "hash": "7ea0c3a6015ec1de92aebeed0963c1af9f3b70c8d57815e477c528c795383604"}},
     {
       "key": "hydra/python/names.py",
-      "value": {"kind": "targetFile", "hash": "13c7f477a13848ed7636bf773aac098599466964c2db5c35472f53b1152b05a2"}},
+      "value": {"kind": "targetFile", "hash": "3e8498f205a99ebfaa570a44ccac515b69ced9d7f3669a32f74d4d05d48204b6"}},
     {
       "key": "hydra/python/pyproject.py",
       "value": {"kind": "targetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7"}},
     {
       "key": "hydra/python/serde.py",
-      "value": {"kind": "targetFile", "hash": "43864d35b843e14c2ee78fc5ee22e88f61d049ace6d9e951d34dbdfa242662f9"}},
+      "value": {"kind": "targetFile", "hash": "1f36ea2dc8c50df72abe464cd395689c71f0af70a9f78e68d26013f9b436c383"}},
     {
       "key": "hydra/python/syntax.py",
       "value": {"kind": "targetFile", "hash": "24a72af882b47d80cc930f16f51a3e9c1a71c9d8da47a921829f40e847459fca"}},
     {
       "key": "hydra/python/testing.py",
-      "value": {"kind": "targetFile", "hash": "069c706253e0c41695c8becd42c27c84b7f6ac54b14be14975757ff09416ba92"}},
+      "value": {"kind": "targetFile", "hash": "5c8f352d976eeeebf14974e9df208b53c8db59810fdbd76e6454868627122635"}},
     {
       "key": "hydra/python/utils.py",
-      "value": {"kind": "targetFile", "hash": "7264b5ca536314e0523ccf46f069ab06dea099d68b2c3459d58ab2c989dc51c6"}}]}
+      "value": {"kind": "targetFile", "hash": "2cfa00436ebc27925f9b45380792aa817921bb7dbaf88e0c17cfb51bbe3c82fc"}}]}

{hydra_python-0.17.4 → hydra_python-0.17.6}/pyproject.toml

@@ -13,7 +13,7 @@
 
 [project]
 name = "hydra-python"
-version = "0.17.4"
+version = "0.17.6"
 description = "Python support for Hydra"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -22,7 +22,7 @@ authors = [
     { name = "Joshua Shinavier", email = "josh@fortytwo.net" },
 ]
 dependencies = [
-    "hydra-kernel == 0.17.4",
+    "hydra-kernel == 0.17.6",
 ]
 
 [project.urls]

{hydra_python-0.17.4 → hydra_python-0.17.6}/src/main/python/hydra/python/coder.py

@@ -339,11 +339,11 @@ def deduplicate_case_variables(cases_: Sequence[hydra.core.CaseAlternative]) ->
                 v = lam.parameter
                 mdom = lam.domain
                 body = lam.body
-                return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(v, count_by_name()),
+                return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(v, count_by_name()),
                 (lambda : (hydra.overlay.python.lib.maps.insert(v, 1, count_by_name()), hydra.overlay.python.lib.lists.cons(field, done()))),
                 (lambda count: (
                   count2 := Lazy((lambda : hydra.overlay.python.lib.math.add(count, 1))),
-                  v2 := Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.concat2(v.value, hydra.overlay.python.lib.literals.show_int32(count2.get()))))),
+                  v2 := Lazy((lambda : hydra.core.Name(hydra.overlay.python.lib.strings.concat2(v.value, hydra.overlay.python.lib.literals.print_int32(count2.get()))))),
                   new_body := Lazy((lambda : hydra.reduction.alpha_convert(v, v2.get(), body))),
                   new_lam := Lazy((lambda : hydra.core.Lambda(v2.get(), mdom, new_body.get()))),
                   new_term := Lazy((lambda : cast(hydra.core.Term, hydra.core.TermLambda(new_lam.get())))),
@@ -444,7 +444,7 @@ def encode_float_value_py_special_float(value: str) -> hydra.python.syntax.Expre
     ConsList.of(hydra.python.utils.single_quoted_string(value)))
 
 def encode_float_value_encode_float32(v: float) -> Either[T0, hydra.python.syntax.Expression]:
-    s = Lazy((lambda : hydra.overlay.python.lib.literals.show_float32(v)))
+    s = Lazy((lambda : hydra.overlay.python.lib.literals.print_float32(v)))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "NaN"),
     (lambda : Right(encode_float_value_py_special_float("nan"))),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "Infinity"),
@@ -455,7 +455,7 @@ def encode_float_value_encode_float32(v: float) -> Either[T0, hydra.python.synta
     hydra.python.syntax.AtomNumber(cast(hydra.python.syntax.Number, hydra.python.syntax.NumberFloat(hydra.overlay.python.lib.literals.float32_to_float64(v)))))))))))))
 
 def encode_float_value_encode_float64(v: float) -> Either[T0, hydra.python.syntax.Expression]:
-    s = Lazy((lambda : hydra.overlay.python.lib.literals.show_float64(v)))
+    s = Lazy((lambda : hydra.overlay.python.lib.literals.print_float64(v)))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "NaN"),
     (lambda : Right(encode_float_value_py_special_float("nan"))),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(s(), "Infinity"),
@@ -538,7 +538,7 @@ def encode_literal(lit: hydra.core.Literal) -> Either[T0, hydra.python.syntax.Ex
 
         case hydra.core.LiteralDecimal(value=d):
             return Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Decimal")),
-            ConsList.of(hydra.python.utils.single_quoted_string(hydra.overlay.python.lib.literals.show_decimal(d)))))
+            ConsList.of(hydra.python.utils.single_quoted_string(hydra.overlay.python.lib.literals.print_decimal(d)))))
 
         case hydra.core.LiteralFloat(value=f):
             return encode_float_value(f)
@@ -891,8 +891,8 @@ def lazy_dot_get(expr: hydra.python.syntax.Expression) -> hydra.python.syntax.Ex
 def make_simple_lambda(arity: int, lhs: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
     r"""Wrap a bare reference to a polymorphic function in an uncurried lambda."""
 
-    args = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
-    hydra.overlay.python.lib.math.range_(1, arity))))
+    args = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.print_int32(i)))),
+    hydra.overlay.python.lib.math.range_(1, hydra.overlay.python.lib.math.add(arity, 1)))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(arity, 0),
     (lambda : lhs),
     (lambda : cast(hydra.python.syntax.Expression,
@@ -945,10 +945,10 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     as_function_call = Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name(True, hydra.util.CaseConvention.LOWER_SNAKE, env, name)),
     args)))
     as_lazy_call = Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(lazy_dot_get(as_variable())), args)))
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(args)),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(args)),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, inline_vars),
     (lambda : Right(as_lazy_call())),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_primitive(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_primitive(g(), name),
     (lambda : Right(as_function_call())),
     (lambda prim: (
       prim_arity := Lazy((lambda : hydra.arity.primitive_arity(prim))),
@@ -957,8 +957,8 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       (lambda : (
         num_remaining := Lazy((lambda : hydra.overlay.python.lib.math.sub(prim_arity.get(), hydra.overlay.python.lib.lists.length(args)))),
         (
-          remaining_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.show_int32(i)))),
-          hydra.overlay.python.lib.math.range_(1, num_remaining.get())))),
+          remaining_params := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda i: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2("x", hydra.overlay.python.lib.literals.print_int32(i)))),
+          hydra.overlay.python.lib.math.range_(1, hydra.overlay.python.lib.math.add(num_remaining.get(), 1))))),
           (
             remaining_exprs := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda n: cast(hydra.python.syntax.Expression,
             hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction(ConsList.of(hydra.python.syntax.Conjunction(ConsList.of(cast(hydra.python.syntax.Inversion,
@@ -981,27 +981,27 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
                 full_call := Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name(True, hydra.util.CaseConvention.LOWER_SNAKE, env, name)),
                 all_args.get()))),
                 Right(make_uncurried_lambda(remaining_params.get(), full_call.get())))[1])[1])[1])[1])[1])))[1]))))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(m_typ(),
+    (lambda : hydra.overlay.python.lib.optionals.match(m_typ(),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, tc_lambda_vars),
     (lambda : Right(as_variable())),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, inline_vars),
     (lambda : Right(lazy_dot_get(as_variable()))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_primitive(g(), name),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(g(), name),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, tc_metadata),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_primitive(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, tc_metadata),
     (lambda : Left(cast(hydra.errors.Error,
     hydra.errors.ErrorOther(hydra.errors.OtherError(hydra.overlay.python.lib.strings.concat2("Unknown variable: ", name.value)))))),
     (lambda _: Right(as_function_call())))),
     (lambda el: (
       el_trivial1 := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
-      hydra.overlay.python.lib.optionals.cases(el.type_scheme,
+      hydra.overlay.python.lib.optionals.match(el.type_scheme,
       (lambda : Right(as_variable())),
       (lambda ts: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0),
       hydra.predicates.is_complex_binding(tc, el)),
       hydra.overlay.python.lib.logic.not_(el_trivial1.get())),
       (lambda : Right(as_function_call())),
       (lambda : (
-        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(ts.variables)),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(ts.variables)),
         (lambda : make_simple_lambda(hydra.arity.type_arity(ts.body), as_variable())),
         (lambda : as_variable())))),
         Right(as_function_ref.get()))[1])))))[1]))),
@@ -1012,7 +1012,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       (lambda : (
         ts := Lazy((lambda : hydra.scoping.term_signature_to_type_scheme(prim.definition.signature))),
         (
-          as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(ts.get().variables)),
+          as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(ts.get().variables)),
           (lambda : make_simple_lambda(hydra.arity.type_arity(ts.get().body), as_variable())),
           (lambda : as_variable())))),
           Right(as_function_ref.get()))[1])[1])))[1]))))))),
@@ -1022,25 +1022,25 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
     (lambda : (
       unwrapped := Lazy((lambda : lazy_dot_get(as_variable()))),
       (
-        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ))),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
         (lambda : make_simple_lambda(hydra.arity.type_arity(typ), unwrapped.get())),
         (lambda : unwrapped.get())))),
         Right(as_function_ref.get()))[1])[1]),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.maps.member(name, tc_metadata)),
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(g(), name),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(g(), name),
     (lambda : (
-      as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ))),
+      as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
       (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
       (lambda : as_variable())))),
       Right(as_function_ref.get()))[1]),
     (lambda el: (
       el_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(el.term))),
-      hydra.overlay.python.lib.optionals.cases(el.type_scheme,
+      hydra.overlay.python.lib.optionals.match(el.type_scheme,
       (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_arity(typ), 0),
       hydra.overlay.python.lib.logic.not_(el_trivial.get())),
       (lambda : Right(as_function_call())),
       (lambda : (
-        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ))),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
         (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
         (lambda : as_variable())))),
         Right(as_function_ref.get()))[1]))),
@@ -1048,14 +1048,14 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       hydra.overlay.python.lib.logic.not_(el_trivial.get())),
       (lambda : Right(as_function_call())),
       (lambda : (
-        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ))),
+        as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
         (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
         (lambda : as_variable())))),
         Right(as_function_ref.get()))[1])))))[1]))),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_arity(typ), 0), hydra.predicates.is_complex_variable(tc, name)),
     (lambda : Right(as_function_call())),
     (lambda : (
-      as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ))),
+      as_function_ref := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ))),
       (lambda : make_simple_lambda(hydra.arity.type_arity(typ), as_variable())),
       (lambda : as_variable())))),
       Right(as_function_ref.get()))[1]))))))))))))
@@ -1128,7 +1128,7 @@ v3: Callable[[hydra.python.environment.PythonEnvironment], T0]) -> T0:
 def lazy_flags_for_primitive(g: hydra.graph.Graph, name: hydra.core.Name) -> Sequence[bool]:
     r"""Per-parameter isLazy flags of a primitive (by name), or empty if not a primitive. Single source of truth for which arguments coders thunk; replaces hard-coded name tables (issue #391)."""
 
-    return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, g.primitives),
+    return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, g.primitives),
     (lambda : ConsList.of()),
     (lambda prim: (
       def0 := Lazy((lambda : prim.definition)),
@@ -1164,9 +1164,9 @@ def term_arity_with_primitives(graph: hydra.graph.Graph, term: hydra.core.Term)
             return 1
 
         case hydra.core.TermVariable(value=name):
-            return hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(graph, name),
+            return hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(graph, name),
             (lambda : 0),
-            (lambda el: hydra.overlay.python.lib.optionals.cases(el.type_scheme, (lambda : hydra.arity.term_arity(el.term)), (lambda ts: hydra.arity.type_scheme_arity(ts)))))
+            (lambda el: hydra.overlay.python.lib.optionals.match(el.type_scheme, (lambda : hydra.arity.term_arity(el.term)), (lambda ts: hydra.arity.type_scheme_arity(ts)))))
 
         case _:
             return 0
@@ -1205,7 +1205,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
     hydra.overlay.python.lib.lists.head(hargs))))
     rest_args = Lazy((lambda : hydra.overlay.python.lib.lists.drop(1, hargs)))
     def with_rest(e: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
-        return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(rest_args()),
+        return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(rest_args()),
         (lambda : e),
         (lambda : hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(e), rest_args())))
     default_case = Lazy((lambda : hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, env, False, fun),
@@ -1222,7 +1222,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
         case hydra.core.TermUnwrap():
             value_expr = Lazy((lambda : hydra.python.utils.project_from_expression(first_arg(), hydra.python.syntax.Name("value"))))
             all_args = Lazy((lambda : hydra.overlay.python.lib.lists.concat2(rest_args(), rargs)))
-            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(all_args()),
+            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(all_args()),
             (lambda : Right((value_expr(), ConsList.of()))),
             (lambda : Right((
               hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(value_expr()), all_args()),
@@ -1236,17 +1236,17 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
             g = Lazy((lambda : python_environment_get_graph(env)))
             all_args = Lazy((lambda : hydra.overlay.python.lib.lists.concat2(hargs, rargs)))
             inline_vars = env.inline_variables
-            return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, g().primitives),
-            (lambda : hydra.overlay.python.lib.optionals.cases(hydra.lexical.lookup_binding(g(), name),
+            return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, g().primitives),
+            (lambda : hydra.overlay.python.lib.optionals.match(hydra.lexical.lookup_binding(g(), name),
             (lambda : hydra.overlay.python.lib.eithers.bind(encode_variable(cx, env, name, hargs), (lambda expr: Right((expr, rargs))))),
-            (lambda el: hydra.overlay.python.lib.optionals.cases(el.type_scheme,
+            (lambda el: hydra.overlay.python.lib.optionals.match(el.type_scheme,
             (lambda : hydra.overlay.python.lib.eithers.bind(encode_variable(cx, env, name, hargs), (lambda expr: Right((expr, rargs))))),
             (lambda ts: (
               el_arity := Lazy((lambda : hydra.arity.type_scheme_arity(ts))),
               consume_count := Lazy((lambda : hydra.overlay.python.lib.ordering.min(el_arity.get(), hydra.overlay.python.lib.lists.length(all_args())))),
               consumed_args := Lazy((lambda : hydra.overlay.python.lib.lists.take(consume_count.get(), all_args()))),
               remaining_args := Lazy((lambda : hydra.overlay.python.lib.lists.drop(consume_count.get(), all_args()))),
-              hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(consumed_args.get()),
+              hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(consumed_args.get()),
               (lambda : hydra.overlay.python.lib.eithers.bind(encode_variable(cx, env, name, ConsList.of()), (lambda expr: Right((expr, rargs))))),
               (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.member(name, inline_vars),
               (lambda : Right((
@@ -1282,7 +1282,7 @@ binding: hydra.core.Binding) -> Either[hydra.errors.Error, hydra.python.syntax.N
       is_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(term))),
       needs_thunk := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(is_trivial.get(),
       (lambda : False),
-      (lambda : hydra.overlay.python.lib.optionals.cases(mts,
+      (lambda : hydra.overlay.python.lib.optionals.match(mts,
       (lambda : hydra.overlay.python.lib.logic.and_(allow_thunking, hydra.overlay.python.lib.logic.or_(is_complex_var.get(), term_is_complex.get()))),
       (lambda ts: hydra.overlay.python.lib.logic.and_(allow_thunking,
       hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.arity.type_scheme_arity(ts), 0),
@@ -1350,7 +1350,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
               (lambda pbody: (
                 pparams := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda v1: hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, inner_env.get(), v1)),
                 params.get()))),
-                hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(bindings.get()),
+                hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(bindings.get()),
                 (lambda : Right(make_uncurried_lambda(pparams.get(), pbody))),
                 (lambda : hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda v1: encode_binding_as_assignment(cx, False, inner_env.get(), v1)), bindings.get()),
                 (lambda pbinding_exprs: (
@@ -1408,7 +1408,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
         case hydra.core.TermLet(value=lt):
             bindings = lt.bindings
             body = lt.body
-            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(bindings),
+            return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(bindings),
             (lambda : encode_term_inline(cx, env, False, body)),
             (lambda : with_let_inline(env,
             lt,
@@ -1451,7 +1451,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
               Right(hydra.python.utils.function_call(hydra.python.utils.py_expression_to_py_primary(pmap_of_entries.get()), tuple_pairs)))[1]))
 
         case hydra.core.TermOptional(value=mt):
-            return hydra.overlay.python.lib.optionals.cases(mt,
+            return hydra.overlay.python.lib.optionals.match(mt,
             (lambda : Right(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("None_")), ConsList.of()))),
             (lambda t1: hydra.overlay.python.lib.eithers.bind(encode(t1),
             (lambda pyexp: with_cast(hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("Given")), ConsList.of(pyexp)))))))
@@ -1495,7 +1495,7 @@ def encode_term_inline(cx: hydra.typing.InferenceContext, env: hydra.python.envi
             (lambda : (
               fname := Lazy((lambda : field.name)),
               (
-                is_unit_variant := Lazy((lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.find((lambda ft: hydra.overlay.python.lib.equality.equal(ft.name.value, fname.get().value)), rt),
+                is_unit_variant := Lazy((lambda : hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.lists.find((lambda ft: hydra.overlay.python.lib.equality.equal(ft.name.value, fname.get().value)), rt),
                 (lambda : False),
                 (lambda ft: hydra.predicates.is_unit_type(hydra.strip.deannotate_type(ft.type)))))),
                 hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.or_(hydra.predicates.is_unit_term(field.term), is_unit_variant.get()),
@@ -1535,7 +1535,7 @@ py_arg: hydra.python.syntax.Expression) -> Either[hydra.errors.Error, hydra.pyth
       is_enum := Lazy((lambda : hydra.predicates.is_enum_row_type(rt))),
       value_expr := Lazy((lambda : hydra.python.utils.project_from_expression(py_arg, hydra.python.syntax.Name("value")))),
       isinstance_primary := Lazy((lambda : hydra.python.utils.py_name_to_py_primary(hydra.python.syntax.Name("isinstance")))),
-      hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mdefault,
+      hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.match(mdefault,
       (lambda : Right(unsupported_expression("no matching case in inline union elimination"))),
       (lambda dflt: encode_term_inline(cx, env, False, dflt))),
       (lambda py_default: (
@@ -1580,7 +1580,7 @@ mdflt: Optional[T0],
 tname: hydra.core.Name) -> Either[T1, Sequence[hydra.python.syntax.CaseBlock]]:
     r"""Encode the default (wildcard) case block for a match statement."""
 
-    return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mdflt,
+    return hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.match(mdflt,
     (lambda : Right(hydra.overlay.python.lib.logic.if_else(is_full,
     (lambda : hydra.python.utils.raise_assertion_error("Unreachable: all variants handled")),
     (lambda : hydra.python.utils.raise_type_error(hydra.overlay.python.lib.strings.concat2("Unsupported ", hydra.names.local_name_of(tname))))))),
@@ -1754,7 +1754,7 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
     term1 = binding.term
     mts = binding.type_scheme
     fname = Lazy((lambda : hydra.python.names.encode_name(True, hydra.util.CaseConvention.LOWER_SNAKE, env, name1)))
-    return hydra.overlay.python.lib.optionals.cases(mts,
+    return hydra.overlay.python.lib.optionals.match(mts,
     (lambda : (
       gathered := Lazy((lambda : gather_lambdas(term1))),
       (
@@ -1763,12 +1763,12 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
           inner_body := Lazy((lambda : hydra.overlay.python.lib.pairs.second(gathered.get()))),
           (
             mcsa := Lazy((lambda : is_case_statement_application(inner_body.get()))),
-            hydra.overlay.python.lib.optionals.cases(mcsa.get(),
+            hydra.overlay.python.lib.optionals.match(mcsa.get(),
             (lambda : (
               mcs := Lazy((lambda : extract_case_elimination(term1))),
-              hydra.overlay.python.lib.optionals.cases(mcs.get(),
+              hydra.overlay.python.lib.optionals.match(mcs.get(),
               (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env, term1),
-              (lambda stmts: hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.head(stmts),
+              (lambda stmts: hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.lists.head(stmts),
               (lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError("encodeTermMultiline returned no statements"))))),
               (lambda x: Right(x)))))),
               (lambda cs: (
@@ -1799,12 +1799,12 @@ def encode_binding_as(cx: hydra.typing.InferenceContext, env: hydra.python.envir
                     Right(cast(hydra.python.syntax.Statement,
                     hydra.python.syntax.StatementCompound(cast(hydra.python.syntax.CompoundStatement,
                     hydra.python.syntax.CompoundStatementFunction(hydra.python.syntax.FunctionDefinition(None_(), func_def_raw.get())))))))[5])))))[5])))[3])))[1]),
-            (lambda csa: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(lambda_params.get()),
+            (lambda csa: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(lambda_params.get()),
             (lambda : (
               mcs := Lazy((lambda : extract_case_elimination(term1))),
-              hydra.overlay.python.lib.optionals.cases(mcs.get(),
+              hydra.overlay.python.lib.optionals.match(mcs.get(),
               (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env, term1),
-              (lambda stmts: hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.head(stmts),
+              (lambda stmts: hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.lists.head(stmts),
               (lambda : Left(cast(hydra.errors.Error, hydra.errors.ErrorOther(hydra.errors.OtherError("encodeTermMultiline returned no statements"))))),
               (lambda x: Right(x)))))),
               (lambda cs: (
@@ -1909,7 +1909,7 @@ comment: Optional[str]) -> Either[hydra.errors.Error, hydra.python.syntax.Statem
       is_complex := Lazy((lambda : hydra.predicates.is_complex_binding(tc.get(), binding.get()))),
       is_trivial := Lazy((lambda : hydra.predicates.is_trivial_term(term))),
       hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(is_complex.get(), hydra.overlay.python.lib.logic.not_(is_trivial.get())),
-      (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(top_level), hydra.overlay.python.lib.lists.null(params.get())),
+      (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(top_level), hydra.overlay.python.lib.lists.is_empty(params.get())),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, env2.get(), False, term),
       (lambda body_expr: (
         py_name := Lazy((lambda : hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env2.get(), name))),
@@ -1931,7 +1931,7 @@ def encode_term_multiline(cx: hydra.typing.InferenceContext, env: hydra.python.e
       bindings := Lazy((lambda : fs.bindings)),
       inner_body := Lazy((lambda : fs.body)),
       env2 := Lazy((lambda : fs.environment)),
-      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(bindings.get()),
+      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(bindings.get()),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_inline(cx, env, False, term), (lambda expr: Right(ConsList.of(hydra.python.utils.return_single(expr)))))),
       (lambda : hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.eithers.map_list((lambda v1: encode_binding_as(cx, env2.get(), v1)), bindings.get()),
       (lambda binding_stmts: hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env2.get(), inner_body.get()),
@@ -1988,7 +1988,7 @@ prefixes: Sequence[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error,
     (lambda py_args: (
       py_params := Lazy((lambda : cast(hydra.python.syntax.Parameters,
       hydra.python.syntax.ParametersParamNoDefault(hydra.python.syntax.ParamNoDefaultParameters(py_args, ConsList.of(), None_()))))),
-      is_t_c_o := Lazy((lambda : hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(args)),
+      is_t_c_o := Lazy((lambda : hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(args)),
       hydra.analysis.is_self_tail_recursive(name, body)))),
       hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.logic.if_else(is_t_c_o.get(),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline_t_c_o(cx, env, name, args, body),
@@ -2002,14 +2002,14 @@ prefixes: Sequence[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error,
         Right(hydra.python.utils.indented_block(comment, ConsList.of(ConsList.of(while_stmt.get())))))[3]))),
       (lambda : hydra.overlay.python.lib.eithers.bind(encode_term_multiline(cx, env, body),
       (lambda stmts: Right(hydra.python.utils.indented_block(comment, ConsList.of(hydra.overlay.python.lib.lists.concat2(prefixes, stmts)))))))),
-      (lambda block: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.cases(mcod,
+      (lambda block: hydra.overlay.python.lib.eithers.bind(hydra.overlay.python.lib.optionals.match(mcod,
       (lambda : Right(None_())),
       (lambda cod: hydra.overlay.python.lib.eithers.bind(encode_type(env, cod), (lambda pytyp: Right(Given(pytyp)))))),
       (lambda mreturn_type: (
         py_tparams := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(use_inline_type_params(),
         (lambda : hydra.overlay.python.lib.lists.map((lambda arg_: hydra.python.utils.py_name_to_py_type_parameter(hydra.python.names.encode_type_variable(arg_))), tparams)),
         (lambda : ConsList.of())))),
-        is_thunk := Lazy((lambda : hydra.overlay.python.lib.lists.null(args))),
+        is_thunk := Lazy((lambda : hydra.overlay.python.lib.lists.is_empty(args))),
         m_decorators := Lazy((lambda : hydra.overlay.python.lib.logic.if_else(is_thunk.get(), (lambda : Given(hydra.python.syntax.Decorators(ConsList.of(lru_cache_decorator())))), (lambda : None_())))),
         py_name := Lazy((lambda : hydra.python.names.encode_name(False, hydra.util.CaseConvention.LOWER_SNAKE, env, name))),
         Right(cast(hydra.python.syntax.Statement,
@@ -2050,7 +2050,7 @@ def encode_name_constants(env: hydra.python.environment.PythonEnvironment, name:
 def generic_arg(tparam_list: Sequence[hydra.core.Name]) -> Optional[hydra.python.syntax.Expression]:
     r"""Create Generic[...] argument expression for class definition."""
 
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparam_list),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparam_list),
     (lambda : None_()),
     (lambda : Given(hydra.python.utils.py_primary_to_py_expression(hydra.python.utils.primary_with_expression_slices(cast(hydra.python.syntax.Primary,
     hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomName(hydra.python.syntax.Name("Generic"))))),
@@ -2205,7 +2205,7 @@ comment: Optional[str]) -> Either[hydra.errors.Error, hydra.python.syntax.Statem
       bound_vars := Lazy((lambda : env.bound_type_variables)),
       tparam_list := Lazy((lambda : hydra.overlay.python.lib.pairs.first(bound_vars.get()))),
       m_generic_arg := Lazy((lambda : generic_arg(tparam_list.get()))),
-      args := Lazy((lambda : hydra.overlay.python.lib.optionals.cases(m_generic_arg.get(), (lambda : None_()), (lambda a: Given(hydra.python.utils.py_expressions_to_py_args(ConsList.of(a))))))),
+      args := Lazy((lambda : hydra.overlay.python.lib.optionals.match(m_generic_arg.get(), (lambda : None_()), (lambda a: Given(hydra.python.utils.py_expressions_to_py_args(ConsList.of(a))))))),
       decs := Lazy((lambda : Given(hydra.python.syntax.Decorators(ConsList.of(dataclass_decorator()))))),
       py_name := Lazy((lambda : hydra.python.names.encode_name(False, hydra.util.CaseConvention.PASCAL, env, name))),
       no_type_params := Lazy((lambda : ConsList.of())),
@@ -2253,7 +2253,7 @@ def encode_enum_value_assignment(cx: T0, env: hydra.python.environment.PythonEnv
       py_value := Lazy((lambda : hydra.python.utils.function_call(hydra.python.utils.py_name_to_py_primary(hydra.python.names.encode_name(True, hydra.util.CaseConvention.PASCAL, env, hydra.core.Name("hydra.core.Name"))),
       ConsList.of(hydra.python.utils.double_quoted_string(fname_str.get()))))),
       assign_stmt := Lazy((lambda : hydra.python.utils.assignment_statement(py_name.get(), py_value.get()))),
-      Right(hydra.overlay.python.lib.optionals.cases(mcomment,
+      Right(hydra.overlay.python.lib.optionals.match(mcomment,
       (lambda : ConsList.of(assign_stmt.get())),
       (lambda c: ConsList.of(assign_stmt.get(), hydra.python.utils.py_expression_to_py_statement(hydra.python.utils.triple_quoted_string(c)))))))[4]))
 
@@ -2261,7 +2261,7 @@ def encode_type_quoted(env: hydra.python.environment.PythonEnvironment, typ: hyd
     r"""Encode a type to a Python expression, quoting if the type has free variables."""
 
     return hydra.overlay.python.lib.eithers.bind(encode_type(env, typ),
-    (lambda pytype: Right(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.null(hydra.variables.free_variables_in_type(typ)),
+    (lambda pytype: Right(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.sets.is_empty(hydra.variables.free_variables_in_type(typ)),
     (lambda : pytype),
     (lambda : hydra.python.utils.double_quoted_string(hydra.serialization.print_expr(hydra.python.serde.expression_to_expr(pytype))))))))
 
@@ -2309,7 +2309,7 @@ def encode_union_field_alt(env: hydra.python.environment.PythonEnvironment, unio
     tparam_names = Lazy((lambda : find_type_params(env, ftype)))
     tparams = Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda x1: hydra.python.names.encode_type_variable(x1)), tparam_names())))
     name_prim = Lazy((lambda : hydra.python.utils.py_name_to_py_primary(hydra.python.names.variant_name(False, env, union_name, fname))))
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams()),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparams()),
     (lambda : name_prim()),
     (lambda : (
       tparam_exprs := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda x1: hydra.python.utils.py_name_to_py_expression(x1)), tparams()))),
@@ -2447,8 +2447,10 @@ def encode_definition(cx: hydra.typing.InferenceContext, env: hydra.python.envir
         case hydra.packaging.DefinitionTerm(value=td):
             name = td.name
             term = td.body
-            typ = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(td.signature,
-            (lambda : hydra.core.TypeScheme(ConsList.of(), cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit"))), None_())),
+            typ = Lazy((lambda : hydra.overlay.python.lib.optionals.match(td.signature,
+            (lambda : hydra.core.TypeScheme(ConsList.of(),
+            cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit"))),
+            hydra.overlay.python.lib.maps.empty())),
             (lambda sig: hydra.scoping.term_signature_to_type_scheme(sig)))))
             return hydra.overlay.python.lib.eithers.bind(hydra.annotations.get_term_description(cx, python_environment_get_graph(env), term),
             (lambda comment: (
@@ -2818,7 +2820,7 @@ def extend_meta_for_type(top_level: bool, is_term_annot: bool, typ: hydra.core.T
         case hydra.core.TypeUnion(value=rt):
             return hydra.overlay.python.lib.logic.if_else(hydra.predicates.is_enum_row_type(rt),
             (lambda : set_meta_uses_enum(meta_with_subtypes(), True)),
-            (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(rt)),
+            (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(rt)),
             (lambda : set_meta_uses_node(meta_with_subtypes(), True)),
             (lambda : meta_with_subtypes()))))
 
@@ -2836,7 +2838,7 @@ def extend_meta_for_type(top_level: bool, is_term_annot: bool, typ: hydra.core.T
 
         case hydra.core.TypeRecord(value=rt2):
             has_annotated = Lazy((lambda : hydra.overlay.python.lib.lists.foldl((lambda b, ft: hydra.overlay.python.lib.logic.or_(b, hydra.annotations.has_type_description(ft.type))), False, rt2)))
-            meta1 = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(rt2),
+            meta1 = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(rt2),
             (lambda : meta_with_subtypes()),
             (lambda : set_meta_uses_dataclass(meta_with_subtypes(), True)))))
             return hydra.overlay.python.lib.logic.if_else(has_annotated(), (lambda : set_meta_uses_annotated(meta1(), True)), (lambda : meta1()))
@@ -2989,14 +2991,14 @@ def extend_meta_for_term(top_level: bool, meta0: hydra.python.environment.Python
                 return hydra.overlay.python.lib.eithers.either((lambda _: set_meta_uses_left(meta_with_cast(), True)), (lambda _: set_meta_uses_right(meta_with_cast(), True)), e)
 
             case hydra.core.TermLambda(value=lam):
-                return hydra.overlay.python.lib.optionals.cases(lam.domain,
+                return hydra.overlay.python.lib.optionals.match(lam.domain,
                 (lambda : meta),
                 (lambda dom: hydra.overlay.python.lib.logic.if_else(top_level, (lambda : extend_meta_for_type(True, False, dom, meta)), (lambda : meta))))
 
             case hydra.core.TermLet(value=lt):
                 bindings = lt.bindings
                 return hydra.overlay.python.lib.lists.foldl((
-                  for_binding := Lazy((lambda : (lambda m, b: hydra.overlay.python.lib.optionals.cases(b.type_scheme,
+                  for_binding := Lazy((lambda : (lambda m, b: hydra.overlay.python.lib.optionals.match(b.type_scheme,
                   (lambda : m),
                   (lambda ts: (
                     term1 := Lazy((lambda : b.term)),
@@ -3018,7 +3020,7 @@ def extend_meta_for_term(top_level: bool, meta0: hydra.python.environment.Python
                 return set_meta_uses_frozen_set(meta, True)
 
             case hydra.core.TermOptional(value=m):
-                return hydra.overlay.python.lib.optionals.cases(m, (lambda : set_meta_uses_nothing(meta, True)), (lambda _: set_meta_uses_just(meta, True)))
+                return hydra.overlay.python.lib.optionals.match(m, (lambda : set_meta_uses_nothing(meta, True)), (lambda _: set_meta_uses_just(meta, True)))
 
             case hydra.core.TermInject():
                 return set_meta_uses_cast(True, meta)
@@ -3110,7 +3112,7 @@ def gather_metadata(overlay_subs: Set[str], focus_ns: hydra.packaging.ModuleName
         match def_:
             case hydra.packaging.DefinitionTerm(value=term_def):
                 term = term_def.body
-                typ = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(term_def.signature,
+                typ = Lazy((lambda : hydra.overlay.python.lib.optionals.match(term_def.signature,
                 (lambda : cast(hydra.core.Type, hydra.core.TypeVariable(hydra.core.Name("hydra.core.Unit")))),
                 (lambda sig: hydra.scoping.term_signature_to_type_scheme(sig).body))))
                 meta2 = Lazy((lambda : extend_meta_for_type(True, True, typ(), meta)))
@@ -3126,7 +3128,7 @@ def gather_metadata(overlay_subs: Set[str], focus_ns: hydra.packaging.ModuleName
     result = Lazy((lambda : hydra.overlay.python.lib.lists.foldl((lambda x1, x2: add_def(x1, x2)), start(), defs)))
     tvars = result().type_variables
     result2 = Lazy((lambda : set_meta_uses_cast(True, set_meta_uses_lru_cache(True, result()))))
-    return set_meta_uses_type_var(result2(), hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.null(tvars)))
+    return set_meta_uses_type_var(result2(), hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.sets.is_empty(tvars)))
 
 # The target Python version for code generation.
 target_python_version = hydra.python.utils.target_python_version
@@ -3153,7 +3155,7 @@ def is_type_module_check(defs: Sequence[hydra.packaging.Definition]) -> bool:
 
             case _:
                 return False
-    return hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(hydra.overlay.python.lib.lists.filter((lambda d: _hoist_hydra_python_coder_is_type_module_check_1(d)), defs)))
+    return hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(hydra.overlay.python.lib.lists.filter((lambda d: _hoist_hydra_python_coder_is_type_module_check_1(d)), defs)))
 
 def module_domain_imports(namespaces: hydra.util.ModuleNames[hydra.python.syntax.DottedName]) -> Sequence[hydra.python.syntax.ImportStatement]:
     r"""Generate domain import statements from namespace mappings."""
@@ -3213,7 +3215,7 @@ def module_standard_imports(meta: hydra.python.environment.PythonModuleMetadata)
     simplified = Lazy((lambda : hydra.overlay.python.lib.optionals.givens(hydra.overlay.python.lib.lists.map((lambda p: (
       mod_name := Lazy((lambda : hydra.overlay.python.lib.pairs.first(p))),
       symbols := Lazy((lambda : hydra.overlay.python.lib.optionals.givens(hydra.overlay.python.lib.pairs.second(p)))),
-      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(symbols.get()),
+      hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(symbols.get()),
       (lambda : None_()),
       (lambda : Given((mod_name.get(), symbols.get())))))[2]),
     pairs()))))
@@ -3309,7 +3311,7 @@ defs0: Sequence[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra
       (lambda : set_meta_uses_type_alias(meta2.get(), True)),
       (lambda : meta2.get())))),
       namespaces := Lazy((lambda : meta0().namespaces)),
-      comment_stmts := Lazy((lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.optionals.map(hydra.formatting.normalize_comment, hydra.overlay.python.lib.optionals.bind(mod.metadata, (lambda em: em.description))),
+      comment_stmts := Lazy((lambda : hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.optionals.map(hydra.formatting.normalize_comment, hydra.overlay.python.lib.optionals.bind(mod.metadata, (lambda em: em.description))),
       (lambda : ConsList.of()),
       (lambda c: ConsList.of(hydra.python.utils.comment_statement(c)))))),
       import_stmts := Lazy((lambda : module_imports(namespaces.get(), meta.get()))),
@@ -3318,7 +3320,7 @@ defs0: Sequence[hydra.packaging.Definition]) -> Either[hydra.errors.Error, hydra
       (lambda : hydra.overlay.python.lib.sets.empty())))),
       tvar_stmts := Lazy((lambda : hydra.overlay.python.lib.lists.map((lambda tv: tvar_statement(hydra.python.names.encode_type_variable(tv))),
       hydra.overlay.python.lib.sets.to_list(tvars.get())))),
-      body := Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda group: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(group))),
+      body := Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda group: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(group))),
       hydra.overlay.python.lib.lists.concat(ConsList.of(ConsList.of(comment_stmts.get(), import_stmts.get(), tvar_stmts.get()), def_stmts))))),
       Right(hydra.python.syntax.Module(body.get())))[8]))))
 

{hydra_python-0.17.4 → hydra_python-0.17.6}/src/main/python/hydra/python/names.py

@@ -50,7 +50,7 @@ def overlay_python_module_aliases() -> Mapping[hydra.packaging.ModuleName, str]:
 def encode_namespace_string_with_overrides(overlay_subs: Set[str], ns_val: hydra.packaging.ModuleName) -> str:
     r"""Convert a ModuleName to its Python dotted import string, routing overlay modules to hydra.overlay.python.*."""
 
-    return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(hydra.overlay.python.lib.strings.split_on(".", ns_val.value)), 3),
+    return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.logic.and_(hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.length(hydra.overlay.python.lib.strings.split_on(".", ns_val.value)), 3),
     hydra.overlay.python.lib.equality.equal(hydra.overlay.python.lib.lists.take(2, hydra.overlay.python.lib.strings.split_on(".", ns_val.value)),
     ConsList.of("hydra", "lib"))),
     hydra.overlay.python.lib.sets.member(hydra.overlay.python.lib.strings.join(".", hydra.overlay.python.lib.lists.drop(2, hydra.overlay.python.lib.strings.split_on(".", ns_val.value))),
@@ -89,10 +89,10 @@ name: hydra.core.Name) -> hydra.python.syntax.Name:
     def py_ns(ns_val: hydra.packaging.ModuleName) -> str:
         return encode_namespace_string_with_overrides(env.overlay_subs, ns_val)
     return hydra.overlay.python.lib.logic.if_else(is_qualified,
-    (lambda : hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, bound_vars()),
+    (lambda : hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, bound_vars()),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(mns, Given(focus_ns())),
     (lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.logic.if_else(use_future_annotations, (lambda : py_local()), (lambda : hydra.python.serde.escape_python_string(True, py_local()))))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(mns,
+    (lambda : hydra.overlay.python.lib.optionals.match(mns,
     (lambda : hydra.python.syntax.Name(py_local())),
     (lambda ns_val: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(py_ns(ns_val), hydra.overlay.python.lib.strings.concat2(".", py_local())))))))),
     (lambda n: n))),
@@ -120,10 +120,10 @@ def encode_name_qualified(env: hydra.python.environment.PythonEnvironment, name:
     local = qual_name().local
     def py_ns(ns_val: hydra.packaging.ModuleName) -> str:
         return encode_namespace_string_with_overrides(env.overlay_subs, ns_val)
-    return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.maps.lookup(name, bound_vars()),
+    return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.maps.lookup(name, bound_vars()),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(mns, Given(focus_ns())),
     (lambda : hydra.python.syntax.Name(hydra.overlay.python.lib.logic.if_else(use_future_annotations, (lambda : local), (lambda : hydra.python.serde.escape_python_string(True, local))))),
-    (lambda : hydra.overlay.python.lib.optionals.cases(mns,
+    (lambda : hydra.overlay.python.lib.optionals.match(mns,
     (lambda : hydra.python.syntax.Name(sanitize_python_name(local))),
     (lambda ns_val: hydra.python.syntax.Name(hydra.overlay.python.lib.strings.concat2(py_ns(ns_val), hydra.overlay.python.lib.strings.concat2(".", sanitize_python_name(local))))))))),
     (lambda n: n))
@@ -167,7 +167,7 @@ def variable_reference(conv: hydra.util.CaseConvention, quoted: bool, env: hydra
     focus_pair = Lazy((lambda : namespaces.focus))
     focus_ns = Lazy((lambda : hydra.overlay.python.lib.pairs.first(focus_pair())))
     mns = Lazy((lambda : hydra.names.module_name_of(name)))
-    same_namespace = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(mns(), (lambda : False), (lambda ns: hydra.overlay.python.lib.equality.equal(ns, focus_ns())))))
+    same_namespace = Lazy((lambda : hydra.overlay.python.lib.optionals.match(mns(), (lambda : False), (lambda ns: hydra.overlay.python.lib.equality.equal(ns, focus_ns())))))
     return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.and_(quoted, same_namespace()),
     (lambda : cast(hydra.python.syntax.Expression,
     hydra.python.syntax.ExpressionSimple(hydra.python.syntax.Disjunction(ConsList.of(hydra.python.syntax.Conjunction(ConsList.of(cast(hydra.python.syntax.Inversion,

{hydra_python-0.17.4 → hydra_python-0.17.6}/src/main/python/hydra/python/serde.py

@@ -10,6 +10,7 @@ from hydra.overlay.python.util import ConsList, Lazy
 from typing import cast
 import hydra.constants
 import hydra.core
+import hydra.formatting
 import hydra.names
 import hydra.overlay.python.lib.equality
 import hydra.overlay.python.lib.lists
@@ -88,13 +89,13 @@ def number_to_expr(num: hydra.python.syntax.Number) -> hydra.ast.Expr:
 
     match num:
         case hydra.python.syntax.NumberFloat(value=f):
-            return hydra.serialization.cst(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f)))
+            return hydra.serialization.cst(python_float_literal_text(hydra.overlay.python.lib.literals.print_float64(f)))
 
         case hydra.python.syntax.NumberImaginary(value=f2):
-            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(python_float_literal_text(hydra.overlay.python.lib.literals.show_float64(f2)), "j"))
+            return hydra.serialization.cst(hydra.overlay.python.lib.strings.concat2(python_float_literal_text(hydra.overlay.python.lib.literals.print_float64(f2)), "j"))
 
         case hydra.python.syntax.NumberInteger(value=i):
-            return hydra.serialization.cst(hydra.overlay.python.lib.literals.show_bigint(i))
+            return hydra.serialization.cst(hydra.overlay.python.lib.literals.print_bigint(i))
 
         case _:
             raise AssertionError("Unreachable: all variants handled")
@@ -136,7 +137,7 @@ def string_to_expr(s: hydra.python.syntax.String) -> hydra.ast.Expr:
     r"""Serialize a Python string literal."""
 
     content = s.value
-    prefix = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(s.prefix, (lambda : ""), (lambda x1: string_prefix_to_text(x1)))))
+    prefix = Lazy((lambda : hydra.overlay.python.lib.optionals.match(s.prefix, (lambda : ""), (lambda x1: string_prefix_to_text(x1)))))
     style = s.quote_style
     match style:
         case hydra.python.syntax.QuoteStyle.SINGLE:
@@ -273,7 +274,7 @@ def comparison_to_expr(cmp: hydra.python.syntax.Comparison) -> hydra.ast.Expr:
 
     lhs = cmp.lhs
     rhs = cmp.rhs
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(rhs),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(rhs),
     (lambda : bitwise_or_to_expr(lhs)),
     (lambda : hydra.serialization.space_sep(hydra.overlay.python.lib.lists.cons(bitwise_or_to_expr(lhs), hydra.overlay.python.lib.lists.map((lambda x1: compare_op_bitwise_or_pair_to_expr(x1)), rhs)))))
 
@@ -759,7 +760,7 @@ def import_from_as_name_to_expr(ifan: hydra.python.syntax.ImportFromAsName) -> h
 
     name = ifan.name
     alias = ifan.as_
-    return hydra.overlay.python.lib.optionals.cases(alias,
+    return hydra.overlay.python.lib.optionals.match(alias,
     (lambda : name_to_expr(name)),
     (lambda a: hydra.serialization.space_sep(ConsList.of(name_to_expr(name), hydra.serialization.cst("as"), name_to_expr(a)))))
 
@@ -881,7 +882,7 @@ def type_alias_to_expr(ta: hydra.python.syntax.TypeAlias) -> hydra.ast.Expr:
     tparams = ta.type_params
     expr = ta.expression
     alias = Lazy((lambda : hydra.serialization.no_sep(hydra.overlay.python.lib.optionals.givens(ConsList.of(Given(name_to_expr(name)),
-    hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams),
+    hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparams),
     (lambda : None_()),
     (lambda : Given(hydra.serialization.bracket_list(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: type_parameter_to_expr(x1)), tparams))))))))))
     return hydra.serialization.space_sep(ConsList.of(hydra.serialization.cst("type"), alias(), hydra.serialization.cst("="), expression_to_expr(expr)))
@@ -1157,7 +1158,7 @@ def to_python_comments(doc_: str) -> str:
     hydra.overlay.python.lib.lists.map((lambda line: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.equality.equal(line, ""),
     (lambda : "#"),
     (lambda : hydra.overlay.python.lib.strings.concat2("# ", line)))),
-    hydra.overlay.python.lib.strings.lines(hydra.print.docs.render_doc_string_with((lambda x1: python_doc_entity_ref(x1)), doc_))))))
+    hydra.formatting.lines(hydra.print.docs.render_doc_string_with((lambda x1: python_doc_entity_ref(x1)), doc_))))))
 
 def annotated_statement_to_expr(as_: hydra.python.syntax.AnnotatedStatement) -> hydra.ast.Expr:
     r"""Serialize an annotated statement (with optional doc comment)."""
@@ -1248,7 +1249,7 @@ def function_def_raw_to_expr(fdr: hydra.python.syntax.FunctionDefRaw) -> hydra.a
     ret_type = fdr.return_type
     block = fdr.block
     async_kw = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(async_, (lambda : Given(hydra.serialization.cst("async"))), (lambda : None_()))))
-    tparam_part = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(tparams),
+    tparam_part = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(tparams),
     (lambda : None_()),
     (lambda : Given(hydra.serialization.bracket_list(hydra.serialization.inline_style, hydra.overlay.python.lib.lists.map((lambda x1: type_parameter_to_expr(x1)), tparams)))))))
     param_part = Lazy((lambda : hydra.overlay.python.lib.optionals.map((lambda x1: parameters_to_expr(x1)), params)))

{hydra_python-0.17.4 → hydra_python-0.17.6}/src/main/python/hydra/python/testing.py

@@ -49,7 +49,7 @@ def generate_python_test_case(group_path: Sequence[str], tcm: hydra.testing.Test
         case hydra.testing.TestCaseUniversal(value=ucase):
             actual_ = Lazy((lambda : ucase.actual(None)))
             expected_ = Lazy((lambda : ucase.expected(None)))
-            full_name = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(group_path),
+            full_name = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(group_path),
             (lambda : name_),
             (lambda : hydra.overlay.python.lib.strings.join("__", hydra.overlay.python.lib.lists.concat2(group_path, ConsList.of(name_)))))))
             formatted_name = Lazy((lambda : format_python_test_name(full_name())))

{hydra_python-0.17.4 → hydra_python-0.17.6}/src/main/python/hydra/python/utils.py

@@ -113,14 +113,14 @@ def py_name_to_py_primary(name: hydra.python.syntax.Name) -> hydra.python.syntax
 def annotated_expression(mcomment: Optional[str], expr: hydra.python.syntax.Expression) -> hydra.python.syntax.Expression:
     r"""Annotate an expression with an optional comment using Annotated[]."""
 
-    return hydra.overlay.python.lib.optionals.cases(mcomment,
+    return hydra.overlay.python.lib.optionals.match(mcomment,
     (lambda : expr),
     (lambda c: py_primary_to_py_expression(primary_with_expression_slices(py_name_to_py_primary(hydra.python.syntax.Name("Annotated")), ConsList.of(expr, double_quoted_string(c))))))
 
 def annotated_statement(mcomment: Optional[str], stmt: hydra.python.syntax.Statement) -> hydra.python.syntax.Statement:
     r"""Annotate a statement with an optional comment."""
 
-    return hydra.overlay.python.lib.optionals.cases(mcomment,
+    return hydra.overlay.python.lib.optionals.match(mcomment,
     (lambda : stmt),
     (lambda c: cast(hydra.python.syntax.Statement, hydra.python.syntax.StatementAnnotated(hydra.python.syntax.AnnotatedStatement(c, stmt)))))
 
@@ -229,7 +229,7 @@ def decode_py_comparison_to_py_await_primary(c: hydra.python.syntax.Comparison)
 
             case _:
                 return None_()
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(rhs)),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(rhs)),
     (lambda : None_()),
     (lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.optionals.is_given(or_lhs),
     (lambda : None_()),
@@ -306,10 +306,10 @@ def get_item_params() -> hydra.python.syntax.Parameters:
 def indented_block(mcomment: Optional[str], stmts: Sequence[Sequence[hydra.python.syntax.Statement]]) -> hydra.python.syntax.Block:
     r"""Create an indented block with optional comment."""
 
-    comment_group = Lazy((lambda : hydra.overlay.python.lib.optionals.cases(mcomment, (lambda : ConsList.of()), (lambda s: ConsList.of(comment_statement(s))))))
-    groups = Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda g: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.null(g))),
+    comment_group = Lazy((lambda : hydra.overlay.python.lib.optionals.match(mcomment, (lambda : ConsList.of()), (lambda s: ConsList.of(comment_statement(s))))))
+    groups = Lazy((lambda : hydra.overlay.python.lib.lists.filter((lambda g: hydra.overlay.python.lib.logic.not_(hydra.overlay.python.lib.lists.is_empty(g))),
     hydra.overlay.python.lib.lists.cons(comment_group(), stmts))))
-    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(groups()),
+    return hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(groups()),
     (lambda : cast(hydra.python.syntax.Block,
     hydra.python.syntax.BlockIndented(ConsList.of(ConsList.of(cast(hydra.python.syntax.Statement,
     hydra.python.syntax.StatementSimple(ConsList.of(py_expression_to_py_simple_statement(py_atom_to_py_expression(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomEllipsis()))))))))))),
@@ -354,11 +354,11 @@ def or_expression(prims: Sequence[hydra.python.syntax.Primary]) -> hydra.python.
     r"""Build an or-expression from multiple primaries."""
 
     def build(prev: Optional[hydra.python.syntax.BitwiseOr], ps: Sequence[hydra.python.syntax.Primary]) -> hydra.python.syntax.BitwiseOr:
-        return hydra.overlay.python.lib.optionals.cases(hydra.overlay.python.lib.lists.uncons(ps),
+        return hydra.overlay.python.lib.optionals.match(hydra.overlay.python.lib.lists.uncons(ps),
         (lambda : hydra.python.syntax.BitwiseOr(prev,
         py_primary_to_py_bitwise_xor(cast(hydra.python.syntax.Primary,
         hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom, hydra.python.syntax.AtomEllipsis())))))),
-        (lambda p: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(hydra.overlay.python.lib.pairs.second(p)),
+        (lambda p: hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(hydra.overlay.python.lib.pairs.second(p)),
         (lambda : hydra.python.syntax.BitwiseOr(prev, py_primary_to_py_bitwise_xor(hydra.overlay.python.lib.pairs.first(p)))),
         (lambda : build(Given(hydra.python.syntax.BitwiseOr(prev, py_primary_to_py_bitwise_xor(hydra.overlay.python.lib.pairs.first(p)))),
         hydra.overlay.python.lib.pairs.second(p))))))
@@ -419,7 +419,7 @@ def py_expression_to_disjunction(e: hydra.python.syntax.Expression) -> hydra.pyt
 def py_expression_to_py_primary(e: hydra.python.syntax.Expression) -> hydra.python.syntax.Primary:
     r"""Extracts the primary from an expression, or wraps it in parentheses if the expression does not contain a primary."""
 
-    return hydra.overlay.python.lib.optionals.cases(decode_py_expression_to_py_primary(e),
+    return hydra.overlay.python.lib.optionals.match(decode_py_expression_to_py_primary(e),
     (lambda : cast(hydra.python.syntax.Primary,
     hydra.python.syntax.PrimarySimple(cast(hydra.python.syntax.Atom,
     hydra.python.syntax.AtomGroup(cast(hydra.python.syntax.Group,
@@ -595,7 +595,7 @@ extra_stmts: Sequence[hydra.python.syntax.Statement]) -> Sequence[hydra.python.s
     ConsList.of())))))))))))),
     indented_block(None_(), ConsList.of(ConsList.of(get_item_method())))))))
     doc_stmt = Lazy((lambda : py_expression_to_py_statement(triple_quoted_string(doc_string()))))
-    body_groups = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.null(extra_stmts),
+    body_groups = Lazy((lambda : hydra.overlay.python.lib.logic.if_else(hydra.overlay.python.lib.lists.is_empty(extra_stmts),
     (lambda : (
       pass_stmt := Lazy((lambda : py_simple_statement_to_py_statement(cast(hydra.python.syntax.SimpleStatement, hydra.python.syntax.SimpleStatementPass())))),
       ConsList.of(ConsList.of(doc_stmt()), ConsList.of(pass_stmt.get())))[1]),