Enum Rule 

pub enum Rule {
    PitchSet {
        offsets: Vec<u8>,
        colour: Vec<u8>,
        giveaway: Vec<u8>,
    },
    Tonic {},
    ChordTones {
        offsets: Vec<u8>,
        choose: Option<Choose>,
    },
    Voicing(Box<VoicingRule>),
    Cycle {
        roots: Vec<u8>,
        chords: Vec<String>,
        bars_per_chord: Option<f64>,
    },
    OnsetSet {
        parts: Vec<PartSlots>,
    },
    OnsetShare {
        slots: Vec<u8>,
        min_share: f64,
    },
    CountPerBar {
        min: u8,
        max: u8,
    },
    Length {
        unit: LengthUnit,
        min: Option<f64>,
        max: Option<f64>,
    },
    Velocity {
        min: u8,
        max: u8,
    },
    Overlap {
        min_ms: f64,
    },
    Swing {
        note: u8,
        min_pct: f64,
        max_pct: f64,
    },
    Shift {
        min_ms: f64,
        max_ms: f64,
    },
    Jitter {
        max_ms: f64,
        velocity: u8,
    },
    Register {
        core: [u8; 2],
        hard: [u8; 2],
        voice: Voice,
    },
    Pattern {
        k: u8,
        n: u8,
        rotation: u8,
    },
    Arp {
        order: ArpOrder,
        rate: f64,
        gate: Option<[u8; 2]>,
        degrees: Vec<u8>,
    },
    Repeat {
        min_share: Option<f64>,
        max_share: Option<f64>,
        min_bars: Option<u8>,
    },
    PhraseLength {
        every: Vec<u8>,
    },
    None {},
}

The checkable note rule of an entry. The kind list is fixed; free text is rejected.

Variants

PitchSet

Every pitch class lies in offsets above the root.

Fields

offsets: Vec<u8>

Semitones above the root.

colour: Vec<u8>

Offsets a line shows at least once per 4 bars to claim the scale.

giveaway: Vec<u8>

Offsets that name a neighbouring scale instead.

Tonic

The first or last note of a phrase, or the held bass note, is the root.

ChordTones

The chord holds these tones above its root.

Fields

offsets: Vec<u8>

Semitones above the chord root; 14 is a ninth.

choose: Option<Choose>

Tones of which at least some must also sound.

Voicing(Box<VoicingRule>)

The spacing of a chord, or the motion between chords.

Cycle

A chord loop: roots above the tonic and a chord per root.

Fields

roots: Vec<u8>

Semitones above the tonic, one per chord.

chords: Vec<String>

Chord entry ids, one per root.

bars_per_chord: Option<f64>

Bars per chord, when the entry fixes it.

OnsetSet

Onsets fall on these slots, per part.

Fields

parts: Vec<PartSlots>

The slots of each part.

OnsetShare

At least min_share of the onsets fall on slots.

Fields

slots: Vec<u8>

The slots that count.

min_share: f64

The smallest share, 0 to 1.

CountPerBar

The number of notes per bar.

Fields

min: u8

The fewest notes.

max: u8

The most notes.

Length

The sounding length, len times gate.

Fields

unit: LengthUnit

Beats, or a share of the grid step.

min: Option<f64>

The shortest length.

max: Option<f64>

The longest length.

Velocity

The velocity band.

Fields

min: u8

The lowest velocity.

max: u8

The highest velocity.

Overlap

The next note starts before this one ends.

Fields

min_ms: f64

The smallest overlap in ms.

Swing

The second note of each pair starts late.

Fields

note: u8

16 for a pair of sixteenths, 8 for a pair of eighths.

min_pct: f64

The lowest pair percent.

max_pct: f64

The highest pair percent.

Shift

Every onset moves by the same amount, late positive.

Fields

min_ms: f64

The smallest shift in ms.

max_ms: f64

The largest shift in ms.

Jitter

Onsets and velocities vary at random.

Fields

max_ms: f64

The largest onset deviation in ms.

velocity: u8

The largest velocity deviation.

Register

The pitch range and default voice of a role.

Fields

core: [u8; 2]

Where most notes sit, inclusive.

hard: [u8; 2]

The limits outside which a note is rejected, inclusive.

voice: Voice

Mono, poly or either.

Pattern

A Euclidean pattern: k onsets spread over n steps.

Fields

k: u8

Onsets.

n: u8

Steps.

rotation: u8

Steps the pattern is turned by.

Arp

Chord notes one per step.

Fields

order: ArpOrder

The play order.

rate: f64

Beats per step.

gate: Option<[u8; 2]>

The gate range in percent of the step.

degrees: Vec<u8>

sequence: chord degrees in play order.

Repeat

Bars identical to an earlier bar.

Fields

min_share: Option<f64>

The smallest share of identical bars.

max_share: Option<f64>

The largest share of identical bars.

min_bars: Option<u8>

The fewest bars the repetition lasts.

PhraseLength

Change events fall on bars 1 + k * every.

Fields

every: Vec<u8>

The bar counts between changes.

None

The word names no note rule.

Implementations

impl Rule

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

The kind name, as in the data.

Trait Implementations

impl Clone for Rule

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Rule

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Rule

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Rule

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Rule

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 Rule