Enum Notation 

pub enum Notation {
    Chord(Chord),
    Scale(Scale),
    Mode(Mode),
}

A unified notation type that can represent a chord, scale, or mode.

This type attempts to parse input in the following order:

1. Scale (most distinctive keywords like “major pentatonic”, “harmonic minor”)
2. Mode (keywords like “dorian”, “lydian”)
3. Chord (fallback, most flexible grammar)

Examples

use klib::core::base::Parsable;
use klib::core::notation::Notation;

// Parses as a scale
let notation = Notation::parse("C major pentatonic").unwrap();
assert!(notation.is_scale());

// Parses as a mode
let notation = Notation::parse("D dorian").unwrap();
assert!(notation.is_mode());

// Parses as a chord
let notation = Notation::parse("Cmaj7").unwrap();
assert!(notation.is_chord());

Variants

Chord(Chord)

A chord notation.

Scale(Scale)

A scale notation.

Mode(Mode)

A mode notation.

Implementations

impl Notation

pub fn is_chord(&self) -> bool

Returns true if this notation is a chord.

pub fn is_scale(&self) -> bool

Returns true if this notation is a scale.

pub fn is_mode(&self) -> bool

Returns true if this notation is a mode.

pub fn as_chord(&self) -> Option<&Chord>

Returns a reference to the inner chord, if this is a chord.

pub fn as_scale(&self) -> Option<&Scale>

Returns a reference to the inner scale, if this is a scale.

pub fn as_mode(&self) -> Option<&Mode>

Returns a reference to the inner mode, if this is a mode.

pub fn into_chord(self) -> Option<Chord>

Consumes the notation and returns the inner chord, if this is a chord.

pub fn into_scale(self) -> Option<Scale>

Consumes the notation and returns the inner scale, if this is a scale.

pub fn into_mode(self) -> Option<Mode>

Consumes the notation and returns the inner mode, if this is a mode.

pub fn notes(&self) -> Vec<Note>

Returns the notes of this notation.

For chords, this returns the chord voicing. For scales and modes, this returns the scale/mode degrees.

pub fn kind(&self) -> &'static str

Returns a static string describing what kind of notation this is.

pub fn parse_with_type(symbol: &str, notation_type: Option<&str>) -> Res<Self>

Parses a symbol into a Notation, optionally forcing a specific type.

If notation_type is Some, it must be one of "chord", "scale", or "mode". If None, auto-detection is used (scale → mode → chord priority).

Examples

use klib::core::notation::Notation;

// Auto-detect
let notation = Notation::parse_with_type("D dorian", None).unwrap();
assert!(notation.is_mode());

// Force chord interpretation
let notation = Notation::parse_with_type("C", Some("chord")).unwrap();
assert!(notation.is_chord());

pub fn format_verbose(&self) -> String

Returns a verbose string representation of this notation.

For chords, this includes recommended scales/modes. For scales and modes, this is equivalent to Display.

Trait Implementations

impl Clone for Notation

fn clone(&self) -> Notation

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Notation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Notation

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Notation

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

Formats the value using the given formatter.

impl Eq for Notation

impl From<Chord> for Notation

fn from(chord: Chord) -> Self

Converts to this type from the input type.

impl From<Mode> for Notation

fn from(mode: Mode) -> Self

Converts to this type from the input type.

impl From<Scale> for Notation

fn from(scale: Scale) -> Self

Converts to this type from the input type.

impl HasDescription for Notation

fn description(&self) -> &'static str

Returns the description of the type.

impl HasIntervals for Notation

fn intervals(&self) -> &'static [Interval]

Returns the intervals of the type.

impl HasName for Notation

fn name(&self) -> String

Returns the computed name of the type.

fn name_ascii(&self) -> String

Returns the computed name of the type in ASCII.

impl HasPreciseName for Notation

fn precise_name(&self) -> String

Returns the computed name of the type.

impl HasRoot for Notation

fn root(&self) -> Note

Returns the root note of the implementor (most likely a Chord).

impl Parsable for Notation

fn parse(input: &str) -> Res<Self>

where Self: Sized,

Attempts to parse the input as a scale, then a mode, then a chord.

The order is intentional: scales have the most distinctive keywords, modes have specific keywords, and chords are the fallback.

impl PartialEq for Notation

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Notation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Notation