Phrase

rust_music

Struct Phrase 

Source 
pub struct Phrase { /* private fields */ }
Expand description

Describes a single musical phrase. Multiple Phrases can be stored in a Part. Phrases can be played in parallel too

Implementations§

Source§

impl Phrase

Source

pub fn new() -> Phrase

Returns a new Phrase A Phrase contains entries that can be either a single Note, a Chord or a Rest Entries in a Phrase are played sequentially.

Examples found in repository?
examples/readme_example.rs (line 13)
10fn main() -> Result<(), Box<dyn Error>> {
11    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
12    // with crotchets, at MezzoForte volume
13    let mut phrase_to_repeat = Phrase::new();
14    phrase_to_repeat.add_note(Note::new(
15        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
16        CROTCHET,
17        MF,
18    )?);
19    phrase_to_repeat.add_note(Note::new(
20        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
21        CROTCHET,
22        MF,
23    )?);
24    phrase_to_repeat.add_note(Note::new(
25        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
26        CROTCHET,
27        MF,
28    )?);
29
30    // Create a piano part that plays the phrase from beat 0
31    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
32    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);
33
34    // Create a Strings part that plays the phrase from beat 0.5
35    // (at the same time as the piano but shifted half a beat)
36    let mut violins_part = Part::new(Instrument::StringEnsemble1);
37    violins_part.add_phrase(phrase_to_repeat, 0.5);
38
39    // Create a score with a tempo of 60 (one beat per second) and add both parts
40    let mut score = Score::new("my score", Tempo::new(60)?, None);
41    score.add_part(piano_part);
42    score.add_part(violins_part);
43
44    // Write the score to a MIDI file for playback
45    score.write_midi_file(File::create("readme_example.mid")?)?;
46    Ok(())
47}
More examples
Hide additional examples
examples/praeludium_no1_multi_phrase.rs (line 48)
47fn right_hand() -> Result<Phrase> {
48    let mut right_hand = Phrase::new();
49    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7| -> Result<()> {
50        for _ in 0..=1 {
51            right_hand.add_rest(QUAVER);
52            for _ in 0..=1 {
53                right_hand.add_sequential_notes(Note::new_sequence(
54                    SEMIQUAVER,
55                    MF,
56                    [pitch1, pitch2, pitch3],
57                ))?;
58            }
59        }
60        Ok(())
61    };
62    add_bar(
63        compute_pitch(NN::G, Acc::Natural, 4)?,
64        compute_pitch(NN::C, Acc::Natural, 5)?,
65        compute_pitch(NN::E, Acc::Natural, 5)?,
66    )?;
67    add_bar(
68        compute_pitch(NN::A, Acc::Natural, 4)?,
69        compute_pitch(NN::D, Acc::Natural, 5)?,
70        compute_pitch(NN::F, Acc::Natural, 5)?,
71    )?;
72    add_bar(
73        compute_pitch(NN::G, Acc::Natural, 4)?,
74        compute_pitch(NN::D, Acc::Natural, 5)?,
75        compute_pitch(NN::F, Acc::Natural, 5)?,
76    )?;
77    add_bar(
78        compute_pitch(NN::G, Acc::Natural, 4)?,
79        compute_pitch(NN::C, Acc::Natural, 5)?,
80        compute_pitch(NN::E, Acc::Natural, 5)?,
81    )?;
82    add_bar(
83        compute_pitch(NN::A, Acc::Natural, 4)?,
84        compute_pitch(NN::E, Acc::Natural, 5)?,
85        compute_pitch(NN::A, Acc::Natural, 5)?,
86    )?;
87    add_bar(
88        compute_pitch(NN::F, Acc::Sharp, 4)?,
89        compute_pitch(NN::A, Acc::Natural, 4)?,
90        compute_pitch(NN::D, Acc::Natural, 5)?,
91    )?;
92    add_bar(
93        compute_pitch(NN::G, Acc::Natural, 4)?,
94        compute_pitch(NN::D, Acc::Natural, 5)?,
95        compute_pitch(NN::G, Acc::Natural, 5)?,
96    )?;
97    add_bar(
98        compute_pitch(NN::E, Acc::Natural, 4)?,
99        compute_pitch(NN::G, Acc::Natural, 4)?,
100        compute_pitch(NN::C, Acc::Natural, 5)?,
101    )?;
102    add_bar(
103        compute_pitch(NN::E, Acc::Natural, 4)?,
104        compute_pitch(NN::G, Acc::Natural, 4)?,
105        compute_pitch(NN::C, Acc::Natural, 5)?,
106    )?;
107    Ok(right_hand)
108}
109
110fn left_hand_low_note() -> Result<Phrase> {
111    let mut lhln = Phrase::new();
112    let mut add_bar = |pitch: u7| -> Result<()> {
113        for _ in 0..=1 {
114            lhln.add_note(Note::new(pitch, MINIM, MF)?);
115        }
116        Ok(())
117    };
118    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
119    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
120    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
121    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
122    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
123    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
124    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
125    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
126    add_bar(compute_pitch(NN::A, Acc::Natural, 3)?)?;
127
128    Ok(lhln)
129}
130
131fn left_hand_high_note() -> Result<Phrase> {
132    let mut lhhn = Phrase::new();
133    let mut add_bar = |pitch: u7| -> Result<()> {
134        for _ in 0..=1 {
135            lhhn.add_rest(SEMIQUAVER);
136            lhhn.add_note(Note::new(pitch, DOTTED_QUAVER + CROTCHET, MF)?);
137        }
138        Ok(())
139    };
140    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
141    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
142    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
143    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
144    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
145    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
146    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
147    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
148    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
149
150    Ok(lhhn)
151}
examples/praeludium_no1_organ_piano.rs (line 46)
45fn right_hand() -> Result<Phrase> {
46    let mut right_hand = Phrase::new();
47    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7| -> Result<()> {
48        for _ in 0..=1 {
49            right_hand.add_rest(QUAVER);
50            for _ in 0..=1 {
51                right_hand.add_sequential_notes(Note::new_sequence(
52                    SEMIQUAVER,
53                    MF,
54                    [pitch1, pitch2, pitch3],
55                ))?;
56            }
57        }
58        Ok(())
59    };
60    add_bar(
61        compute_pitch(NN::G, Acc::Natural, 4)?,
62        compute_pitch(NN::C, Acc::Natural, 5)?,
63        compute_pitch(NN::E, Acc::Natural, 5)?,
64    )?;
65    add_bar(
66        compute_pitch(NN::A, Acc::Natural, 4)?,
67        compute_pitch(NN::D, Acc::Natural, 5)?,
68        compute_pitch(NN::F, Acc::Natural, 5)?,
69    )?;
70    add_bar(
71        compute_pitch(NN::G, Acc::Natural, 4)?,
72        compute_pitch(NN::D, Acc::Natural, 5)?,
73        compute_pitch(NN::F, Acc::Natural, 5)?,
74    )?;
75    add_bar(
76        compute_pitch(NN::G, Acc::Natural, 4)?,
77        compute_pitch(NN::C, Acc::Natural, 5)?,
78        compute_pitch(NN::E, Acc::Natural, 5)?,
79    )?;
80    add_bar(
81        compute_pitch(NN::A, Acc::Natural, 4)?,
82        compute_pitch(NN::E, Acc::Natural, 5)?,
83        compute_pitch(NN::A, Acc::Natural, 5)?,
84    )?;
85    add_bar(
86        compute_pitch(NN::F, Acc::Sharp, 4)?,
87        compute_pitch(NN::A, Acc::Natural, 4)?,
88        compute_pitch(NN::D, Acc::Natural, 5)?,
89    )?;
90    add_bar(
91        compute_pitch(NN::G, Acc::Natural, 4)?,
92        compute_pitch(NN::D, Acc::Natural, 5)?,
93        compute_pitch(NN::G, Acc::Natural, 5)?,
94    )?;
95    add_bar(
96        compute_pitch(NN::E, Acc::Natural, 4)?,
97        compute_pitch(NN::G, Acc::Natural, 4)?,
98        compute_pitch(NN::C, Acc::Natural, 5)?,
99    )?;
100    add_bar(
101        compute_pitch(NN::E, Acc::Natural, 4)?,
102        compute_pitch(NN::G, Acc::Natural, 4)?,
103        compute_pitch(NN::C, Acc::Natural, 5)?,
104    )?;
105    Ok(right_hand)
106}
107
108fn left_hand_low_note() -> Result<Phrase> {
109    let mut lhln = Phrase::new();
110    let mut add_bar = |pitch: u7| -> Result<()> {
111        for _ in 0..=1 {
112            lhln.add_note(Note::new(pitch, MINIM, MF)?);
113        }
114        Ok(())
115    };
116    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
117    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
118    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
119    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
120    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
121    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
122    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
123    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
124    add_bar(compute_pitch(NN::A, Acc::Natural, 3)?)?;
125
126    Ok(lhln)
127}
128
129fn left_hand_high_note() -> Result<Phrase> {
130    let mut lhhn = Phrase::new();
131    let mut add_bar = |pitch: u7| -> Result<()> {
132        for _ in 0..=1 {
133            lhhn.add_rest(SEMIQUAVER);
134            lhhn.add_note(Note::new(pitch, DOTTED_QUAVER + CROTCHET, MF)?);
135        }
136        Ok(())
137    };
138    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
139    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
140    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
141    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
142    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
143    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
144    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
145    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
146    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
147
148    Ok(lhhn)
149}
examples/praeludium_no1_single_phrase.rs (line 36)
35fn phrase() -> Result<Phrase> {
36    let mut phrase = Phrase::new();
37    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7, pitch4: u7, pitch5: u7| -> Result<()> {
38        for _ in 0..=1 {
39            // Using a single note Chord to define a note that lasts while the next notes play.
40            // The next note/chord starts at the end of the Chord's rhythm value, but the notes in the
41            // chord can have a longer duration.
42            phrase.add_chord(Chord::new(SEMIQUAVER, vec![Note::new(pitch1, MINIM, MF)?])?);
43            phrase.add_chord(Chord::new(
44                SEMIQUAVER,
45                vec![Note::new(pitch2, DOTTED_QUAVER + CROTCHET, MF)?],
46            )?);
47            for _ in 0..=1 {
48                phrase.add_sequential_notes(Note::new_sequence(
49                    SEMIQUAVER,
50                    MF,
51                    [pitch3, pitch4, pitch5],
52                ))?;
53            }
54        }
55        Ok(())
56    };
57    add_bar(
58        compute_pitch(NN::C, Acc::Natural, 4)?,
59        compute_pitch(NN::E, Acc::Natural, 4)?,
60        compute_pitch(NN::G, Acc::Natural, 4)?,
61        compute_pitch(NN::C, Acc::Natural, 5)?,
62        compute_pitch(NN::E, Acc::Natural, 5)?,
63    )?;
64    add_bar(
65        compute_pitch(NN::C, Acc::Natural, 4)?,
66        compute_pitch(NN::D, Acc::Natural, 4)?,
67        compute_pitch(NN::A, Acc::Natural, 4)?,
68        compute_pitch(NN::D, Acc::Natural, 5)?,
69        compute_pitch(NN::F, Acc::Natural, 5)?,
70    )?;
71    add_bar(
72        compute_pitch(NN::B, Acc::Natural, 3)?,
73        compute_pitch(NN::D, Acc::Natural, 4)?,
74        compute_pitch(NN::G, Acc::Natural, 4)?,
75        compute_pitch(NN::D, Acc::Natural, 5)?,
76        compute_pitch(NN::F, Acc::Natural, 5)?,
77    )?;
78    add_bar(
79        compute_pitch(NN::C, Acc::Natural, 4)?,
80        compute_pitch(NN::E, Acc::Natural, 4)?,
81        compute_pitch(NN::G, Acc::Natural, 4)?,
82        compute_pitch(NN::C, Acc::Natural, 5)?,
83        compute_pitch(NN::E, Acc::Natural, 5)?,
84    )?;
85    add_bar(
86        compute_pitch(NN::C, Acc::Natural, 4)?,
87        compute_pitch(NN::E, Acc::Natural, 4)?,
88        compute_pitch(NN::A, Acc::Natural, 4)?,
89        compute_pitch(NN::E, Acc::Natural, 5)?,
90        compute_pitch(NN::A, Acc::Natural, 5)?,
91    )?;
92    add_bar(
93        compute_pitch(NN::C, Acc::Natural, 4)?,
94        compute_pitch(NN::D, Acc::Natural, 4)?,
95        compute_pitch(NN::F, Acc::Sharp, 4)?,
96        compute_pitch(NN::A, Acc::Natural, 4)?,
97        compute_pitch(NN::D, Acc::Natural, 5)?,
98    )?;
99    add_bar(
100        compute_pitch(NN::B, Acc::Natural, 3)?,
101        compute_pitch(NN::D, Acc::Natural, 4)?,
102        compute_pitch(NN::G, Acc::Natural, 4)?,
103        compute_pitch(NN::D, Acc::Natural, 5)?,
104        compute_pitch(NN::G, Acc::Natural, 5)?,
105    )?;
106    add_bar(
107        compute_pitch(NN::B, Acc::Natural, 3)?,
108        compute_pitch(NN::C, Acc::Natural, 4)?,
109        compute_pitch(NN::E, Acc::Natural, 4)?,
110        compute_pitch(NN::G, Acc::Natural, 4)?,
111        compute_pitch(NN::C, Acc::Natural, 5)?,
112    )?;
113    add_bar(
114        compute_pitch(NN::A, Acc::Natural, 3)?,
115        compute_pitch(NN::C, Acc::Natural, 4)?,
116        compute_pitch(NN::E, Acc::Natural, 4)?,
117        compute_pitch(NN::G, Acc::Natural, 4)?,
118        compute_pitch(NN::C, Acc::Natural, 5)?,
119    )?;
120    Ok(phrase)
121}
Source

pub fn from_notes_sequence<N: IntoIterator<Item = Result<Note>>>( sequence: N, ) -> Result<Self>

Returns a new Phrase made of the sequential notes from the iterator

§Arguments
  • sequence: iterator over the sequence of notes. Can be produced with Note::new_sequence for example
§Errors

This returns any error that can be found in the iterator entries

Examples found in repository?
examples/scales_example.rs (line 19)
11fn main() -> Result<(), Box<dyn Error>> {
12    // Create a simple C Minor Scale on octave 4 (this requires the `composition` feature)
13    let s = Scale::new(
14        compute_pitch(NoteName::Do, Accidental::Natural, 4)?,
15        ScaleMode::Aeolian,
16    );
17
18    // Create a phrase that just plays the scale as a sequence of quavers (half beat)
19    let phrase = Phrase::from_notes_sequence(Note::new_sequence(QUAVER, MF, s.n_pitches(15)))?;
20
21    // Create a piano part that plays the phrase from beat 0
22    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
23    piano_part.add_phrase(phrase, 0.);
24
25    // Create a score with a tempo of 60 (one beat per second) and add both parts
26    let mut score = Score::new("my score", Tempo::new(60)?, None);
27    score.add_part(piano_part);
28
29    // Write the score to a MIDI file for playback
30    score.write_midi_file(File::create("scale_example.mid")?)?;
31    Ok(())
32}
Source

pub fn set_name<S: ToString>(&mut self, name: S)

Sets a name for the Phrase. The name does not have to be unique.

Source

pub fn add_note(&mut self, note: Note)

Adds a note to the phrase. It starts after the previous entry.

Examples found in repository?
examples/praeludium_no1_multi_phrase.rs (line 114)
110fn left_hand_low_note() -> Result<Phrase> {
111    let mut lhln = Phrase::new();
112    let mut add_bar = |pitch: u7| -> Result<()> {
113        for _ in 0..=1 {
114            lhln.add_note(Note::new(pitch, MINIM, MF)?);
115        }
116        Ok(())
117    };
118    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
119    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
120    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
121    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
122    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
123    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
124    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
125    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
126    add_bar(compute_pitch(NN::A, Acc::Natural, 3)?)?;
127
128    Ok(lhln)
129}
130
131fn left_hand_high_note() -> Result<Phrase> {
132    let mut lhhn = Phrase::new();
133    let mut add_bar = |pitch: u7| -> Result<()> {
134        for _ in 0..=1 {
135            lhhn.add_rest(SEMIQUAVER);
136            lhhn.add_note(Note::new(pitch, DOTTED_QUAVER + CROTCHET, MF)?);
137        }
138        Ok(())
139    };
140    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
141    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
142    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
143    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
144    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
145    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
146    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
147    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
148    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
149
150    Ok(lhhn)
151}
More examples
Hide additional examples
examples/praeludium_no1_organ_piano.rs (line 112)
108fn left_hand_low_note() -> Result<Phrase> {
109    let mut lhln = Phrase::new();
110    let mut add_bar = |pitch: u7| -> Result<()> {
111        for _ in 0..=1 {
112            lhln.add_note(Note::new(pitch, MINIM, MF)?);
113        }
114        Ok(())
115    };
116    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
117    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
118    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
119    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
120    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
121    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
122    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
123    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
124    add_bar(compute_pitch(NN::A, Acc::Natural, 3)?)?;
125
126    Ok(lhln)
127}
128
129fn left_hand_high_note() -> Result<Phrase> {
130    let mut lhhn = Phrase::new();
131    let mut add_bar = |pitch: u7| -> Result<()> {
132        for _ in 0..=1 {
133            lhhn.add_rest(SEMIQUAVER);
134            lhhn.add_note(Note::new(pitch, DOTTED_QUAVER + CROTCHET, MF)?);
135        }
136        Ok(())
137    };
138    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
139    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
140    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
141    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
142    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
143    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
144    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
145    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
146    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
147
148    Ok(lhhn)
149}
examples/readme_example.rs (lines 14-18)
10fn main() -> Result<(), Box<dyn Error>> {
11    // Create a musical phrase that plays C-E-G (arpeggiated C Major chord)
12    // with crotchets, at MezzoForte volume
13    let mut phrase_to_repeat = Phrase::new();
14    phrase_to_repeat.add_note(Note::new(
15        compute_pitch(NoteName::C, Accidental::Natural, 4)?,
16        CROTCHET,
17        MF,
18    )?);
19    phrase_to_repeat.add_note(Note::new(
20        compute_pitch(NoteName::E, Accidental::Natural, 4)?,
21        CROTCHET,
22        MF,
23    )?);
24    phrase_to_repeat.add_note(Note::new(
25        compute_pitch(NoteName::G, Accidental::Natural, 4)?,
26        CROTCHET,
27        MF,
28    )?);
29
30    // Create a piano part that plays the phrase from beat 0
31    let mut piano_part = Part::new(Instrument::AcousticGrandPiano);
32    piano_part.add_phrase(phrase_to_repeat.clone(), 0.);
33
34    // Create a Strings part that plays the phrase from beat 0.5
35    // (at the same time as the piano but shifted half a beat)
36    let mut violins_part = Part::new(Instrument::StringEnsemble1);
37    violins_part.add_phrase(phrase_to_repeat, 0.5);
38
39    // Create a score with a tempo of 60 (one beat per second) and add both parts
40    let mut score = Score::new("my score", Tempo::new(60)?, None);
41    score.add_part(piano_part);
42    score.add_part(violins_part);
43
44    // Write the score to a MIDI file for playback
45    score.write_midi_file(File::create("readme_example.mid")?)?;
46    Ok(())
47}
Source

pub fn add_sequential_notes<N: IntoIterator<Item = Result<Note>>>( &mut self, notes: N, ) -> Result<()>

Adds multiple sequential notes to the phrase Each note will be played after the previous one. This function will clone the notes into the Phrase’s entry Vec

Examples found in repository?
examples/praeludium_no1_multi_phrase.rs (lines 53-57)
47fn right_hand() -> Result<Phrase> {
48    let mut right_hand = Phrase::new();
49    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7| -> Result<()> {
50        for _ in 0..=1 {
51            right_hand.add_rest(QUAVER);
52            for _ in 0..=1 {
53                right_hand.add_sequential_notes(Note::new_sequence(
54                    SEMIQUAVER,
55                    MF,
56                    [pitch1, pitch2, pitch3],
57                ))?;
58            }
59        }
60        Ok(())
61    };
62    add_bar(
63        compute_pitch(NN::G, Acc::Natural, 4)?,
64        compute_pitch(NN::C, Acc::Natural, 5)?,
65        compute_pitch(NN::E, Acc::Natural, 5)?,
66    )?;
67    add_bar(
68        compute_pitch(NN::A, Acc::Natural, 4)?,
69        compute_pitch(NN::D, Acc::Natural, 5)?,
70        compute_pitch(NN::F, Acc::Natural, 5)?,
71    )?;
72    add_bar(
73        compute_pitch(NN::G, Acc::Natural, 4)?,
74        compute_pitch(NN::D, Acc::Natural, 5)?,
75        compute_pitch(NN::F, Acc::Natural, 5)?,
76    )?;
77    add_bar(
78        compute_pitch(NN::G, Acc::Natural, 4)?,
79        compute_pitch(NN::C, Acc::Natural, 5)?,
80        compute_pitch(NN::E, Acc::Natural, 5)?,
81    )?;
82    add_bar(
83        compute_pitch(NN::A, Acc::Natural, 4)?,
84        compute_pitch(NN::E, Acc::Natural, 5)?,
85        compute_pitch(NN::A, Acc::Natural, 5)?,
86    )?;
87    add_bar(
88        compute_pitch(NN::F, Acc::Sharp, 4)?,
89        compute_pitch(NN::A, Acc::Natural, 4)?,
90        compute_pitch(NN::D, Acc::Natural, 5)?,
91    )?;
92    add_bar(
93        compute_pitch(NN::G, Acc::Natural, 4)?,
94        compute_pitch(NN::D, Acc::Natural, 5)?,
95        compute_pitch(NN::G, Acc::Natural, 5)?,
96    )?;
97    add_bar(
98        compute_pitch(NN::E, Acc::Natural, 4)?,
99        compute_pitch(NN::G, Acc::Natural, 4)?,
100        compute_pitch(NN::C, Acc::Natural, 5)?,
101    )?;
102    add_bar(
103        compute_pitch(NN::E, Acc::Natural, 4)?,
104        compute_pitch(NN::G, Acc::Natural, 4)?,
105        compute_pitch(NN::C, Acc::Natural, 5)?,
106    )?;
107    Ok(right_hand)
108}
More examples
Hide additional examples
examples/praeludium_no1_organ_piano.rs (lines 51-55)
45fn right_hand() -> Result<Phrase> {
46    let mut right_hand = Phrase::new();
47    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7| -> Result<()> {
48        for _ in 0..=1 {
49            right_hand.add_rest(QUAVER);
50            for _ in 0..=1 {
51                right_hand.add_sequential_notes(Note::new_sequence(
52                    SEMIQUAVER,
53                    MF,
54                    [pitch1, pitch2, pitch3],
55                ))?;
56            }
57        }
58        Ok(())
59    };
60    add_bar(
61        compute_pitch(NN::G, Acc::Natural, 4)?,
62        compute_pitch(NN::C, Acc::Natural, 5)?,
63        compute_pitch(NN::E, Acc::Natural, 5)?,
64    )?;
65    add_bar(
66        compute_pitch(NN::A, Acc::Natural, 4)?,
67        compute_pitch(NN::D, Acc::Natural, 5)?,
68        compute_pitch(NN::F, Acc::Natural, 5)?,
69    )?;
70    add_bar(
71        compute_pitch(NN::G, Acc::Natural, 4)?,
72        compute_pitch(NN::D, Acc::Natural, 5)?,
73        compute_pitch(NN::F, Acc::Natural, 5)?,
74    )?;
75    add_bar(
76        compute_pitch(NN::G, Acc::Natural, 4)?,
77        compute_pitch(NN::C, Acc::Natural, 5)?,
78        compute_pitch(NN::E, Acc::Natural, 5)?,
79    )?;
80    add_bar(
81        compute_pitch(NN::A, Acc::Natural, 4)?,
82        compute_pitch(NN::E, Acc::Natural, 5)?,
83        compute_pitch(NN::A, Acc::Natural, 5)?,
84    )?;
85    add_bar(
86        compute_pitch(NN::F, Acc::Sharp, 4)?,
87        compute_pitch(NN::A, Acc::Natural, 4)?,
88        compute_pitch(NN::D, Acc::Natural, 5)?,
89    )?;
90    add_bar(
91        compute_pitch(NN::G, Acc::Natural, 4)?,
92        compute_pitch(NN::D, Acc::Natural, 5)?,
93        compute_pitch(NN::G, Acc::Natural, 5)?,
94    )?;
95    add_bar(
96        compute_pitch(NN::E, Acc::Natural, 4)?,
97        compute_pitch(NN::G, Acc::Natural, 4)?,
98        compute_pitch(NN::C, Acc::Natural, 5)?,
99    )?;
100    add_bar(
101        compute_pitch(NN::E, Acc::Natural, 4)?,
102        compute_pitch(NN::G, Acc::Natural, 4)?,
103        compute_pitch(NN::C, Acc::Natural, 5)?,
104    )?;
105    Ok(right_hand)
106}
examples/praeludium_no1_single_phrase.rs (lines 48-52)
35fn phrase() -> Result<Phrase> {
36    let mut phrase = Phrase::new();
37    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7, pitch4: u7, pitch5: u7| -> Result<()> {
38        for _ in 0..=1 {
39            // Using a single note Chord to define a note that lasts while the next notes play.
40            // The next note/chord starts at the end of the Chord's rhythm value, but the notes in the
41            // chord can have a longer duration.
42            phrase.add_chord(Chord::new(SEMIQUAVER, vec![Note::new(pitch1, MINIM, MF)?])?);
43            phrase.add_chord(Chord::new(
44                SEMIQUAVER,
45                vec![Note::new(pitch2, DOTTED_QUAVER + CROTCHET, MF)?],
46            )?);
47            for _ in 0..=1 {
48                phrase.add_sequential_notes(Note::new_sequence(
49                    SEMIQUAVER,
50                    MF,
51                    [pitch3, pitch4, pitch5],
52                ))?;
53            }
54        }
55        Ok(())
56    };
57    add_bar(
58        compute_pitch(NN::C, Acc::Natural, 4)?,
59        compute_pitch(NN::E, Acc::Natural, 4)?,
60        compute_pitch(NN::G, Acc::Natural, 4)?,
61        compute_pitch(NN::C, Acc::Natural, 5)?,
62        compute_pitch(NN::E, Acc::Natural, 5)?,
63    )?;
64    add_bar(
65        compute_pitch(NN::C, Acc::Natural, 4)?,
66        compute_pitch(NN::D, Acc::Natural, 4)?,
67        compute_pitch(NN::A, Acc::Natural, 4)?,
68        compute_pitch(NN::D, Acc::Natural, 5)?,
69        compute_pitch(NN::F, Acc::Natural, 5)?,
70    )?;
71    add_bar(
72        compute_pitch(NN::B, Acc::Natural, 3)?,
73        compute_pitch(NN::D, Acc::Natural, 4)?,
74        compute_pitch(NN::G, Acc::Natural, 4)?,
75        compute_pitch(NN::D, Acc::Natural, 5)?,
76        compute_pitch(NN::F, Acc::Natural, 5)?,
77    )?;
78    add_bar(
79        compute_pitch(NN::C, Acc::Natural, 4)?,
80        compute_pitch(NN::E, Acc::Natural, 4)?,
81        compute_pitch(NN::G, Acc::Natural, 4)?,
82        compute_pitch(NN::C, Acc::Natural, 5)?,
83        compute_pitch(NN::E, Acc::Natural, 5)?,
84    )?;
85    add_bar(
86        compute_pitch(NN::C, Acc::Natural, 4)?,
87        compute_pitch(NN::E, Acc::Natural, 4)?,
88        compute_pitch(NN::A, Acc::Natural, 4)?,
89        compute_pitch(NN::E, Acc::Natural, 5)?,
90        compute_pitch(NN::A, Acc::Natural, 5)?,
91    )?;
92    add_bar(
93        compute_pitch(NN::C, Acc::Natural, 4)?,
94        compute_pitch(NN::D, Acc::Natural, 4)?,
95        compute_pitch(NN::F, Acc::Sharp, 4)?,
96        compute_pitch(NN::A, Acc::Natural, 4)?,
97        compute_pitch(NN::D, Acc::Natural, 5)?,
98    )?;
99    add_bar(
100        compute_pitch(NN::B, Acc::Natural, 3)?,
101        compute_pitch(NN::D, Acc::Natural, 4)?,
102        compute_pitch(NN::G, Acc::Natural, 4)?,
103        compute_pitch(NN::D, Acc::Natural, 5)?,
104        compute_pitch(NN::G, Acc::Natural, 5)?,
105    )?;
106    add_bar(
107        compute_pitch(NN::B, Acc::Natural, 3)?,
108        compute_pitch(NN::C, Acc::Natural, 4)?,
109        compute_pitch(NN::E, Acc::Natural, 4)?,
110        compute_pitch(NN::G, Acc::Natural, 4)?,
111        compute_pitch(NN::C, Acc::Natural, 5)?,
112    )?;
113    add_bar(
114        compute_pitch(NN::A, Acc::Natural, 3)?,
115        compute_pitch(NN::C, Acc::Natural, 4)?,
116        compute_pitch(NN::E, Acc::Natural, 4)?,
117        compute_pitch(NN::G, Acc::Natural, 4)?,
118        compute_pitch(NN::C, Acc::Natural, 5)?,
119    )?;
120    Ok(phrase)
121}
Source

pub fn add_chord(&mut self, c: Chord)

Adds a chord to the phrase. All notes of the Chord will start simultaneously but can end at different times depending on their respective rhythm values. The following Entry of the Phrase will start at the end of this Chord‘s rhythm value, regardless of its inner notes’ duration. Therefore, a Chord with a single Note (or several) allows to play the next notes/chords while the current is still playing, by setting a rhythm shorter than the notes it contains.

Examples found in repository?
examples/praeludium_no1_single_phrase.rs (line 42)
35fn phrase() -> Result<Phrase> {
36    let mut phrase = Phrase::new();
37    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7, pitch4: u7, pitch5: u7| -> Result<()> {
38        for _ in 0..=1 {
39            // Using a single note Chord to define a note that lasts while the next notes play.
40            // The next note/chord starts at the end of the Chord's rhythm value, but the notes in the
41            // chord can have a longer duration.
42            phrase.add_chord(Chord::new(SEMIQUAVER, vec![Note::new(pitch1, MINIM, MF)?])?);
43            phrase.add_chord(Chord::new(
44                SEMIQUAVER,
45                vec![Note::new(pitch2, DOTTED_QUAVER + CROTCHET, MF)?],
46            )?);
47            for _ in 0..=1 {
48                phrase.add_sequential_notes(Note::new_sequence(
49                    SEMIQUAVER,
50                    MF,
51                    [pitch3, pitch4, pitch5],
52                ))?;
53            }
54        }
55        Ok(())
56    };
57    add_bar(
58        compute_pitch(NN::C, Acc::Natural, 4)?,
59        compute_pitch(NN::E, Acc::Natural, 4)?,
60        compute_pitch(NN::G, Acc::Natural, 4)?,
61        compute_pitch(NN::C, Acc::Natural, 5)?,
62        compute_pitch(NN::E, Acc::Natural, 5)?,
63    )?;
64    add_bar(
65        compute_pitch(NN::C, Acc::Natural, 4)?,
66        compute_pitch(NN::D, Acc::Natural, 4)?,
67        compute_pitch(NN::A, Acc::Natural, 4)?,
68        compute_pitch(NN::D, Acc::Natural, 5)?,
69        compute_pitch(NN::F, Acc::Natural, 5)?,
70    )?;
71    add_bar(
72        compute_pitch(NN::B, Acc::Natural, 3)?,
73        compute_pitch(NN::D, Acc::Natural, 4)?,
74        compute_pitch(NN::G, Acc::Natural, 4)?,
75        compute_pitch(NN::D, Acc::Natural, 5)?,
76        compute_pitch(NN::F, Acc::Natural, 5)?,
77    )?;
78    add_bar(
79        compute_pitch(NN::C, Acc::Natural, 4)?,
80        compute_pitch(NN::E, Acc::Natural, 4)?,
81        compute_pitch(NN::G, Acc::Natural, 4)?,
82        compute_pitch(NN::C, Acc::Natural, 5)?,
83        compute_pitch(NN::E, Acc::Natural, 5)?,
84    )?;
85    add_bar(
86        compute_pitch(NN::C, Acc::Natural, 4)?,
87        compute_pitch(NN::E, Acc::Natural, 4)?,
88        compute_pitch(NN::A, Acc::Natural, 4)?,
89        compute_pitch(NN::E, Acc::Natural, 5)?,
90        compute_pitch(NN::A, Acc::Natural, 5)?,
91    )?;
92    add_bar(
93        compute_pitch(NN::C, Acc::Natural, 4)?,
94        compute_pitch(NN::D, Acc::Natural, 4)?,
95        compute_pitch(NN::F, Acc::Sharp, 4)?,
96        compute_pitch(NN::A, Acc::Natural, 4)?,
97        compute_pitch(NN::D, Acc::Natural, 5)?,
98    )?;
99    add_bar(
100        compute_pitch(NN::B, Acc::Natural, 3)?,
101        compute_pitch(NN::D, Acc::Natural, 4)?,
102        compute_pitch(NN::G, Acc::Natural, 4)?,
103        compute_pitch(NN::D, Acc::Natural, 5)?,
104        compute_pitch(NN::G, Acc::Natural, 5)?,
105    )?;
106    add_bar(
107        compute_pitch(NN::B, Acc::Natural, 3)?,
108        compute_pitch(NN::C, Acc::Natural, 4)?,
109        compute_pitch(NN::E, Acc::Natural, 4)?,
110        compute_pitch(NN::G, Acc::Natural, 4)?,
111        compute_pitch(NN::C, Acc::Natural, 5)?,
112    )?;
113    add_bar(
114        compute_pitch(NN::A, Acc::Natural, 3)?,
115        compute_pitch(NN::C, Acc::Natural, 4)?,
116        compute_pitch(NN::E, Acc::Natural, 4)?,
117        compute_pitch(NN::G, Acc::Natural, 4)?,
118        compute_pitch(NN::C, Acc::Natural, 5)?,
119    )?;
120    Ok(phrase)
121}
Source

pub fn add_rest(&mut self, rhythm: f64)

Adds a rest to the phrase. It starts after the previous entry

Examples found in repository?
examples/praeludium_no1_multi_phrase.rs (line 51)
47fn right_hand() -> Result<Phrase> {
48    let mut right_hand = Phrase::new();
49    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7| -> Result<()> {
50        for _ in 0..=1 {
51            right_hand.add_rest(QUAVER);
52            for _ in 0..=1 {
53                right_hand.add_sequential_notes(Note::new_sequence(
54                    SEMIQUAVER,
55                    MF,
56                    [pitch1, pitch2, pitch3],
57                ))?;
58            }
59        }
60        Ok(())
61    };
62    add_bar(
63        compute_pitch(NN::G, Acc::Natural, 4)?,
64        compute_pitch(NN::C, Acc::Natural, 5)?,
65        compute_pitch(NN::E, Acc::Natural, 5)?,
66    )?;
67    add_bar(
68        compute_pitch(NN::A, Acc::Natural, 4)?,
69        compute_pitch(NN::D, Acc::Natural, 5)?,
70        compute_pitch(NN::F, Acc::Natural, 5)?,
71    )?;
72    add_bar(
73        compute_pitch(NN::G, Acc::Natural, 4)?,
74        compute_pitch(NN::D, Acc::Natural, 5)?,
75        compute_pitch(NN::F, Acc::Natural, 5)?,
76    )?;
77    add_bar(
78        compute_pitch(NN::G, Acc::Natural, 4)?,
79        compute_pitch(NN::C, Acc::Natural, 5)?,
80        compute_pitch(NN::E, Acc::Natural, 5)?,
81    )?;
82    add_bar(
83        compute_pitch(NN::A, Acc::Natural, 4)?,
84        compute_pitch(NN::E, Acc::Natural, 5)?,
85        compute_pitch(NN::A, Acc::Natural, 5)?,
86    )?;
87    add_bar(
88        compute_pitch(NN::F, Acc::Sharp, 4)?,
89        compute_pitch(NN::A, Acc::Natural, 4)?,
90        compute_pitch(NN::D, Acc::Natural, 5)?,
91    )?;
92    add_bar(
93        compute_pitch(NN::G, Acc::Natural, 4)?,
94        compute_pitch(NN::D, Acc::Natural, 5)?,
95        compute_pitch(NN::G, Acc::Natural, 5)?,
96    )?;
97    add_bar(
98        compute_pitch(NN::E, Acc::Natural, 4)?,
99        compute_pitch(NN::G, Acc::Natural, 4)?,
100        compute_pitch(NN::C, Acc::Natural, 5)?,
101    )?;
102    add_bar(
103        compute_pitch(NN::E, Acc::Natural, 4)?,
104        compute_pitch(NN::G, Acc::Natural, 4)?,
105        compute_pitch(NN::C, Acc::Natural, 5)?,
106    )?;
107    Ok(right_hand)
108}
109
110fn left_hand_low_note() -> Result<Phrase> {
111    let mut lhln = Phrase::new();
112    let mut add_bar = |pitch: u7| -> Result<()> {
113        for _ in 0..=1 {
114            lhln.add_note(Note::new(pitch, MINIM, MF)?);
115        }
116        Ok(())
117    };
118    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
119    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
120    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
121    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
122    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
123    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
124    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
125    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
126    add_bar(compute_pitch(NN::A, Acc::Natural, 3)?)?;
127
128    Ok(lhln)
129}
130
131fn left_hand_high_note() -> Result<Phrase> {
132    let mut lhhn = Phrase::new();
133    let mut add_bar = |pitch: u7| -> Result<()> {
134        for _ in 0..=1 {
135            lhhn.add_rest(SEMIQUAVER);
136            lhhn.add_note(Note::new(pitch, DOTTED_QUAVER + CROTCHET, MF)?);
137        }
138        Ok(())
139    };
140    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
141    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
142    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
143    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
144    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
145    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
146    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
147    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
148    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
149
150    Ok(lhhn)
151}
More examples
Hide additional examples
examples/praeludium_no1_organ_piano.rs (line 49)
45fn right_hand() -> Result<Phrase> {
46    let mut right_hand = Phrase::new();
47    let mut add_bar = |pitch1: u7, pitch2: u7, pitch3: u7| -> Result<()> {
48        for _ in 0..=1 {
49            right_hand.add_rest(QUAVER);
50            for _ in 0..=1 {
51                right_hand.add_sequential_notes(Note::new_sequence(
52                    SEMIQUAVER,
53                    MF,
54                    [pitch1, pitch2, pitch3],
55                ))?;
56            }
57        }
58        Ok(())
59    };
60    add_bar(
61        compute_pitch(NN::G, Acc::Natural, 4)?,
62        compute_pitch(NN::C, Acc::Natural, 5)?,
63        compute_pitch(NN::E, Acc::Natural, 5)?,
64    )?;
65    add_bar(
66        compute_pitch(NN::A, Acc::Natural, 4)?,
67        compute_pitch(NN::D, Acc::Natural, 5)?,
68        compute_pitch(NN::F, Acc::Natural, 5)?,
69    )?;
70    add_bar(
71        compute_pitch(NN::G, Acc::Natural, 4)?,
72        compute_pitch(NN::D, Acc::Natural, 5)?,
73        compute_pitch(NN::F, Acc::Natural, 5)?,
74    )?;
75    add_bar(
76        compute_pitch(NN::G, Acc::Natural, 4)?,
77        compute_pitch(NN::C, Acc::Natural, 5)?,
78        compute_pitch(NN::E, Acc::Natural, 5)?,
79    )?;
80    add_bar(
81        compute_pitch(NN::A, Acc::Natural, 4)?,
82        compute_pitch(NN::E, Acc::Natural, 5)?,
83        compute_pitch(NN::A, Acc::Natural, 5)?,
84    )?;
85    add_bar(
86        compute_pitch(NN::F, Acc::Sharp, 4)?,
87        compute_pitch(NN::A, Acc::Natural, 4)?,
88        compute_pitch(NN::D, Acc::Natural, 5)?,
89    )?;
90    add_bar(
91        compute_pitch(NN::G, Acc::Natural, 4)?,
92        compute_pitch(NN::D, Acc::Natural, 5)?,
93        compute_pitch(NN::G, Acc::Natural, 5)?,
94    )?;
95    add_bar(
96        compute_pitch(NN::E, Acc::Natural, 4)?,
97        compute_pitch(NN::G, Acc::Natural, 4)?,
98        compute_pitch(NN::C, Acc::Natural, 5)?,
99    )?;
100    add_bar(
101        compute_pitch(NN::E, Acc::Natural, 4)?,
102        compute_pitch(NN::G, Acc::Natural, 4)?,
103        compute_pitch(NN::C, Acc::Natural, 5)?,
104    )?;
105    Ok(right_hand)
106}
107
108fn left_hand_low_note() -> Result<Phrase> {
109    let mut lhln = Phrase::new();
110    let mut add_bar = |pitch: u7| -> Result<()> {
111        for _ in 0..=1 {
112            lhln.add_note(Note::new(pitch, MINIM, MF)?);
113        }
114        Ok(())
115    };
116    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
117    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
118    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
119    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
120    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
121    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
122    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
123    add_bar(compute_pitch(NN::B, Acc::Natural, 3)?)?;
124    add_bar(compute_pitch(NN::A, Acc::Natural, 3)?)?;
125
126    Ok(lhln)
127}
128
129fn left_hand_high_note() -> Result<Phrase> {
130    let mut lhhn = Phrase::new();
131    let mut add_bar = |pitch: u7| -> Result<()> {
132        for _ in 0..=1 {
133            lhhn.add_rest(SEMIQUAVER);
134            lhhn.add_note(Note::new(pitch, DOTTED_QUAVER + CROTCHET, MF)?);
135        }
136        Ok(())
137    };
138    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
139    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
140    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
141    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
142    add_bar(compute_pitch(NN::E, Acc::Natural, 4)?)?;
143    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
144    add_bar(compute_pitch(NN::D, Acc::Natural, 4)?)?;
145    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
146    add_bar(compute_pitch(NN::C, Acc::Natural, 4)?)?;
147
148    Ok(lhhn)
149}
Source

pub fn entries(&self) -> &[PhraseEntry]

Returns the Phrase’s Vec of notes

Source

pub fn name(&self) -> &str

Returns the Phrase’s name

Source

pub fn duration(&self) -> f64

Trait Implementations§

Source§

impl Clone for Phrase

Source§

fn clone(&self) -> Phrase

Returns a duplicate of the value. Read more
1.0.0 · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for Phrase

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Default for Phrase

Source§

fn default() -> Phrase

Returns the “default value” for a type. Read more
Source§

impl PartialEq for Phrase

Source§

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

Tests for self and other values to be equal, and is used by ==.
1.0.0 · Source§

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

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

impl StructuralPartialEq for Phrase

Auto Trait Implementations§

§

impl Freeze for Phrase

§

impl RefUnwindSafe for Phrase

§

impl Send for Phrase

§

impl Sync for Phrase

§

impl Unpin for Phrase

§

impl UnwindSafe for Phrase

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.