update

Signed-off-by: Joe McCain III <jo3mccain@icloud.com>

Author: FL03

core/src/intervals/interval.rs

@@ -2,28 +2,28 @@
     Appellation: interval <module>
     Contrib: FL03 <jo3mccain@icloud.com>
 */
+use super::IntervalLevel;
 
 pub struct Interval<Q> {
     pub level: IntervalLevel,
     pub quality: Option<Q>,
     pub value: i8,
 }
 
-pub enum IntervalLevel {
-    Semitone,
-    Tone,
-    Third,
-    Fourth,
-    Fifth,
-    Sixth,
-    Seventh,
-    Octave,
-}
 
-pub trait IntervalQuality {
-    fn level(&self) -> IntervalLevel;
+
+pub trait Quality<T> {
+    type Group;
+
+    fn group(&self) -> Self::Group;
 
     fn name(&self) -> &str;
 
-    fn value(&self) -> i8;
+    fn value(&self) -> T;
+}
+
+pub struct Variant<K, V> {
+    pub group: K,
+    pub name: &'static str,
+    pub value: V,
 }

core/src/intervals/kinds.rs

@@ -2,6 +2,11 @@
     Appellation: kinds <module>
     Contrib: FL03 <jo3mccain@icloud.com>
 */
+#[doc(inline)]
+pub use self::variants::*;
+
+pub(crate) mod variants;
+
 use crate::{IntoPitch, Pitch};
 
 /// [Intervals] enumerates the various intervals used within music theory.
@@ -121,7 +126,7 @@ impl Intervals {
     }
 }
 
-macro_rules! new_interval {
+macro_rules! impl_new_interval {
     (@impl $name:ident::$variant:ident.$call:ident($($T:ident)::*)) => {
         pub fn $call() -> Self {
             $name::$variant($($T)::*)
@@ -136,7 +141,7 @@ macro_rules! new_interval {
 
     ($name:ident {$($variant:ident.$call:ident$(($($T:ident)::*))?),* $(,)?}) => {
         impl $name {
-            $(new_interval!(@impl $name::$variant.$call$(($($T)::*))?);)*
+            $(impl_new_interval!(@impl $name::$variant.$call$(($($T)::*))?);)*
         }
     };
 }
@@ -156,7 +161,7 @@ macro_rules! impl_from_value {
     };
 }
 
-new_interval! {
+impl_new_interval! {
     Intervals {
         Thirds.minor_third(Third::Minor),
         Thirds.major_third(Third::Major),
@@ -188,61 +193,3 @@ impl_from_value! {
         Sevenths(Seventh),
     }
 }
-
-interval! {
-    default: Major;
-    pub enum Third {
-        Minor = 3,
-        Major = 4,
-    }
-}
-
-interval! {
-    default: Perfect;
-    pub enum Fourth {
-        Perfect = 5,
-    }
-}
-
-interval! {
-    default: Perfect;
-    pub enum Fifth {
-        Diminished = 6,
-        Perfect = 7,
-        Augmented = 8,
-    }
-}
-
-interval! {
-    default: Diminished;
-    pub enum Seventh {
-        Diminished = 9,
-        Minor = 10,
-        Major = 11,
-        Augmented = 12,
-    }
-}
-
-impl Fifth {
-    pub fn augmented() -> Self {
-        Fifth::Augmented
-    }
-
-    pub fn diminished() -> Self {
-        Fifth::Diminished
-    }
-
-    pub fn perfect() -> Self {
-        Fifth::Perfect
-    }
-
-    pub fn from_thirds(lhs: Third, rhs: Third) -> Self {
-        let value = lhs as i8 + rhs as i8;
-        match value {
-            6 => Fifth::Diminished,
-            7 => Fifth::Perfect,
-            8 => Fifth::Augmented,
-            _ => panic!("Invalid fifth value: {}", value),
-        }
-    }
-}

core/src/intervals/kinds/variants.rs

@@ -0,0 +1,99 @@
+/*
+    Appellation: variants <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+*/
+
+interval! {
+    default: Major;
+    pub enum Third {
+        Minor = 3,
+        Major = 4,
+    }
+}
+
+interval! {
+    default: Perfect;
+    pub enum Fourth {
+        Perfect = 5,
+    }
+}
+
+interval! {
+    default: Perfect;
+    pub enum Fifth {
+        Diminished = 6,
+        Perfect = 7,
+        Augmented = 8,
+    }
+}
+
+interval! {
+    default: Diminished;
+    pub enum Seventh {
+        Diminished = 9,
+        Minor = 10,
+        Major = 11,
+        Augmented = 12,
+    }
+}
+
+/*
+    ************* Implementations *************
+*/
+impl Third {
+    pub fn minor() -> Self {
+        Third::Minor
+    }
+
+    pub fn major() -> Self {
+        Third::Major
+    }
+}
+
+impl Fourth {
+    pub fn perfect() -> Self {
+        Fourth::Perfect
+    }
+}
+
+impl Fifth {
+    pub fn augmented() -> Self {
+        Fifth::Augmented
+    }
+
+    pub fn diminished() -> Self {
+        Fifth::Diminished
+    }
+
+    pub fn perfect() -> Self {
+        Fifth::Perfect
+    }
+
+    pub fn from_thirds(lhs: Third, rhs: Third) -> Self {
+        let value = lhs as i8 + rhs as i8;
+        match value {
+            6 => Fifth::Diminished,
+            7 => Fifth::Perfect,
+            8 => Fifth::Augmented,
+            _ => panic!("Invalid fifth value: {}", value),
+        }
+    }
+}
+
+impl Seventh {
+    pub fn augmented() -> Self {
+        Seventh::Augmented
+    }
+
+    pub fn diminished() -> Self {
+        Seventh::Diminished
+    }
+
+    pub fn major() -> Self {
+        Seventh::Major
+    }
+
+    pub fn minor() -> Self {
+        Seventh::Minor
+    }
+}

core/src/intervals/mod.rs

@@ -3,23 +3,23 @@
     Contrib: FL03 <jo3mccain@icloud.com>
 */
 #[doc(inline)]
-pub use self::kinds::*;
+pub use self::{kinds::*, types::*};
 
 pub(crate) mod kinds;
+pub(crate) mod types;
 
 #[doc(hidden)]
 pub mod interval;
-#[doc(hidden)]
-pub mod qualities;
 
 pub(crate) mod prelude {
     pub use super::kinds::*;
+    pub use super::types::IntervalLevel;
     pub use super::IntervalKind;
 }
 
 pub(crate) type IntervalTy = i8;
 
-pub trait IntervalT {
+pub trait Intervallic {
     private!();
 
     fn as_i8(&self) -> i8;

core/src/intervals/types/level.rs

@@ -0,0 +1,85 @@
+/*
+    Appellation: level <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+*/
+#[derive(
+    Clone,
+    Copy,
+    Debug,
+    Default,
+    Eq,
+    Hash,
+    Ord,
+    PartialEq,
+    PartialOrd,
+    strum::AsRefStr,
+    strum::Display,
+    strum::EnumCount,
+    strum::EnumIs,
+    strum::EnumIter,
+    strum::EnumString,
+    strum::VariantNames,
+    strum::VariantArray,
+)]
+#[cfg_attr(
+    feature = "serde",
+    derive(serde::Deserialize, serde::Serialize),
+    serde(rename_all = "lowercase")
+)]
+#[strum(serialize_all = "lowercase")]
+pub enum IntervalLevel {
+    #[default]
+    Semitone = 1,
+    Tone = 2,
+    Third = 4,
+    Fourth = 5,
+    Fifth = 7,
+    Sixth,
+    Seventh,
+    Octave = 12,
+}
+
+impl IntervalLevel {
+    pub const MOD: i8 = 12;
+
+    pub fn from_i8(value: i8) -> Self {
+        use IntervalLevel::*;
+        match value.abs() % 12 {
+            1 => Semitone,
+            2 => Tone,
+            3..=4 => Third,
+            5 => Fourth,
+            6..=8 => Fifth,
+            9..=11 => Seventh,
+            0 => Octave,
+            _ => unreachable!(),
+        }
+    }
+    pub fn semitone() -> Self {
+        IntervalLevel::Semitone
+    }
+
+    pub fn tone() -> Self {
+        IntervalLevel::Tone
+    }
+
+    pub fn third() -> Self {
+        IntervalLevel::Third
+    }
+
+    pub fn fourth() -> Self {
+        IntervalLevel::Fourth
+    }
+
+    pub fn fifth() -> Self {
+        IntervalLevel::Fifth
+    }
+
+    pub fn sixth() -> Self {
+        IntervalLevel::Sixth
+    }
+
+    pub fn seventh() -> Self {
+        IntervalLevel::Seventh
+    }
+}

core/src/intervals/types/mod.rs

@@ -0,0 +1,16 @@
+/*
+    Appellation: types <module>
+    Contrib: FL03 <jo3mccain@icloud.com>
+*/
+#[doc(inline)]
+pub use self::{level::*, qualities::*};
+
+pub(crate) mod level;
+pub(crate) mod qualities;
+
+#[allow(unused_imports)]
+#[doc(hidden)]
+pub(crate) mod prelude {
+    pub use super::level::IntervalLevel;
+    // pub use super::qualities::*;
+}

core/src/intervals/qualities.rs renamed to core/src/intervals/types/qualities.rs

@@ -2,7 +2,8 @@
     Appellation: qualities <module>
     Contrib: FL03 <jo3mccain@icloud.com>
 */
-/// Musically speaking, an [interval quality](Quality) is used to identify the different versions of various musical
+/// Musically speaking, the [quality](Quality) of an interval is used to denote the particular
+/// variation, or [level](super::IntervalLevel), of the interval.
 /// objects.
 ///
 /// With respect to intervals, the quality is used to identify the different versions of the interval.