add an overload to take() that takes a slice

Author: cleoold

doc/api/types_linq.enumerable.rst

@@ -2061,6 +2061,30 @@ Example
 
 ----
 
+instancemethod ``take(__index)``
+----------------------------------
+
+Parameters
+  - `__index` (``slice``)
+
+Returns
+  - ``Enumerable[TSource_co]``
+
+Produces a subsequence defined by the given slice notation.
+
+This method currently is identical to `elements_in()` when it takes a slice.
+
+Example
+    .. code-block:: python
+
+        >>> def gen():
+        ...     yield 1; yield 10; yield 100; yield 1000; yield 10000
+
+        >>> Enumerable(gen()).take(slice(1, 3)).to_list()
+        [10, 100]
+
+----
+
 instancemethod ``take_last(count)``
 -------------------------------------
 
@@ -2461,6 +2485,9 @@ Returns
 
 Produces a subsequence defined by the given slice notation.
 
+This method always uses a generic list slicing method regardless the implementation of the
+wrapped iterable.
+
 Example
     .. code-block:: python
 
@@ -2485,6 +2512,8 @@ Returns
 
 Produces a subsequence with indices that define a slice.
 
+This method always uses a generic list slicing method regardless the implementation of the
+wrapped iterable.
 
 Example
     .. code-block:: python

doc/to-start/differences.rst

@@ -36,6 +36,10 @@ and its .NET counterpart.
   Some C# methods return such default values if the source sequence is empty, or skip ``null``'s if the source sequence contains
   concrete data too. There are no such notions in Python and the C#-like default semantics are non-existent. So, this usage is
   not supported by this library (Can ``None`` be considered a default value for all cases? Hmm..).
+* C# has `Index <https://docs.microsoft.com/en-us/dotnet/api/system.index>`_ syntaxes, and to be Pythonic, these are
+  negative indices. C# has `Range <https://docs.microsoft.com/en-us/dotnet/api/system.range>`_, which are
+  `slices <https://docs.python.org/3/library/functions.html#slice>`_. This difference can be seen in ``Enumerable.element_at()``
+  and ``Enumerable.take()``.
 * All classes in this library are concrete. There are no interfaces like what are usually done in C#.
 
 Limitations:

tests/test_usage.py

@@ -1349,28 +1349,38 @@ def test_sum2_overload2(self):
 
 
 class TestTakeMethod:
-    def test_some(self):
+    def test_overload1_some(self):
         lst = [1, 4, 6, 9, 10]
         en = Enumerable(lst)
         assert en.take(3).to_list() == [1, 4, 6]
         assert en.take(5).to_list() == lst
 
-    def test_more(self):
+    def test_overload1_more(self):
         lst = [1, 4, 6, 9, 10]
         en = Enumerable(lst)
         assert en.take(6).to_list() == lst
 
-    def test_count_zero_or_negative(self):
+    def test_overload1_count_zero_or_negative(self):
         lst = [1, 4, 6, 9, 10]
         en = Enumerable(lst)
         assert en.take(0).to_list() == []
         assert en.take(-1).to_list() == []
 
-    def test_id(self):
+    def test_overload1_id(self):
         lst = [1, 4, 6, 9, 10]
         en = Enumerable(lst)
         assert en.take(4).concat(en.skip(4)).to_list() == lst
 
+    def test_overload2(self):
+        def gen():
+            yield from [1, 10, 100, 1000, 10000]
+        en = Enumerable(gen())
+        assert en.take(slice(1, 3)).to_list() == [10, 100]
+
+    def test_overload2_fallback(self):
+        en = Enumerable(TestElementAtMethod.OnlyHasGetItem(['x']))
+        assert en.elements_in(slice(7)).to_list() == ['x']
+
 
 class TestTakeLastMethod:
     def test_some(self):

types_linq/enumerable.py

@@ -841,15 +841,18 @@ def sum2(self, *args) -> Any:
             selector, default = args
         return self._sum_helper(selector, lambda: default)
 
-    def take(self, count: int) -> Enumerable[TSource_co]:
-        def inner():
-            iterator = iter(self)
-            try:
-                for _ in range(count):
-                    yield next(iterator)
-            except StopIteration:
-                return
-        return Enumerable(inner)
+    def take(self, count: Union[int, slice]) -> Enumerable[TSource_co]:
+        if isinstance(count, int):
+            def inner():
+                iterator = iter(self)
+                try:
+                    for _ in range(count):
+                        yield next(iterator)
+                except StopIteration:
+                    return
+            return Enumerable(inner)
+        else:  # isinstance(count, slice)
+            return self.elements_in(count)
 
     def take_last(self, count: int) -> Enumerable[TSource_co]:
         if count <= 0:

types_linq/enumerable.pyi

@@ -1490,6 +1490,7 @@ class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
             880
         '''
 
+    @overload
     def take(self, count: int) -> Enumerable[TSource_co]:
         '''
         Returns a specified number of contiguous elements from the start of the sequence.
@@ -1500,6 +1501,23 @@ class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
             [98, 92, 85]
         '''
 
+    @overload
+    def take(self, __index: slice) -> Enumerable[TSource_co]:
+        '''
+        Produces a subsequence defined by the given slice notation.
+
+        This method currently is identical to `elements_in()` when it takes a slice.
+
+        Example
+            .. code-block:: python
+
+                >>> def gen():
+                ...     yield 1; yield 10; yield 100; yield 1000; yield 10000
+
+                >>> Enumerable(gen()).take(slice(1, 3)).to_list()
+                [10, 100]
+        '''
+
     def take_last(self, count: int) -> Enumerable[TSource_co]:
         '''
         Returns a new sequence that contains the last `count` elements.
@@ -1737,6 +1755,9 @@ class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
         '''
         Produces a subsequence defined by the given slice notation.
 
+        This method always uses a generic list slicing method regardless the implementation of the
+        wrapped iterable.
+
         Example
             .. code-block:: python
 
@@ -1752,6 +1773,8 @@ class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
         '''
         Produces a subsequence with indices that define a slice.
 
+        This method always uses a generic list slicing method regardless the implementation of the
+        wrapped iterable.
 
         Example
             .. code-block:: python