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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hydra-python
-Version: 0.17.5
+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.5
+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.5 → 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.5 → hydra_python-0.17.6}/build/main/digest.json

@@ -1,20 +1,20 @@
 {
   "digestFormatVersion": 2,
   "moduleFormatVersion": 1,
-  "generator": "9de7bd43d8cafa93",
+  "generator": "3fcbb2c3eed9a625",
   "generation": {
-    "generatorId": "9de7bd43d8cafa93",
+    "generatorId": "3fcbb2c3eed9a625",
     "mode": "published",
     "host": "python",
-    "hydraVersion": "0.17.4",
-    "revision": "9571823830-dirty",
-    "timestamp": "2026-08-19T17:44:59Z"},
-  "selfHash": "f628802be436ebb317632a9429323b63f0ae5045bda0ba24aa263ccf2092e014",
-  "dependencyHashes": [{"key": "hydra-kernel", "value": "5b5813a6dabbc89ed0e4ddd918744636da84f3542d7961284c423aea53629b02"}],
+    "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": "0b1e385015be90731b3a461486eec1c2ab2448e1643f3a9e4f1f7427ec0e085a"}},
+      "value": {"kind": "other", "hash": "0f6f038ef11ca726af501d1483716d1d5adff54e3c03e9a1f2cb61875260f4f7"}},
     {
       "key": "hydra.python.environment",
       "value": {"kind": "other", "hash": "663b02271ddd4a6ad9ab8a2bdc152a64802a675a59280909f605d6dedcc4017e"}},
@@ -29,16 +29,16 @@
       "value": {"kind": "other", "hash": "249512648b2b008db234ee348a72056d4d625cfeb0a80d8caacbda95002569a2"}},
     {
       "key": "hydra.python.serde",
-      "value": {"kind": "other", "hash": "83e48906bdec70d3d0d427c0e1b02b5e4d08bb172d3f85be13992ef4c1120859"}},
+      "value": {"kind": "other", "hash": "8d35f12f8ef3aa33db2064a266d6c97a31e2c8675a6f77005cdb011b01597b8a"}},
     {
       "key": "hydra.python.syntax",
       "value": {"kind": "other", "hash": "88a9154b48fd429f06efa0ba8981bdf12af3fed4de5a057b3304fadc623dbc19"}},
     {
       "key": "hydra.python.testing",
-      "value": {"kind": "other", "hash": "113853c870177388fbcc53800768d872fae34fdbfd1a0e2f30d2b2aefb966451"}},
+      "value": {"kind": "other", "hash": "52629d9f9aba82fbae03c9250b42d962eea9b2cdfde77c02466282ab95c51b5b"}},
     {
       "key": "hydra.python.utils",
-      "value": {"kind": "other", "hash": "f480bc8a4c39e62ea073357517964a2175e582fd220de0fbc1bc27b9b108d327"}},
+      "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": "e2f66b5c16393d8050923aab1f832f430334e4bddfc101f4cebc1f158daee01d"}},
+      "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": "afaa99c99874efa5e02a10973651a7a74ab1089feedb9de0f8a74904a8ec4eb7"}},
+      "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": "e987b94392abfc72cedc08d2e6b8a4528479a9023c9eff636f8980e9af6e6cfb"}},
+      "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": "0ef54f39243803add5f5634d67bf8c949d89159b3fc1c4ff82d9cb0bf829f4b9"}},
+      "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": "eb662817f2e3390220a06eb6eda9cc7adce67d3e22b47f3e2823ab273d688af6"}},
+      "value": {"kind": "targetFile", "hash": "d7e39526e1f7802a5af9d6ea57596766be03b9e16505095c57597f8903683461"}},
     {
       "key": "hydra/python/environment.py",
       "value": {"kind": "targetFile", "hash": "1036eb9d285ba3e98c85095820f2e77900334340c9f0223fd4dfd6b3e847f4df"}},
@@ -111,13 +111,13 @@
       "value": {"kind": "targetFile", "hash": "1f9001d8d2273d4783105e099b874c273ce520b58456f9b447cb8d5e9a6a37d7"}},
     {
       "key": "hydra/python/serde.py",
-      "value": {"kind": "targetFile", "hash": "a783457c64ea85769cd2ab757bd429be4d0c7333ab5765b0c04f3b0bf86b1e80"}},
+      "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": "b53dbe52de14f67d6a3c74d8f6bd7051fbaa65dbf686362565bb5cda61f15075"}}]}
+      "value": {"kind": "targetFile", "hash": "2cfa00436ebc27925f9b45380792aa817921bb7dbaf88e0c17cfb51bbe3c82fc"}}]}

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

@@ -13,7 +13,7 @@
 
 [project]
 name = "hydra-python"
-version = "0.17.5"
+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.5",
+    "hydra-kernel == 0.17.6",
 ]
 
 [project.urls]

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

@@ -343,7 +343,7 @@ def deduplicate_case_variables(cases_: Sequence[hydra.core.CaseAlternative]) ->
                 (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,7 +891,7 @@ 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)))),
+    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),
@@ -945,7 +945,7 @@ 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.match(hydra.lexical.lookup_primitive(g(), name),
@@ -957,7 +957,7 @@ 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)))),
+          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,
@@ -1001,7 +1001,7 @@ args: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, hy
       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,14 +1022,14 @@ 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.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]),
@@ -1040,7 +1040,7 @@ 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]))),
@@ -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]))))))))))))
@@ -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()),
@@ -1246,7 +1246,7 @@ rargs: Sequence[hydra.python.syntax.Expression]) -> Either[hydra.errors.Error, t
               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((
@@ -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,
@@ -1799,7 +1799,7 @@ 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.match(mcs.get(),
@@ -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),
@@ -2009,7 +2009,7 @@ prefixes: Sequence[hydra.python.syntax.Statement]) -> Either[hydra.errors.Error,
         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"))))),
@@ -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()))),
@@ -2448,7 +2448,9 @@ def encode_definition(cx: hydra.typing.InferenceContext, env: hydra.python.envir
             name = td.name
             term = td.body
             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"))), None_())),
+            (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()))
@@ -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()))))
@@ -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.5 → hydra_python-0.17.6}/src/main/python/hydra/python/serde.py

@@ -89,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")
@@ -274,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)))))
 
@@ -882,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)))
@@ -1249,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.5 → 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.5 → hydra_python-0.17.6}/src/main/python/hydra/python/utils.py

@@ -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_()),
@@ -307,9 +307,9 @@ def indented_block(mcomment: Optional[str], stmts: Sequence[Sequence[hydra.pytho
     r"""Create an indented block with optional comment."""
 
     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.null(g))),
+    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()))))))))))),
@@ -358,7 +358,7 @@ def or_expression(prims: Sequence[hydra.python.syntax.Primary]) -> hydra.python.
         (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))))))
@@ -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]),