pyochain 0.5.1__py3-none-any.whl → 0.5.32__py3-none-any.whl

pyochain/__init__.py

@@ -1,5 +1,5 @@
 from ._core import Wrapper
-from ._dict import Dict, Expr, key
+from ._dict import Dict
 from ._iter import Iter, Seq
 
-__all__ = ["Dict", "Iter", "Wrapper", "key", "Seq", "Expr"]
+__all__ = ["Dict", "Iter", "Wrapper", "Seq"]

pyochain/_core/__init__.py

@@ -1,6 +1,6 @@
+from ._format import Peeked, peek, peekn
 from ._main import CommonBase, IterWrapper, MappingWrapper, Pipeable, Wrapper
 from ._protocols import (
-    Peeked,
     SizedIterable,
     SupportsAllComparisons,
     SupportsKeysAndGetItem,
@@ -18,4 +18,6 @@ __all__ = [
     "Peeked",
     "SizedIterable",
     "Pipeable",
+    "peek",
+    "peekn",
 ]

pyochain/_core/_format.py

@@ -0,0 +1,34 @@
+from collections.abc import Iterable, Iterator, Mapping
+from pprint import pformat
+from typing import Any, NamedTuple
+
+import cytoolz as cz
+
+
+class Peeked[T](NamedTuple):
+    value: T | tuple[T, ...]
+    sequence: Iterator[T]
+
+
+def peekn[T](data: Iterable[T], n: int) -> Iterator[T]:
+    peeked = Peeked(*cz.itertoolz.peekn(n, data))
+    print(f"Peeked {n} values: {peeked.value}")
+    return peeked.sequence
+
+
+def peek[T](data: Iterable[T]) -> Iterator[T]:
+    peeked = Peeked(*cz.itertoolz.peek(data))
+    print(f"Peeked value: {peeked.value}")
+    return peeked.sequence
+
+
+def dict_repr(
+    v: Mapping[Any, Any],
+    max_items: int = 20,
+    depth: int = 3,
+    width: int = 80,
+    compact: bool = True,
+) -> str:
+    truncated = dict(list(v.items())[:max_items])
+    suffix = "..." if len(v) > max_items else ""
+    return pformat(truncated, depth=depth, width=width, compact=compact) + suffix

pyochain/_core/_main.py

@@ -1,9 +1,11 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from collections.abc import Callable, Collection, Iterable, Iterator
+from collections.abc import Callable, Iterable, Iterator, Sequence
 from typing import TYPE_CHECKING, Any, Concatenate, Self
 
+from ._format import dict_repr
+
 if TYPE_CHECKING:
     from .._dict import Dict
     from .._iter import Iter, Seq
@@ -27,12 +29,12 @@ class CommonBase[T](ABC, Pipeable):
     The pipe unwrap method must be implemented to allow piping functions that transform the underlying data type, whilst retaining the wrapper.
     """
 
-    _data: T
+    _inner: T
 
-    __slots__ = ("_data",)
+    __slots__ = ("_inner",)
 
     def __init__(self, data: T) -> None:
-        self._data = data
+        self._inner = data
 
     @abstractmethod
     def apply[**P](
@@ -53,9 +55,9 @@ class CommonBase[T](ABC, Pipeable):
         from pprint import pprint
 
         if pretty:
-            pprint(self.unwrap(), sort_dicts=False)
+            self.into(pprint, sort_dicts=False)
         else:
-            print(self.unwrap())
+            self.into(print)
         return self
 
     def unwrap(self) -> T:
@@ -64,7 +66,7 @@ class CommonBase[T](ABC, Pipeable):
 
         This is a terminal operation.
         """
-        return self._data
+        return self._inner
 
     def into[**P, R](
         self,
@@ -86,57 +88,73 @@ class CommonBase[T](ABC, Pipeable):
         """
         return func(self.unwrap(), *args, **kwargs)
 
-
-class IterWrapper[T](CommonBase[Iterable[T]]):
-    _data: Iterable[T]
-
-    def apply[**P, R](
-        self,
-        func: Callable[Concatenate[Iterable[T], P], Iterator[R]],
-        *args: P.args,
-        **kwargs: P.kwargs,
-    ) -> Iter[R]:
+    def equals_to(self, other: Self | T) -> bool:
         """
-        Apply a function to the underlying iterable and return an Iter of the result.
-        Allow to pass user defined functions that transform the iterable while retaining the Iter wrapper.
+        Check if two records are equal based on their data.
+
         Args:
-            func: Function to apply to the underlying iterable.
-            *args: Positional arguments to pass to the function.
-            **kwargs: Keyword arguments to pass to the function.
+            other: Another instance or corresponding underlying data to compare against.
 
         Example:
         ```python
         >>> import pyochain as pc
-        >>> def double(data: Iterable[int]) -> Iterator[int]:
-        ...     return (x * 2 for x in data)
-        >>> pc.Iter.from_([1, 2, 3]).apply(double).into(list)
-        [2, 4, 6]
+        >>> d1 = pc.Dict({"a": 1, "b": 2})
+        >>> d2 = pc.Dict({"a": 1, "b": 2})
+        >>> d3 = pc.Dict({"a": 1, "b": 3})
+        >>> d1.equals_to(d2)
+        True
+        >>> d1.equals_to(d3)
+        False
+
+        ```
         """
-        from .._iter import Iter
+        other_data = other.unwrap() if isinstance(other, self.__class__) else other
+        return self.unwrap() == other_data
 
-        return Iter(self.into(func, *args, **kwargs))
 
-    def collect(self, factory: Callable[[Iterable[T]], Collection[T]] = list) -> Seq[T]:
-        """
-        Collect the elements into a sequence.
-        Args:
-            factory: A callable that takes an iterable and returns a collection. Defaults to list.
+class IterWrapper[T](CommonBase[Iterable[T]]):
+    _inner: Iterable[T]
 
-        Example:
-        ```python
-        >>> import pyochain as pc
-        >>> pc.Iter.from_(range(5)).collect().unwrap()
-        [0, 1, 2, 3, 4]
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self.unwrap().__repr__()})"
 
-        ```
-        """
+    def _eager[**P, U](
+        self,
+        factory: Callable[Concatenate[Iterable[T], P], Sequence[U]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Seq[U]:
         from .._iter import Seq
 
-        return Seq(self.into(factory))
+        def _(data: Iterable[T]):
+            return Seq(factory(data, *args, **kwargs))
+
+        return self.into(_)
+
+    def _lazy[**P, U](
+        self,
+        factory: Callable[Concatenate[Iterable[T], P], Iterator[U]],
+        *args: P.args,
+        **kwargs: P.kwargs,
+    ) -> Iter[U]:
+        from .._iter import Iter
+
+        def _(data: Iterable[T]):
+            return Iter(factory(data, *args, **kwargs))
+
+        return self.into(_)
 
 
 class MappingWrapper[K, V](CommonBase[dict[K, V]]):
-    _data: dict[K, V]
+    _inner: dict[K, V]
+
+    def __repr__(self) -> str:
+        return f"{self.into(dict_repr)}"
+
+    def _new[KU, VU](self, func: Callable[[dict[K, V]], dict[KU, VU]]) -> Dict[KU, VU]:
+        from .._dict import Dict
+
+        return Dict(func(self.unwrap()))
 
     def apply[**P, KU, VU](
         self,
@@ -147,6 +165,7 @@ class MappingWrapper[K, V](CommonBase[dict[K, V]]):
         """
         Apply a function to the underlying dict and return a Dict of the result.
         Allow to pass user defined functions that transform the dict while retaining the Dict wrapper.
+
         Args:
             func: Function to apply to the underlying dict.
             *args: Positional arguments to pass to the function.
@@ -161,9 +180,11 @@ class MappingWrapper[K, V](CommonBase[dict[K, V]]):
 
         ```
         """
-        from .._dict import Dict
 
-        return Dict(self.into(func, *args, **kwargs))
+        def _(data: dict[K, V]) -> dict[KU, VU]:
+            return func(data, *args, **kwargs)
+
+        return self._new(_)
 
 
 class Wrapper[T](CommonBase[T]):

pyochain/_core/_protocols.py

@@ -1,10 +1,5 @@
-from collections.abc import Iterable, Iterator, Sized
-from typing import NamedTuple, Protocol
-
-
-class Peeked[T](NamedTuple):
-    value: T | tuple[T, ...]
-    sequence: Iterator[T]
+from collections.abc import Iterable, Sized
+from typing import Protocol
 
 
 class SupportsDunderLT[T](Protocol):

pyochain/_dict/__init__.py

@@ -1,4 +1,3 @@
-from ._exprs import Expr, key
 from ._main import Dict
 
-__all__ = ["Dict", "key", "Expr"]
+__all__ = ["Dict"]

pyochain/_dict/_filters.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from collections.abc import Callable, Mapping
 from functools import partial
-from typing import TYPE_CHECKING, Any, TypeGuard
+from typing import TYPE_CHECKING, Any, TypeIs, overload
 
 import cytoolz as cz
 
@@ -13,9 +13,15 @@ if TYPE_CHECKING:
 
 
 class FilterDict[K, V](MappingWrapper[K, V]):
-    def filter_keys(self, predicate: Callable[[K], bool]) -> Dict[K, V]:
+    @overload
+    def filter_keys[U](self, predicate: Callable[[K], TypeIs[U]]) -> Dict[U, V]: ...
+    @overload
+    def filter_keys(self, predicate: Callable[[K], bool]) -> Dict[K, V]: ...
+    def filter_keys[U](
+        self, predicate: Callable[[K], bool | TypeIs[U]]
+    ) -> Dict[K, V] | Dict[U, V]:
         """
-        Return a new Dict containing keys that satisfy predicate.
+        Return keys that satisfy predicate.
 
         Args:
             predicate: Function to determine if a key should be included.
@@ -28,11 +34,17 @@ class FilterDict[K, V](MappingWrapper[K, V]):
 
         ```
         """
-        return self.apply(partial(cz.dicttoolz.keyfilter, predicate))
-
-    def filter_values(self, predicate: Callable[[V], bool]) -> Dict[K, V]:
+        return self._new(partial(cz.dicttoolz.keyfilter, predicate))
+
+    @overload
+    def filter_values[U](self, predicate: Callable[[V], TypeIs[U]]) -> Dict[K, U]: ...
+    @overload
+    def filter_values(self, predicate: Callable[[V], bool]) -> Dict[K, V]: ...
+    def filter_values[U](
+        self, predicate: Callable[[V], bool] | Callable[[V], TypeIs[U]]
+    ) -> Dict[K, V] | Dict[K, U]:
         """
-        Return a new Dict containing items whose values satisfy predicate.
+        Return items whose values satisfy predicate.
 
         Args:
             predicate: Function to determine if a value should be included.
@@ -47,12 +59,9 @@ class FilterDict[K, V](MappingWrapper[K, V]):
 
         ```
         """
-        return self.apply(partial(cz.dicttoolz.valfilter, predicate))
+        return self._new(partial(cz.dicttoolz.valfilter, predicate))
 
-    def filter_items(
-        self,
-        predicate: Callable[[tuple[K, V]], bool],
-    ) -> Dict[K, V]:
+    def filter_items(self, predicate: Callable[[tuple[K, V]], bool]) -> Dict[K, V]:
         """
         Filter items by predicate applied to (key, value) tuples.
 
@@ -73,12 +82,9 @@ class FilterDict[K, V](MappingWrapper[K, V]):
 
         ```
         """
-        return self.apply(partial(cz.dicttoolz.itemfilter, predicate))
+        return self._new(partial(cz.dicttoolz.itemfilter, predicate))
 
-    def filter_kv(
-        self,
-        predicate: Callable[[K, V], bool],
-    ) -> Dict[K, V]:
+    def filter_kv(self, predicate: Callable[[K, V], bool]) -> Dict[K, V]:
         """
         Filter items by predicate applied to unpacked (key, value) tuples.
 
@@ -105,13 +111,14 @@ class FilterDict[K, V](MappingWrapper[K, V]):
 
             return cz.dicttoolz.itemfilter(_, data)
 
-        return self.apply(_filter_kv)
+        return self._new(_filter_kv)
 
     def filter_attr[U](self, attr: str, dtype: type[U] = object) -> Dict[K, U]:
         """
         Filter values that have a given attribute.
 
         This does not enforce type checking at runtime for performance considerations.
+
         Args:
             attr: Attribute name to check for.
             dtype: Optional expected type of the attribute for type hinting.
@@ -127,19 +134,19 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
 
         def _filter_attr(data: dict[K, V]) -> dict[K, U]:
-            def has_attr(x: V) -> TypeGuard[U]:
+            def has_attr(x: object) -> TypeIs[U]:
                 return hasattr(x, attr)
 
             return cz.dicttoolz.valfilter(has_attr, data)
 
-        return self.apply(_filter_attr)
+        return self._new(_filter_attr)
 
-    def filter_type[R](self, typ: type[R]) -> Dict[K, R]:
+    def filter_type[R](self, dtype: type[R]) -> Dict[K, R]:
         """
         Filter values by type.
 
         Args:
-            typ: Type to filter values by.
+            dtype: Type to filter values by.
         Example:
         ```python
         >>> import pyochain as pc
@@ -151,34 +158,12 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
 
         def _filter_type(data: dict[K, V]) -> dict[K, R]:
-            def _(x: V) -> TypeGuard[R]:
-                return isinstance(x, typ)
-
-            return cz.dicttoolz.valfilter(_, data)
-
-        return self.apply(_filter_type)
-
-    def filter_callable(self) -> Dict[K, Callable[..., Any]]:
-        """
-        Filter values that are callable.
-        ```python
-        >>> import pyochain as pc
-        >>> def foo():
-        ...     pass
-        >>> data = {1: "one", 2: "two", 3: foo, 4: print}
-        >>> pc.Dict(data).filter_callable().map_values(lambda x: x.__name__).unwrap()
-        {3: 'foo', 4: 'print'}
-
-        ```
-        """
-
-        def _filter_callable(data: dict[K, V]) -> dict[K, Callable[..., Any]]:
-            def _(x: V) -> TypeGuard[Callable[..., Any]]:
-                return callable(x)
+            def _(x: object) -> TypeIs[R]:
+                return isinstance(x, dtype)
 
             return cz.dicttoolz.valfilter(_, data)
 
-        return self.apply(_filter_callable)
+        return self._new(_filter_type)
 
     def filter_subclass[U: type[Any], R](
         self: FilterDict[K, U], parent: type[R], keep_parent: bool = True
@@ -210,7 +195,7 @@ class FilterDict[K, V](MappingWrapper[K, V]):
         """
 
         def _filter_subclass(data: dict[K, U]) -> dict[K, type[R]]:
-            def _(x: type[Any]) -> TypeGuard[type[R]]:
+            def _(x: type[Any]) -> TypeIs[type[R]]:
                 if keep_parent:
                     return issubclass(x, parent)
                 else:
@@ -218,11 +203,11 @@ class FilterDict[K, V](MappingWrapper[K, V]):
 
             return cz.dicttoolz.valfilter(_, data)
 
-        return self.apply(_filter_subclass)
+        return self._new(_filter_subclass)
 
     def intersect_keys(self, *others: Mapping[K, V]) -> Dict[K, V]:
         """
-        Return a new Dict keeping only keys present in self and all others.
+        Keep only keys present in self and all others mappings.
 
         Args:
             *others: Other mappings to intersect keys with.
@@ -244,11 +229,11 @@ class FilterDict[K, V](MappingWrapper[K, V]):
                 self_keys.intersection_update(other.keys())
             return {k: data[k] for k in self_keys}
 
-        return self.apply(_intersect_keys)
+        return self._new(_intersect_keys)
 
     def diff_keys(self, *others: Mapping[K, V]) -> Dict[K, V]:
         """
-        Return a new Dict keeping only keys present in self but not in others.
+        Keep only keys present in self but not in others mappings.
 
         Args:
             *others: Other mappings to exclude keys from.
@@ -270,4 +255,4 @@ class FilterDict[K, V](MappingWrapper[K, V]):
                 self_keys.difference_update(other.keys())
             return {k: data[k] for k in self_keys}
 
-        return self.apply(_diff_keys)
+        return self._new(_diff_keys)

pyochain/_dict/_groups.py

@@ -34,7 +34,7 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
 
             return cz.dicttoolz.valmap(dict, cz.itertoolz.groupby(_, data.items()))
 
-        return self.apply(_group_by_value)
+        return self._new(_group_by_value)
 
     def group_by_key[G](self, func: Callable[[K], G]) -> Dict[G, dict[K, V]]:
         """
@@ -58,7 +58,7 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
 
             return cz.dicttoolz.valmap(dict, cz.itertoolz.groupby(_, data.items()))
 
-        return self.apply(_group_by_key)
+        return self._new(_group_by_key)
 
     def group_by_key_agg[G, R](
         self,
@@ -72,7 +72,7 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
             key_func: Function to determine the group for each key.
             agg_func: Function to aggregate each sub-dictionary.
 
-        This avoids materializing intermediate `Dict` objects if you only need
+        This avoids materializing intermediate `dict` objects if you only need
         an aggregated result for each group.
         ```python
         >>> import pyochain as pc
@@ -118,7 +118,7 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
             groups = cz.itertoolz.groupby(_key_func, data.items())
             return cz.dicttoolz.valmap(_agg_func, groups)
 
-        return self.apply(_group_by_key_agg)
+        return self._new(_group_by_key_agg)
 
     def group_by_value_agg[G, R](
         self,
@@ -132,7 +132,7 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
             value_func: Function to determine the group for each value.
             agg_func: Function to aggregate each sub-dictionary.
 
-        This avoids materializing intermediate `Dict` objects if you only need
+        This avoids materializing intermediate `dict` objects if you only need
         an aggregated result for each group.
         ```python
         >>> import pyochain as pc
@@ -143,8 +143,7 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
         ...     agg_func=lambda d: d.iter_keys().count(),
         ... ).unwrap()
         {'A': 2, 'B': 1}
-        >>>
-        >>> # --- Exemple 2: Agrégation plus complexe ---
+        >>> # Second example
         >>> sales_data = {
         ...     "store_1": "Electronics",
         ...     "store_2": "Groceries",
@@ -173,4 +172,4 @@ class GroupsDict[K, V](MappingWrapper[K, V]):
             groups = cz.itertoolz.groupby(_key_func, data.items())
             return cz.dicttoolz.valmap(_agg_func, groups)
 
-        return self.apply(_group_by_value_agg)
+        return self._new(_group_by_value_agg)

pyochain/_dict/_iter.py

@@ -1,14 +1,14 @@
 from __future__ import annotations
 
 from collections.abc import Callable, Iterable, Mapping
-from typing import TYPE_CHECKING, Concatenate
+from typing import TYPE_CHECKING, Any, Concatenate
 
 import cytoolz as cz
 
 from .._core import MappingWrapper
 
 if TYPE_CHECKING:
-    from .._iter import Iter
+    from .._iter import Iter, Seq
     from ._main import Dict
 
 
@@ -43,15 +43,15 @@ class IterDict[K, V](MappingWrapper[K, V]):
 
         def _itr(data: Mapping[K, Iterable[U]]) -> dict[K, R]:
             def _(v: Iterable[U]) -> R:
-                return func(Iter.from_(v), *args, **kwargs)
+                return func(Iter(iter(v)), *args, **kwargs)
 
             return cz.dicttoolz.valmap(_, data)
 
-        return self.apply(_itr)
+        return self._new(_itr)
 
     def iter_keys(self) -> Iter[K]:
         """
-        Return a Iter of the dict's keys.
+        Return an Iter of the dict's keys.
         ```python
         >>> import pyochain as pc
         >>> pc.Dict({1: 2}).iter_keys().into(list)
@@ -61,7 +61,10 @@ class IterDict[K, V](MappingWrapper[K, V]):
         """
         from .._iter import Iter
 
-        return Iter.from_(self.unwrap().keys())
+        def _keys(data: dict[K, V]) -> Iter[K]:
+            return Iter(iter(data.keys()))
+
+        return self.into(_keys)
 
     def iter_values(self) -> Iter[V]:
         """
@@ -75,11 +78,14 @@ class IterDict[K, V](MappingWrapper[K, V]):
         """
         from .._iter import Iter
 
-        return Iter.from_(self.unwrap().values())
+        def _values(data: dict[K, V]) -> Iter[V]:
+            return Iter(iter(data.values()))
+
+        return self.into(_values)
 
     def iter_items(self) -> Iter[tuple[K, V]]:
         """
-        Return a Iter of the dict's items.
+        Return an Iter of the dict's items.
         ```python
         >>> import pyochain as pc
         >>> pc.Dict({1: 2}).iter_items().into(list)
@@ -89,4 +95,41 @@ class IterDict[K, V](MappingWrapper[K, V]):
         """
         from .._iter import Iter
 
-        return Iter.from_(self.unwrap().items())
+        def _items(data: dict[K, V]) -> Iter[tuple[K, V]]:
+            return Iter(iter(data.items()))
+
+        return self.into(_items)
+
+    def to_arrays(self) -> Seq[list[Any]]:
+        """
+        Convert the nested dictionary into a sequence of arrays.
+
+        The sequence represents all paths from root to leaves.
+
+        ```python
+        >>> import pyochain as pc
+        >>> data = {
+        ...     "a": {"b": 1, "c": 2},
+        ...     "d": {"e": {"f": 3}},
+        ... }
+        >>> pc.Dict(data).to_arrays().unwrap()
+        [['a', 'b', 1], ['a', 'c', 2], ['d', 'e', 'f', 3]]
+
+        ```
+        """
+        from .._iter import Seq
+
+        def _to_arrays(d: Mapping[Any, Any]) -> list[list[Any]]:
+            """from dictutils.pivot"""
+            match d:
+                case Mapping():
+                    arr: list[Any] = []
+                    for k, v in d.items():
+                        for el in _to_arrays(v):
+                            arr.append([k] + el)
+                    return arr
+
+                case _:
+                    return [[d]]
+
+        return Seq(self.into(_to_arrays))

pyochain/_dict/_joins.py

@@ -33,7 +33,7 @@ class JoinsDict[K, V](MappingWrapper[K, V]):
         def _inner_join(data: Mapping[K, V]) -> dict[K, tuple[V, W]]:
             return {k: (v, other[k]) for k, v in data.items() if k in other}
 
-        return self.apply(_inner_join)
+        return self._new(_inner_join)
 
     def left_join[W](self, other: Mapping[K, W]) -> Dict[K, tuple[V, W | None]]:
         """
@@ -56,7 +56,7 @@ class JoinsDict[K, V](MappingWrapper[K, V]):
         def _left_join(data: Mapping[K, V]) -> dict[K, tuple[V, W | None]]:
             return {k: (v, other.get(k)) for k, v in data.items()}
 
-        return self.apply(_left_join)
+        return self._new(_left_join)
 
     def diff(self, other: Mapping[K, V]) -> Dict[K, tuple[V | None, V | None]]:
         """
@@ -77,9 +77,7 @@ class JoinsDict[K, V](MappingWrapper[K, V]):
         ```
         """
 
-        def _diff(
-            data: Mapping[K, V], other: Mapping[K, V]
-        ) -> dict[K, tuple[V | None, V | None]]:
+        def _diff(data: Mapping[K, V]) -> dict[K, tuple[V | None, V | None]]:
             all_keys: set[K] = data.keys() | other.keys()
             diffs: dict[K, tuple[V | None, V | None]] = {}
             for key in all_keys:
@@ -89,11 +87,11 @@ class JoinsDict[K, V](MappingWrapper[K, V]):
                     diffs[key] = (self_val, other_val)
             return diffs
 
-        return self.apply(_diff, other)
+        return self._new(_diff)
 
     def merge(self, *others: Mapping[K, V]) -> Dict[K, V]:
         """
-        Merge other dicts into this one and return a new Dict.
+        Merge other dicts into this one.
 
         Args:
             *others: One or more mappings to merge into the current dictionary.
@@ -108,7 +106,11 @@ class JoinsDict[K, V](MappingWrapper[K, V]):
 
         ```
         """
-        return self.apply(cz.dicttoolz.merge, *others)
+
+        def _merge(data: Mapping[K, V]) -> dict[K, V]:
+            return cz.dicttoolz.merge(data, *others)
+
+        return self._new(_merge)
 
     def merge_with(
         self, *others: Mapping[K, V], func: Callable[[Iterable[V]], V]
@@ -134,4 +136,4 @@ class JoinsDict[K, V](MappingWrapper[K, V]):
         def _merge_with(data: Mapping[K, V]) -> dict[K, V]:
             return cz.dicttoolz.merge_with(func, data, *others)
 
-        return self.apply(_merge_with)
+        return self._new(_merge_with)