Struct Note

pub struct Note(/* private fields */);

Implementations

impl Note

pub fn base(&self) -> Self

Returns the base note (the one in the C4 octave)

Examples found in repository

examples/notes.rs (line 6)

fn main() {
    let note = A;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A: {i} => {note:?} base={b} octave={o}");

    let note = G_SHARP;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("G#: {i} => {note:?} base={b} octave={o}");

    let note = A + SEMI_TONE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A + H: {i} => {note:?} base={b} octave={o}");

    let note = G_SHARP + SEMI_TONE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("G# + H: {i} => {note:?} base={b} octave={o}");

    let note = A - SEMI_TONE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A - H: {i} => {note:?} base={b} octave={o}");

    let note = A - SEMI_TONE - OCTAVE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A - H - O: {i} => {note:?} base={b} octave={o}");
}

pub fn octave(&self) -> i8

Returns the octave for the given note (eg. C4)

Examples found in repository

examples/notes.rs (line 7)

fn main() {
    let note = A;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A: {i} => {note:?} base={b} octave={o}");

    let note = G_SHARP;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("G#: {i} => {note:?} base={b} octave={o}");

    let note = A + SEMI_TONE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A + H: {i} => {note:?} base={b} octave={o}");

    let note = G_SHARP + SEMI_TONE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("G# + H: {i} => {note:?} base={b} octave={o}");

    let note = A - SEMI_TONE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A - H: {i} => {note:?} base={b} octave={o}");

    let note = A - SEMI_TONE - OCTAVE;
    let i = i8::from(note);
    let b = note.base();
    let o = note.octave();
    println!("A - H - O: {i} => {note:?} base={b} octave={o}");
}

pub fn dim(self) -> Chords

Builds a dim chord with the root in the current note.

Examples found in repository

examples/exercise4.rs (line 9)

fn main() {
    println!();
    println!("Exercise 4: | C | F | Bdim | Em | Am | Dm | G | C |");

    println!("{:X}", C.maj());
    println!("{:X}", F.maj());
    println!("{:X}", B.dim());
    println!("{:X}", E.min());
    println!("{:X}", A.min());
    println!("{:X}", D.min());
    println!("{:X}", G.maj());
    println!("{:X}", C.maj());
}

pub fn dim7(self) -> Chords

Builds a dim7 chord with the root in the current note.

Example

use musika_rs::*;

let chord = C.dim7();
println!("{:X}", chord);

pub fn dimished_chords(self) -> impl Iterator<Item = Chords>

Return all the diminished chords for the current note.

pub fn dom7(self) -> Chords

Builds a dominant7 choard with the root in the current note.

Example

use musika_rs::*;

let chord = C.dom7();
println!("{:X}", chord);

Examples found in repository

examples/chords.rs (line 13)

fn main() {
    let chord = C.maj();
    println!("{chord:X}");

    let chord = C.maj7();
    println!("{chord:X}");

    let chord = C.min();
    println!("{chord:X}");

    let chord = C.dom7();
    println!("{chord:X}");
}

pub fn dom7b5(self) -> Chords

pub fn dom7s5(self) -> Chords

pub fn dom9(self) -> Chords

pub fn dom11(self) -> Chords

pub fn dom13(self) -> Chords

Examples found in repository

examples/exercise5.rs (line 6)

fn key_c_major() {
    // Bar1
    let bar1 = Bar::new().with_chord(D.min9(), 2).with_chord(D.min9(), 2);
    let bar2 = Bar::new().with_chord(G.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new().with_chord(F.maj13(), 2).with_chord(F.maj13(), 2);
    let bar5 = Bar::new()
        .with_chord(A.dom13b9b13(), 2)
        .with_chord(A.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

fn key_f_major() {
    // Bar1
    // D -> G [D, F, G]
    // G -> C [G, A, B]

    let bar1 = Bar::new().with_chord(G.min9(), 2).with_chord(G.min9(), 2);
    let bar2 = Bar::new().with_chord(C.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    // C -> F [C, D, E, F]
    // F -> Bb
    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new()
        .with_chord(A_SHARP.maj13(), 2)
        .with_chord(A_SHARP.maj13(), 2);
    // A -> D [A, B, C, D]
    let bar5 = Bar::new()
        .with_chord(D.dom13b9b13(), 2)
        .with_chord(D.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

pub fn dom13b9b13(self) -> Chords

Examples found in repository

examples/exercise5.rs (line 20)

fn key_c_major() {
    // Bar1
    let bar1 = Bar::new().with_chord(D.min9(), 2).with_chord(D.min9(), 2);
    let bar2 = Bar::new().with_chord(G.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new().with_chord(F.maj13(), 2).with_chord(F.maj13(), 2);
    let bar5 = Bar::new()
        .with_chord(A.dom13b9b13(), 2)
        .with_chord(A.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

fn key_f_major() {
    // Bar1
    // D -> G [D, F, G]
    // G -> C [G, A, B]

    let bar1 = Bar::new().with_chord(G.min9(), 2).with_chord(G.min9(), 2);
    let bar2 = Bar::new().with_chord(C.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    // C -> F [C, D, E, F]
    // F -> Bb
    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new()
        .with_chord(A_SHARP.maj13(), 2)
        .with_chord(A_SHARP.maj13(), 2);
    // A -> D [A, B, C, D]
    let bar5 = Bar::new()
        .with_chord(D.dom13b9b13(), 2)
        .with_chord(D.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

pub fn dominant_chords(self) -> impl Iterator<Item = Chords>

pub fn maj(self) -> Chords

Builds a major chord with the root in the current note.

Example

use musika_rs::*;

let chord = C.maj();
println!("{:X}", chord);

Examples found in repository

examples/chords.rs (line 4)

fn main() {
    let chord = C.maj();
    println!("{chord:X}");

    let chord = C.maj7();
    println!("{chord:X}");

    let chord = C.min();
    println!("{chord:X}");

    let chord = C.dom7();
    println!("{chord:X}");
}

examples/exercise1.rs (line 6)

fn main() {
    println!();
    println!("Exercise 1: | C - Am | F - G |");
    println!("{:X}", C.maj()); // C [C, E, G]
    println!("{:X}", A.min()); // Am [A, C, E]
    println!("{:X}", F.maj()); // F [F, A, C]
    println!("{:X}", G.maj()); // G [G, B, D]
}

examples/exercise4.rs (line 7)

fn main() {
    println!();
    println!("Exercise 4: | C | F | Bdim | Em | Am | Dm | G | C |");

    println!("{:X}", C.maj());
    println!("{:X}", F.maj());
    println!("{:X}", B.dim());
    println!("{:X}", E.min());
    println!("{:X}", A.min());
    println!("{:X}", D.min());
    println!("{:X}", G.maj());
    println!("{:X}", C.maj());
}

examples/exercise2.rs (line 6)

fn main() {
    println!();
    println!("Exercise 2: | C - G | Am - F | C - G | F - Em - Dm - C |");
    println!("{:X}", C.maj()); // C [C, E, G]
    println!("{:X}", G.maj()); // G [G, B, D]
    println!("{:X}", A.min()); // Am [A, C, E]
    println!("{:X}", F.maj()); // F [F, A, C]
    println!("{:X}", C.maj()); // C [C, E, G]
    println!("{:X}", G.maj()); // G [G, B, D]
    println!("{:X}", F.maj()); // F [F, A, C]
    println!("{:X}", E.min()); // Em [E, G, B]
    println!("{:X}", D.min()); // Dm [D, F, A]
    println!("{:X}", C.maj()); // C [C, E, G]
}

examples/exercise3.rs (line 7)

fn main() {
    println!();
    println!("Exercise 3: | Cx4 | Gx4 | Gx4 | Cx4 | Fx4 | Cx4 | Gx4 | Cx4 |");

    let cmaj = C.maj();
    let gmaj = G.maj();
    let fmaj = F.maj();

    // bar 1
    for _ in 0..4 {
        println!("{:X}", cmaj); // C [C, E, G]
    }

    // bar 2
    for _ in 0..4 {
        println!("{:X}", gmaj); // C [C, E, G]
    }

    // bar 3
    for _ in 0..4 {
        println!("{:X}", gmaj); // C [C, E, G]
    }

    // bar 4
    for _ in 0..4 {
        println!("{:X}", cmaj); // C [C, E, G]
    }

    // bar 5
    for _ in 0..4 {
        println!("{:X}", fmaj); // C [C, E, G]
    }

    // bar 6
    for _ in 0..4 {
        println!("{:X}", cmaj); // C [C, E, G]
    }

    // bar 7
    for _ in 0..4 {
        println!("{:X}", gmaj); // C [C, E, G]
    }

    // bar 8
    for _ in 0..4 {
        println!("{:X}", cmaj); // C [C, E, G]
    }
}

pub fn maj7(self) -> Chords

Builds a major7 chord with the root in the current note.

Example

use musika_rs::*;

let chord = C.maj7();
println!("{:X}", chord);

Examples found in repository

examples/chords.rs (line 7)

fn main() {
    let chord = C.maj();
    println!("{chord:X}");

    let chord = C.maj7();
    println!("{chord:X}");

    let chord = C.min();
    println!("{chord:X}");

    let chord = C.dom7();
    println!("{chord:X}");
}

pub fn maj9(self) -> Chords

Examples found in repository

examples/exercise5.rs (line 17)

fn key_c_major() {
    // Bar1
    let bar1 = Bar::new().with_chord(D.min9(), 2).with_chord(D.min9(), 2);
    let bar2 = Bar::new().with_chord(G.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new().with_chord(F.maj13(), 2).with_chord(F.maj13(), 2);
    let bar5 = Bar::new()
        .with_chord(A.dom13b9b13(), 2)
        .with_chord(A.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

fn key_f_major() {
    // Bar1
    // D -> G [D, F, G]
    // G -> C [G, A, B]

    let bar1 = Bar::new().with_chord(G.min9(), 2).with_chord(G.min9(), 2);
    let bar2 = Bar::new().with_chord(C.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    // C -> F [C, D, E, F]
    // F -> Bb
    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new()
        .with_chord(A_SHARP.maj13(), 2)
        .with_chord(A_SHARP.maj13(), 2);
    // A -> D [A, B, C, D]
    let bar5 = Bar::new()
        .with_chord(D.dom13b9b13(), 2)
        .with_chord(D.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

pub fn maj11(self) -> Chords

pub fn maj13(self) -> Chords

Examples found in repository

examples/exercise5.rs (line 18)

fn key_c_major() {
    // Bar1
    let bar1 = Bar::new().with_chord(D.min9(), 2).with_chord(D.min9(), 2);
    let bar2 = Bar::new().with_chord(G.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new().with_chord(F.maj13(), 2).with_chord(F.maj13(), 2);
    let bar5 = Bar::new()
        .with_chord(A.dom13b9b13(), 2)
        .with_chord(A.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

fn key_f_major() {
    // Bar1
    // D -> G [D, F, G]
    // G -> C [G, A, B]

    let bar1 = Bar::new().with_chord(G.min9(), 2).with_chord(G.min9(), 2);
    let bar2 = Bar::new().with_chord(C.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    // C -> F [C, D, E, F]
    // F -> Bb
    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new()
        .with_chord(A_SHARP.maj13(), 2)
        .with_chord(A_SHARP.maj13(), 2);
    // A -> D [A, B, C, D]
    let bar5 = Bar::new()
        .with_chord(D.dom13b9b13(), 2)
        .with_chord(D.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

pub fn major_chords(self) -> impl Iterator<Item = Chords>

pub fn min(self) -> Chords

Builds a minor chord with the root in the current note.

Example

use musika_rs::*;

let chord = C.min();
println!("{:X}", chord);

Examples found in repository

examples/chords.rs (line 10)

fn main() {
    let chord = C.maj();
    println!("{chord:X}");

    let chord = C.maj7();
    println!("{chord:X}");

    let chord = C.min();
    println!("{chord:X}");

    let chord = C.dom7();
    println!("{chord:X}");
}

examples/exercise1.rs (line 7)

fn main() {
    println!();
    println!("Exercise 1: | C - Am | F - G |");
    println!("{:X}", C.maj()); // C [C, E, G]
    println!("{:X}", A.min()); // Am [A, C, E]
    println!("{:X}", F.maj()); // F [F, A, C]
    println!("{:X}", G.maj()); // G [G, B, D]
}

examples/exercise4.rs (line 10)

fn main() {
    println!();
    println!("Exercise 4: | C | F | Bdim | Em | Am | Dm | G | C |");

    println!("{:X}", C.maj());
    println!("{:X}", F.maj());
    println!("{:X}", B.dim());
    println!("{:X}", E.min());
    println!("{:X}", A.min());
    println!("{:X}", D.min());
    println!("{:X}", G.maj());
    println!("{:X}", C.maj());
}

examples/exercise2.rs (line 8)

fn main() {
    println!();
    println!("Exercise 2: | C - G | Am - F | C - G | F - Em - Dm - C |");
    println!("{:X}", C.maj()); // C [C, E, G]
    println!("{:X}", G.maj()); // G [G, B, D]
    println!("{:X}", A.min()); // Am [A, C, E]
    println!("{:X}", F.maj()); // F [F, A, C]
    println!("{:X}", C.maj()); // C [C, E, G]
    println!("{:X}", G.maj()); // G [G, B, D]
    println!("{:X}", F.maj()); // F [F, A, C]
    println!("{:X}", E.min()); // Em [E, G, B]
    println!("{:X}", D.min()); // Dm [D, F, A]
    println!("{:X}", C.maj()); // C [C, E, G]
}

pub fn min7(self) -> Chords

Builds a minor7 chord with the root in the current note.

Example

use musika_rs::*;

let chord = C.min7();
println!("{:X}", chord);

pub fn min7b5(self) -> Chords

pub fn min9(self) -> Chords

Examples found in repository

examples/exercise5.rs (line 5)

fn key_c_major() {
    // Bar1
    let bar1 = Bar::new().with_chord(D.min9(), 2).with_chord(D.min9(), 2);
    let bar2 = Bar::new().with_chord(G.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new().with_chord(F.maj13(), 2).with_chord(F.maj13(), 2);
    let bar5 = Bar::new()
        .with_chord(A.dom13b9b13(), 2)
        .with_chord(A.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

fn key_f_major() {
    // Bar1
    // D -> G [D, F, G]
    // G -> C [G, A, B]

    let bar1 = Bar::new().with_chord(G.min9(), 2).with_chord(G.min9(), 2);
    let bar2 = Bar::new().with_chord(C.dom13(), 2).with_chord(G.dom13(), 2);

    let line1 = [&bar1, &bar2, &bar1, &bar2];
    let s = line1
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");

    // C -> F [C, D, E, F]
    // F -> Bb
    let bar3 = Bar::new().with_chord(C.maj9(), 2).with_chord(C.maj9(), 2);
    let bar4 = Bar::new()
        .with_chord(A_SHARP.maj13(), 2)
        .with_chord(A_SHARP.maj13(), 2);
    // A -> D [A, B, C, D]
    let bar5 = Bar::new()
        .with_chord(D.dom13b9b13(), 2)
        .with_chord(D.dom13b9b13(), 2);

    let line2 = [&bar3, &bar4, &bar3, &bar5];
    let s = line2
        .iter()
        .map(|b| format!("{}", b))
        .collect::<Vec<_>>()
        .as_slice()
        .join(" | ");
    println!("| {s} |");
}

pub fn min11(self) -> Chords

pub fn min13(self) -> Chords

pub fn minor_chords(self) -> impl Iterator<Item = Chords>

pub fn all_chords(self) -> impl Iterator<Item = Chords>

Examples found in repository

examples/all.rs (line 5)

fn main() {
    let root = C;
    for c in root.all_chords() {
        println!("{c:X}")
    }
}

Trait Implementations

impl Add<Tone> for Note

type Output = Note

The resulting type after applying the + operator.

fn add(self, tone: Tone) -> Self::Output

Performs the + operation.

impl AsRef<i8> for Note

fn as_ref(&self) -> &i8

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Note

fn clone(&self) -> Note

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Note

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Note

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<Note> for i8

fn from(note: Note) -> Self

Converts to this type from the input type.

impl From<i8> for Note

fn from(value: i8) -> Self

Converts to this type from the input type.

impl LowerHex for Note

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Ord for Note

fn cmp(&self, other: &Note) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Note

fn eq(&self, other: &Note) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Note

fn partial_cmp(&self, other: &Note) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub<Tone> for Note

type Output = Note

The resulting type after applying the - operator.

fn sub(self, tone: Tone) -> Self::Output

Performs the - operation.

impl Sub for Note

type Output = Tone

The resulting type after applying the - operator.

fn sub(self, other: Note) -> Self::Output

Performs the - operation.

impl UpperHex for Note

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Copy for Note

impl Eq for Note

impl StructuralPartialEq for Note