staff 0.11.0

Music theory library with midi, notes, chords, scales, and more
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use super::{Degree, Scale, ScaleIntervals};

pub type DiatonicScale<T> = Scale<T, Diatonic<T, ScaleIntervals>>;

impl<T> DiatonicScale<T>
where
    T: Degree + Clone,
{
    /// ```
    /// use staff::{midi, Note, Scale};
    ///
    /// // C major
    /// let scale = Scale::major(midi!(C, 4));
    ///
    /// assert!(scale.eq([
    ///     midi!(C, 4),
    ///     midi!(D, 4),
    ///     midi!(E, 4),
    ///     midi!(F, 4),
    ///     midi!(G, 4),
    ///     midi!(A, 4),
    ///     midi!(B, 4),
    /// ]));
    /// ```
    pub fn major(root: T) -> Self {
        Self::diatonic(root, ScaleIntervals::major())
    }

    /// ```
    /// use staff::{Natural, Note, Scale};
    ///
    /// // B natural minor
    /// let scale = Scale::natural_minor(Note::from(Natural::B));
    ///
    /// assert!(scale.eq([
    ///     Note::from(Natural::B),
    ///     Note::sharp(Natural::C),
    ///     Note::from(Natural::D),
    ///     Note::from(Natural::E),
    ///     Note::sharp(Natural::F),
    ///     Note::from(Natural::G),
    ///     Note::from(Natural::A),
    /// ]));
    /// ```
    pub fn natural_minor(root: T) -> Self {
        Self::diatonic(root, ScaleIntervals::natural_minor())
    }

    /// ```
    /// use staff::{Natural, Note, Scale};
    ///
    /// // A harmonic minor
    /// let scale = Scale::harmonic_minor(Note::from(Natural::A));
    ///
    /// assert!(scale.eq([
    ///     Note::from(Natural::A),
    ///     Note::from(Natural::B),
    ///     Note::from(Natural::C),
    ///     Note::from(Natural::D),
    ///     Note::from(Natural::E),
    ///     Note::from(Natural::F),
    ///     Note::sharp(Natural::G),
    /// ]));
    /// ```
    pub fn harmonic_minor(root: T) -> Self {
        Self::diatonic(root, ScaleIntervals::harmonic_minor())
    }

    /// ```
    /// use staff::{Natural, Note, Scale};
    ///
    /// // E melodic minor
    /// let scale = Scale::melodic_minor(Note::from(Natural::E));
    ///
    /// assert!(scale.eq([
    ///     Note::from(Natural::E),
    ///     Note::sharp(Natural::F),
    ///     Note::from(Natural::G),
    ///     Note::from(Natural::A),
    ///     Note::from(Natural::B),
    ///     Note::sharp(Natural::C),
    ///     Note::sharp(Natural::D),
    /// ]));
    /// ```
    pub fn melodic_minor(root: T) -> Self {
        Self::diatonic(root, ScaleIntervals::melodic_minor())
    }

    pub fn dorian(root: T) -> Self {
        Self::diatonic(root, ScaleIntervals::dorian())
    }
}

#[derive(Clone)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Diatonic<T: Degree, U> {
    pub state: T::State,
    pub intervals: U,
}

impl<T, U> Diatonic<T, U>
where
    T: Degree,
{
    pub fn new(root: T, intervals: U) -> Self {
        Self {
            state: root.state(),
            intervals,
        }
    }
}