Update to rust 1.78

src/data/music/intervals.rs

@@ -1,5 +1,7 @@
 //! Defines the musical intervals.
 
+use std::fmt::{Display, Formatter, Result};
+
 /// Defines the different musical intervals.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[allow(missing_docs)]
@@ -19,22 +21,22 @@ pub enum Interval {
     Octave,
 }
 
-impl ToString for Interval {
-    fn to_string(&self) -> String {
+impl Display for Interval {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
         match self {
-            Interval::Unison => "Unison".to_string(),
-            Interval::MinorSecond => "Minor Second".to_string(),
-            Interval::MajorSecond => "Major Second".to_string(),
-            Interval::MinorThird => "Minor Third".to_string(),
-            Interval::MajorThird => "Major Third".to_string(),
-            Interval::PerfectFourth => "Perfect Fourth".to_string(),
-            Interval::Tritone => "Tritone".to_string(),
-            Interval::PerfectFifth => "Perfect Fifth".to_string(),
-            Interval::MinorSixth => "Minor Sixth".to_string(),
-            Interval::MajorSixth => "Major Sixth".to_string(),
-            Interval::MinorSeventh => "Minor Seventh".to_string(),
-            Interval::MajorSeventh => "Major Seventh".to_string(),
-            Interval::Octave => "Octave".to_string(),
+            Interval::Unison => write!(f, "Unison"),
+            Interval::MinorSecond => write!(f, "Minor Second"),
+            Interval::MajorSecond => write!(f, "Major Second"),
+            Interval::MinorThird => write!(f, "Minor Third"),
+            Interval::MajorThird => write!(f, "Major Third"),
+            Interval::PerfectFourth => write!(f, "Perfect Fourth"),
+            Interval::Tritone => write!(f, "Tritone"),
+            Interval::PerfectFifth => write!(f, "Perfect Fifth"),
+            Interval::MinorSixth => write!(f, "Minor Sixth"),
+            Interval::MajorSixth => write!(f, "Major Sixth"),
+            Interval::MinorSeventh => write!(f, "Minor Seventh"),
+            Interval::MajorSeventh => write!(f, "Major Seventh"),
+            Interval::Octave => write!(f, "Octave"),
         }
     }
 }

src/data/music/notes.rs

@@ -1,5 +1,7 @@
 //! Defines the notes and accidentals for use in generating music courses.
 
+use std::fmt::{Display, Formatter};
+
 /// Defines the names of the natural notes.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[allow(missing_docs)]
@@ -13,16 +15,16 @@ pub enum NaturalNote {
     G,
 }
 
-impl ToString for NaturalNote {
-    fn to_string(&self) -> String {
-        match &self {
-            NaturalNote::A => "A".to_string(),
-            NaturalNote::B => "B".to_string(),
-            NaturalNote::C => "C".to_string(),
-            NaturalNote::D => "D".to_string(),
-            NaturalNote::E => "E".to_string(),
-            NaturalNote::F => "F".to_string(),
-            NaturalNote::G => "G".to_string(),
+impl Display for NaturalNote {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            NaturalNote::A => write!(f, "A"),
+            NaturalNote::B => write!(f, "B"),
+            NaturalNote::C => write!(f, "C"),
+            NaturalNote::D => write!(f, "D"),
+            NaturalNote::E => write!(f, "E"),
+            NaturalNote::F => write!(f, "F"),
+            NaturalNote::G => write!(f, "G"),
         }
     }
 }
@@ -36,12 +38,12 @@ pub enum Accidental {
     Sharp,
 }
 
-impl ToString for Accidental {
-    fn to_string(&self) -> String {
-        match &self {
-            Accidental::Natural => String::new(),
-            Accidental::Flat => "♭".to_string(),
-            Accidental::Sharp => "♯".to_string(),
+impl Display for Accidental {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Accidental::Natural => write!(f, ""),
+            Accidental::Flat => write!(f, "♭"),
+            Accidental::Sharp => write!(f, "♯"),
         }
     }
 }
@@ -83,15 +85,13 @@ impl Note {
             Accidental::Flat => "_flat".to_string(),
             Accidental::Sharp => "_sharp".to_string(),
         };
-        format!("{}{}", self.0.to_string(), accidental)
+        format!("{}{}", self.0, accidental)
     }
 }
 
-impl ToString for Note {
-    fn to_string(&self) -> String {
-        let mut output = self.0.to_string();
-        output.push_str(&self.1.to_string());
-        output
+impl Display for Note {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}{}", self.0, self.1)
     }
 }
 

src/data/music/scales.rs

@@ -1,6 +1,7 @@
 //! Defines musical scales for use in generating music courses.
 
 use anyhow::{anyhow, Result};
+use std::fmt::{Display, Formatter};
 
 use crate::data::music::intervals::*;
 use crate::data::music::notes::*;
@@ -25,13 +26,13 @@ pub enum ScaleType {
     MinorPentatonic,
 }
 
-impl ToString for ScaleType {
-    fn to_string(&self) -> String {
+impl Display for ScaleType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            ScaleType::Major => "Major".to_string(),
-            ScaleType::Minor => "Minor".to_string(),
-            ScaleType::MajorPentatonic => "Major Pentatonic".to_string(),
-            ScaleType::MinorPentatonic => "Minor Pentatonic".to_string(),
+            ScaleType::Major => write!(f, "Major"),
+            ScaleType::Minor => write!(f, "Minor"),
+            ScaleType::MajorPentatonic => write!(f, "Major Pentatonic"),
+            ScaleType::MinorPentatonic => write!(f, "Minor Pentatonic"),
         }
     }
 }

src/lib.rs

@@ -35,6 +35,7 @@
 
 // Allow pedantic warnings but disable some that are not useful.
 #![warn(clippy::pedantic)]
+#![allow(clippy::doc_markdown)]
 #![allow(clippy::float_cmp)]
 #![allow(clippy::missing_errors_doc)]
 #![allow(clippy::missing_panics_doc)]

src/testutil.rs

@@ -7,6 +7,7 @@
 
 use std::{
     collections::BTreeMap,
+    fmt::{Display, Formatter},
     fs::{self, File},
     io::Write,
     path::Path,
@@ -76,19 +77,17 @@ impl TestId {
     }
 }
 
-impl ToString for TestId {
+impl Display for TestId {
     /// Converts the test ID to a valid string representation.
-    fn to_string(&self) -> String {
-        let mut s = self.0.to_string();
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)?;
         if let Some(lesson_id) = &self.1 {
-            s.push_str("::");
-            s.push_str(&lesson_id.to_string());
+            write!(f, "::{lesson_id}")?;
         }
         if let Some(exercise_id) = &self.2 {
-            s.push_str("::");
-            s.push_str(&exercise_id.to_string());
+            write!(f, "::{exercise_id}")?;
         }
-        s
+        Ok(())
     }
 }