pitchy 0.2.0

Minimalistic Rust library for working with frequencies (Hz), MIDI numbers, musical notes, and pitch operations like transposition and octave shifts.
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

//! Components for symbolic musical notes: note letters and accidentals.
//!
//! These types define the spelled representation of notes (e.g., `C#`, `Bb`, `F𝄪`).

use error::SymbolError;

mod error;

/// Represents the base letter of a musical note (C, D, E, F, G, A, B).
///
/// The `repr(u8)` maps each letter to its position in the chromatic scale,
/// which allows direct semitone indexing: C=0, D=2, E=4, F=5, G=7, A=9, B=11.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u8)]
pub enum NoteLetter {
    C = 0,
    D = 2,
    E = 4,
    F = 5,
    G = 7,
    A = 9,
    B = 11,
}

impl NoteLetter {
    /// All 7 possible note letters
    pub const fn all() -> [Self; 7] {
        use NoteLetter::*;

        [C, D, E, F, G, A, B]
    }

    pub fn as_str(&self) -> &'static str {
        use NoteLetter::*;

        match self {
            C => "C",
            D => "D",
            E => "E",
            F => "F",
            G => "G",
            A => "A",
            B => "B",
        }
    }
}

impl core::fmt::Display for NoteLetter {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str(self.as_str())
    }
}

/// Represents the accidental applied to a note (double flat, flat, natural, sharp, double sharp).
///
/// The `repr(i8)` lets us treat accidentals as signed semitone offsets:
/// DoubleFlat = -2, Flat = -1, Natural = 0, Sharp = 1, DoubleSharp = 2.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(i8)]
pub enum Accidental {
    DoubleFlat = -2,
    Flat = -1,
    Natural = 0,
    Sharp = 1,
    DoubleSharp = 2,
}

impl Accidental {
    pub fn as_str(&self) -> &'static str {
        use Accidental::*;

        match self {
            Natural => "",
            Sharp => "#",
            Flat => "b",
            DoubleSharp => "𝄪",
            DoubleFlat => "𝄫",
        }
    }
}

impl core::fmt::Display for Accidental {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl TryFrom<i8> for Accidental {
    type Error = SymbolError;

    fn try_from(v: i8) -> Result<Self, Self::Error> {
        match v {
            -2 => Ok(Accidental::DoubleFlat),
            -1 => Ok(Accidental::Flat),
            0 => Ok(Accidental::Natural),
            1 => Ok(Accidental::Sharp),
            2 => Ok(Accidental::DoubleSharp),
            _ => Err(SymbolError::InvalidAccidental(v)),
        }
    }
}