Enum redact_composer_musical::ChordShape

pub enum ChordShape {
    maj,
    maj6,
    maj6_9,
    maj7,
    maj9,
    maj11,
    maj13,
    min,
    min6,
    min7,
    min_M7,
    min9,
    min11,
    min13,
    dom7,
    dom9,
    dom11,
    dom13,
    dim,
    dim7,
    min7_b5,
    aug,
    aug7,
    sus2,
    sus4,
    sus4_7,
    add9,
    add11,
}

Chord types as interval collections.

Variants

maj

Major

use redact_composer_musical::Interval as I;
assert_eq!(maj.intervals(), vec![I::P1, I::M3, I::P5]);

maj6

Major 6th

use redact_composer_musical::Interval as I;
assert_eq!(maj6.intervals(), vec![I::P1, I::M3, I::P5, I::M6]);

maj6_9

Major 6/9

use redact_composer_musical::Interval as I;
assert_eq!(maj6_9.intervals(), vec![I::P1, I::M3, I::P5, I::M6, I::M9]);

maj7

Major 7th

use redact_composer_musical::Interval as I;
assert_eq!(maj7.intervals(), vec![I::P1, I::M3, I::P5, I::M7]);

maj9

Major 9th

use redact_composer_musical::Interval as I;
assert_eq!(maj9.intervals(), vec![I::P1, I::M3, I::P5, I::M7, I::M9]);

maj11

Major 11th

use redact_composer_musical::Interval as I;
assert_eq!(maj11.intervals(), vec![I::P1, I::M3, I::P5, I::M7, I::M9, I::P11]);

maj13

Major 13th

use redact_composer_musical::Interval as I;
assert_eq!(maj13.intervals(), vec![I::P1, I::M3, I::P5, I::M7, I::M9, I::P11, I::M13]);

min

Minor

use redact_composer_musical::Interval as I;
assert_eq!(min.intervals(), vec![I::P1, I::m3, I::P5]);

min6

Minor 6th

use redact_composer_musical::Interval as I;
assert_eq!(min6.intervals(), vec![I::P1, I::m3, I::P5, I::M6]);

min7

Minor 7th

use redact_composer_musical::Interval as I;
assert_eq!(min7.intervals(), vec![I::P1, I::m3, I::P5, I::m7]);

min_M7

Minor Major 7th

use redact_composer_musical::Interval as I;
assert_eq!(min_M7.intervals(), vec![I::P1, I::m3, I::P5, I::M7]);

min9

Minor 9th

use redact_composer_musical::Interval as I;
assert_eq!(min9.intervals(), vec![I::P1, I::m3, I::P5, I::m7, I::M9]);

min11

Minor 11th

use redact_composer_musical::Interval as I;
assert_eq!(min11.intervals(), vec![I::P1, I::m3, I::P5, I::m7, I::M9, I::P11]);

min13

Minor 13th

use redact_composer_musical::Interval as I;
assert_eq!(min13.intervals(), vec![I::P1, I::m3, I::P5, I::m7, I::M9, I::P11, I::M13]);

dom7

Dominant 7

use redact_composer_musical::Interval as I;
assert_eq!(dom7.intervals(), vec![I::P1, I::M3, I::P5, I::m7]);

dom9

Dominant 9

use redact_composer_musical::Interval as I;
assert_eq!(dom9.intervals(), vec![I::P1, I::M3, I::P5, I::m7, I::M9]);

dom11

Dominant 11

use redact_composer_musical::Interval as I;
assert_eq!(dom11.intervals(), vec![I::P1, I::M3, I::P5, I::m7, I::M9, I::P11]);

dom13

Dominant 13

use redact_composer_musical::Interval as I;
assert_eq!(dom13.intervals(), vec![I::P1, I::M3, I::P5, I::m7, I::M9, I::P11, I::M13]);

dim

Diminished

use redact_composer_musical::Interval as I;
assert_eq!(dim.intervals(), vec![I::P1, I::m3, I::d5]);

dim7

Diminished 7

use redact_composer_musical::Interval as I;
assert_eq!(dim7.intervals(), vec![I::P1, I::m3, I::d5, I::d7]);

min7_b5

Half Diminished (min7 with flat 5)

use redact_composer_musical::Interval as I;
assert_eq!(min7_b5.intervals(), vec![I::P1, I::m3, I::d5, I::m7]);

aug

Augmented

use redact_composer_musical::Interval as I;
assert_eq!(aug.intervals(), vec![I::P1, I::M3, I::A5]);

aug7

Augmented 7

use redact_composer_musical::Interval as I;
assert_eq!(aug7.intervals(), vec![I::P1, I::M3, I::A5, I::m7]);

sus2

Suspended 2

use redact_composer_musical::Interval as I;
assert_eq!(sus2.intervals(), vec![I::P1, I::M2, I::P5]);

sus4

Suspended 4

use redact_composer_musical::Interval as I;
assert_eq!(sus4.intervals(), vec![I::P1, I::P4, I::P5]);

sus4_7

Suspended 4 w/ m7

use redact_composer_musical::Interval as I;
assert_eq!(sus4_7.intervals(), vec![I::P1, I::P4, I::P5, I::m7]);

add9

Add 9

use redact_composer_musical::Interval as I;
assert_eq!(add9.intervals(), vec![I::P1, I::M3, I::P5, I::M9]);

add11

Add 11

use redact_composer_musical::Interval as I;
assert_eq!(add11.intervals(), vec![I::P1, I::M3, I::P5, I::P11]);

Implementations

impl ChordShape

pub fn all() -> Vec<ChordShape>

All chord shapes.

pub fn triad() -> Vec<ChordShape>

Basic triad shapes.

pub fn simple() -> Vec<ChordShape>

Simple chord shapes which fit into a single octave.

pub fn jazz() -> Vec<ChordShape>

Chord shapes spanning two octaves.

pub fn major() -> Vec<ChordShape>

Major chord shapes.

pub fn minor() -> Vec<ChordShape>

Minor chord shapes.

pub fn diminished() -> Vec<ChordShape>

Diminished chord shapes.

pub fn augmented() -> Vec<ChordShape>

Augmented chord shapes.

pub fn suspended() -> Vec<ChordShape>

Suspended chord shapes.

Trait Implementations

impl Clone for ChordShape

fn clone(&self) -> ChordShape

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for ChordShape

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

Formats the value using the given formatter.

impl IntervalCollection for ChordShape

fn intervals(&self) -> Vec<Interval>

Provides a collection of intervals, each as an absolute interval from a relative pitch.

impl PartialEq for ChordShape

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for ChordShape

impl Eq for ChordShape

impl StructuralPartialEq for ChordShape