[ 
https://issues.apache.org/jira/browse/GROOVY-12016?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=18081582#comment-18081582
 ] 

ASF GitHub Bot commented on GROOVY-12016:
-----------------------------------------

testlens-app[bot] commented on PR #2541:
URL: https://github.com/apache/groovy/pull/2541#issuecomment-4474795066

   ## ✅ All tests passed ✅
   
   🏷️ Commit: 0f890027beea99f5437ce82506e476228519ea4e
   ▶️ Tests:  99147 executed
   ⚪️ Checks: 28/28 completed
   
   ---
   _Learn more about TestLens at [testlens.app](https://testlens.app)._
   




> New GDK methods: zipWithNext and groupConsecutive
> -------------------------------------------------
>
>                 Key: GROOVY-12016
>                 URL: https://issues.apache.org/jira/browse/GROOVY-12016
>             Project: Groovy
>          Issue Type: New Feature
>          Components: Extension methods
>            Reporter: Paul King
>            Assignee: Paul King
>            Priority: Major
>
> h2. {{zipWithNext}} 
> Add a {{zipWithNext}} GDK method returning successive adjacent pairs
> (a sliding window of size 2, step 1), plus an overload taking a
> combiner. Mirrors Kotlin's {{zipWithNext()}} / {{zipWithNext(transform)}}.
> Today this needs the non-obvious, off-by-one-prone {{collate(2, 1, false)}}.
> h3. Proposed signatures
> {code:java}
> List<Tuple2<T,T>>      zipWithNext(Iterable<T> self)
> <R> List<R>            zipWithNext(Iterable<T> self, BiFunction<? super T,? 
> super T,? extends R> combiner)
> Iterator<Tuple2<T,T>>  zipWithNext(Iterator<T> self)                 // lazy
> <R> Iterator<R>        zipWithNext(Iterator<T> self, BiFunction<? super T,? 
> super T,? extends R> combiner)
> List<Tuple2<T,T>>      zipWithNext(T[] self)
> <R> List<R>            zipWithNext(T[] self, BiFunction<? super T,? super T,? 
> extends R> combiner)
> {code}
> h3. Examples
> {code:groovy}
> [1, 2, 3, 4].zipWithNext()            == [new Tuple2(1,2), new Tuple2(2,3), 
> new Tuple2(3,4)]
> [1, 2, 3, 4].zipWithNext{ a,b -> b-a } == [1, 1, 1]            // pairwise 
> deltas
> [3,1,4,1,5].zipWithNext{ a,b -> a<=b }.every()  == false       // monotonic 
> check
> [].zipWithNext()  == []
> [42].zipWithNext() == []                                       // no adjacent 
> pair
> {code}
> h3. Notes
> Groovy closures coerce to {{BiFunction}}. Primitive-array overloads
> deferred (Tuple2 boxes anyway).
> h2. {{groupConsecutive}}
> Add a {{groupConsecutive}} GDK method splitting a sequence into maximal
> runs of adjacent "same" elements (order preserved; the same key may
> recur in separate runs). Unlike {{groupBy}} (a {{Map}}, global, loses
> order and run boundaries) there is no native equivalent today.
> h3. Proposed signatures
> {code:java}
> List<List<T>>      groupConsecutive(Iterable<T> self)                         
>                // default equality
> <K> List<List<T>>  groupConsecutive(Iterable<T> self, Function<? super T,? 
> extends K> keyFn)  // by derived key
> List<List<T>>      groupConsecutive(Iterable<T> self, BiPredicate<? super T,? 
> super T> sameRun)
> // + Iterator (lazy) and T[] receiver rows, same trio
> {code}
> h3. Examples
> {code:groovy}
> [1,1,2,2,2,3,1,1].groupConsecutive()        == [[1,1],[2,2,2],[3],[1,1]]   // 
> two separate [1,1] runs
> [1,1L,1.0,2,2].groupConsecutive()           == [[1,1L,1.0],[2,2]]          // 
> number-aware default
> ['apple','avocado','banana'].groupConsecutive{ it[0] } == 
> [['apple','avocado'],['banana']]
> xs.groupConsecutive{ a,b -> Objects.equals(a,b) }                          // 
> opt out to strict .equals()
> 'aaabbbcccd'.toList().groupConsecutive().collect{ [it[0], it.size()] }     // 
> run-length encoding
> {code}
> h3. Design notes
> * No-arg uses Groovy's number-aware equality ({{coercedEquals}}),
>   consistent with {{unique()}} and the set-algebra family (derived from
>   the DefaultGroovyMethods source; {{contains}}'s plain-equals is the
>   documented anomaly, not the model).
> * Opt out via the {{BiPredicate}} overload: {{Objects.equals}} for
>   strict, {{(a <=> b) == 0}} for natural-order/value equivalence,
>   {{cmp.compare(a,b)==0}} for a Comparator. A {{Comparator}} overload was
>   rejected: a boolean closure silently mis-coerces to it.
> * Arity-disambiguated overloads (0/1/2 params); no closure-arity sniffing.
> * {{dedupeConsecutive}} intentionally NOT included — it is
>   {{groupConsecutive()*.first()}} (cf. {{findAll}} with no {{rejectAll}}).



--
This message was sent by Atlassian Jira
(v8.20.10#820010)

Reply via email to