rust_music

Struct Note

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

Represents a music note, with a pitch, a rhythm, and a dynamic (volume)

Implementations§

Source§

impl Note

Source

pub fn new(pitch: u7, rhythm: f64, dynamic: u7) -> Result<Note>

Returns a Note with the given rhythm, pitch, and dynamic

§Arguments
  • pitch - The pitch of the note (between 0 and 127)
  • rhythm - The rhythm value of the note
  • dynamic - The dynamic (volume) of the note
§Errors
  • Error::Note(Invalid::Rhythm) if rhythm is below 0.000_001
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}
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 new_sequence<'a, PitchIter: IntoIterator<Item = u7> + 'a>( rhythm: f64, dynamic: u7, pitches: PitchIter, ) -> impl Iterator<Item = Result<Note>> + 'a

Creates an iterator of notes with idential rhythms and dynamic which can be added directly to a phrase using phrase.add_sequential_notes to be played sequentially or collected as a vector to use in a Chord.

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}
More examples
Hide additional examples
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}
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 pitch(&self) -> u7

Returns the pitch of the note

Source

pub fn rhythm(&self) -> f64

Returns the rhythm value of the note

Source

pub fn dynamic(&self) -> u7

Returns the dynamic value of the note

Source

pub fn pitch_info(&self, sharps: bool) -> (NoteName, Accidental, u8)

Returns the note name, accidental, and octave of the Note’s pitch

§Arguments
  • pitch: pitch to analyse
  • sharps: specifies if an accidental should be returned as a sharp (if false, an accidentals will be returned as a flat). This does not affect naturals.

Trait Implementations§

Source§

impl Clone for Note

Source§

fn clone(&self) -> Note

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 Note

Source§

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

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

impl Default for Note

Source§

fn default() -> Note

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

impl PartialEq for Note

Source§

fn eq(&self, other: &Note) -> 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 Note

Auto Trait Implementations§

§

impl Freeze for Note

§

impl RefUnwindSafe for Note

§

impl Send for Note

§

impl Sync for Note

§

impl Unpin for Note

§

impl UnwindSafe for Note

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.