add with-default-value overload to __getitem__()

Author: cleoold

doc/api/types_linq.enumerable.rst

@@ -86,6 +86,30 @@ Example
 
 ----
 
+instancemethod ``__getitem__[TDefault](__index_and_default)``
+---------------------------------------------------------------
+
+Parameters
+  - `__index_and_default` (``Tuple[int, TDefault]``)
+
+Returns
+  - ``Union[TSource_co, TDefault]``
+
+Returns the element at specified index in the sequence or returns the default value if it does not
+exist. Prefers calling `__getitem__()` on the wrapped iterable if available, otherwise, calls
+`self.element_at()`.
+
+Example
+    .. code-block:: python
+
+        >>> def gen():
+        ...     yield 1; yield 10; yield 100
+
+        >>> Enumerable(gen())[3, 1000]
+        1000
+
+----
+
 instancemethod ``__getitem__(index)``
 ---------------------------------------
 

doc/to-start/differences.rst

@@ -43,3 +43,5 @@ Limitations:
 * To deal with overloads, some method parameters are positional-only, e.g. those starting with double
   underscores. Some of them can be improved.
 * ``OrderedEnumerable`` exposing unnecessary type parameter ``TKey``.
+* ``Lookup.__getitem__()``, ``Lookup.contains()``, ``Lookup.count`` are incompatible with the superclass methods they
+  are overriding.

tests/test_usage.py

@@ -370,6 +370,10 @@ def test_fallback(self):
         with pytest.raises(IndexOutOfRangeError):
             en3[1]
 
+    def test_not_fallback_and_with_default(self):
+        en = Enumerable([])
+        assert en[1, 'haha'] == 'haha'
+
 
     class OnlyHasGetItem(BasicIterable[TSource_co], Sequence[TSource_co]):
         # note: we get into troubles if Sequence is the first superclass

types_linq/enumerable.py

@@ -126,9 +126,16 @@ def inner(s: slice = index):
             return Enumerable(inner)
 
     def __getitem__(self,  # type: ignore[override]
-        index: Union[int, slice],
-    ) -> Union[TSource_co, Enumerable[TSource_co]]:
-        return self._getitem_impl(index, fallback=False)
+        index: Union[int, slice, Tuple[int, TDefault]],
+    ) -> Union[TSource_co, Enumerable[TSource_co], TDefault]:
+        if isinstance(index, tuple):
+            idx, default = index
+            try:
+                return self._getitem_impl(idx, fallback=False)
+            except IndexOutOfRangeError:
+                return default
+        else:  # isinstance(index, (int, slice))
+            return self._getitem_impl(index, fallback=False)
 
     def __iter__(self) -> Iterator[TSource_co]:
         return iter(self._get_iterable())

types_linq/enumerable.pyi

@@ -75,6 +75,23 @@ class Enumerable(Sequence[TSource_co], Generic[TSource_co]):
                 10
         '''
 
+    @overload
+    def __getitem__(self, __index_and_default: Tuple[int, TDefault]) -> Union[TSource_co, TDefault]:
+        '''
+        Returns the element at specified index in the sequence or returns the default value if it does not
+        exist. Prefers calling `__getitem__()` on the wrapped iterable if available, otherwise, calls
+        `self.element_at()`.
+
+        Example
+            .. code-block:: python
+
+                >>> def gen():
+                ...     yield 1; yield 10; yield 100
+
+                >>> Enumerable(gen())[3, 1000]
+                1000
+        '''
+
     @overload
     def __getitem__(self, index: slice) -> Enumerable[TSource_co]:
         '''