Merge pull request #1336 from hannobraun/array

Use `iter_fixed` to zip arrays

Cargo.lock

@@ -1187,6 +1187,7 @@ dependencies = [
  "anyhow",
  "fj-interop",
  "fj-math",
+ "iter_fixed",
  "itertools",
  "parking_lot",
  "pretty_assertions",
@@ -1836,6 +1837,12 @@ version = "2.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f88c5561171189e69df9d98bcf18fd5f9558300f7ea7b801eb8a0fd748bd8745"
 
+[[package]]
+name = "iter_fixed"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d1d13810ef04ff22d946a8445d1e0016c9e98dbb6deeeb2af061e753060737c"
+
 [[package]]
 name = "itertools"
 version = "0.10.5"

crates/fj-interop/src/ext.rs

@@ -13,11 +13,6 @@ pub trait ArrayExt<T, const N: usize> {
     fn try_map_ext<F, U, E>(self, f: F) -> Result<[U; N], E>
     where
         F: FnMut(T) -> Result<U, E>;
-
-    /// Stable replacement for `zip`
-    ///
-    /// <https://doc.rust-lang.org/std/primitive.array.html#method.zip>
-    fn zip_ext<U>(self, rhs: [U; N]) -> [(T, U); N];
 }
 
 impl<T> ArrayExt<T, 2> for [T; 2] {
@@ -33,13 +28,6 @@ impl<T> ArrayExt<T, 2> for [T; 2] {
         let [a, b] = self.map(f);
         Ok([a?, b?])
     }
-
-    fn zip_ext<U>(self, rhs: [U; 2]) -> [(T, U); 2] {
-        let [a, b] = self;
-        let [c, d] = rhs;
-
-        [(a, c), (b, d)]
-    }
 }
 
 impl<T> ArrayExt<T, 4> for [T; 4] {
@@ -55,13 +43,6 @@ impl<T> ArrayExt<T, 4> for [T; 4] {
         let [a, b, c, d] = self.map(f);
         Ok([a?, b?, c?, d?])
     }
-
-    fn zip_ext<U>(self, rhs: [U; 4]) -> [(T, U); 4] {
-        let [a, b, c, d] = self;
-        let [e, f, g, h] = rhs;
-
-        [(a, e), (b, f), (c, g), (d, h)]
-    }
 }
 
 /// Extension trait for arrays

crates/fj-kernel/Cargo.toml

@@ -13,6 +13,7 @@ categories.workspace = true
 [dependencies]
 fj-interop.workspace = true
 fj-math.workspace = true
+iter_fixed = "0.3.1"
 itertools = "0.10.5"
 parking_lot = "0.12.0"
 pretty_assertions = "1.3.0"

crates/fj-kernel/src/algorithms/intersect/face_face.rs

@@ -1,4 +1,5 @@
 use fj_interop::ext::ArrayExt;
+use iter_fixed::IntoIteratorFixed;
 
 use crate::{
     objects::{Curve, Face, Objects},
@@ -41,8 +42,10 @@ impl FaceFaceIntersection {
 
         let curve_face_intersections = intersection_curves
             .each_ref_ext()
-            .zip_ext(faces)
+            .into_iter_fixed()
-            .map(|(curve, face)| CurveFaceIntersection::compute(curve, face));
+            .zip(faces)
+            .map(|(curve, face)| CurveFaceIntersection::compute(curve, face))
+            .collect::<[_; 2]>();
 
         let intersection_intervals = {
             let [a, b] = curve_face_intersections;

crates/fj-kernel/src/algorithms/sweep/edge.rs

@@ -1,5 +1,6 @@
 use fj_interop::{ext::ArrayExt, mesh::Color};
 use fj_math::{Line, Scalar, Vector};
+use iter_fixed::IntoIteratorFixed;
 
 use crate::{
     algorithms::{reverse::Reverse, transform::TransformObject},
@@ -65,7 +66,9 @@ impl Sweep for (Handle<HalfEdge>, Color) {
 
                 vertices
                     .each_ref_ext()
-                    .zip_ext(points_surface)
+                    .into_iter_fixed()
+                    .zip(points_surface)
+                    .collect::<[_; 2]>()
                     .try_map_ext(
                     |(vertex, point_surface)| -> Result<_, ValidationError> {
                         let surface_vertex = objects.surface_vertices.insert(
@@ -135,7 +138,9 @@ impl Sweep for (Handle<HalfEdge>, Color) {
 
             let vertices = bottom_vertices
                 .each_ref_ext()
-                .zip_ext(surface_vertices)
+                .into_iter_fixed()
+                .zip(surface_vertices)
+                .collect::<[_; 2]>()
                 .try_map_ext(|(vertex, surface_form)| {
                     objects.vertices.insert(Vertex::new(
                         vertex.position(),

crates/fj-kernel/src/builder/edge.rs

@@ -1,5 +1,5 @@
-use fj_interop::ext::ArrayExt;
 use fj_math::{Point, Scalar};
+use iter_fixed::IntoIteratorFixed;
 
 use crate::{
     insert::Insert,
@@ -187,17 +187,21 @@ impl HalfEdgeBuilder for PartialHalfEdge {
                     .unwrap_or([None, None])
             };
 
-            vertices.zip_ext(global_forms).map(|(vertex, global_form)| {
+            vertices
-                vertex.update_partial(|vertex| {
+                .into_iter_fixed()
-                    vertex.clone().with_surface_form(
+                .zip(global_forms)
-                        vertex.surface_form().update_partial(
+                .collect::<[_; 2]>()
-                            |surface_vertex| {
+                .map(|(vertex, global_form)| {
-                                surface_vertex.with_global_form(global_form)
+                    vertex.update_partial(|vertex| {
-                            },
+                        vertex.clone().with_surface_form(
-                        ),
+                            vertex.surface_form().update_partial(
-                    )
+                                |surface_vertex| {
+                                    surface_vertex.with_global_form(global_form)
+                                },
+                            ),
+                        )
+                    })
                 })
-            })
         };
 
         self.with_curve(curve).with_vertices([back, front])

crates/fj-kernel/src/builder/shell.rs

@@ -2,6 +2,7 @@ use std::array;
 
 use fj_interop::ext::{ArrayExt, SliceExt};
 use fj_math::Scalar;
+use iter_fixed::IntoIteratorFixed;
 
 use crate::{
     algorithms::transform::TransformObject,
@@ -235,8 +236,11 @@ impl<'a> ShellBuilder<'a> {
                 let mut edges = top_edges.iter();
                 let half_edges = array::from_fn(|_| edges.next().unwrap());
 
-                let [a, b, c, d] =
+                let [a, b, c, d] = points
-                    points.zip_ext(half_edges).map(|(point, edge)| {
+                    .into_iter_fixed()
+                    .zip(half_edges)
+                    .collect::<[_; 4]>()
+                    .map(|(point, edge)| {
                         let vertex = edge.back();
 
                         SurfaceVertex::partial()
@@ -263,7 +267,9 @@ impl<'a> ShellBuilder<'a> {
                 let vertices = edge
                     .vertices()
                     .each_ref_ext()
-                    .zip_ext(surface_vertices.clone())
+                    .into_iter_fixed()
+                    .zip(surface_vertices.clone())
+                    .collect::<[_; 2]>()
                     .map(|(vertex, surface_form)| {
                         Vertex::partial()
                             .with_position(Some(vertex.position()))

crates/fj-kernel/src/partial/util.rs

@@ -1,4 +1,4 @@
-use fj_interop::ext::ArrayExt;
+use iter_fixed::IntoIteratorFixed;
 
 use super::{HasPartial, MaybePartial};
 
@@ -22,5 +22,8 @@ pub fn merge_arrays<T: HasPartial>(
     a: [MaybePartial<T>; 2],
     b: [MaybePartial<T>; 2],
 ) -> [MaybePartial<T>; 2] {
-    a.zip_ext(b).map(|(a, b)| a.merge_with(b))
+    a.into_iter_fixed()
+        .zip(b)
+        .collect::<[_; 2]>()
+        .map(|(a, b)| a.merge_with(b))
 }