Merge pull request #1312 from hannobraun/partial

Continue cleanup of partial object API

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

@@ -208,58 +208,56 @@ mod tests {
         let face =
             (half_edge, Color::default()).sweep([0., 0., 1.], &objects)?;
 
-        let expected_face = {
+        let expected_face =
-            let surface = objects.surfaces.xz_plane();
+            {
+                let surface = objects.surfaces.xz_plane();
 
-            let bottom = HalfEdge::partial()
+                let bottom = HalfEdge::partial()
-                .update_as_line_segment_from_points(
+                    .update_as_line_segment_from_points(
-                    surface.clone(),
+                        surface.clone(),
-                    [[0., 0.], [1., 0.]],
+                        [[0., 0.], [1., 0.]],
-                )
+                    )
-                .build(&objects)?;
+                    .build(&objects)?;
-            let side_up = HalfEdge::partial()
+                let side_up = HalfEdge::partial()
-                .with_surface(Some(surface.clone()))
+                    .with_surface(surface.clone())
-                .with_back_vertex(Some(Vertex::partial().with_surface_form(
+                    .with_back_vertex(Vertex::partial().with_surface_form(
-                    Some(bottom.front().surface_form().clone()),
+                        bottom.front().surface_form().clone(),
-                )))
+                    ))
-                .with_front_vertex(Some(Vertex::partial().with_surface_form(
+                    .with_front_vertex(Vertex::partial().with_surface_form(
-                    Some(
                         SurfaceVertex::partial().with_position(Some([1., 1.])),
-                    ),
+                    ))
-                )))
+                    .update_as_line_segment()
-                .update_as_line_segment()
+                    .build(&objects)?;
-                .build(&objects)?;
+                let top = HalfEdge::partial()
-            let top = HalfEdge::partial()
+                    .with_surface(surface.clone())
-                .with_surface(Some(surface.clone()))
+                    .with_back_vertex(Vertex::partial().with_surface_form(
-                .with_back_vertex(Some(Vertex::partial().with_surface_form(
-                    Some(
                         SurfaceVertex::partial().with_position(Some([0., 1.])),
-                    ),
+                    ))
-                )))
+                    .with_front_vertex(Vertex::partial().with_surface_form(
-                .with_front_vertex(Some(Vertex::partial().with_surface_form(
+                        side_up.front().surface_form().clone(),
-                    Some(side_up.front().surface_form().clone()),
+                    ))
-                )))
+                    .update_as_line_segment()
-                .update_as_line_segment()
+                    .build(&objects)?
-                .build(&objects)?
+                    .reverse(&objects)?;
-                .reverse(&objects)?;
+                let side_down =
-            let side_down = HalfEdge::partial()
+                    HalfEdge::partial()
-                .with_surface(Some(surface))
+                        .with_surface(surface)
-                .with_back_vertex(Some(Vertex::partial().with_surface_form(
+                        .with_back_vertex(Vertex::partial().with_surface_form(
-                    Some(bottom.back().surface_form().clone()),
+                            bottom.back().surface_form().clone(),
-                )))
+                        ))
-                .with_front_vertex(Some(Vertex::partial().with_surface_form(
+                        .with_front_vertex(Vertex::partial().with_surface_form(
-                    Some(top.front().surface_form().clone()),
+                            top.front().surface_form().clone(),
-                )))
+                        ))
-                .update_as_line_segment()
+                        .update_as_line_segment()
-                .build(&objects)?
+                        .build(&objects)?
-                .reverse(&objects)?;
+                        .reverse(&objects)?;
 
-            let cycle = objects
+                let cycle = objects
-                .cycles
+                    .cycles
-                .insert(Cycle::new([bottom, side_up, top, side_down]))?;
+                    .insert(Cycle::new([bottom, side_up, top, side_down]))?;
 
-            Face::builder(&objects).with_exterior(cycle).build()
+                Face::builder(&objects).with_exterior(cycle).build()
-        };
+            };
 
         assert_eq!(face, expected_face);
         Ok(())

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

@@ -184,7 +184,7 @@ mod tests {
             .build(&objects)?;
         let vertex = Vertex::partial()
             .with_position(Some([0.]))
-            .with_curve(Some(curve))
+            .with_curve(curve)
             .build(&objects)?;
 
         let half_edge =

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

@@ -25,19 +25,18 @@ impl TransformObject for PartialHalfEdge {
                 Ok(vertex
                     .into_partial()
                     .transform(transform, objects)?
-                    .with_curve(Some(curve.clone())))
+                    .with_curve(curve.clone()))
             },
         )?;
         let global_form = self
             .global_form()
             .into_partial()
             .transform(transform, objects)?
-            .with_curve(curve.global_form())
+            .with_curve(curve.global_form());
-            .into();
 
         Ok(Self::default()
-            .with_curve(Some(curve))
+            .with_curve(curve)
-            .with_vertices(Some(vertices))
+            .with_vertices(vertices)
             .with_global_form(global_form))
     }
 }

crates/fj-kernel/src/algorithms/transform/vertex.rs

@@ -18,14 +18,13 @@ impl TransformObject for PartialVertex {
         let surface_form = self
             .surface_form()
             .into_partial()
-            .transform(transform, objects)?
+            .transform(transform, objects)?;
-            .into();
 
         // Don't need to transform `self.position`, as that is in curve
         // coordinates and thus transforming the curve takes care of it.
         Ok(Self::default()
             .with_position(self.position())
-            .with_curve(Some(curve))
+            .with_curve(curve)
             .with_surface_form(surface_form))
     }
 }

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

@@ -74,15 +74,15 @@ impl CycleBuilder for PartialCycle {
                 let [from, to] =
                     [(0., from), (1., to)].map(|(position, surface_form)| {
                         Vertex::partial()
-                            .with_curve(Some(curve.clone()))
+                            .with_curve(curve.clone())
                             .with_position(Some([position]))
-                            .with_surface_form(Some(surface_form))
+                            .with_surface_form(surface_form)
                     });
 
                 half_edges.push(
                     HalfEdge::partial()
-                        .with_curve(Some(curve))
+                        .with_curve(curve)
-                        .with_vertices(Some([from, to])),
+                        .with_vertices([from, to]),
                 );
 
                 continue;

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

@@ -75,13 +75,11 @@ impl HalfEdgeBuilder for PartialHalfEdge {
         let [back, front] = [a_curve, b_curve].map(|point_curve| {
             Vertex::partial()
                 .with_position(Some(point_curve))
-                .with_curve(Some(curve.clone()))
+                .with_curve(curve.clone())
-                .with_surface_form(Some(surface_vertex.clone()))
+                .with_surface_form(surface_vertex.clone())
         });
 
-        Ok(self
+        Ok(self.with_curve(curve).with_vertices([back, front]))
-            .with_curve(Some(curve))
-            .with_vertices(Some([back, front])))
     }
 
     fn update_as_line_segment_from_points(
@@ -94,11 +92,11 @@ impl HalfEdgeBuilder for PartialHalfEdge {
                 .with_surface(Some(surface.clone()))
                 .with_position(Some(point));
 
-            Vertex::partial().with_surface_form(Some(surface_form))
+            Vertex::partial().with_surface_form(surface_form)
         });
 
-        self.with_surface(Some(surface))
+        self.with_surface(surface)
-            .with_vertices(Some(vertices))
+            .with_vertices(vertices)
             .update_as_line_segment()
     }
 
@@ -129,7 +127,7 @@ impl HalfEdgeBuilder for PartialHalfEdge {
                 vertex.update_partial(|vertex| {
                     vertex
                         .with_position(Some([position]))
-                        .with_curve(Some(curve.clone()))
+                        .with_curve(curve.clone())
                 })
             });
 
@@ -170,19 +168,18 @@ impl HalfEdgeBuilder for PartialHalfEdge {
 
             vertices.zip_ext(global_forms).map(|(vertex, global_form)| {
                 vertex.update_partial(|vertex| {
-                    vertex.clone().with_surface_form(Some(
+                    vertex.clone().with_surface_form(
                         vertex.surface_form().update_partial(
                             |surface_vertex| {
                                 surface_vertex.with_global_form(global_form)
                             },
                         ),
-                    ))
+                    )
                 })
             })
         };
 
-        self.with_curve(Some(curve))
+        self.with_curve(curve).with_vertices([back, front])
-            .with_vertices(Some([back, front]))
     }
 }
 

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

@@ -89,7 +89,7 @@ impl<'a> ShellBuilder<'a> {
                 .zip(&surfaces)
                 .map(|(half_edge, surface)| {
                     HalfEdge::partial()
-                        .with_global_form(Some(half_edge.global_form().clone()))
+                        .with_global_form(half_edge.global_form().clone())
                         .update_as_line_segment_from_points(
                             surface.clone(),
                             [[Z, Z], [edge_length, Z]],
@@ -112,10 +112,10 @@ impl<'a> ShellBuilder<'a> {
                         .with_surface(Some(surface.clone()));
 
                     HalfEdge::partial()
-                        .with_vertices(Some([
+                        .with_vertices([
-                            Vertex::partial().with_surface_form(Some(from)),
+                            Vertex::partial().with_surface_form(from),
-                            Vertex::partial().with_surface_form(Some(to)),
+                            Vertex::partial().with_surface_form(to),
-                        ]))
+                        ])
                         .update_as_line_segment()
                         .build(self.objects)
                         .unwrap()
@@ -148,11 +148,11 @@ impl<'a> ShellBuilder<'a> {
                         ));
 
                         HalfEdge::partial()
-                            .with_curve(Some(curve))
+                            .with_curve(curve)
-                            .with_vertices(Some([
+                            .with_vertices([
-                                Vertex::partial().with_surface_form(Some(from)),
+                                Vertex::partial().with_surface_form(from),
-                                Vertex::partial().with_surface_form(Some(to)),
+                                Vertex::partial().with_surface_form(to),
-                            ]))
+                            ])
                             .update_as_line_segment()
                             .build(self.objects)
                             .unwrap()
@@ -171,11 +171,11 @@ impl<'a> ShellBuilder<'a> {
                     let from = from.surface_form().clone();
                     let to = to.surface_form().clone();
 
-                    let from = Vertex::partial().with_surface_form(Some(from));
+                    let from = Vertex::partial().with_surface_form(from);
-                    let to = Vertex::partial().with_surface_form(Some(to));
+                    let to = Vertex::partial().with_surface_form(to);
 
                     HalfEdge::partial()
-                        .with_vertices(Some([from, to]))
+                        .with_vertices([from, to])
                         .update_as_line_segment()
                         .build(self.objects)
                         .unwrap()
@@ -246,13 +246,13 @@ impl<'a> ShellBuilder<'a> {
                     .map(|(vertex, surface_form)| {
                         Vertex::partial()
                             .with_position(Some(vertex.position()))
-                            .with_surface_form(Some(surface_form))
+                            .with_surface_form(surface_form)
                     });
 
                 edges.push(
                     HalfEdge::partial()
-                        .with_vertices(Some(vertices))
+                        .with_vertices(vertices)
-                        .with_global_form(Some(edge.global_form().clone()))
+                        .with_global_form(edge.global_form().clone())
                         .update_as_line_segment()
                         .build(self.objects)
                         .unwrap(),

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

@@ -16,7 +16,7 @@ pub trait VertexBuilder {
 
 impl VertexBuilder for PartialVertex {
     fn infer_surface_form(self) -> Self {
-        self.with_surface_form(Some(PartialSurfaceVertex::default()))
+        self.with_surface_form(PartialSurfaceVertex::default())
     }
 }
 

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

@@ -65,8 +65,8 @@ impl<T: HasPartial> MaybePartial<T> {
     }
 
     /// Merge this `MaybePartial` with another of the same type
-    pub fn merge_with(self, other: Self) -> Self {
+    pub fn merge_with(self, other: impl Into<Self>) -> Self {
-        match (self, other) {
+        match (self, other.into()) {
             (Self::Full(_), Self::Full(_)) => {
                 panic!("Can't merge two full objects")
             }

crates/fj-kernel/src/partial/objects/cycle.rs

@@ -1,6 +1,8 @@
 use crate::{
     objects::{Cycle, HalfEdge, Objects, Surface},
-    partial::{util::merge_options, MaybePartial},
+    partial::{
+        util::merge_options, MaybePartial, PartialHalfEdge, PartialVertex,
+    },
     storage::Handle,
     validate::ValidationError,
 };
@@ -56,7 +58,7 @@ impl PartialCycle {
         if let Some(surface) = surface {
             for half_edge in &mut self.half_edges {
                 *half_edge = half_edge.clone().update_partial(|half_edge| {
-                    half_edge.with_surface(Some(surface.clone()))
+                    half_edge.with_surface(surface.clone())
                 });
             }
         }
@@ -84,63 +86,47 @@ impl PartialCycle {
         mut self,
         objects: &Objects,
     ) -> Result<Handle<Cycle>, ValidationError> {
-        let half_edges = {
+        // To create a cycle, we need to make sure that all its half-edges
-            let last_vertex = self
+        // connect to each other. Let's start with all the connections between
-                .half_edges
+        // the first and the last half-edge.
-                .last_mut()
+        let mut previous_vertex = None;
-                .map(|half_edge| {
+        for half_edge in &mut self.half_edges {
-                    let vertex = half_edge.front();
+            let back_vertex = previous_vertex.unwrap_or_default();
-                    (half_edge, vertex)
+            let front_vertex =
-                })
+                half_edge.front().surface_form().into_full(objects)?;
-                .map(|(half_edge, vertex)| {
-                    let surface_vertex = vertex.surface_form();
-                    (half_edge, vertex, surface_vertex)
-                })
-                .map(|(half_edge, vertex, surface_vertex)|
-                    -> Result<_, ValidationError>
-                {
-                    let surface_vertex = surface_vertex.into_full(objects)?;
 
-                    *half_edge =
+            *half_edge = half_edge.clone().merge_with(
-                        half_edge.clone().update_partial(|half_edge| {
+                PartialHalfEdge::default()
-                            half_edge.with_front_vertex(Some(
+                    .with_back_vertex(
-                                vertex.update_partial(|vertex| {
+                        PartialVertex::default().with_surface_form(back_vertex),
-                                    vertex.with_surface_form(Some(
+                    )
-                                        surface_vertex.clone(),
+                    .with_front_vertex(
-                                    ))
+                        PartialVertex::default()
-                                }),
+                            .with_surface_form(front_vertex.clone()),
-                            ))
+                    ),
-                        });
+            );
 
-                    Ok(surface_vertex)
+            previous_vertex = Some(MaybePartial::from(front_vertex));
-                })
+        }
-                .transpose()?;
 
-            let (half_edges, _) = self.half_edges.into_iter().fold(
+        // We're not quite done yet. We need to close the cycle, by connecting
-                Ok((Vec::new(), last_vertex)),
+        // the last half-edge back around to the first one.
-                |result: Result<_, ValidationError>, half_edge| {
+        if let Some(half_edge) = self.half_edges.first_mut() {
-                    let (mut half_edges, previous_vertex) = result?;
+            let back_vertex = previous_vertex.unwrap_or_default();
 
-                    let half_edge = half_edge
+            *half_edge = half_edge.clone().merge_with(
-                        .update_partial(|half_edge| {
+                PartialHalfEdge::default().with_back_vertex(
-                            let [back, _] = half_edge.vertices();
+                    PartialVertex::default().with_surface_form(back_vertex),
-                            let back = back.update_partial(|partial| {
+                ),
-                                partial.with_surface_form(previous_vertex)
+            );
-                            });
+        }
 
-                            half_edge.with_back_vertex(Some(back))
+        // All connections made! All that's left is to build the half-edges.
-                        })
+        let mut half_edges = Vec::new();
-                        .into_full(objects)?;
+        for half_edge in self.half_edges {
-
+            let half_edge = half_edge.into_full(objects)?;
-                    let front = half_edge.front().surface_form().clone();
+            half_edges.push(half_edge);
-                    half_edges.push(half_edge);
+        }
-
-                    Ok((half_edges, Some(front)))
-                },
-            )?;
-
-            half_edges
-        };
 
         Ok(objects.cycles.insert(Cycle::new(half_edges))?)
     }

crates/fj-kernel/src/partial/objects/edge.rs

@@ -47,82 +47,70 @@ impl PartialHalfEdge {
     }
 
     /// Update the partial half-edge with the given surface
-    pub fn with_surface(mut self, surface: Option<Handle<Surface>>) -> Self {
+    pub fn with_surface(mut self, surface: Handle<Surface>) -> Self {
-        if let Some(surface) = surface {
+        self.curve = self
-            self.curve = self.curve.update_partial(|curve| {
+            .curve
-                curve.with_surface(Some(surface.clone()))
+            .update_partial(|curve| curve.with_surface(Some(surface.clone())));
-            });
 
-            self.vertices = self.vertices.map(|vertex| {
+        self.vertices = self.vertices.map(|vertex| {
-                vertex.update_partial(|vertex| {
+            vertex.update_partial(|vertex| {
-                    let surface_form = vertex.surface_form().update_partial(
+                let surface_form =
-                        |surface_vertex| {
+                    vertex.surface_form().update_partial(|surface_vertex| {
-                            surface_vertex.with_surface(Some(surface.clone()))
+                        surface_vertex.with_surface(Some(surface.clone()))
-                        },
+                    });
-                    );
+
+                vertex.with_surface_form(surface_form)
+            })
+        });
 
-                    vertex.with_surface_form(Some(surface_form))
-                })
-            });
-        }
         self
     }
 
     /// Update the partial half-edge with the given curve
-    pub fn with_curve(
+    pub fn with_curve(mut self, curve: impl Into<MaybePartial<Curve>>) -> Self {
-        mut self,
+        self.curve = curve.into();
-        curve: Option<impl Into<MaybePartial<Curve>>>,
+
-    ) -> Self {
-        if let Some(curve) = curve {
-            self.curve = curve.into();
-        }
         self
     }
 
     /// Update the partial half-edge with the given back vertex
     pub fn with_back_vertex(
         mut self,
-        vertex: Option<impl Into<MaybePartial<Vertex>>>,
+        vertex: impl Into<MaybePartial<Vertex>>,
     ) -> Self {
-        if let Some(vertex) = vertex {
+        let [from, _] = &mut self.vertices;
-            let [from, _] = &mut self.vertices;
+        *from = vertex.into();
-            *from = vertex.into();
+
-        }
         self
     }
 
     /// Update the partial half-edge with the given front vertex
     pub fn with_front_vertex(
         mut self,
-        vertex: Option<impl Into<MaybePartial<Vertex>>>,
+        vertex: impl Into<MaybePartial<Vertex>>,
     ) -> Self {
-        if let Some(vertex) = vertex {
+        let [_, to] = &mut self.vertices;
-            let [_, to] = &mut self.vertices;
+        *to = vertex.into();
-            *to = vertex.into();
+
-        }
         self
     }
 
     /// Update the partial half-edge with the given vertices
     pub fn with_vertices(
         mut self,
-        vertices: Option<[impl Into<MaybePartial<Vertex>>; 2]>,
+        vertices: [impl Into<MaybePartial<Vertex>>; 2],
     ) -> Self {
-        let vertices = vertices.map(|vertices| vertices.map(Into::into));
+        self.vertices = vertices.map(Into::into);
-        if let Some([back, front]) = vertices {
-            self.vertices = [back, front];
-        }
         self
     }
 
     /// Update the partial half-edge with the given global form
     pub fn with_global_form(
         mut self,
-        global_form: Option<impl Into<MaybePartial<GlobalEdge>>>,
+        global_form: impl Into<MaybePartial<GlobalEdge>>,
     ) -> Self {
-        if let Some(global_form) = global_form {
+        self.global_form = global_form.into();
-            self.global_form = global_form.into();
+
-        }
         self
     }
 
@@ -143,7 +131,7 @@ impl PartialHalfEdge {
         let curve = self.curve.into_full(objects)?;
         let vertices = self.vertices.try_map_ext(|vertex| {
             vertex
-                .update_partial(|vertex| vertex.with_curve(Some(curve.clone())))
+                .update_partial(|vertex| vertex.with_curve(curve.clone()))
                 .into_full(objects)
         })?;
 

crates/fj-kernel/src/partial/objects/vertex.rs

@@ -46,24 +46,17 @@ impl PartialVertex {
     }
 
     /// Provide a curve for the partial vertex
-    pub fn with_curve(
+    pub fn with_curve(mut self, curve: impl Into<MaybePartial<Curve>>) -> Self {
-        mut self,
+        self.curve = curve.into();
-        curve: Option<impl Into<MaybePartial<Curve>>>,
-    ) -> Self {
-        if let Some(curve) = curve {
-            self.curve = curve.into();
-        }
         self
     }
 
     /// Provide a surface form for the partial vertex
     pub fn with_surface_form(
         mut self,
-        surface_form: Option<impl Into<MaybePartial<SurfaceVertex>>>,
+        surface_form: impl Into<MaybePartial<SurfaceVertex>>,
     ) -> Self {
-        if let Some(surface_form) = surface_form {
+        self.surface_form = surface_form.into();
-            self.surface_form = surface_form.into();
-        }
         self
     }
 

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

@@ -217,7 +217,7 @@ mod tests {
             vertices[1] = vertices[1]
                 .to_partial()
                 // Arranging for an equal but not identical curve here.
-                .with_curve(Some(valid.curve().to_partial()))
+                .with_curve(valid.curve().to_partial())
                 .build(&objects)?;
 
             HalfEdge::new(vertices, valid.global_form().clone())

crates/fj-kernel/src/validate/vertex.rs

@@ -191,11 +191,11 @@ mod tests {
 
         let valid = Vertex::partial()
             .with_position(Some([0.]))
-            .with_curve(Some(
+            .with_curve(
                 Curve::partial()
                     .with_surface(Some(objects.surfaces.xy_plane()))
                     .update_as_u_axis(),
-            ))
+            )
             .build(&objects)?;
         let invalid = Vertex::new(
             valid.position(),
@@ -219,11 +219,11 @@ mod tests {
 
         let valid = Vertex::partial()
             .with_position(Some([0.]))
-            .with_curve(Some(
+            .with_curve(
                 Curve::partial()
                     .with_surface(Some(objects.surfaces.xy_plane()))
                     .update_as_u_axis(),
-            ))
+            )
             .build(&objects)?;
         let invalid = Vertex::new(
             valid.position(),

crates/fj-operations/src/sketch.rs

@@ -28,7 +28,7 @@ impl Shape for fj::Sketch {
                 // none need to be added here.
 
                 let half_edge = HalfEdge::partial()
-                    .with_surface(Some(surface))
+                    .with_surface(surface)
                     .update_as_circle_from_radius(circle.radius(), objects)?
                     .build(objects)?;
                 let cycle = objects.cycles.insert(Cycle::new([half_edge]))?;