Fix bug #2

Author: mifeet

pyfluent_iterables/fluent.py

@@ -88,7 +88,7 @@ def _iterable(self) -> Iterable[T]:
     def map(self, transform: Callable[[T], R]) -> "FluentIterable[R]":
         """Returns a FluentIterable containing the results of applying the given transform function to each element in this Iterable."""
         iterable = self._iterable()
-        return FluentFactoryWrapper(lambda: map(transform, iterable))
+        return FluentFactoryWrapper(lambda: map(transform, iterable), maybe_sized=iterable)
 
     def filter(self, predicate: Optional[Callable[[T], Any]] = None) -> "FluentIterable[T]":
         """Returns a FluentIterable containing only elements matching the given predicate. If no predicate is given, returns only truthy elements."""
@@ -107,7 +107,7 @@ def filter_false(self, predicate: Optional[Callable[[T], Any]] = None) -> "Fluen
     def enumerate(self, start: int = 0) -> "FluentIterable[Tuple[int, T]]":
         """Returns a FluentIterable over pairs of (index, element) for elements in the original Iterable. Indices start with the value of `start`."""
         iterable = self._iterable()
-        return FluentFactoryWrapper(lambda: enumerate(iterable, start=start))
+        return FluentFactoryWrapper(lambda: enumerate(iterable, start=start), maybe_sized=iterable)
 
     def zip(self, *with_iterables: Iterable) -> "FluentIterable[Tuple]":
         """Returns a sequence of tuples built from the elements of this iterable and other given iterables with the same index. The resulting Iterable ends as soon as the shortest input Iterable ends."""
@@ -229,10 +229,10 @@ def reversed(self) -> "FluentIterable[T]":
         """
         iterable = self._iterable()
         if hasattr(iterable, "__reversed__"):
-            return FluentFactoryWrapper(lambda: iterable.__reversed__())  # type: ignore[attr-defined]
+            return FluentFactoryWrapper(lambda: iterable.__reversed__(), maybe_sized=iterable)  # type: ignore[attr-defined]
         else:
             copy = list(iterable)
-            return FluentFactoryWrapper(lambda: copy.__reversed__())
+            return FluentFactoryWrapper(lambda: copy.__reversed__(), maybe_sized=copy)
 
     def grouped(self, n: int) -> "FluentIterable[List[T]]":
         """
@@ -356,42 +356,45 @@ def not_empty(self) -> bool:
         """
         return any(True for _ in self._iterable())
 
-    def len(self) -> int: 
+    def len(self) -> int:
         """Returns the number of elements in this iterable.
         Note that evaluation may result in iterating over the iterable if the wrapped collections doesn't implement the Sized contract.
         """
         it = self.__iter__()
         if hasattr(it, "__len__"):
-            return it.__len__()  # type: ignore
+            return cast(Sized, it).__len__()
         else:
             count = 0
             for _ in it:
                 count += 1
             return count
 
     def __len__(self) -> int:
-        """Returns the number of elements in this iterable.
-        Note that evaluation may result in iterating over the iterable if the wrapped collections doesn't implement the Sized contract.
-        """
-        return self.len()
+        """Returns the number of elements in this iterable, if it's known for the underlying iterable. Otherwise throws TypeError."""
+        it = self.__iter__()
+        if hasattr(it, "__len__"):
+            return cast(Sized, it).__len__()
+        # Raising exception instead of defering to len().
+        # This is necessary, e.g., to work around undocumented behavior of len() which assumes __len__() is present only if size is known in advance
+        raise TypeError(f"object of type '{type(self).__name__}' has no len()")
 
     def sum(self):
         """Returns the sum of elements in this iterable with the sum() built-in function"""
-        return sum(self._iterable()) # type: ignore
+        return sum(self._iterable())  # type: ignore
 
     def min(self, key: Optional[Callable[[T], Any]] = None, default: Optional[T] = None):
         """
         Return the smallest item in this iterable. The arguments have identical meaning to the min() built-in function:
         `key` specifies a function used to extract a comparison key, `default` specifies result value if this iterable is empty.
         """
-        return min(self._iterable(), key=key, default=default) # type: ignore
+        return min(self._iterable(), key=key, default=default)  # type: ignore
 
     def max(self, key: Optional[Callable[[T], Any]] = None, default: Optional[T] = None):
         """
         Return the smallest item in this iterable. The arguments have identical meaning to the min() built-in function:
         `key` specifies a function used to extract a comparison key, `default` specifies result value if this iterable is empty.
         """
-        return max(self._iterable(), key=key, default=default) # type: ignore
+        return max(self._iterable(), key=key, default=default)  # type: ignore
 
     def reduce(
         self,
@@ -429,16 +432,22 @@ def _iterable(self):
         return self.inner
 
 
-
 class FluentFactoryWrapper(FluentIterable[T]):
     """Implementation for cases where a known factory to a non-reusable Iterator is available"""
 
-    def __init__(self, factory: Callable[[], Iterator[T]]):
+    def __init__(self, factory: Callable[[], Iterator[T]], *, maybe_sized: Optional[Iterable] = None):
         self._factory = factory
+        self._maybe_sized = maybe_sized
 
     def __iter__(self) -> Iterator[T]:
         return self._factory()
 
+    def __len__(self) -> int:
+        """Returns the number of elements in this iterable, if it's known for the underlying iterable. Otherwise throws TypeError."""
+        if hasattr(self._maybe_sized, "__len__"):
+            return cast(Sized, self._maybe_sized).__len__()
+        return super().__len__()
+
     def _iterable(self):
         return self
 

tests/test_fluent_iterable.py

@@ -1,6 +1,7 @@
 import itertools
 from operator import mul
 from typing import Iterable, Any, Callable, Mapping
+from unittest.mock import Mock
 
 import pytest
 
@@ -762,6 +763,26 @@ def test_iterable_supports_contains():
     assert 9 not in f
 
 
+######
+# Regression tests
+######
+@pytest.mark.parametrize(
+    "elements,operation",
+    [
+        ([1, 2], lambda f: f.to_list()),
+        ([1, 2], lambda f: f.to_set()),
+        ([1, 2], lambda f: f.to_frozenset()),
+        ([1, 2], lambda f: f.to_tuple()),
+        ([("a", 1), ("b", 2)], lambda f: f.to_dict()),
+    ],
+)
+def test_does_not_invoke_map_transform_unnecessarily(elements, operation: Callable[[FluentIterable], Any]):
+    transform = Mock(side_effect=lambda x: x)
+    f = fluent(elements).map(transform)
+    operation(f)
+    assert transform.call_count == len(elements)
+
+
 ######
 # Helper functions
 ######