arctrl 3.0.0a3__py3-none-any.whl

arctrl/py/ContractIO/file_system_helper.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+from collections.abc import Callable
+from pathlib import Path
+import shutil
+import os
+from typing import Any
+from ..cross_async import all
+from ..fable_modules.fable_library.array_ import map
+from ..fable_modules.fable_library.async_builder import (singleton, Async)
+from ..fable_modules.fable_library.seq import (is_empty, empty, map as map_1, concat, append, to_array)
+from ..fable_modules.fable_library.string_ import (starts_with_exact, trim as trim_1, replace, substring)
+from ..fable_modules.fable_library.types import Array
+from ..fable_modules.fable_library.util import (IEnumerable_1, to_enumerable)
+from ..fable_modules.fs_spreadsheet.fs_workbook import FsWorkbook
+from ..fable_modules.fs_spreadsheet_py.fs_extension import (FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5, FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static)
+
+shutil
+
+os
+
+Path
+
+def directory_exists_async(path: str) -> Async[bool]:
+    def _arrow3579(__unit: None=None, path: Any=path) -> Async[bool]:
+        return singleton.Return(Path(path).is_dir())
+
+    return singleton.Delay(_arrow3579)
+
+
+def create_directory_async(path: str) -> Async[None]:
+    def _arrow3580(__unit: None=None, path: Any=path) -> Async[None]:
+        Path(path).mkdir(parents=True, exist_ok=True)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3580)
+
+
+def ensure_directory_async(path: str) -> Async[None]:
+    def _arrow3582(__unit: None=None, path: Any=path) -> Async[None]:
+        def _arrow3581(_arg: bool) -> Async[None]:
+            return singleton.ReturnFrom(create_directory_async(path)) if (not _arg) else singleton.Zero()
+
+        return singleton.Bind(directory_exists_async(path), _arrow3581)
+
+    return singleton.Delay(_arrow3582)
+
+
+def ensure_directory_of_file_async(file_path: str) -> Async[None]:
+    def _arrow3583(__unit: None=None, file_path: Any=file_path) -> Async[None]:
+        return singleton.ReturnFrom(ensure_directory_async(Path(file_path).parent))
+
+    return singleton.Delay(_arrow3583)
+
+
+def file_exists_async(path: str) -> Async[bool]:
+    def _arrow3584(__unit: None=None, path: Any=path) -> Async[bool]:
+        return singleton.Return(Path(path).is_file())
+
+    return singleton.Delay(_arrow3584)
+
+
+def read_file_text_async(path: str) -> Async[str]:
+    def _arrow3586(__unit: None=None, path: Any=path) -> Async[str]:
+        def _arrow3585(__unit: None=None) -> str:
+            with open(path, 'r', encoding='utf-8') as f: return f.read()
+
+        return singleton.Return(_arrow3585())
+
+    return singleton.Delay(_arrow3586)
+
+
+def read_file_binary_async(path: str) -> Async[bytearray]:
+    def _arrow3588(__unit: None=None, path: Any=path) -> Async[bytearray]:
+        def _arrow3587(__unit: None=None) -> bytearray:
+            with open(path, 'rb') as f: return f.read()
+
+        return singleton.Return(_arrow3587())
+
+    return singleton.Delay(_arrow3588)
+
+
+def read_file_xlsx_async(path: str) -> Async[FsWorkbook]:
+    def _arrow3589(__unit: None=None, path: Any=path) -> Async[FsWorkbook]:
+        return singleton.Return(FsSpreadsheet_FsWorkbook__FsWorkbook_fromXlsxFile_Static_Z721C83C5(path))
+
+    return singleton.Delay(_arrow3589)
+
+
+def move_file_async(old_path: str, new_path: str) -> Async[None]:
+    def _arrow3590(__unit: None=None, old_path: Any=old_path, new_path: Any=new_path) -> Async[None]:
+        shutil.move(old_path, new_path)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3590)
+
+
+def move_directory_async(old_path: str, new_path: str) -> Async[None]:
+    return move_file_async(old_path, new_path)
+
+
+def delete_file_async(path: str) -> Async[None]:
+    def _arrow3591(__unit: None=None, path: Any=path) -> Async[None]:
+        try:
+            os.remove(path)
+        except FileNotFoundError:
+            pass
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3591)
+
+
+def delete_directory_async(path: str) -> Async[None]:
+    def _arrow3592(__unit: None=None, path: Any=path) -> Async[None]:
+        shutil.rmtree(path, ignore_errors=True)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3592)
+
+
+def write_file_text_async(path: str, text: str) -> Async[None]:
+    def _arrow3593(__unit: None=None, path: Any=path, text: Any=text) -> Async[None]:
+        with open(path, 'w') as f: f.write(text)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3593)
+
+
+def write_file_binary_async(path: str, bytes: bytearray) -> Async[None]:
+    def _arrow3594(__unit: None=None, path: Any=path, bytes: Any=bytes) -> Async[None]:
+        with open(path, 'wb') as f: f.write(bytes)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3594)
+
+
+def write_file_xlsx_async(path: str, wb: FsWorkbook) -> Async[None]:
+    def _arrow3595(__unit: None=None, path: Any=path, wb: Any=wb) -> Async[None]:
+        FsSpreadsheet_FsWorkbook__FsWorkbook_toXlsxFile_Static(path, wb)
+        return singleton.Zero()
+
+    return singleton.Delay(_arrow3595)
+
+
+def trim(path: str) -> str:
+    if starts_with_exact(path, "./"):
+        return trim_1(replace(path, "./", ""), "/")
+
+    else: 
+        return trim_1(path, "/")
+
+
+
+def make_relative(directory_path: str, path: str) -> str:
+    if True if (True if (directory_path == ".") else (directory_path == "/")) else (directory_path == ""):
+        return path
+
+    else: 
+        directory_path_1: str = trim(directory_path)
+        path_1: str = trim(path)
+        if starts_with_exact(path_1, directory_path_1):
+            return substring(path_1, len(directory_path_1))
+
+        else: 
+            return path_1
+
+
+
+
+def standardize_slashes(path: str) -> str:
+    return replace(path, "\\", "/")
+
+
+def get_sub_directories_async(path: str) -> Async[Array[str]]:
+    def _arrow3596(__unit: None=None, path: Any=path) -> Async[Array[str]]:
+        paths: Array[str] = [str(entry) for entry in Path(path).iterdir() if entry.is_dir()]
+        return singleton.Return(map(standardize_slashes, paths, None))
+
+    return singleton.Delay(_arrow3596)
+
+
+def get_sub_files_async(path: str) -> Async[Array[str]]:
+    def _arrow3597(__unit: None=None, path: Any=path) -> Async[Array[str]]:
+        paths: Array[str] = [str(entry) for entry in Path(path).iterdir() if entry.is_file()]
+        return singleton.Return(map(standardize_slashes, paths, None))
+
+    return singleton.Delay(_arrow3597)
+
+
+def get_all_file_paths_async(directory_path: str) -> Async[Array[str]]:
+    directory_path_1: str = standardize_slashes(directory_path)
+    def _arrow3603(__unit: None=None, directory_path: Any=directory_path) -> Async[Array[str]]:
+        def all_files(dirs: IEnumerable_1[str]) -> Async[IEnumerable_1[str]]:
+            def _arrow3601(__unit: None=None, dirs: Any=dirs) -> Async[IEnumerable_1[str]]:
+                def _arrow3600(_arg: Array[Array[str]]) -> Async[IEnumerable_1[str]]:
+                    sub_files_1: IEnumerable_1[str] = concat(_arg)
+                    def _arrow3599(_arg_1: Array[Array[str]]) -> Async[IEnumerable_1[str]]:
+                        def _arrow3598(_arg_2: Array[IEnumerable_1[str]]) -> Async[IEnumerable_1[str]]:
+                            sub_dir_contents_1: IEnumerable_1[str] = concat(_arg_2)
+                            return singleton.Return(append(sub_dir_contents_1, sub_files_1))
+
+                        return singleton.Bind(all(map_1(all_files, _arg_1)), _arrow3598)
+
+                    return singleton.Bind(all(map_1(get_sub_directories_async, dirs)), _arrow3599)
+
+                return singleton.Return(empty()) if is_empty(dirs) else singleton.Bind(all(map_1(get_sub_files_async, dirs)), _arrow3600)
+
+            return singleton.Delay(_arrow3601)
+
+        def _arrow3602(_arg_3: IEnumerable_1[str]) -> Async[Array[str]]:
+            def mapping_1(arg_2: str) -> str:
+                return standardize_slashes(make_relative(directory_path_1, arg_2))
+
+            all_files_relative: Array[str] = map(mapping_1, to_array(_arg_3), None)
+            return singleton.Return(all_files_relative)
+
+        return singleton.Bind(all_files(to_enumerable([directory_path_1])), _arrow3602)
+
+    return singleton.Delay(_arrow3603)
+
+
+def rename_file_or_directory_async(old_path: str, new_path: str) -> Async[None]:
+    def _arrow3606(__unit: None=None, old_path: Any=old_path, new_path: Any=new_path) -> Async[None]:
+        def _arrow3605(_arg: bool) -> Async[None]:
+            def _arrow3604(_arg_1: bool) -> Async[None]:
+                if _arg:
+                    return singleton.ReturnFrom(move_file_async(old_path, new_path))
+
+                elif _arg_1:
+                    return singleton.ReturnFrom(move_directory_async(old_path, new_path))
+
+                else: 
+                    return singleton.Zero()
+
+
+            return singleton.Bind(directory_exists_async(old_path), _arrow3604)
+
+        return singleton.Bind(file_exists_async(old_path), _arrow3605)
+
+    return singleton.Delay(_arrow3606)
+
+
+def delete_file_or_directory_async(path: str) -> Async[None]:
+    def _arrow3609(__unit: None=None, path: Any=path) -> Async[None]:
+        def _arrow3608(_arg: bool) -> Async[None]:
+            def _arrow3607(_arg_1: bool) -> Async[None]:
+                if _arg:
+                    return singleton.ReturnFrom(delete_file_async(path))
+
+                elif _arg_1:
+                    return singleton.ReturnFrom(delete_directory_async(path))
+
+                else: 
+                    return singleton.Zero()
+
+
+            return singleton.Bind(directory_exists_async(path), _arrow3607)
+
+        return singleton.Bind(file_exists_async(path), _arrow3608)
+
+    return singleton.Delay(_arrow3609)
+
+
+__all__ = ["directory_exists_async", "create_directory_async", "ensure_directory_async", "ensure_directory_of_file_async", "file_exists_async", "read_file_text_async", "read_file_binary_async", "read_file_xlsx_async", "move_file_async", "move_directory_async", "delete_file_async", "delete_directory_async", "write_file_text_async", "write_file_binary_async", "write_file_xlsx_async", "trim", "make_relative", "standardize_slashes", "get_sub_directories_async", "get_sub_files_async", "get_all_file_paths_async", "rename_file_or_directory_async", "delete_file_or_directory_async"]
+

arctrl/py/Core/Helper/collections_.py

@@ -0,0 +1,438 @@
+from __future__ import annotations
+from collections.abc import Callable
+from typing import (Any, TypeVar)
+from ...fable_modules.fable_library.array_ import contains
+from ...fable_modules.fable_library.list import (is_empty as is_empty_1, tail, FSharpList, head, append, singleton, empty)
+from ...fable_modules.fable_library.map_util import (add_to_dict, try_get_value, remove_from_dict)
+from ...fable_modules.fable_library.mutable_map import Dictionary
+from ...fable_modules.fable_library.option import (some, value as value_1)
+from ...fable_modules.fable_library.seq import (is_empty, iterate, map)
+from ...fable_modules.fable_library.seq2 import group_by
+from ...fable_modules.fable_library.types import (FSharpRef, Array)
+from ...fable_modules.fable_library.util import (equals, structural_hash, IEnumerable_1, ignore, get_enumerator, dispose, min, compare_primitives)
+
+_T = TypeVar("_T")
+
+_U = TypeVar("_U")
+
+_KEY_ = TypeVar("_KEY_")
+
+_KEY = TypeVar("_KEY")
+
+__B = TypeVar("__B")
+
+__A = TypeVar("__A")
+
+__C = TypeVar("__C")
+
+__A_ = TypeVar("__A_")
+
+_A = TypeVar("_A")
+
+_A_ = TypeVar("_A_")
+
+def Option_fromValueWithDefault(d: Any, v: Any) -> Any | None:
+    if equals(d, v):
+        return None
+
+    else: 
+        return some(v)
+
+
+
+def Option_mapDefault(d: Any, f: Callable[[_T], _T], o: Any | None=None) -> Any | None:
+    return Option_fromValueWithDefault(d, f(d) if (o is None) else f(value_1(o)))
+
+
+def Option_mapOrDefault(d: Any | None, f: Callable[[_U], _T], o: Any | None=None) -> Any | None:
+    if o is None:
+        return d
+
+    else: 
+        return some(f(value_1(o)))
+
+
+
+def Option_fromSeq(v: Any | None=None) -> Any | None:
+    if is_empty(v):
+        return None
+
+    else: 
+        return some(v)
+
+
+
+def List_tryPickAndRemove(f: Callable[[_T], _U | None], lst: FSharpList[Any]) -> tuple[_U | None, FSharpList[_T]]:
+    def loop(new_list_mut: FSharpList[_T], remaining_list_mut: FSharpList[_T], f: Any=f, lst: Any=lst) -> tuple[_U | None, FSharpList[_T]]:
+        while True:
+            (new_list, remaining_list) = (new_list_mut, remaining_list_mut)
+            if not is_empty_1(remaining_list):
+                t: FSharpList[_T] = tail(remaining_list)
+                h: _T = head(remaining_list)
+                match_value: _U | None = f(h)
+                if match_value is None:
+                    new_list_mut = append(new_list, singleton(h))
+                    remaining_list_mut = t
+                    continue
+
+                else: 
+                    return (some(value_1(match_value)), append(new_list, t))
+
+
+            else: 
+                return (None, new_list)
+
+            break
+
+    return loop(empty(), lst)
+
+
+def Dictionary_addOrUpdate(key: Any, value: Any, dict_1: Any) -> None:
+    if key in dict_1:
+        dict_1[key] = value
+
+    else: 
+        add_to_dict(dict_1, key, value)
+
+
+
+def Dictionary_ofSeq(s: IEnumerable_1[tuple[_KEY, _T]]) -> Any:
+    class ObjectExpr503:
+        @property
+        def Equals(self) -> Callable[[_KEY_, _KEY_], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[_KEY_], int]:
+            return structural_hash
+
+    dict_1: Any = Dictionary([], ObjectExpr503())
+    def action(tupled_arg: tuple[_KEY, _T], s: Any=s) -> None:
+        add_to_dict(dict_1, tupled_arg[0], tupled_arg[1])
+
+    iterate(action, s)
+    return dict_1
+
+
+def Dictionary_tryFind(key: Any, dict_1: Any) -> Any | None:
+    pattern_input: tuple[bool, _T]
+    out_arg: _T = None
+    def _arrow504(__unit: None=None, key: Any=key, dict_1: Any=dict_1) -> _T:
+        return out_arg
+
+    def _arrow505(v: _T | None=None, key: Any=key, dict_1: Any=dict_1) -> None:
+        nonlocal out_arg
+        out_arg = v
+
+    pattern_input = (try_get_value(dict_1, key, FSharpRef(_arrow504, _arrow505)), out_arg)
+    if pattern_input[0]:
+        return some(pattern_input[1])
+
+    else: 
+        return None
+
+
+
+def Dictionary_ofSeqWithMerge(merge: Callable[[_T, _T], _T], s: IEnumerable_1[tuple[_KEY, _T]]) -> Any:
+    class ObjectExpr506:
+        @property
+        def Equals(self) -> Callable[[_KEY_, _KEY_], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[_KEY_], int]:
+            return structural_hash
+
+    dict_1: Any = Dictionary([], ObjectExpr506())
+    def action(tupled_arg: tuple[_KEY, _T], merge: Any=merge, s: Any=s) -> None:
+        k: _KEY = tupled_arg[0]
+        v: _T = tupled_arg[1]
+        match_value: _T | None = Dictionary_tryFind(k, dict_1)
+        if match_value is None:
+            add_to_dict(dict_1, k, v)
+
+        else: 
+            v_0027: _T = value_1(match_value)
+            ignore(remove_from_dict(dict_1, k))
+            add_to_dict(dict_1, k, merge(v_0027, v))
+
+
+    iterate(action, s)
+    return dict_1
+
+
+def ResizeArray_create(i: int, v: Any) -> Array[Any]:
+    a: Array[_T] = []
+    if i > 0:
+        for for_loop_var in range(1, i + 1, 1):
+            (a.append(v))
+
+    return a
+
+
+def ResizeArray_singleton(a: Any | None=None) -> Array[Any]:
+    b: Array[_T] = []
+    (b.append(a))
+    return b
+
+
+def ResizeArray_map(f: Callable[[__A], __B], a: Array[Any]) -> Array[Any]:
+    b: Array[__B] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: __A = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            (b.append(f(i)))
+
+    finally: 
+        dispose(enumerator)
+
+    return b
+
+
+def ResizeArray_choose(f: Callable[[__A], __B | None], a: Array[Any]) -> Array[Any]:
+    b: Array[__B] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            match_value: __B | None = f(enumerator.System_Collections_Generic_IEnumerator_1_get_Current())
+            if match_value is None:
+                pass
+
+            else: 
+                x: __B = value_1(match_value)
+                (b.append(x))
+
+
+    finally: 
+        dispose(enumerator)
+
+    return b
+
+
+def ResizeArray_filter(f: Callable[[__A], bool], a: Array[Any]) -> Array[Any]:
+    b: Array[__A] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: __A = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            if f(i):
+                (b.append(i))
+
+
+    finally: 
+        dispose(enumerator)
+
+    return b
+
+
+def ResizeArray_fold(f: Callable[[__A, __B], __A], s: Any, a: Array[Any]) -> Any:
+    state: __A = s
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: __B = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            state = f(state, i)
+
+    finally: 
+        dispose(enumerator)
+
+    return state
+
+
+def ResizeArray_foldBack(f: Callable[[__A, __B], __B], a: Array[Any], s: Any) -> Any:
+    state: __B = s
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: __A = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            state = f(i, state)
+
+    finally: 
+        dispose(enumerator)
+
+    return state
+
+
+def ResizeArray_iter(f: Callable[[__A], None], a: Array[Any]) -> None:
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            f(enumerator.System_Collections_Generic_IEnumerator_1_get_Current())
+
+    finally: 
+        dispose(enumerator)
+
+
+
+def ResizeArray_reduce(f: Callable[[__A, __A], __A], a: Array[Any]) -> Any:
+    if len(a) == 0:
+        raise Exception("ResizeArray.reduce: empty array")
+
+    elif len(a) == 1:
+        return a[0]
+
+    else: 
+        a_5: Array[__A] = a
+        state: __A = a_5[0]
+        for i in range(1, (len(a_5) - 1) + 1, 1):
+            state = f(state, a_5[i])
+        return state
+
+
+
+def ResizeArray_collect(f: Callable[[__A], __B], a: Array[Any]) -> Array[Any]:
+    b: Array[__C] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            with get_enumerator(f(enumerator.System_Collections_Generic_IEnumerator_1_get_Current())) as enumerator_1:
+                while enumerator_1.System_Collections_IEnumerator_MoveNext():
+                    j: __C = enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current()
+                    (b.append(j))
+
+    finally: 
+        dispose(enumerator)
+
+    return b
+
+
+def ResizeArray_distinct(a: Array[Any]) -> Array[Any]:
+    b: Array[__A] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: __A = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            class ObjectExpr507:
+                @property
+                def Equals(self) -> Callable[[__A_, __A_], bool]:
+                    return equals
+
+                @property
+                def GetHashCode(self) -> Callable[[__A_], int]:
+                    return structural_hash
+
+            if not contains(i, b, ObjectExpr507()):
+                (b.append(i))
+
+
+    finally: 
+        dispose(enumerator)
+
+    return b
+
+
+def ResizeArray_isEmpty(a: Array[Any]) -> bool:
+    return len(a) == 0
+
+
+def ResizeArray_append(a: Array[Any], b: Array[Any]) -> Array[Any]:
+    c: Array[__A] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: __A = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            (c.append(i))
+
+    finally: 
+        dispose(enumerator)
+
+    enumerator_1: Any = get_enumerator(b)
+    try: 
+        while enumerator_1.System_Collections_IEnumerator_MoveNext():
+            i_1: __A = enumerator_1.System_Collections_Generic_IEnumerator_1_get_Current()
+            (c.append(i_1))
+
+    finally: 
+        dispose(enumerator_1)
+
+    return c
+
+
+def ResizeArray_appendSingleton(b: Any, a: Array[Any]) -> Array[Any]:
+    c: Array[_T] = []
+    enumerator: Any = get_enumerator(a)
+    try: 
+        while enumerator.System_Collections_IEnumerator_MoveNext():
+            i: _T = enumerator.System_Collections_Generic_IEnumerator_1_get_Current()
+            (c.append(i))
+
+    finally: 
+        dispose(enumerator)
+
+    (c.append(b))
+    return c
+
+
+def ResizeArray_groupBy(f: Callable[[_T], _A], a: Array[Any]) -> Array[tuple[_A, Array[_T]]]:
+    def mapping(tupled_arg: tuple[_A, IEnumerable_1[_T]], f: Any=f, a: Any=a) -> tuple[_A, Array[_T]]:
+        return (tupled_arg[0], list(tupled_arg[1]))
+
+    class ObjectExpr508:
+        @property
+        def Equals(self) -> Callable[[_A_, _A_], bool]:
+            return equals
+
+        @property
+        def GetHashCode(self) -> Callable[[_A_], int]:
+            return structural_hash
+
+    return list(map(mapping, group_by(f, a, ObjectExpr508())))
+
+
+def ResizeArray_tryPick(f: Callable[[_T], __A | None], a: Array[Any]) -> Any | None:
+    def loop(i_mut: int, f: Any=f, a: Any=a) -> __A | None:
+        while True:
+            (i,) = (i_mut,)
+            if i < len(a):
+                match_value: __A | None = f(a[i])
+                if match_value is None:
+                    i_mut = i + 1
+                    continue
+
+                else: 
+                    return some(value_1(match_value))
+
+
+            else: 
+                return None
+
+            break
+
+    return loop(0)
+
+
+def ResizeArray_zip(a: Array[Any], b: Array[Any]) -> Array[tuple[_T, _U]]:
+    c: Array[tuple[_T, _U]] = []
+    def _arrow509(x: int, y: int, a: Any=a, b: Any=b) -> int:
+        return compare_primitives(x, y)
+
+    n: int = min(_arrow509, len(a), len(b)) or 0
+    for i in range(0, (n - 1) + 1, 1):
+        (c.append((a[i], b[i])))
+    return c
+
+
+def ResizeArray_tryFind(f: Callable[[_T], bool], a: Array[Any]) -> Any | None:
+    def loop(i_mut: int, f: Any=f, a: Any=a) -> _T | None:
+        while True:
+            (i,) = (i_mut,)
+            if i < len(a):
+                if f(a[i]):
+                    return some(a[i])
+
+                else: 
+                    i_mut = i + 1
+                    continue
+
+
+            else: 
+                return None
+
+            break
+
+    return loop(0)
+
+
+__all__ = ["Option_fromValueWithDefault", "Option_mapDefault", "Option_mapOrDefault", "Option_fromSeq", "List_tryPickAndRemove", "Dictionary_addOrUpdate", "Dictionary_ofSeq", "Dictionary_tryFind", "Dictionary_ofSeqWithMerge", "ResizeArray_create", "ResizeArray_singleton", "ResizeArray_map", "ResizeArray_choose", "ResizeArray_filter", "ResizeArray_fold", "ResizeArray_foldBack", "ResizeArray_iter", "ResizeArray_reduce", "ResizeArray_collect", "ResizeArray_distinct", "ResizeArray_isEmpty", "ResizeArray_append", "ResizeArray_appendSingleton", "ResizeArray_groupBy", "ResizeArray_tryPick", "ResizeArray_zip", "ResizeArray_tryFind"]
+