Simplify handling of MaybePartial

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

@@ -2,7 +2,7 @@ use fj_interop::ext::ArrayExt;
 use fj_math::Transform;
 
 use crate::{
- objects::{Curve, Objects},
+ objects::Objects,
  partial::{MaybePartial, PartialGlobalEdge, PartialHalfEdge},
  validate::ValidationError,
 };
@@ -19,40 +19,28 @@ impl TransformObject for PartialHalfEdge {
  .surface
  .map(|surface| surface.transform(transform, objects))
  .transpose()?;
- let curve = self
+ let curve: MaybePartial<_> = self
  .curve
  .clone()
- .map(|curve| -> Result<_, ValidationError> {
- Ok(curve
+ .into_partial()
+ .transform(transform, objects)?
+ .with_surface(surface.clone())
+ .into();
+ let vertices = self.vertices.clone().try_map_ext(
+ |vertex| -> Result<_, ValidationError> {
+ Ok(vertex
  .into_partial()
  .transform(transform, objects)?
- .with_surface(surface.clone())
+ .with_curve(Some(curve.clone()))
  .into())
- })
- .transpose()?;
- let vertices = self.vertices.clone().try_map_ext(|vertices| {
- vertices
- .map(|vertex| -> Result<_, ValidationError> {
- Ok(vertex
- .into_partial()
- .transform(transform, objects)?
- .with_curve(curve.clone())
- .into())
- })
- .transpose()
- })?;
+ },
+ )?;
  let global_form = self
  .global_form
- .map(|global_form| -> Result<_, ValidationError> {
- Ok(global_form
- .into_partial()
- .transform(transform, objects)?
- .with_curve(curve.as_ref().and_then(
- |curve: &MaybePartial<Curve>| curve.global_form(),
- ))
- .into())
- })
- .transpose()?;
+ .into_partial()
+ .transform(transform, objects)?
+ .with_curve(curve.global_form())
+ .into();
 
  Ok(Self {
  surface,

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

@@ -14,31 +14,19 @@ impl TransformObject for PartialVertex {
  transform: &Transform,
  objects: &Objects,
  ) -> Result<Self, ValidationError> {
- let curve = self
- .curve
- .map(|curve| curve.transform(transform, objects))
- .transpose()?;
+ let curve = self.curve.transform(transform, objects)?;
  let surface_form = self
  .surface_form
- .map(|surface_form| -> Result<_, ValidationError> {
- Ok(surface_form
- .into_partial()
- .transform(transform, objects)?
- .into())
- })
- .transpose()?;
- let global_form = self
- .global_form
- .map(|global_form| global_form.transform(transform, objects))
- .transpose()?;
+ .into_partial()
+ .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 {
  position: self.position,
  curve,
  surface_form,
- global_form,
  })
  }
 }
@@ -53,10 +41,7 @@ impl TransformObject for PartialSurfaceVertex {
  .surface
  .map(|surface| surface.transform(transform, objects))
  .transpose()?;
- let global_form = self
- .global_form
- .map(|global_form| global_form.transform(transform, objects))
- .transpose()?;
+ let global_form = self.global_form.transform(transform, objects)?;
 
  // Don't need to transform `self.position`, as that is in surface
  // coordinates and thus transforming the surface takes care of it.

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

@@ -72,6 +72,16 @@ impl<T: HasPartial> MaybePartial<T> {
  }
 }
 
+impl<T> Default for MaybePartial<T>
+where
+ T: HasPartial,
+ T::Partial: Default,
+{
+ fn default() -> Self {
+ Self::Partial(T::Partial::default())
+ }
+}
+
 impl<T> From<Handle<T>> for MaybePartial<T>
 where
  T: HasPartial,
@@ -119,21 +129,10 @@ impl MaybePartial<GlobalEdge> {
 }
 
 impl MaybePartial<HalfEdge> {
- /// Access the back vertex
- pub fn back(&self) -> Option<MaybePartial<Vertex>> {
- match self {
- Self::Full(full) => Some(full.back().clone().into()),
- Self::Partial(partial) => {
- let [back, _] = &partial.vertices;
- back.clone()
- }
- }
- }
-
  /// Access the front vertex
- pub fn front(&self) -> Option<MaybePartial<Vertex>> {
+ pub fn front(&self) -> MaybePartial<Vertex> {
  match self {
- Self::Full(full) => Some(full.front().clone().into()),
+ Self::Full(full) => full.front().clone().into(),
  Self::Partial(partial) => {
  let [_, front] = &partial.vertices;
  front.clone()
@@ -142,11 +141,9 @@ impl MaybePartial<HalfEdge> {
  }
 
  /// Access the vertices
- pub fn vertices(&self) -> [Option<MaybePartial<Vertex>>; 2] {
+ pub fn vertices(&self) -> [MaybePartial<Vertex>; 2] {
  match self {
- Self::Full(full) => {
- full.vertices().clone().map(|vertex| Some(vertex.into()))
- }
+ Self::Full(full) => full.vertices().clone().map(Into::into),
  Self::Partial(partial) => partial.vertices.clone(),
  }
  }
@@ -172,9 +169,9 @@ impl MaybePartial<SurfaceVertex> {
 
 impl MaybePartial<Vertex> {
  /// Access the surface form
- pub fn surface_form(&self) -> Option<MaybePartial<SurfaceVertex>> {
+ pub fn surface_form(&self) -> MaybePartial<SurfaceVertex> {
  match self {
- Self::Full(full) => Some(full.surface_form().clone().into()),
+ Self::Full(full) => full.surface_form().clone().into(),
  Self::Partial(partial) => partial.surface_form.clone(),
  }
  }

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

@@ -49,11 +49,8 @@ impl PartialCycle {
  .half_edges
  .last()
  .map(|half_edge| {
- let [_, last] = half_edge.vertices().map(|vertex| {
- vertex.expect("Need half-edge vertices to extend cycle")
- });
+ let [_, last] = half_edge.vertices();
  last.surface_form()
- .expect("Need surface vertex to extend cycle")
  })
  .into_iter()
  .chain(vertices);
@@ -130,19 +127,13 @@ impl PartialCycle {
  let first = self.half_edges.first();
  let last = self.half_edges.last();
 
- let vertices = [first, last].map(|option| {
- option.map(|half_edge| {
- half_edge
- .vertices()
- .map(|vertex| vertex.expect("Need vertices to close cycle"))
- })
- });
+ let vertices = [first, last]
+ .map(|option| option.map(|half_edge| half_edge.vertices()));
 
  if let [Some([first, _]), Some([_, last])] = vertices {
  let vertices = [last, first].map(|vertex| {
  vertex
  .surface_form()
- .expect("Need surface vertex to close cycle")
  .position()
  .expect("Need surface position to close cycle")
  });
@@ -171,13 +162,13 @@ impl PartialCycle {
  let last_vertex = self
  .half_edges
  .last_mut()
- .and_then(|half_edge| {
- half_edge.front().map(|vertex| (half_edge, vertex))
+ .map(|half_edge| {
+ let vertex = half_edge.front();
+ (half_edge, vertex)
  })
- .and_then(|(half_edge, vertex)| {
- vertex.surface_form().map(|surface_vertex| {
- (half_edge, vertex, surface_vertex)
- })
+ .map(|(half_edge, vertex)| {
+ let surface_vertex = vertex.surface_form();
+ (half_edge, vertex, surface_vertex)
  })
  .map(|(half_edge, vertex, surface_vertex)|
  -> Result<_, ValidationError>
@@ -211,15 +202,13 @@ impl PartialCycle {
  let half_edge = half_edge
  .update_partial(|half_edge| {
  let [back, _] = half_edge.vertices.clone();
- let back = back.map(|vertex| {
- vertex.update_partial(|partial| {
- partial.with_surface_form(previous_vertex)
- })
+ let back = back.update_partial(|partial| {
+ partial.with_surface_form(previous_vertex)
  });
 
  half_edge
  .with_surface(Some(surface_for_edges.clone()))
- .with_back_vertex(back)
+ .with_back_vertex(Some(back))
  })
  .into_full(objects)?;