Struct minstrel::Note

pub struct Note {
    pub value: usize,
}

A note, represented as a single positive integer (called it's value). A value of 0 = C0, 1 = Db0 etc.

You can create a Note by either parsing from a string or directly inputting a number value:

use minstrel::Note;
use std::str::FromStr;

// Directly
let A0 = Note::new(9);

// From a string
let Eb100 = Note::from_str("Eb100");

Notes have a number of useful features. For example, you can easily transpose one by using the addition or subtraction operators:

use minstrel::Note;

let C1 = Note::new(12);
assert_eq!(C1 + 5, Note::new(17));
assert_eq!(C1 - 2, Note::new(10));

You can also get the semitone difference between two Notes just by subtracting them:

use minstrel::Note;

let C0 = Note::new(0);
let E0 = Note::new(4);

// It doesn't matter which order the notes are in
assert_eq!(C0 - E0, 4);
assert_eq!(E0 - C0, 4);

Finally, you can call into_iter on a Note to iterate over it:

use minstrel::Note;

// Prints the chromatic scale
for note in Note::new(0).into_iter().take(12) {
   println!("{}", note);
}

Fields

value: usize

Implementations

impl Note

pub fn new(value: usize) -> Self

Creates a new Note with the given value.

Examples

use minstrel::Note;

let C0 = Note::new(0);
let F4 = Note::new(53);
let Ab5 = Note::new(68);

pub fn disregard_octave(self) -> Self

Returns a new Note where the inner value holds no octave information i.e. it is constrained between 0 and 11.

Examples

use minstrel::Note;

let F = Note::new(53).disregard_octave();

let Ab5 = Note::new(68);
let Ab = Ab5.disregard_octave();

Trait Implementations

impl Add<usize> for Note

type Output = Self

The resulting type after applying the + operator.

fn add(self, semitones: usize) -> Self::Output

Performs the + operation.

impl Clone for Note

fn clone(&self) -> Note

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for Note

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 Eq for Note

impl FromStr for Note

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl IntoIterator for Note

type Item = Self

The type of the elements being iterated over.

type IntoIter = NoteIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl PartialEq<Note> for Note

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl StructuralEq for Note

impl StructuralPartialEq for Note

impl Sub<Note> for Note

type Output = usize

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<usize> for Note

type Output = Self

The resulting type after applying the - operator.

fn sub(self, semitones: usize) -> Self::Output

Performs the - operation.