Simplify trait method argument

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

@@ -1,22 +1,24 @@
+use fj_math::Vector;
+
 use crate::objects::{Curve, GlobalCurve, Surface, SweptCurve};
 
 use super::Sweep;
 
 impl Sweep for Curve {
     type Swept = Surface;
 
-    fn sweep(self, path: impl Into<super::Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         self.global_form().sweep(path)
     }
 }
 
 impl Sweep for GlobalCurve {
     type Swept = Surface;
 
-    fn sweep(self, path: impl Into<super::Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         Surface::SweptCurve(SweptCurve {
             curve: *self.kind(),
-            path: path.into().inner(),
+            path: path.into(),
         })
     }
 }

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

@@ -1,5 +1,5 @@
 use fj_interop::mesh::Color;
-use fj_math::{Line, Scalar};
+use fj_math::{Line, Scalar, Vector};
 
 use crate::{
     algorithms::{reverse::Reverse, transform::TransformObject},
@@ -8,12 +8,12 @@ use crate::{
     },
 };
 
-use super::{Path, Sweep};
+use super::Sweep;
 
 impl Sweep for (Edge, Color) {
     type Swept = Face;
 
-    fn sweep(self, path: impl Into<Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         let (edge, color) = self;
         let path = path.into();
 
@@ -87,8 +87,7 @@ impl Sweep for (Edge, Color) {
             });
 
             let curve = {
-                let global =
-                    bottom_edge.curve().global_form().translate(path.inner());
+                let global = bottom_edge.curve().global_form().translate(path);
 
                 // Please note that creating a line here is correct, even if the
                 // global curve is a circle. Projected into the side surface, it

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

@@ -5,12 +5,12 @@ use crate::{
     objects::{CurveKind, Face, Shell, Surface},
 };
 
-use super::{Path, Sweep};
+use super::Sweep;
 
 impl Sweep for Face {
     type Swept = Shell;
 
-    fn sweep(self, path: impl Into<Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         let path = path.into();
 
         let mut faces = Vec::new();
@@ -29,14 +29,13 @@ impl Sweep for Face {
 
             let normal = a.cross(&b);
 
-            normal.dot(&path.inner()) < Scalar::ZERO
+            normal.dot(&path) < Scalar::ZERO
         };
 
         let bottom_face = create_bottom_face(&self, is_negative_sweep);
         faces.push(bottom_face);
 
-        let top_face =
-            create_top_face(self.clone(), path.inner(), is_negative_sweep);
+        let top_face = create_top_face(self.clone(), path, is_negative_sweep);
         faces.push(top_face);
 
         for cycle in self.all_cycles() {

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

@@ -14,7 +14,7 @@ pub trait Sweep {
     type Swept;
 
     /// Sweep the object along the given path
-    fn sweep(self, path: impl Into<Path>) -> Self::Swept;
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept;
 }
 
 /// A path to be used with [`Sweep`]

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

@@ -1,11 +1,13 @@
+use fj_math::Vector;
+
 use crate::objects::{Sketch, Solid};
 
-use super::{Path, Sweep};
+use super::Sweep;
 
 impl Sweep for Sketch {
     type Swept = Solid;
 
-    fn sweep(self, path: impl Into<Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         let path = path.into();
 
         let mut shells = Vec::new();

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

@@ -1,16 +1,16 @@
-use fj_math::{Line, Point, Scalar};
+use fj_math::{Line, Point, Scalar, Vector};
 
 use crate::objects::{
     Curve, CurveKind, Edge, GlobalCurve, GlobalEdge, GlobalVertex, Surface,
     SurfaceVertex, SweptCurve, Vertex,
 };
 
-use super::{Path, Sweep};
+use super::Sweep;
 
 impl Sweep for (Vertex, Surface) {
     type Swept = Edge;
 
-    fn sweep(self, path: impl Into<Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         let (vertex, surface) = self;
         let path = path.into();
 
@@ -53,7 +53,7 @@ impl Sweep for (Vertex, Surface) {
             }) = surface;
 
             assert_eq!(vertex.curve().global_form().kind(), &surface_curve);
-            assert_eq!(path.inner(), surface_path);
+            assert_eq!(path, surface_path);
         }
 
         // With that out of the way, let's start by creating the `GlobalEdge`,
@@ -132,10 +132,9 @@ impl Sweep for (Vertex, Surface) {
 impl Sweep for GlobalVertex {
     type Swept = GlobalEdge;
 
-    fn sweep(self, path: impl Into<Path>) -> Self::Swept {
+    fn sweep(self, path: impl Into<Vector<3>>) -> Self::Swept {
         let a = self;
-        let b =
-            GlobalVertex::from_position(self.position() + path.into().inner());
+        let b = GlobalVertex::from_position(self.position() + path.into());
 
         let curve =
             GlobalCurve::build().line_from_points([a.position(), b.position()]);