fable-library 5.3.0__tar.gz → 5.4.0__tar.gz

{fable_library-5.3.0 → fable_library-5.4.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: fable-library
-Version: 5.3.0
+Version: 5.4.0
 Summary: Fable library for Python
 Author-email: Dag Brattli <dag@brattli.net>
-License-Expression: MIT License
+License-Expression: MIT
 Requires-Python: >=3.10, <4.0
 Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 Project-URL: Homepage, https://fable.io

fable_library-5.4.0/fable_library/_version.py

@@ -0,0 +1 @@
+__version__ = "5.4.0"

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/fsharp_core.py

@@ -10,6 +10,7 @@ from .option import value as value_1
 from .protocols import IComparer_1, IDisposable, IEqualityComparer, IEqualityComparer_1
 from .system import ArgumentNullException__ctor_Z721C83C5, NullReferenceException__ctor
 from .system_text import StringBuilder__Append_Z721C83C5
+from .types import ExceptionBase
 from .util import UNIT, Unit, dispose, equals, ignore, structural_hash
 
 
@@ -52,7 +53,7 @@ def LanguagePrimitives_FastGenericEqualityComparerFromTable[T](__unit: Unit = UN
 
 
 def Operators_Failure(message: str) -> Exception:
-    return Exception(message)
+    return ExceptionBase(message)
 
 
 def Operators_FailurePattern(exn: Exception) -> str | None:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/list.py

@@ -42,6 +42,7 @@ from .protocols import IComparer_1, IEnumerable_1, IEnumerator, IEqualityCompare
 from .record import Record
 from .reflection import TypeInfo, class_type, option_type, record_type
 from .string_ import join
+from .types import ExceptionBase
 from .util import (
     UNIT,
     Disposable,
@@ -304,7 +305,7 @@ def FSharpList__get_Item_Z524259A4[T](xs: FSharpList[T], index: int32) -> T:
 
 
 def index_not_found[_A](__unit: Unit = UNIT) -> _A:
-    raise Exception(SR_keyNotFoundAlt)
+    raise ExceptionBase(SR_keyNotFoundAlt)
 
 
 def empty[_A](__unit: Unit = UNIT) -> FSharpList[_A]:
@@ -695,10 +696,10 @@ def map[T, U](mapping: Callable[[T], U], xs: FSharpList[T]) -> FSharpList[U]:
 
 
 def indexed[_A](xs: FSharpList[_A]) -> FSharpList[tuple[int32, _A]]:
-    def _arrow51(i: int32, x: _A) -> tuple[int32, _A]:
+    def _arrow40(i: int32, x: _A) -> tuple[int32, _A]:
         return (i, x)
 
-    return map_indexed(_arrow51, xs)
+    return map_indexed(_arrow40, xs)
 
 
 def map2[T1, T2, U](mapping: Callable[[T1, T2], U], xs: FSharpList[T1], ys: FSharpList[T2]) -> FSharpList[U]:
@@ -729,14 +730,14 @@ def map_indexed2[T1, T2, U](
             else:
                 i_mut = i + int32.ONE
 
-                def _arrow52(i: Any = i, acc: Any = acc, xs_1: Any = xs_1, ys_1: Any = ys_1) -> FSharpList[U]:
+                def _arrow41(i: Any = i, acc: Any = acc, xs_1: Any = xs_1, ys_1: Any = ys_1) -> FSharpList[U]:
                     t: FSharpList[Any] = FSharpList(
                         mapping(i, FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1)), None
                     )
                     acc.tail_ = t
                     return t
 
-                acc_mut = _arrow52()
+                acc_mut = _arrow41()
                 xs_1_mut = FSharpList__get_Tail(xs_1)
                 ys_1_mut = FSharpList__get_Tail(ys_1)
                 continue
@@ -771,7 +772,7 @@ def map3[T1, T2, T3, U](
 
             else:
 
-                def _arrow53(acc: Any = acc, xs_1: Any = xs_1, ys_1: Any = ys_1, zs_1: Any = zs_1) -> FSharpList[U]:
+                def _arrow42(acc: Any = acc, xs_1: Any = xs_1, ys_1: Any = ys_1, zs_1: Any = zs_1) -> FSharpList[U]:
                     t: FSharpList[Any] = FSharpList(
                         mapping(FSharpList__get_Head(xs_1), FSharpList__get_Head(ys_1), FSharpList__get_Head(zs_1)),
                         None,
@@ -779,7 +780,7 @@ def map3[T1, T2, T3, U](
                     acc.tail_ = t
                     return t
 
-                acc_mut = _arrow53()
+                acc_mut = _arrow42()
                 xs_1_mut = FSharpList__get_Tail(xs_1)
                 ys_1_mut = FSharpList__get_Tail(ys_1)
                 zs_1_mut = FSharpList__get_Tail(zs_1)
@@ -804,12 +805,12 @@ def map_fold[STATE, T, RESULT](
     ) -> tuple[FSharpList[RESULT], STATE]:
         pattern_input: tuple[Any, Any] = mapping(tupled_arg[1], x)
 
-        def _arrow54(tupled_arg: Any = tupled_arg) -> FSharpList[RESULT]:
+        def _arrow43(tupled_arg: Any = tupled_arg) -> FSharpList[RESULT]:
             t: FSharpList[Any] = FSharpList(pattern_input[0], None)
             tupled_arg[0].tail_ = t
             return t
 
-        return (_arrow54(), pattern_input[1])
+        return (_arrow43(), pattern_input[1])
 
     pattern_input_1: tuple[FSharpList[Any], Any] = fold(folder, (root, state), xs)
     t_2: FSharpList[Any] = FSharpList_get_Empty()
@@ -820,10 +821,10 @@ def map_fold[STATE, T, RESULT](
 def map_fold_back[T, STATE, RESULT](
     mapping: Callable[[T, STATE], tuple[RESULT, STATE]], xs: FSharpList[T], state: STATE
 ) -> tuple[FSharpList[RESULT], STATE]:
-    def _arrow55(acc: STATE, x: T, mapping: Any = mapping) -> tuple[RESULT, STATE]:
+    def _arrow48(acc: STATE, x: T, mapping: Any = mapping) -> tuple[RESULT, STATE]:
         return mapping(x, acc)
 
-    return map_fold(_arrow55, state, reverse(xs))
+    return map_fold(_arrow48, state, reverse(xs))
 
 
 def try_pick[T, _A](f: Callable[[T], Option[_A]], xs: FSharpList[T]) -> Option[_A]:
@@ -1283,21 +1284,21 @@ def all_pairs[T1, T2](xs: FSharpList[T1], ys: FSharpList[T2]) -> FSharpList[tupl
     root: FSharpList[tuple[Any, Any]] = FSharpList_get_Empty()
     node: FSharpList[tuple[Any, Any]] = root
 
-    def _arrow87(x: T1 = UNIT, ys: Any = ys) -> None:
-        def _arrow86(y: T2 = UNIT) -> None:
+    def _arrow81(x: T1 = UNIT, ys: Any = ys) -> None:
+        def _arrow80(y: T2 = UNIT) -> None:
             nonlocal node
 
-            def _arrow85(__unit: Unit = UNIT) -> FSharpList[tuple[T1, T2]]:
+            def _arrow79(__unit: Unit = UNIT) -> FSharpList[tuple[T1, T2]]:
                 xs_1: FSharpList[tuple[Any, Any]] = node
                 t: FSharpList[tuple[Any, Any]] = FSharpList((x, y), None)
                 xs_1.tail_ = t
                 return t
 
-            node = _arrow85()
+            node = _arrow79()
 
-        iterate(_arrow86, ys)
+        iterate(_arrow80, ys)
 
-    iterate(_arrow87, xs)
+    iterate(_arrow81, xs)
     xs_3: FSharpList[tuple[Any, Any]] = node
     t_2: FSharpList[tuple[Any, Any]] = FSharpList_get_Empty()
     xs_3.tail_ = t_2

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/map.py

@@ -25,6 +25,7 @@ from .seq import pick as pick_1
 from .seq import try_pick as try_pick_1
 from .string_ import format, join
 from .system import NotSupportedException__ctor_Z721C83C5
+from .types import ExceptionBase
 from .util import UNIT, Disposable, Unit, compare, equals, get_enumerator, ignore, nullable, range, structural_hash
 
 
@@ -349,7 +350,7 @@ def MapTreeModule_find[KEY, VALUE](
 ) -> VALUE:
     match_value: Option[Any] = MapTreeModule_tryFind(comparer, k, m)
     if match_value is None:
-        raise Exception()
+        raise ExceptionBase()
 
     else:
         return value_1(match_value)
@@ -1243,7 +1244,7 @@ def MapTreeModule_leftmost[KEY, VALUE](m_mut: MapTreeLeaf_2[KEY, VALUE] | None)
                 return (MapTreeLeaf_2__get_Key(m2), MapTreeLeaf_2__get_Value(m2))
 
         else:
-            raise Exception()
+            raise ExceptionBase()
 
         break
 
@@ -1277,7 +1278,7 @@ def MapTreeModule_rightmost[KEY, VALUE](m_mut: MapTreeLeaf_2[KEY, VALUE] | None)
                 return (MapTreeLeaf_2__get_Key(m2), MapTreeLeaf_2__get_Value(m2))
 
         else:
-            raise Exception()
+            raise ExceptionBase()
 
         break
 
@@ -1608,7 +1609,7 @@ def pick[_A, _B, _C](chooser: Callable[[_A, _B], Option[_C]], table: FSharpMap[_
         return value_1(match_value)
 
     else:
-        raise Exception()
+        raise ExceptionBase()
 
 
 def exists[_A, _B](predicate: Callable[[_A, _B], bool], table: FSharpMap[_A, _B]) -> bool:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/mutable_map.py

@@ -16,6 +16,7 @@ from .resize_array import find_index
 from .seq import concat, delay, iterate_indexed, map
 from .string_ import format
 from .system import ArgumentException__ctor_Z721C83C5
+from .types import ExceptionBase
 from .types import FSharpRef as FSharpRef_1
 from .util import UNIT, Disposable, Unit, dispose, equals, get_enumerator, ignore, nullable, to_enumerable
 
@@ -276,7 +277,7 @@ def Dictionary__get_Item_2B595[KEY, VALUE](this: Dictionary[KEY, VALUE], k: KEY)
         return match_value[1]
 
     else:
-        raise Exception("The item was not found in collection")
+        raise ExceptionBase("The item was not found in collection")
 
 
 def Dictionary__set_Item_5BDDA1[KEY, VALUE](this: Dictionary[KEY, VALUE], k: KEY, v: VALUE) -> None:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/mutable_set.py

@@ -19,7 +19,7 @@ from .types import FSharpRef
 from .util import UNIT, Disposable, Unit, dispose, get_enumerator, ignore, to_enumerable
 
 
-def _expr8(gen0: TypeInfo) -> TypeInfo:
+def _expr9(gen0: TypeInfo) -> TypeInfo:
     return class_type("Fable.Collections.HashSet", Array([gen0]), HashSet)
 
 
@@ -111,7 +111,7 @@ class HashSet[T](MutableSet[Any], Set[Any], EnumerableBase[Any]):
         self.Remove(value)
 
 
-HashSet_reflection = _expr8
+HashSet_reflection = _expr9
 
 
 def HashSet__ctor_Z6150332D[T](items: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]) -> HashSet[T]:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/range.py

@@ -25,7 +25,7 @@ def make_range_step_function[T](
 
     step_greater_than_zero: bool = step_compared_with_zero > int32.ZERO
 
-    def _arrow79(x: T = UNIT, step: Any = step, stop: Any = stop, add: Any = add) -> tuple[T, T] | None:
+    def _arrow82(x: T = UNIT, step: Any = step, stop: Any = stop, add: Any = add) -> tuple[T, T] | None:
         compared_with_last: int32 = compare(x, stop)
         return (
             ((x, add(x, step)))
@@ -37,16 +37,16 @@ def make_range_step_function[T](
             else None
         )
 
-    return _arrow79
+    return _arrow82
 
 
 def integral_range_step[T](start: T, step: T, stop: T, zero: T, add: Callable[[T, T], T]) -> IEnumerable_1[T]:
     step_fn: Callable[[Any], tuple[Any, Any] | None] = erase(make_range_step_function(step, stop, zero, add))
 
-    def _arrow80(start: Any = start) -> IEnumerable_1[T]:
+    def _arrow83(start: Any = start) -> IEnumerable_1[T]:
         return unfold(step_fn, start)
 
-    return delay(_arrow80)
+    return delay(_arrow83)
 
 
 def range_big_int(start: int, step: int, stop: int) -> IEnumerable_1[int]:
@@ -60,24 +60,24 @@ def range_decimal(start: Decimal, step: Decimal, stop: Decimal) -> IEnumerable_1
 
 
 def range_double(start: float64, step: float64, stop: float64) -> IEnumerable_1[float64]:
-    def _arrow81(x: float64, y: float64) -> float64:
+    def _arrow84(x: float64, y: float64) -> float64:
         return x + y
 
-    return integral_range_step(start, step, stop, float64(0.0), _arrow81)
+    return integral_range_step(start, step, stop, float64(0.0), _arrow84)
 
 
 def range_int32(start: int32, step: int32, stop: int32) -> IEnumerable_1[int32]:
-    def _arrow82(x: int32, y: int32) -> int32:
+    def _arrow85(x: int32, y: int32) -> int32:
         return x + y
 
-    return integral_range_step(start, step, stop, int32.ZERO, _arrow82)
+    return integral_range_step(start, step, stop, int32.ZERO, _arrow85)
 
 
 def range_uint32(start: uint32, step: uint32, stop: uint32) -> IEnumerable_1[uint32]:
-    def _arrow83(x: uint32, y: uint32) -> uint32:
+    def _arrow86(x: uint32, y: uint32) -> uint32:
         return x + y
 
-    return integral_range_step(start, step, stop, uint32.ZERO, _arrow83)
+    return integral_range_step(start, step, stop, uint32.ZERO, _arrow86)
 
 
 def range_int64(start: int64, step: int64, stop: int64) -> IEnumerable_1[int64]:
@@ -91,7 +91,7 @@ def range_uint64(start: uint64, step: uint64, stop: uint64) -> IEnumerable_1[uin
 def range_char(start: str, stop: str) -> IEnumerable_1[str]:
     int_stop: int32 = int32(char_code_at(stop, int32.ZERO))
 
-    def _arrow84(start: Any = start) -> IEnumerable_1[str]:
+    def _arrow87(start: Any = start) -> IEnumerable_1[str]:
         def step_fn(i: int32) -> tuple[str, int32] | None:
             if i <= int_stop:
                 return (chr(int(i)), i + int32.ONE)
@@ -101,7 +101,7 @@ def range_char(start: str, stop: str) -> IEnumerable_1[str]:
 
         return unfold(step_fn, int32(char_code_at(start, int32.ZERO)))
 
-    return delay(_arrow84)
+    return delay(_arrow87)
 
 
 __all__ = [

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/result.py

@@ -12,7 +12,7 @@ from .union import Union, tagged_union
 from .util import equals
 
 
-def _expr9(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
+def _expr8(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
     return union_type(
         "FSharp.Core.FSharpResult`2",
         Array([gen0, gen1]),
@@ -40,7 +40,7 @@ class Error[T, TERROR](_FSharpResult_2[T, TERROR]):
 
 type FSharpResult_2[T, TERROR] = Ok[T, TERROR] | Error[T, TERROR]
 
-FSharpResult_2_reflection = _expr9
+FSharpResult_2_reflection = _expr8
 
 
 def Result_Map[A, B, C](mapping: Callable[[A], B], result: FSharpResult_2[A, C]) -> FSharpResult_2[B, C]:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/seq.py

@@ -48,6 +48,7 @@ from .option import value as value_1
 from .protocols import IComparer_1, IDisposable, IEnumerable, IEnumerable_1, IEnumerator, IEqualityComparer_1
 from .reflection import TypeInfo, class_type
 from .system import InvalidOperationException__ctor_Z721C83C5, NotSupportedException__ctor_Z721C83C5
+from .types import ExceptionBase
 from .util import (
     UNIT,
     Disposable,
@@ -396,7 +397,7 @@ def Enumerator_unfold[STATE, T](f: Callable[[STATE], tuple[T, STATE] | None], st
 
 
 def index_not_found[_A](__unit: Unit = UNIT) -> _A:
-    raise Exception(SR_keyNotFoundAlt)
+    raise ExceptionBase(SR_keyNotFoundAlt)
 
 
 def mk_seq[T](f: Callable[[], IEnumerator[T]]) -> IEnumerable_1[T]:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/seq2.py

@@ -15,7 +15,7 @@ from .util import UNIT, Disposable, Unit, get_enumerator, to_enumerable
 
 
 def distinct[T](xs: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]) -> IEnumerable_1[T]:
-    def _arrow40(xs: Any = xs, comparer: Any = comparer) -> IEnumerable_1[T]:
+    def _arrow44(xs: Any = xs, comparer: Any = comparer) -> IEnumerable_1[T]:
         hash_set: Any = HashSet(Array[Any]([]), comparer)
 
         def predicate(x: T = UNIT) -> bool:
@@ -23,13 +23,13 @@ def distinct[T](xs: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]) -> IEn
 
         return filter(predicate, xs)
 
-    return delay(_arrow40)
+    return delay(_arrow44)
 
 
 def distinct_by[T, KEY](
     projection: Callable[[T], KEY], xs: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]
 ) -> IEnumerable_1[T]:
-    def _arrow41(projection: Any = projection, xs: Any = xs, comparer: Any = comparer) -> IEnumerable_1[T]:
+    def _arrow45(projection: Any = projection, xs: Any = xs, comparer: Any = comparer) -> IEnumerable_1[T]:
         hash_set: Any = HashSet(Array[Any]([]), comparer)
 
         def predicate(x: T = UNIT) -> bool:
@@ -37,13 +37,13 @@ def distinct_by[T, KEY](
 
         return filter(predicate, xs)
 
-    return delay(_arrow41)
+    return delay(_arrow45)
 
 
 def except_[T](
     items_to_exclude: IEnumerable_1[T], xs: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]
 ) -> IEnumerable_1[T]:
-    def _arrow42(items_to_exclude: Any = items_to_exclude, xs: Any = xs, comparer: Any = comparer) -> IEnumerable_1[T]:
+    def _arrow46(items_to_exclude: Any = items_to_exclude, xs: Any = xs, comparer: Any = comparer) -> IEnumerable_1[T]:
         hash_set: Any = HashSet(items_to_exclude, comparer)
 
         def predicate(x: T = UNIT) -> bool:
@@ -51,13 +51,13 @@ def except_[T](
 
         return filter(predicate, xs)
 
-    return delay(_arrow42)
+    return delay(_arrow46)
 
 
 def count_by[T, KEY](
     projection: Callable[[T], KEY], xs: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]
 ) -> IEnumerable_1[tuple[KEY, int32]]:
-    def _arrow46(
+    def _arrow51(
         projection: Any = projection, xs: Any = xs, comparer: Any = comparer
     ) -> IEnumerable_1[tuple[KEY, int32]]:
         dict_1: Any = Dictionary(Array[Any]([]), comparer)
@@ -68,14 +68,14 @@ def count_by[T, KEY](
                 match_value: tuple[bool, int32]
                 out_arg: int32 = int32.ZERO
 
-                def _arrow43(__unit: Unit = UNIT) -> int32:
+                def _arrow47(__unit: Unit = UNIT) -> int32:
                     return out_arg
 
-                def _arrow44(v: int32) -> None:
+                def _arrow49(v: int32) -> None:
                     nonlocal out_arg
                     out_arg = v
 
-                match_value = (try_get_value(dict_1, key, FSharpRef(_arrow43, _arrow44)), out_arg)
+                match_value = (try_get_value(dict_1, key, FSharpRef(_arrow47, _arrow49)), out_arg)
                 if match_value[0]:
                     dict_1[key] = match_value[1] + int32.ONE
 
@@ -83,18 +83,18 @@ def count_by[T, KEY](
                     dict_1[key] = int32.ONE
                     (keys.append(key))
 
-        def _arrow45(key_1: KEY = UNIT) -> tuple[KEY, int32]:
+        def _arrow50(key_1: KEY = UNIT) -> tuple[KEY, int32]:
             return (key_1, get_item_from_dict(dict_1, key_1))
 
-        return map(_arrow45, to_enumerable(keys))
+        return map(_arrow50, to_enumerable(keys))
 
-    return delay(_arrow46)
+    return delay(_arrow51)
 
 
 def group_by[T, KEY](
     projection: Callable[[T], KEY], xs: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]
 ) -> IEnumerable_1[tuple[KEY, IEnumerable_1[T]]]:
-    def _arrow50(
+    def _arrow55(
         projection: Any = projection, xs: Any = xs, comparer: Any = comparer
     ) -> IEnumerable_1[tuple[KEY, IEnumerable_1[T]]]:
         dict_1: Any = Dictionary(Array[Any]([]), comparer)
@@ -106,14 +106,14 @@ def group_by[T, KEY](
                 match_value: tuple[bool, list[Any]]
                 out_arg: list[Any] = cast(list[Any], None)
 
-                def _arrow47(__unit: Unit = UNIT) -> list[T]:
+                def _arrow52(__unit: Unit = UNIT) -> list[T]:
                     return out_arg
 
-                def _arrow48(v: list[T]) -> None:
+                def _arrow53(v: list[T]) -> None:
                     nonlocal out_arg
                     out_arg = v
 
-                match_value = (try_get_value(dict_1, key, FSharpRef(_arrow47, _arrow48)), out_arg)
+                match_value = (try_get_value(dict_1, key, FSharpRef(_arrow52, _arrow53)), out_arg)
                 if match_value[0]:
                     (match_value[1].append(x))
 
@@ -121,12 +121,12 @@ def group_by[T, KEY](
                     add_to_dict(dict_1, key, [x])
                     (keys.append(key))
 
-        def _arrow49(key_1: KEY = UNIT) -> tuple[KEY, IEnumerable_1[T]]:
+        def _arrow54(key_1: KEY = UNIT) -> tuple[KEY, IEnumerable_1[T]]:
             return (key_1, to_enumerable(get_item_from_dict(dict_1, key_1)))
 
-        return map(_arrow49, to_enumerable(keys))
+        return map(_arrow54, to_enumerable(keys))
 
-    return delay(_arrow50)
+    return delay(_arrow55)
 
 
 def Array_distinct[T](xs: Array[T], comparer: IEqualityComparer_1[Any]) -> Array[T]:

{fable_library-5.3.0 → fable_library-5.4.0}/fable_library/set.py

@@ -40,7 +40,7 @@ from .system import NotSupportedException__ctor_Z721C83C5
 from .util import UNIT, Disposable, Unit, get_enumerator, ignore, nullable, structural_hash
 
 
-def _expr216(gen0: TypeInfo) -> TypeInfo:
+def _expr197(gen0: TypeInfo) -> TypeInfo:
     return class_type("Set.SetTreeLeaf`1", Array([gen0]), SetTreeLeaf_1)
 
 
@@ -49,7 +49,7 @@ class SetTreeLeaf_1[T]:
         self.k: Any = k
 
 
-SetTreeLeaf_1_reflection = _expr216
+SetTreeLeaf_1_reflection = _expr197
 
 
 def SetTreeLeaf_1__ctor_2B595[T](k: T = UNIT) -> SetTreeLeaf_1[T]:
@@ -60,7 +60,7 @@ def SetTreeLeaf_1__get_Key[T](_: SetTreeLeaf_1[T]) -> T:
     return _.k
 
 
-def _expr217(gen0: TypeInfo) -> TypeInfo:
+def _expr198(gen0: TypeInfo) -> TypeInfo:
     return class_type("Set.SetTreeNode`1", Array([gen0]), SetTreeNode_1, SetTreeLeaf_1_reflection(gen0))
 
 
@@ -72,7 +72,7 @@ class SetTreeNode_1[T](SetTreeLeaf_1):
         self.h: int32 = h
 
 
-SetTreeNode_1_reflection = _expr217
+SetTreeNode_1_reflection = _expr198
 
 
 def SetTreeNode_1__ctor_5F465FC9[T](
@@ -174,7 +174,7 @@ def SetTreeModule_rebalance[T](
         if isinstance(match_value, SetTreeNode_1):
             t2_0027: SetTreeNode_1[Any] = match_value
 
-            def _arrow218(__unit: Unit = UNIT) -> int32:
+            def _arrow201(__unit: Unit = UNIT) -> int32:
                 t_2: SetTreeLeaf_1[Any] | None = erase(SetTreeNode_1__get_Left(t2_0027))
                 if t_2 is not None:
                     t2_3: SetTreeLeaf_1[Any] = t_2
@@ -183,7 +183,7 @@ def SetTreeModule_rebalance[T](
                 else:
                     return int32.ZERO
 
-            if _arrow218() > (t1h + int32.ONE):
+            if _arrow201() > (t1h + int32.ONE):
                 match_value_1: SetTreeLeaf_1[Any] = value_1(SetTreeNode_1__get_Left(t2_0027))
                 if isinstance(match_value_1, SetTreeNode_1):
                     t2l: SetTreeNode_1[Any] = match_value_1
@@ -219,7 +219,7 @@ def SetTreeModule_rebalance[T](
         if isinstance(match_value_2, SetTreeNode_1):
             t1_0027: SetTreeNode_1[Any] = match_value_2
 
-            def _arrow219(__unit: Unit = UNIT) -> int32:
+            def _arrow204(__unit: Unit = UNIT) -> int32:
                 t_3: SetTreeLeaf_1[Any] | None = erase(SetTreeNode_1__get_Right(t1_0027))
                 if t_3 is not None:
                     t2_4: SetTreeLeaf_1[Any] = t_3
@@ -228,7 +228,7 @@ def SetTreeModule_rebalance[T](
                 else:
                     return int32.ZERO
 
-            if _arrow219() > (t2h + int32.ONE):
+            if _arrow204() > (t2h + int32.ONE):
                 match_value_3: SetTreeLeaf_1[Any] = value_1(SetTreeNode_1__get_Right(t1_0027))
                 if isinstance(match_value_3, SetTreeNode_1):
                     t1r: SetTreeNode_1[Any] = match_value_3