Crate remade to be no_std with alloc. By default std still required for one Error trait, but can be turned off using features.

hatmajster · hatmajster · commit c17b9bbeac53 · 2023-11-09T17:20:41.000+01:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -12,16 +12,21 @@ autobenches = false
 [lib]
 bench = false
 
+[features]
+default = [ "std" ]
+std = []
+
 [dependencies]
 smallvec = "1"
 robust = "1.1.0"
 num-traits = "0.2"
+hashbrown  = "0.14.2"
 
 [dependencies.serde]
 package = "serde"
 optional = true
 version = "1"
-features = ["derive"]
+features = ["derive", "alloc"]
 
 [workspace]
 members = ["delaunay_compare"]
diff --git a/benches/benchmark_utilities.rs b/benches/benchmark_utilities.rs
@@ -1,4 +1,4 @@
-use std::fmt::{self, Display, Formatter};
+use core::fmt::{self, Display, Formatter};
 
 use criterion::{measurement::WallTime, BenchmarkGroup, BenchmarkId, Throughput};
 use rand::{distributions::uniform::SampleUniform, Rng, SeedableRng};
@@ -29,7 +29,7 @@ where
 {
     let range = rand::distributions::Uniform::new_inclusive(-range, range);
     let mut rng = rand::rngs::StdRng::from_seed(seed);
-    std::iter::from_fn(move || Some(Point2::new(rng.sample(range), rng.sample(range))))
+    core::iter::from_fn(move || Some(Point2::new(rng.sample(range), rng.sample(range))))
 }
 
 pub fn uniform_f64() -> impl Iterator<Item = Point2<f64>> {
@@ -54,7 +54,7 @@ where
 
         Some(Point2::new(last_x, last_y))
     };
-    std::iter::from_fn(step_fn)
+    core::iter::from_fn(step_fn)
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
diff --git a/delaunay_compare/benches/bench_utilities.rs b/delaunay_compare/benches/bench_utilities.rs
@@ -14,7 +14,7 @@ where
 {
     let range = rand::distributions::Uniform::new_inclusive(-range, range);
     let mut rng = StdRng::from_seed(seed);
-    std::iter::from_fn(move || Some([rng.sample(range), rng.sample(range)]))
+    core::iter::from_fn(move || Some([rng.sample(range), rng.sample(range)]))
 }
 
 pub fn uniform_f64() -> impl Iterator<Item = [f64; 2]> {
@@ -41,5 +41,5 @@ where
 
         Some([last_x, last_y])
     };
-    std::iter::from_fn(step_fn)
+    core::iter::from_fn(step_fn)
 }
diff --git a/delaunay_compare/src/spade_crate.rs b/delaunay_compare/src/spade_crate.rs
@@ -5,7 +5,7 @@ type SpadePoint = spade::Point2<f64>;
 #[derive(Default)]
 pub struct SpadeCrateWithHintGenerator<HintGeneratorType> {
     vertices: Vec<SpadePoint>,
-    _hint_generator_type: std::marker::PhantomData<HintGeneratorType>,
+    _hint_generator_type: core::marker::PhantomData<HintGeneratorType>,
 }
 
 pub type SpadeCrate = SpadeCrateWithHintGenerator<spade::LastUsedVertexHintGenerator>;
diff --git a/examples/svg_renderer/main.rs b/examples/svg_renderer/main.rs
@@ -2,7 +2,7 @@ pub mod quicksketch;
 mod scenario;
 mod scenario_list;
 
-type Result = std::result::Result<(), Box<dyn std::error::Error>>;
+type Result = core::result::Result<(), Box<dyn std::error::Error>>;
 
 /// Used for rendering SVGs for documentation. These are inlined (via #[doc = include_str!(...)])
 /// into the doc comment of a few items. That makes sure they will be visible even for offline users.
diff --git a/examples/svg_renderer/quicksketch/color.rs b/examples/svg_renderer/quicksketch/color.rs
@@ -1,4 +1,4 @@
-use std::fmt::Display;
+use core::fmt::Display;
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Copy)]
 pub struct SketchColor {
@@ -8,7 +8,7 @@ pub struct SketchColor {
 }
 
 impl Display for SketchColor {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         write!(f, "rgb({} {} {})", self.red, self.green, self.blue)
     }
 }
diff --git a/examples/svg_renderer/quicksketch/mod.rs b/examples/svg_renderer/quicksketch/mod.rs
@@ -178,7 +178,7 @@ impl Style {
             stroke_dash_array,
         ])
         .flatten()
-        .chain(std::iter::once(fill))
+        .chain(core::iter::once(fill))
         .collect::<Vec<_>>()
         .join("; ")
     }
diff --git a/fuzz/fuzz_targets/bulk_load_fuzz.rs b/fuzz/fuzz_targets/bulk_load_fuzz.rs
@@ -27,8 +27,8 @@ pub struct FuzzPoint {
     y: f64,
 }
 
-impl std::fmt::Debug for FuzzPoint {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for FuzzPoint {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_fmt(format_args!("Point2::new({:?}, {:?})", self.x, self.y))
     }
 }
diff --git a/fuzz/fuzz_targets/bulk_load_int_fuzz.rs b/fuzz/fuzz_targets/bulk_load_int_fuzz.rs
@@ -26,8 +26,8 @@ pub struct IntFuzzPoint {
     y: i32,
 }
 
-impl std::fmt::Debug for IntFuzzPoint {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for IntFuzzPoint {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.write_fmt(format_args!("Point2::new({:?}.0, {:?}.0)", self.x, self.y))
     }
 }
diff --git a/src/cdt.rs b/src/cdt.rs
@@ -7,6 +7,8 @@ use crate::{
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use alloc::{vec, vec::Vec};
+
 /// Undirected edge type of a [ConstrainedDelaunayTriangulation] (CDT).
 ///
 /// CDTs need to store if an undirected edge is a constrained edge. To do so, CDTs don't use
@@ -362,7 +364,7 @@ where
                 VertexOutDirection::EdgeIntersection(edge) => edge,
             };
 
-            let mut border_loop = std::collections::VecDeque::new();
+            let mut border_loop = alloc::collections::VecDeque::new();
 
             border_loop.push_back(first_edge.rev().next().fix());
             border_loop.push_front(first_edge.rev().prev().fix());
@@ -552,6 +554,8 @@ mod test {
     type Cdt = ConstrainedDelaunayTriangulation<Point2<f64>>;
     type Delaunay = DelaunayTriangulation<Point2<f64>>;
 
+    use alloc::{vec, vec::Vec};
+
     #[test]
     fn test_add_single_simple_constraint() -> Result<(), InsertionError> {
         let mut cdt = Cdt::new();
@@ -657,7 +661,7 @@ mod test {
     fn test_add_border_constraint() -> Result<(), InsertionError> {
         let points = random_points_with_seed(1000, SEED);
         let mut cdt = Cdt::new();
-        let mut max_y = -::std::f64::MAX;
+        let mut max_y = -::core::f64::MAX;
         for point in points {
             max_y = max_y.max(point.y);
             cdt.insert(point)?;
@@ -695,7 +699,8 @@ mod test {
         for p in delaunay_points {
             d.insert(p)?;
         }
-        let mut used_vertices = ::std::collections::HashSet::new();
+        let mut used_vertices = ::hashbrown::HashSet::new();
+
         let mut inserted_constraints = Vec::new();
         for v in d.vertices() {
             // Insert only edges that do not touch at the end points if
diff --git a/src/delaunay_core/bulk_load.rs b/src/delaunay_core/bulk_load.rs
@@ -1,9 +1,11 @@
-use std::cmp::{Ordering, Reverse};
+use core::cmp::{Ordering, Reverse};
 
 use crate::{HasPosition, InsertionError, Point2, Triangulation, TriangulationExt};
 
 use super::{dcel_operations, FixedDirectedEdgeHandle, FixedUndirectedEdgeHandle};
 
+use alloc::vec::Vec;
+
 /// An `f64` wrapper implementing `Ord` and `Eq`.
 ///
 /// This is only used as part of bulk loading.
@@ -469,7 +471,7 @@ impl Hull {
 
         const INVALID: usize = usize::MAX;
         self.buckets
-            .extend(std::iter::repeat(INVALID).take(target_size));
+            .extend(core::iter::repeat(INVALID).take(target_size));
 
         let (first_index, current_node) = self
             .data
@@ -753,6 +755,8 @@ mod test {
 
     use super::Hull;
 
+    use alloc::vec::Vec;
+
     #[test]
     fn test_bulk_load_with_small_number_of_vertices() -> Result<(), InsertionError> {
         for size in 0..10 {
diff --git a/src/delaunay_core/bulk_load_fuzz_tests.rs b/src/delaunay_core/bulk_load_fuzz_tests.rs
@@ -1,5 +1,7 @@
 use crate::{DelaunayTriangulation, Point2, Triangulation, TriangulationExt};
 
+use alloc::{vec, vec::Vec};
+
 fn fuzz_test(vertices: Vec<Point2<f64>>) {
     let mut clone = vertices.clone();
     clone.sort_by(|l, r| l.partial_cmp(r).unwrap());
diff --git a/src/delaunay_core/dcel.rs b/src/delaunay_core/dcel.rs
@@ -5,6 +5,8 @@ use super::handles::*;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use alloc::vec::Vec;
+
 #[derive(Default, PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Copy, Hash)]
 pub struct EdgeData<DE, UE> {
     directed_data: [DE; 2],
diff --git a/src/delaunay_core/dcel_operations.rs b/src/delaunay_core/dcel_operations.rs
@@ -5,6 +5,8 @@ use super::handles::*;
 
 use smallvec::SmallVec;
 
+use alloc::{vec, vec::Vec};
+
 pub const OUTER_FACE_HANDLE: FixedFaceHandle<PossiblyOuterTag> = new_fixed_face_handle(0);
 
 #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -1308,6 +1310,8 @@ mod test {
 
     use super::{Dcel, FixedDirectedEdgeHandle, FixedFaceHandle, FixedVertexHandle};
 
+    use alloc::{vec, vec::Vec};
+
     fn default_triangle() -> Dcel<usize, (), ()> {
         use super::{EdgeEntry, FaceEntry, HalfEdgeEntry, VertexEntry};
 
diff --git a/src/delaunay_core/handles/handle_defs.rs b/src/delaunay_core/handles/handle_defs.rs
@@ -1,4 +1,4 @@
-use std::convert::TryInto;
+use core::convert::TryInto;
 
 use super::super::Dcel;
 use super::public_handles::{InnerOuterMarker, PossiblyOuterTag};
@@ -27,8 +27,8 @@ pub struct FixedHandleImpl<Type, InnerOuter: InnerOuterMarker> {
     inner_outer: InnerOuter,
 }
 
-impl<Type, InnerOuter: InnerOuterMarker> std::fmt::Debug for FixedHandleImpl<Type, InnerOuter> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl<Type, InnerOuter: InnerOuterMarker> core::fmt::Debug for FixedHandleImpl<Type, InnerOuter> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("FixedHandle")
             .field("index", &self.index)
             .finish()
diff --git a/src/delaunay_core/handles/handle_impls.rs b/src/delaunay_core/handles/handle_impls.rs
@@ -6,20 +6,20 @@ use super::iterators::NextBackFn;
 use super::public_handles::*;
 
 use crate::{HasPosition, LineSideInfo, Point2};
+use core::cmp::Ordering;
+use core::fmt::Debug;
+use core::hash::{Hash, Hasher};
 use num_traits::{Float, One};
-use std::cmp::Ordering;
-use std::fmt::Debug;
-use std::hash::{Hash, Hasher};
 
 // Debug implementations
-impl<'a, V, DE, UE, F> std::fmt::Debug for VertexHandle<'a, V, DE, UE, F> {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+impl<'a, V, DE, UE, F> core::fmt::Debug for VertexHandle<'a, V, DE, UE, F> {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         write!(f, "VertexHandle({:?})", self.handle.index())
     }
 }
 
 impl<'a, V, DE, UE, F> Debug for DirectedEdgeHandle<'a, V, DE, UE, F> {
-    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
+    fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
         write!(
             f,
             "DirectedEdgeHandle - id: {:?} ({:?} -> {:?})",
@@ -30,8 +30,8 @@ impl<'a, V, DE, UE, F> Debug for DirectedEdgeHandle<'a, V, DE, UE, F> {
     }
 }
 
-impl<'a, V, DE, UE, F> std::fmt::Debug for UndirectedEdgeHandle<'a, V, DE, UE, F> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> ::std::fmt::Result {
+impl<'a, V, DE, UE, F> core::fmt::Debug for UndirectedEdgeHandle<'a, V, DE, UE, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> ::core::fmt::Result {
         let [v0, v1] = self.vertices();
         write!(
             f,
@@ -43,8 +43,8 @@ impl<'a, V, DE, UE, F> std::fmt::Debug for UndirectedEdgeHandle<'a, V, DE, UE, F
     }
 }
 
-impl<'a, V, DE, UE, F> std::fmt::Debug for FaceHandle<'a, PossiblyOuterTag, V, DE, UE, F> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> ::std::fmt::Result {
+impl<'a, V, DE, UE, F> core::fmt::Debug for FaceHandle<'a, PossiblyOuterTag, V, DE, UE, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> ::core::fmt::Result {
         if let Some(inner) = self.as_inner() {
             inner.fmt(f)
         } else {
@@ -53,8 +53,8 @@ impl<'a, V, DE, UE, F> std::fmt::Debug for FaceHandle<'a, PossiblyOuterTag, V, D
     }
 }
 
-impl<'a, V, DE, UE, F> std::fmt::Debug for FaceHandle<'a, InnerTag, V, DE, UE, F> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> ::std::fmt::Result {
+impl<'a, V, DE, UE, F> core::fmt::Debug for FaceHandle<'a, InnerTag, V, DE, UE, F> {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> ::core::fmt::Result {
         let [v0, v1, v2] = self.vertices();
         write!(
             f,
diff --git a/src/delaunay_core/handles/iterators/circular_iterator.rs b/src/delaunay_core/handles/iterators/circular_iterator.rs
@@ -1,4 +1,4 @@
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 use super::super::DirectedEdgeHandle;
 
diff --git a/src/delaunay_core/handles/iterators/fixed_iterators.rs b/src/delaunay_core/handles/iterators/fixed_iterators.rs
@@ -1,12 +1,12 @@
-use std::marker::PhantomData;
+use core::marker::PhantomData;
 
 use super::super::handle_defs::{DelaunayElementType, DynamicHandleImpl, FixedHandleImpl};
 use super::super::InnerOuterMarker;
 
 use crate::delaunay_core::Dcel;
 
 pub struct FixedHandleIterator<Type, InnerOuter> {
-    range: std::ops::Range<usize>,
+    range: core::ops::Range<usize>,
     ty: PhantomData<Type>,
     inner_outer: PhantomData<InnerOuter>,
 }
@@ -59,7 +59,7 @@ impl<Type: Default, InnerOuter: InnerOuterMarker> DoubleEndedIterator
 pub struct DynamicHandleIterator<'a, V, DE, UE, F, Type, InnerOuter> {
     fixed_iterator: FixedHandleIterator<Type, InnerOuter>,
     dcel: &'a Dcel<V, DE, UE, F>,
-    inner_outer: std::marker::PhantomData<InnerOuter>,
+    inner_outer: core::marker::PhantomData<InnerOuter>,
 }
 
 impl<'a, V, DE, UE, F, Type, InnerOuter> DynamicHandleIterator<'a, V, DE, UE, F, Type, InnerOuter>
@@ -71,7 +71,7 @@ where
         DynamicHandleIterator {
             fixed_iterator: FixedHandleIterator::new(Type::num_elements(dcel)),
             dcel,
-            inner_outer: std::marker::PhantomData,
+            inner_outer: core::marker::PhantomData,
         }
     }
 }
diff --git a/src/delaunay_core/handles/iterators/hull_iterator.rs b/src/delaunay_core/handles/iterators/hull_iterator.rs
@@ -58,6 +58,9 @@ impl<'a, V, DE, UE, F> DoubleEndedIterator for HullIterator<'a, V, DE, UE, F> {
 
 #[cfg(test)]
 mod test {
+
+    use alloc::vec::Vec;
+
     use crate::test_utilities::{random_points_with_seed, SEED};
     use crate::{DelaunayTriangulation, InsertionError, Point2, Triangulation};
 
diff --git a/src/delaunay_core/handles/public_handles.rs b/src/delaunay_core/handles/public_handles.rs
@@ -19,7 +19,7 @@ pub const OUTER_FACE: FixedFaceHandle<PossiblyOuterTag> = dcel_operations::OUTER
 ///
 /// There should be no need to implement this.
 pub trait InnerOuterMarker:
-    Clone + Copy + PartialEq + Eq + PartialOrd + Ord + std::fmt::Debug + Default + std::hash::Hash
+    Clone + Copy + PartialEq + Eq + PartialOrd + Ord + core::fmt::Debug + Default + core::hash::Hash
 {
     fn debug_string() -> &'static str;
 }
diff --git a/src/delaunay_core/hint_generator.rs b/src/delaunay_core/hint_generator.rs
@@ -1,4 +1,4 @@
-use std::sync::atomic::{AtomicUsize, Ordering};
+use core::sync::atomic::{AtomicUsize, Ordering};
 
 use crate::{
     DelaunayTriangulation, HasPosition, Point2, SpadeNum, Triangulation, TriangulationExt,
@@ -9,6 +9,8 @@ use super::FixedVertexHandle;
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
+use alloc::vec::Vec;
+
 /// A structure used to speed up common operations on delaunay triangulations like insertion and geometry queries by providing
 /// hints on where to start searching for elements.
 ///
@@ -288,6 +290,8 @@ mod test {
         Triangulation, TriangulationExt,
     };
 
+    use alloc::vec::Vec;
+
     const BRANCH_FACTOR: u32 = 3;
 
     type HierarchyTriangulation = DelaunayTriangulation<
diff --git a/src/delaunay_core/math.rs b/src/delaunay_core/math.rs
diff --git a/src/delaunay_core/triangulation_ext.rs b/src/delaunay_core/triangulation_ext.rs
diff --git a/src/flood_fill_iterator.rs b/src/flood_fill_iterator.rs
diff --git a/src/intersection_iterator.rs b/src/intersection_iterator.rs
diff --git a/src/lib.rs b/src/lib.rs
diff --git a/src/point.rs b/src/point.rs
diff --git a/src/test_utilities.rs b/src/test_utilities.rs
diff --git a/src/triangulation.rs b/src/triangulation.rs

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use std::fmt::{self, Display, Formatter};`
	`1`	`+use core::fmt::{self, Display, Formatter};`
`2`	`2`
`3`	`3`	`use criterion::{measurement::WallTime, BenchmarkGroup, BenchmarkId, Throughput};`
`4`	`4`	`use rand::{distributions::uniform::SampleUniform, Rng, SeedableRng};`
`@@ -29,7 +29,7 @@ where`
`29`	`29`	`{`
`30`	`30`	`let range = rand::distributions::Uniform::new_inclusive(-range, range);`
`31`	`31`	`let mut rng = rand::rngs::StdRng::from_seed(seed);`
`32`		`- std::iter::from_fn(move \|\| Some(Point2::new(rng.sample(range), rng.sample(range))))`
	`32`	`+ core::iter::from_fn(move \|\| Some(Point2::new(rng.sample(range), rng.sample(range))))`
`33`	`33`	`}`
`34`	`34`
`35`	`35`	`pub fn uniform_f64() -> impl Iterator<Item = Point2<f64>> {`
`@@ -54,7 +54,7 @@ where`
`54`	`54`
`55`	`55`	`Some(Point2::new(last_x, last_y))`
`56`	`56`	`};`
`57`		`- std::iter::from_fn(step_fn)`
	`57`	`+ core::iter::from_fn(step_fn)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]`
Original file line number	Diff line number	Diff line change
`@@ -14,7 +14,7 @@ where`
`14`	`14`	`{`
`15`	`15`	`let range = rand::distributions::Uniform::new_inclusive(-range, range);`
`16`	`16`	`let mut rng = StdRng::from_seed(seed);`
`17`		`- std::iter::from_fn(move \|\| Some([rng.sample(range), rng.sample(range)]))`
	`17`	`+ core::iter::from_fn(move \|\| Some([rng.sample(range), rng.sample(range)]))`
`18`	`18`	`}`
`19`	`19`
`20`	`20`	`pub fn uniform_f64() -> impl Iterator<Item = [f64; 2]> {`
`@@ -41,5 +41,5 @@ where`
`41`	`41`
`42`	`42`	`Some([last_x, last_y])`
`43`	`43`	`};`
`44`		`- std::iter::from_fn(step_fn)`
	`44`	`+ core::iter::from_fn(step_fn)`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@ type SpadePoint = spade::Point2<f64>;`
`5`	`5`	`#[derive(Default)]`
`6`	`6`	`pub struct SpadeCrateWithHintGenerator<HintGeneratorType> {`
`7`	`7`	`vertices: Vec<SpadePoint>,`
`8`		`- _hint_generator_type: std::marker::PhantomData<HintGeneratorType>,`
	`8`	`+ _hint_generator_type: core::marker::PhantomData<HintGeneratorType>,`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`pub type SpadeCrate = SpadeCrateWithHintGenerator<spade::LastUsedVertexHintGenerator>;`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-use std::fmt::Display;`
	`1`	`+use core::fmt::Display;`
`2`	`2`
`3`	`3`	`#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Copy)]`
`4`	`4`	`pub struct SketchColor {`
`@@ -8,7 +8,7 @@ pub struct SketchColor {`
`8`	`8`	`}`
`9`	`9`
`10`	`10`	`impl Display for SketchColor {`
`11`		`- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
	`11`	`+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`12`	`12`	`write!(f, "rgb({} {} {})", self.red, self.green, self.blue)`
`13`	`13`	`}`
`14`	`14`	`}`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ impl Style {`
`178`	`178`	`stroke_dash_array,`
`179`	`179`	`])`
`180`	`180`	`.flatten()`
`181`		`- .chain(std::iter::once(fill))`
	`181`	`+ .chain(core::iter::once(fill))`
`182`	`182`	`.collect::<Vec<_>>()`
`183`	`183`	`.join("; ")`
`184`	`184`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,8 +27,8 @@ pub struct FuzzPoint {`
`27`	`27`	`y: f64,`
`28`	`28`	`}`
`29`	`29`
`30`		`-impl std::fmt::Debug for FuzzPoint {`
`31`		`- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
	`30`	`+impl core::fmt::Debug for FuzzPoint {`
	`31`	`+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`32`	`32`	`f.write_fmt(format_args!("Point2::new({:?}, {:?})", self.x, self.y))`
`33`	`33`	`}`
`34`	`34`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,8 +26,8 @@ pub struct IntFuzzPoint {`
`26`	`26`	`y: i32,`
`27`	`27`	`}`
`28`	`28`
`29`		`-impl std::fmt::Debug for IntFuzzPoint {`
`30`		`- fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
	`29`	`+impl core::fmt::Debug for IntFuzzPoint {`
	`30`	`+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {`
`31`	`31`	`f.write_fmt(format_args!("Point2::new({:?}.0, {:?}.0)", self.x, self.y))`
`32`	`32`	`}`
`33`	`33`	`}`