Add Intersect trait; rename intersection module to intersect

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

@@ -8,6 +8,14 @@ pub use self::segment::RaySegmentHit;
 use fj_math::Point;
 
 /// Implemented by types that support ray casting
+///
+/// # Implementation Note
+///
+/// This is basically a more limited version of [`Intersect`]. It probably makes
+/// sense to migrate all of this trait's implementations to [`Intersect`] and
+/// remove this trait.
+///
+/// [`Intersect`]: super::intersect::Intersect
 pub trait CastRay<const D: usize> {
     /// The type that describes a hit of the ray on the implementing type
     type Hit;

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

@@ -1,6 +1,14 @@
 mod face_point;
 
 /// Test whether an object or shape contains another
+///
+/// # Implementation Note
+///
+/// This is basically a more limited version of [`Intersect`]. It probably makes
+/// sense to migrate all of this trait's implementations to [`Intersect`] and
+/// remove this trait.
+///
+/// [`Intersect`]: super::intersect::Intersect
 pub trait Contains<T> {
     /// Test whether an object or shape contains another
     ///

crates/fj-kernel/src/algorithms/intersection/curve_face.rs → crates/fj-kernel/src/algorithms/intersect/curve_face.rs

@@ -2,10 +2,9 @@ use std::vec;
 
 use fj_math::Point;
 
-use crate::{
-    algorithms::intersection::CurveEdgeIntersection,
-    objects::{Curve, Face},
-};
+use crate::objects::{Curve, Face};
+
+use super::CurveEdgeIntersection;
 
 /// The intersections between a [`Curve`] and a [`Face`], in curve coordinates
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]

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

@@ -59,7 +59,7 @@ mod tests {
     use pretty_assertions::assert_eq;
 
     use crate::{
-        algorithms::intersection::CurveFaceIntersection,
+        algorithms::intersect::CurveFaceIntersection,
         objects::{Curve, Face, Surface},
     };
 

crates/fj-kernel/src/algorithms/intersection/line_segment.rs → crates/fj-kernel/src/algorithms/intersect/line_segment.rs

@@ -68,7 +68,7 @@ impl LineSegmentIntersection {
 mod tests {
     use fj_math::{Line, Point, Scalar, Segment, Vector};
 
-    use crate::algorithms::intersection::LineSegmentIntersection;
+    use super::LineSegmentIntersection;
 
     #[test]
     fn compute_one_hit() {

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

@@ -0,0 +1,29 @@
+//! Intersection algorithms
+
+mod curve_edge;
+mod curve_face;
+mod face_face;
+mod line_segment;
+mod surface_surface;
+
+pub use self::{
+    curve_edge::CurveEdgeIntersection,
+    curve_face::{CurveFaceIntersection, CurveFaceIntersectionInterval},
+    face_face::FaceFaceIntersection,
+    line_segment::LineSegmentIntersection,
+    surface_surface::SurfaceSurfaceIntersection,
+};
+
+/// Compute the intersection between a tuple of objects
+///
+/// # Implementation Note
+///
+/// This trait is newer than most of the intersection algorithms in this module.
+/// Most of them don't support it yet.
+pub trait Intersect {
+    /// The type that describes the intersection between the objects in `Self`
+    type Intersection;
+
+    /// Compute the intersection between a tuple of objects
+    fn intersect(&self) -> Option<Self::Intersection>;
+}

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

@@ -11,7 +11,7 @@ mod transform;
 mod triangulate;
 
 pub mod cast_ray;
-pub mod intersection;
+pub mod intersect;
 
 pub use self::{
     approx::{CycleApprox, FaceApprox, InvalidTolerance, Tolerance},