Struct mumuse::music::chord::Chord

pub struct Chord {
    pub notes: Vec<Note>,
}

A Chord contains a vector of Notes

Fields

notes: Vec<Note>

Implementations

impl Chord

pub fn new(notes: Vec<Note>) -> Self

Creates a new Chord from a vector of Note.

Examples

Basic usage:

use mumuse::music::chord::Chord;
use mumuse::music::note::Note;
let n = Note::try_from("A3").unwrap();
let t = Chord::new(vec![n, n]);

pub fn invert(&self, inversion: usize) -> Self

Invert a chord in natural order.

Inversion wrap around the length of the chord.

Examples

Basic usage:

use mumuse::music::note::Note;
let n = Note::try_from("A3").unwrap();
let c = n.chord("maj").invert(2);

Trait Implementations

impl Add<Interval> for Chord

Overload operator + for Chord + Interval

Examples

Basic usage:

use mumuse::music::note::Note;
use mumuse::music::common::Interval;
let n = Note::try_from("A3").unwrap();
let c = n.chord("maj");
let c_ = c + Interval::MinorSecond;

type Output = Chord

The resulting type after applying the + operator.

fn add(self, rhs: Interval) -> Chord

Performs the + operation.

impl Clone for Chord

fn clone(&self) -> Chord

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Chord

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

Formats the value using the given formatter.

impl Default for Chord

fn default() -> Chord

Returns the “default value” for a type.

impl Display for Chord

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

Formats the value using the given formatter.

impl From<Vec<&'_ str, Global>> for Chord

fn from(notes: Vec<&str>) -> Self

Performs the conversion.

impl MidiSend for Chord

fn send_midi_with_duration(
    &self,
    conn_out: &mut MidiOutputConnection,
    duration: u64,
    velocity: u8
)

fn send_midi(&self, status: Status, conn_out: &mut MidiOutputConnection)

impl Sub<Interval> for Chord

Overload operator - for Chord - Interval

Examples

Basic usage:

use mumuse::music::note::Note;
use mumuse::music::common::Interval;
let n = Note::try_from("A3").unwrap();
let c = n.chord("maj");
let c_ = c - Interval::MinorSecond;

type Output = Chord

The resulting type after applying the - operator.

fn sub(self, rhs: Interval) -> Chord

Performs the - operation.