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

{fable_library-5.2.0 → fable_library-5.3.0}/Cargo.lock

@@ -179,9 +179,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
 dependencies = [
  "chrono",
  "libc",
@@ -194,18 +194,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -213,9 +213,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -225,13 +225,12 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn",
 ]

{fable_library-5.2.0 → fable_library-5.3.0}/Cargo.toml

@@ -12,7 +12,7 @@ name = "_core"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = { version = "0.28.3", features = ["extension-module", "chrono"] }
+pyo3 = { version = "0.29.0", features = ["extension-module", "chrono"] }
 byteorder = "1.5.0"
 chrono = "0.4.45"
 regex = "1.12.4"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fable-library
-Version: 5.2.0
+Version: 5.3.0
 Summary: Fable library for Python
 Author-email: Dag Brattli <dag@brattli.net>
 License-Expression: MIT License

fable_library-5.3.0/fable_library/_version.py

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

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

@@ -269,7 +269,7 @@ def FSharpList__get_Head[T](xs: FSharpList[T]) -> T:
         return xs.head_
 
     else:
-        raise Exception((SR_inputWasEmpty + "\\nParameter name: ") + "list")
+        raise Exception(SR_inputWasEmpty + " (Parameter 'list')")
 
 
 def FSharpList__get_Tail[T](xs: FSharpList[T]) -> FSharpList[T]:
@@ -278,7 +278,7 @@ def FSharpList__get_Tail[T](xs: FSharpList[T]) -> FSharpList[T]:
         return match_value
 
     else:
-        raise Exception((SR_inputWasEmpty + "\\nParameter name: ") + "list")
+        raise Exception(SR_inputWasEmpty + " (Parameter 'list')")
 
 
 def FSharpList__get_Item_Z524259A4[T](xs: FSharpList[T], index: int32) -> T:
@@ -296,7 +296,7 @@ def FSharpList__get_Item_Z524259A4[T](xs: FSharpList[T], index: int32) -> T:
                     continue
 
             else:
-                raise Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index")
+                raise Exception(SR_indexOutOfBounds + " (Parameter 'index')")
 
             break
 
@@ -695,10 +695,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 _arrow40(i: int32, x: _A) -> tuple[int32, _A]:
+    def _arrow51(i: int32, x: _A) -> tuple[int32, _A]:
         return (i, x)
 
-    return map_indexed(_arrow40, xs)
+    return map_indexed(_arrow51, xs)
 
 
 def map2[T1, T2, U](mapping: Callable[[T1, T2], U], xs: FSharpList[T1], ys: FSharpList[T2]) -> FSharpList[U]:
@@ -729,14 +729,14 @@ def map_indexed2[T1, T2, U](
             else:
                 i_mut = i + int32.ONE
 
-                def _arrow41(i: Any = i, acc: Any = acc, xs_1: Any = xs_1, ys_1: Any = ys_1) -> FSharpList[U]:
+                def _arrow52(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 = _arrow41()
+                acc_mut = _arrow52()
                 xs_1_mut = FSharpList__get_Tail(xs_1)
                 ys_1_mut = FSharpList__get_Tail(ys_1)
                 continue
@@ -771,7 +771,7 @@ def map3[T1, T2, T3, U](
 
             else:
 
-                def _arrow42(acc: Any = acc, xs_1: Any = xs_1, ys_1: Any = ys_1, zs_1: Any = zs_1) -> FSharpList[U]:
+                def _arrow53(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 +779,7 @@ def map3[T1, T2, T3, U](
                     acc.tail_ = t
                     return t
 
-                acc_mut = _arrow42()
+                acc_mut = _arrow53()
                 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 +804,12 @@ def map_fold[STATE, T, RESULT](
     ) -> tuple[FSharpList[RESULT], STATE]:
         pattern_input: tuple[Any, Any] = mapping(tupled_arg[1], x)
 
-        def _arrow43(tupled_arg: Any = tupled_arg) -> FSharpList[RESULT]:
+        def _arrow54(tupled_arg: Any = tupled_arg) -> FSharpList[RESULT]:
             t: FSharpList[Any] = FSharpList(pattern_input[0], None)
             tupled_arg[0].tail_ = t
             return t
 
-        return (_arrow43(), pattern_input[1])
+        return (_arrow54(), pattern_input[1])
 
     pattern_input_1: tuple[FSharpList[Any], Any] = fold(folder, (root, state), xs)
     t_2: FSharpList[Any] = FSharpList_get_Empty()
@@ -820,10 +820,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 _arrow44(acc: STATE, x: T, mapping: Any = mapping) -> tuple[RESULT, STATE]:
+    def _arrow55(acc: STATE, x: T, mapping: Any = mapping) -> tuple[RESULT, STATE]:
         return mapping(x, acc)
 
-    return map_fold(_arrow44, state, reverse(xs))
+    return map_fold(_arrow55, state, reverse(xs))
 
 
 def try_pick[T, _A](f: Callable[[T], Option[_A]], xs: FSharpList[T]) -> Option[_A]:
@@ -857,10 +857,10 @@ def pick[_A, _B](f: Callable[[_A], Option[_B]], xs: FSharpList[_A]) -> _B:
 
 
 def try_find[_A](f: Callable[[_A], bool], xs: FSharpList[_A]) -> Option[_A]:
-    def _arrow45(x: _A = UNIT, f: Any = f) -> Option[_A]:
+    def _arrow56(x: _A = UNIT, f: Any = f) -> Option[_A]:
         return some(x) if f(x) else None
 
-    return try_pick(_arrow45, xs)
+    return try_pick(_arrow56, xs)
 
 
 def find[_A](f: Callable[[_A], bool], xs: FSharpList[_A]) -> _A:
@@ -983,21 +983,21 @@ def partition[T](f: Callable[[T], bool], xs: FSharpList[T]) -> tuple[FSharpList[
         racc: FSharpList[Any] = tupled_arg[1]
         if f(x):
 
-            def _arrow46(x: Any = x) -> FSharpList[T]:
+            def _arrow57(x: Any = x) -> FSharpList[T]:
                 t: FSharpList[Any] = FSharpList(x, None)
                 lacc.tail_ = t
                 return t
 
-            return (_arrow46(), racc)
+            return (_arrow57(), racc)
 
         else:
 
-            def _arrow47(x: Any = x) -> FSharpList[T]:
+            def _arrow58(x: Any = x) -> FSharpList[T]:
                 t_2: FSharpList[Any] = FSharpList(x, None)
                 racc.tail_ = t_2
                 return t_2
 
-            return (lacc, _arrow47())
+            return (lacc, _arrow58())
 
     pattern_input_1: tuple[FSharpList[Any], FSharpList[Any]] = fold(folder, (root1, root2), xs)
     t_4: FSharpList[Any] = FSharpList_get_Empty()
@@ -1125,7 +1125,7 @@ def exists2[T1, T2](f_mut: Callable[[T1, T2], bool], xs_mut: FSharpList[T1], ys_
                 continue
 
         else:
-            raise Exception((SR_differentLengths + "\\nParameter name: ") + "list2")
+            raise Exception(SR_differentLengths + " (Parameter 'list2')")
 
         break
 
@@ -1283,21 +1283,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 _arrow81(x: T1 = UNIT, ys: Any = ys) -> None:
-        def _arrow80(y: T2 = UNIT) -> None:
+    def _arrow87(x: T1 = UNIT, ys: Any = ys) -> None:
+        def _arrow86(y: T2 = UNIT) -> None:
             nonlocal node
 
-            def _arrow79(__unit: Unit = UNIT) -> FSharpList[tuple[T1, T2]]:
+            def _arrow85(__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 = _arrow79()
+            node = _arrow85()
 
-        iterate(_arrow80, ys)
+        iterate(_arrow86, ys)
 
-    iterate(_arrow81, xs)
+    iterate(_arrow87, xs)
     xs_3: FSharpList[tuple[Any, Any]] = node
     t_2: FSharpList[tuple[Any, Any]] = FSharpList_get_Empty()
     xs_3.tail_ = t_2
@@ -1311,7 +1311,7 @@ def skip[T](count_mut: int32, xs_mut: FSharpList[T]) -> FSharpList[T]:
             return xs
 
         elif FSharpList__get_IsEmpty(xs):
-            raise Exception((SR_notEnoughElements + "\\nParameter name: ") + "list")
+            raise Exception(SR_notEnoughElements + " (Parameter 'list')")
 
         else:
             count_mut = count - int32.ONE
@@ -1340,7 +1340,7 @@ def skip_while[T](predicate_mut: Callable[[T], bool], xs_mut: FSharpList[T]) ->
 
 def take[T](count: int32, xs: FSharpList[T]) -> FSharpList[T]:
     if count < int32.ZERO:
-        raise Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "count")
+        raise Exception(SR_inputMustBeNonNegative + " (Parameter 'count')")
 
     def loop(i_mut: int32, acc_mut: FSharpList[T], xs_1_mut: FSharpList[T]) -> FSharpList[T]:
         while True:
@@ -1349,17 +1349,17 @@ def take[T](count: int32, xs: FSharpList[T]) -> FSharpList[T]:
                 return acc
 
             elif FSharpList__get_IsEmpty(xs_1):
-                raise Exception((SR_notEnoughElements + "\\nParameter name: ") + "list")
+                raise Exception(SR_notEnoughElements + " (Parameter 'list')")
 
             else:
                 i_mut = i - int32.ONE
 
-                def _arrow82(acc: Any = acc, xs_1: Any = xs_1) -> FSharpList[T]:
+                def _arrow88(acc: Any = acc, xs_1: Any = xs_1) -> FSharpList[T]:
                     t: FSharpList[Any] = FSharpList(FSharpList__get_Head(xs_1), None)
                     acc.tail_ = t
                     return t
 
-                acc_mut = _arrow82()
+                acc_mut = _arrow88()
                 xs_1_mut = FSharpList__get_Tail(xs_1)
                 continue
 
@@ -1384,12 +1384,12 @@ def take_while[T](predicate: Callable[[T], bool], xs: FSharpList[T]) -> FSharpLi
 
             else:
 
-                def _arrow83(acc: Any = acc, xs_1: Any = xs_1) -> FSharpList[T]:
+                def _arrow89(acc: Any = acc, xs_1: Any = xs_1) -> FSharpList[T]:
                     t: FSharpList[Any] = FSharpList(FSharpList__get_Head(xs_1), None)
                     acc.tail_ = t
                     return t
 
-                acc_mut = _arrow83()
+                acc_mut = _arrow89()
                 xs_1_mut = FSharpList__get_Tail(xs_1)
                 continue
 
@@ -1415,12 +1415,12 @@ def truncate[T](count: int32, xs: FSharpList[T]) -> FSharpList[T]:
             else:
                 i_mut = i - int32.ONE
 
-                def _arrow84(acc: Any = acc, xs_1: Any = xs_1) -> FSharpList[T]:
+                def _arrow90(acc: Any = acc, xs_1: Any = xs_1) -> FSharpList[T]:
                     t: FSharpList[Any] = FSharpList(FSharpList__get_Head(xs_1), None)
                     acc.tail_ = t
                     return t
 
-                acc_mut = _arrow84()
+                acc_mut = _arrow90()
                 xs_1_mut = FSharpList__get_Tail(xs_1)
                 continue
 
@@ -1450,23 +1450,23 @@ def get_slice[T](start_index: int32 | None, end_index: int32 | None, xs: FSharpL
 
 def split_at[T](index: int32, xs: FSharpList[T]) -> tuple[FSharpList[T], FSharpList[T]]:
     if index < int32.ZERO:
-        raise Exception((SR_inputMustBeNonNegative + "\\nParameter name: ") + "index")
+        raise Exception(SR_inputMustBeNonNegative + " (Parameter 'index')")
 
     if index > FSharpList__get_Length(xs):
-        raise Exception((SR_notEnoughElements + "\\nParameter name: ") + "index")
+        raise Exception(SR_notEnoughElements + " (Parameter 'index')")
 
     return (take(index, xs), skip(index, xs))
 
 
 def exactly_one[T](xs: FSharpList[T]) -> T:
     if FSharpList__get_IsEmpty(xs):
-        raise Exception((SR_inputSequenceEmpty + "\\nParameter name: ") + "list")
+        raise Exception(SR_inputSequenceEmpty + " (Parameter 'list')")
 
     elif FSharpList__get_IsEmpty(FSharpList__get_Tail(xs)):
         return FSharpList__get_Head(xs)
 
     else:
-        raise Exception((SR_inputSequenceTooLong + "\\nParameter name: ") + "list")
+        raise Exception(SR_inputSequenceTooLong + " (Parameter 'list')")
 
 
 def try_exactly_one[T](xs: FSharpList[T]) -> Option[T]:
@@ -1513,11 +1513,11 @@ def insert_at[T](index: int32, y: T, xs: FSharpList[T]) -> FSharpList[T]:
 
     result: FSharpList[Any] = fold(folder, FSharpList_get_Empty(), xs)
 
-    def _arrow85(__unit: Unit = UNIT) -> FSharpList[T]:
-        raise Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index")
+    def _arrow91(__unit: Unit = UNIT) -> FSharpList[T]:
+        raise Exception(SR_indexOutOfBounds + " (Parameter 'index')")
 
     return reverse(
-        result if is_done else (FSharpList_Cons_305B8EAC(y, result) if ((i + int32.ONE) == index) else _arrow85())
+        result if is_done else (FSharpList_Cons_305B8EAC(y, result) if ((i + int32.ONE) == index) else _arrow91())
     )
 
 
@@ -1538,10 +1538,10 @@ def insert_many_at[T](index: int32, ys: IEnumerable_1[T], xs: FSharpList[T]) ->
 
     result: FSharpList[Any] = fold(folder, FSharpList_get_Empty(), xs)
 
-    def _arrow91(__unit: Unit = UNIT) -> FSharpList[T]:
-        raise Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index")
+    def _arrow92(__unit: Unit = UNIT) -> FSharpList[T]:
+        raise Exception(SR_indexOutOfBounds + " (Parameter 'index')")
 
-    return reverse(result if is_done else (append(ys_1, result) if ((i + int32.ONE) == index) else _arrow91()))
+    return reverse(result if is_done else (append(ys_1, result) if ((i + int32.ONE) == index) else _arrow92()))
 
 
 def remove_at[T](index: int32, xs: FSharpList[T]) -> FSharpList[T]:
@@ -1560,7 +1560,7 @@ def remove_at[T](index: int32, xs: FSharpList[T]) -> FSharpList[T]:
 
     ys: FSharpList[Any] = filter(f, xs)
     if not is_done:
-        raise Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index")
+        raise Exception(SR_indexOutOfBounds + " (Parameter 'index')")
 
     return ys
 
@@ -1593,7 +1593,7 @@ def remove_many_at[T](index: int32, count: int32, xs: FSharpList[T]) -> FSharpLi
     )
     if status_1 < int32.ONE:
         raise Exception(
-            (SR_indexOutOfBounds + "\\nParameter name: ") + ("index" if (status_1 < int32.ZERO) else "count")
+            SR_indexOutOfBounds + ((" (Parameter '" + ("index" if (status_1 < int32.ZERO) else "count")) + "')")
         )
 
     return ys
@@ -1613,7 +1613,7 @@ def update_at[T](index: int32, y: T, xs: FSharpList[T]) -> FSharpList[T]:
 
     ys: FSharpList[Any] = map_indexed(mapping, xs)
     if not is_done:
-        raise Exception((SR_indexOutOfBounds + "\\nParameter name: ") + "index")
+        raise Exception(SR_indexOutOfBounds + " (Parameter 'index')")
 
     return ys
 

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

@@ -20,7 +20,7 @@ from .types import FSharpRef as FSharpRef_1
 from .util import UNIT, Disposable, Unit, dispose, equals, get_enumerator, ignore, nullable, to_enumerable
 
 
-def _expr13(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
+def _expr17(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
     return class_type("Fable.Collections.Dictionary", Array([gen0, gen1]), Dictionary)
 
 
@@ -126,13 +126,13 @@ class Dictionary[KEY, VALUE](MutableMapping[Any, Any], Mapping[Any, Any], Enumer
     def System_Collections_Generic_IDictionary_2_get_Keys(self, __unit: Unit = UNIT) -> ICollection[KEY]:
         this: Dictionary[Any, Any] = self
 
-        def _arrow9(__unit: Unit = UNIT) -> IEnumerable_1[KEY]:
-            def _arrow8(pair: Any) -> KEY:
+        def _arrow14(__unit: Unit = UNIT) -> IEnumerable_1[KEY]:
+            def _arrow13(pair: Any) -> KEY:
                 return pair[0]
 
-            return map(_arrow8, this)
+            return map(_arrow13, this)
 
-        return Array[Any](delay(_arrow9))
+        return Array[Any](delay(_arrow14))
 
     def System_Collections_Generic_IDictionary_2_Remove2B595(self, key: KEY = UNIT) -> bool:
         this: Dictionary[Any, Any] = self
@@ -152,13 +152,13 @@ class Dictionary[KEY, VALUE](MutableMapping[Any, Any], Mapping[Any, Any], Enumer
     def System_Collections_Generic_IDictionary_2_get_Values(self, __unit: Unit = UNIT) -> ICollection[VALUE]:
         this: Dictionary[Any, Any] = self
 
-        def _arrow11(__unit: Unit = UNIT) -> IEnumerable_1[VALUE]:
-            def _arrow10(pair: Any) -> VALUE:
+        def _arrow16(__unit: Unit = UNIT) -> IEnumerable_1[VALUE]:
+            def _arrow15(pair: Any) -> VALUE:
                 return pair[1]
 
-            return map(_arrow10, this)
+            return map(_arrow15, this)
 
-        return Array[Any](delay(_arrow11))
+        return Array[Any](delay(_arrow16))
 
     def get_item(self, key: KEY = UNIT) -> VALUE:
         this: Dictionary[Any, Any] = self
@@ -205,7 +205,7 @@ class Dictionary[KEY, VALUE](MutableMapping[Any, Any], Mapping[Any, Any], Enumer
         self.Remove(key)
 
 
-Dictionary_reflection = _expr13
+Dictionary_reflection = _expr17
 
 
 def Dictionary__ctor_6623D9B3[KEY, VALUE](
@@ -219,20 +219,20 @@ def Dictionary__TryFindIndex_2B595[KEY, VALUE](this: Dictionary[KEY, VALUE], k:
     match_value: tuple[bool, list[Any]]
     out_arg: list[Any] = cast(list[Any], None)
 
-    def _arrow15(__unit: Unit = UNIT) -> list[Any]:
+    def _arrow18(__unit: Unit = UNIT) -> list[Any]:
         return out_arg
 
-    def _arrow17(v: list[Any]) -> None:
+    def _arrow19(v: list[Any]) -> None:
         nonlocal out_arg
         out_arg = v
 
-    match_value = (try_get_value(this.hash_map, h, FSharpRef(_arrow15, _arrow17)), out_arg)
+    match_value = (try_get_value(this.hash_map, h, FSharpRef(_arrow18, _arrow19)), out_arg)
     if match_value[0]:
 
-        def _arrow19(pair: Any, this: Any = this, k: Any = k) -> bool:
+        def _arrow20(pair: Any, this: Any = this, k: Any = k) -> bool:
             return this.comparer.Equals(k, pair[0])
 
-        return (True, h, find_index(_arrow19, match_value[1]))
+        return (True, h, find_index(_arrow20, match_value[1]))
 
     else:
         return (False, h, int32.NEG_ONE)

{fable_library-5.2.0 → fable_library-5.3.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 _expr12(gen0: TypeInfo) -> TypeInfo:
+def _expr8(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 = _expr12
+HashSet_reflection = _expr8
 
 
 def HashSet__ctor_Z6150332D[T](items: IEnumerable_1[T], comparer: IEqualityComparer_1[Any]) -> HashSet[T]:
@@ -123,20 +123,20 @@ def HashSet__TryFindIndex_2B595[T](this: HashSet[T], k: T) -> tuple[bool, int32,
     match_value: tuple[bool, list[Any]]
     out_arg: list[Any] = cast(list[Any], None)
 
-    def _arrow14(__unit: Unit = UNIT) -> list[T]:
+    def _arrow10(__unit: Unit = UNIT) -> list[T]:
         return out_arg
 
-    def _arrow16(v: list[T]) -> None:
+    def _arrow11(v: list[T]) -> None:
         nonlocal out_arg
         out_arg = v
 
-    match_value = (try_get_value(this.hash_map, h, FSharpRef_1(_arrow14, _arrow16)), out_arg)
+    match_value = (try_get_value(this.hash_map, h, FSharpRef_1(_arrow10, _arrow11)), out_arg)
     if match_value[0]:
 
-        def _arrow18(v_1: T = UNIT, this: Any = this, k: Any = k) -> bool:
+        def _arrow12(v_1: T = UNIT, this: Any = this, k: Any = k) -> bool:
             return this.comparer.Equals(k, v_1)
 
-        return (True, h, find_index(_arrow18, match_value[1]))
+        return (True, h, find_index(_arrow12, match_value[1]))
 
     else:
         return (False, h, int32.NEG_ONE)

{fable_library-5.2.0 → fable_library-5.3.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 _arrow86(x: T = UNIT, step: Any = step, stop: Any = stop, add: Any = add) -> tuple[T, T] | None:
+    def _arrow79(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 _arrow86
+    return _arrow79
 
 
 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 _arrow87(start: Any = start) -> IEnumerable_1[T]:
+    def _arrow80(start: Any = start) -> IEnumerable_1[T]:
         return unfold(step_fn, start)
 
-    return delay(_arrow87)
+    return delay(_arrow80)
 
 
 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 _arrow88(x: float64, y: float64) -> float64:
+    def _arrow81(x: float64, y: float64) -> float64:
         return x + y
 
-    return integral_range_step(start, step, stop, float64(0.0), _arrow88)
+    return integral_range_step(start, step, stop, float64(0.0), _arrow81)
 
 
 def range_int32(start: int32, step: int32, stop: int32) -> IEnumerable_1[int32]:
-    def _arrow89(x: int32, y: int32) -> int32:
+    def _arrow82(x: int32, y: int32) -> int32:
         return x + y
 
-    return integral_range_step(start, step, stop, int32.ZERO, _arrow89)
+    return integral_range_step(start, step, stop, int32.ZERO, _arrow82)
 
 
 def range_uint32(start: uint32, step: uint32, stop: uint32) -> IEnumerable_1[uint32]:
-    def _arrow90(x: uint32, y: uint32) -> uint32:
+    def _arrow83(x: uint32, y: uint32) -> uint32:
         return x + y
 
-    return integral_range_step(start, step, stop, uint32.ZERO, _arrow90)
+    return integral_range_step(start, step, stop, uint32.ZERO, _arrow83)
 
 
 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 _arrow92(start: Any = start) -> IEnumerable_1[str]:
+    def _arrow84(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(_arrow92)
+    return delay(_arrow84)
 
 
 __all__ = [

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

@@ -12,7 +12,7 @@ from .union import Union, tagged_union
 from .util import equals
 
 
-def _expr20(gen0: TypeInfo, gen1: TypeInfo) -> TypeInfo:
+def _expr9(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 = _expr20
+FSharpResult_2_reflection = _expr9
 
 
 def Result_Map[A, B, C](mapping: Callable[[A], B], result: FSharpResult_2[A, C]) -> FSharpResult_2[B, C]: