add @array.zip and @array.zip_with

[myfreess]

No description provided.

[coveralls]

Pull Request Test Coverage Report for Build 6413

Details

• 20 of 21 (95.24%) changed or added relevant lines in 2 files are covered.
• No unchanged relevant lines lost coverage.
• Overall coverage increased (+0.002%) to 93.255%

---

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
array/array.mbt	16	17	94.12%

Totals
Change from base Build 6409:	0.002%
Covered Lines:	5890
Relevant Lines:	6316

---

💛 - Coveralls

[Lampese]

I have an API design concern, with Array zip, what about FixedArray? What about other linearly traversable structures? This leads to the discussion that Iter::zip, but our Iter can't do zip...

cc @bobzhang

[FlammeShadow]

It seems zip_with can be easily composed with zip and map?

[illusory0x0]

related issue.

• zip for arrays, iters, etc #994

[Yoorkin]

There is a zip function in immut/list:

/// Zip two lists.
/// If the lists have different lengths, it will return None.
pub fn zip[A, B](self : T[A], other : T[B]) -> T[(A, B)]?

It's a method that returns an option. To make the API more consistent, consider changing the API like this:

// in immut/list
pub fn zip[A, B](self : T[A], other : T[B]) -> T[(A, B)]

// in array
pub fn zip[A, B](self : T[A], other : T[B]) -> T[(A, B)]
pub fn zip_with[A, B, C](self : T[A], other : T[B], merge~ : (A,B)->C) -> T[C]

[Lampese]

I have an API design concern, with Array zip, what about FixedArray? What about other linearly traversable structures? This leads to the discussion that Iter::zip, but our Iter can't do zip...

cc @bobzhang

So that the zip for FixedArray is a todo issue?

[peter-jerry-ye-code-review]

Different behaviors between Array.zip and List.zip may confuse users

Category
Maintainability
Code Snippet
// Array.zip truncates to shortest length
array1.zip(array2) // Returns [(1,a), (2,b)] for [1,2] and [a,b,c]

// List.zip behavior changed from returning Option to truncating
list1.zip(list2) // Now returns same truncating behavior
Recommendation
Consider adding documentation to explicitly highlight this behavioral change in List.zip, and explain why Option was removed in favor of truncation
Reasoning
The change in List.zip behavior from returning Option to truncating is significant and should be clearly documented. While aligning behavior with Array.zip makes sense for consistency, the change could break existing code that expects an Option return type.

zip_to_iter2 lacks documentation about early termination behavior

Category
Correctness
Code Snippet
pub fn zip_to_iter2[A, B](self : Array[A], other : Array[B]) -> Iter2[A, B] {
// ... if yield_(self[i], other[i]) == IterEnd { break IterEnd } ...
}
Recommendation
Add documentation explaining that iteration can be terminated early if the yield function returns IterEnd
Reasoning
The early termination behavior via IterEnd is an important detail that users should be aware of, as it affects how the iterator can be used in practice

Array capacity pre-allocation could be optimized in zip functions

Category
Performance
Code Snippet
let length = if self.length() < other.length() { self.length() } else { other.length() }
let arr = Array::new(capacity=length)
Recommendation
Consider adding a specialized implementation when arrays have equal length to avoid the length comparison
Reasoning
For the common case where arrays have equal length, we could avoid the length comparison. This could be done via a fast path check: if self.length() == other.length() { ... }

[peter-jerry-ye]

without labelled argument

[peter-jerry-ye]

Provide zip_to_iter for creating Iter2

[peter-jerry-ye]

drop the changes in immut/list as they are irrelevant and we are going to deprecate them.