From: "ufuk (Ufuk Kayserilioglu) via ruby-core" Date: 2026-11-13T19:27:06+00:00 Subject: [ruby-core:127473] [Ruby Feature#22536] Add Enumerable#longest_slice to return the range of the longest consecutive matching sequence Issue #22536 has been updated by ufuk (Ufuk Kayserilioglu). One concern that I have about this proposal is that the method proposed needs to iterate all the items to be sure that it found the longest slice, but an `Enumerable` can be infinite, which would guarantee that the method call would never return: ```ruby (1..).longest_slice(&:even) # does this ever return? ``` I know there are other instances of `Enumerable` methods that are misbehaved with infinite items, and if I recall correctly that was a discussion about them on this bug tracker before. The ship has sailed on those ones, but I'd rather not add another misbehaved method on `Enumerable`. The method might be more appropriate on `Array`, though, since all the examples are either on arrays, or ones that can be trivially converted to arrays. ---------------------------------------- Feature #22536: Add Enumerable#longest_slice to return the range of the longest consecutive matching sequence https://bugs.ruby-lang.org/issues/22536#change-119940 * Author: datibbaw (Tjerk Meesters) * Status: Open ---------------------------------------- I propose adding `Enumerable#longest_slice`, which returns a Range identifying the longest consecutive sequence of matching entries. Without a block, entries match when they are truthy. Both `nil` and `false` break a sequence. With a block, entries match when the block returns a truthy value. ### Motivation Finding the longest consecutive matching sequence currently requires manually tracking positions and run lengths, or creating intermediate collections. Returning a Range makes the result directly usable for slicing an Array or identifying positions in another enumerable. I ran into this when analysing IPv6 compression logic and reasoned that it may have other uses; in comparison, longest prefix / suffix is already covered with e.g. `#index` and `#rindex` using block syntax. ### Examples [nil, 'a', 'b', nil, 'c'].longest_slice # => 1...3 [1, 2, 4, 3, 6].longest_slice(&:even?) # => 1...3 [false, 0, []].longest_slice # => 1...3 a = [10, 20, 30, 40] a.each.with_index(1).longest_slice do |value, index| value >= 20 && index <= 3 end # => 1...3 ### Proposed behavior * Return a zero-based, end-exclusive Range. * Return `0...0` for an empty enumerable or when no entries match. * When multiple matching sequences have the same maximum length, return the first. * Forward all arguments yielded by `each` to the block, supporting indexed enumerators and multi-argument iterators. * Always express the result in iteration positions, independently of any index yielded to the block. * Traverse the enumerable once, using constant auxiliary space. The name `longest_slice` and the API details are open for discussion. A draft implementation with documentation and tests is available at: https://github.com/ruby/ruby/pull/19838 -- https://bugs.ruby-lang.org/ ______________________________________________ ruby-core mailing list -- ruby-core@ml.ruby-lang.org To unsubscribe send an email to ruby-core-leave@ml.ruby-lang.org ruby-core info -- https://ml.ruby-lang.org/mailman3/lists/ruby-core.ml.ruby-lang.org/