Enum weresocool_ast::ast::Op

pub enum Op {
    AsIs,
    Id(String),
    Tag(String),
    CSV1d {
        path: String,
        scale: Option<Rational64>,
    },
    CSV2d {
        path: String,
        scales: Vec<Scale>,
    },
    Lowpass {
        hash: String,
        cutoff_frequency: Rational64,
        q_factor: Rational64,
    },
    Highpass {
        hash: String,
        cutoff_frequency: Rational64,
        q_factor: Rational64,
    },
    Bandpass {
        hash: String,
        cutoff_frequency: Rational64,
        q_factor: Rational64,
    },
    FunctionCall {
        name: String,
        args: Vec<Term>,
    },
    Lambda {
        input_name: Option<String>,
        term: Box<Term>,
        scope: String,
    },
    Noise,
    Saw,
    Sine {
        pow: Option<Rational64>,
    },
    Triangle {
        pow: Option<Rational64>,
    },
    Square {
        width: Option<Rational64>,
    },
    AD {
        attack: Rational64,
        decay: Rational64,
        asr: ASR,
    },
    Portamento {
        m: Rational64,
    },
    Reverse,
    FInvert,
    Silence {
        m: Rational64,
    },
    TransposeM {
        m: Rational64,
    },
    TransposeA {
        a: Rational64,
    },
    PanM {
        m: Rational64,
    },
    PanA {
        a: Rational64,
    },
    Gain {
        m: Rational64,
    },
    Length {
        m: Rational64,
    },
    Reverb {
        m: Option<Rational64>,
    },
    Sequence {
        operations: Vec<Term>,
    },
    Overlay {
        operations: Vec<Term>,
    },
    Compose {
        operations: Vec<Term>,
    },
    ModulateBy {
        operations: Vec<Term>,
    },
    WithLengthRatioOf {
        main: Option<Box<Term>>,
        with_length_of: Box<Term>,
    },
    Focus {
        name: String,
        main: Box<Term>,
        op_to_apply: Box<Term>,
    },
}

Variants

AsIs

Id(String)

Tag(String)

CSV1d

Fields

path: String

scale: Option<Rational64>

CSV2d

Fields

path: String

scales: Vec<Scale>

Lowpass

Fields

hash: String

cutoff_frequency: Rational64

q_factor: Rational64

Highpass

Fields

hash: String

cutoff_frequency: Rational64

q_factor: Rational64

Bandpass

Fields

hash: String

cutoff_frequency: Rational64

q_factor: Rational64

FunctionCall

Fields

name: String

args: Vec<Term>

Lambda

Fields

input_name: Option<String>

term: Box<Term>

scope: String

Noise

Saw

Sine

Fields

pow: Option<Rational64>

Triangle

Fields

pow: Option<Rational64>

Square

Fields

width: Option<Rational64>

AD

Fields

attack: Rational64

decay: Rational64

asr: ASR

Portamento

Fields

m: Rational64

Reverse

FInvert

Silence

Fields

m: Rational64

TransposeM

Fields

m: Rational64

TransposeA

Fields

a: Rational64

PanM

Fields

m: Rational64

PanA

Fields

a: Rational64

Gain

Fields

m: Rational64

Length

Fields

m: Rational64

Reverb

Fields

m: Option<Rational64>

Sequence

Fields

operations: Vec<Term>

Overlay

Fields

operations: Vec<Term>

Compose

Fields

operations: Vec<Term>

ModulateBy

Fields

operations: Vec<Term>

WithLengthRatioOf

Fields

main: Option<Box<Term>>

with_length_of: Box<Term>

Focus

Fields

name: String

main: Box<Term>

op_to_apply: Box<Term>

Trait Implementations

impl Clone for Op

fn clone(&self) -> Op

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Op

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

Formats the value using the given formatter.

impl GetLengthRatio<Term> for Op

fn get_length_ratio( &self, normal_form: &NormalForm, defs: &mut Defs<Term> ) -> Result<Rational64, Error>

impl Hash for Op

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Normalize<Term> for Op

fn apply_to_normal_form( &self, input: &mut NormalForm, defs: &mut Defs<Term> ) -> Result<(), Error>

impl PartialEq<Op> for Op

fn eq(&self, other: &Op) -> 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 Substitute<Term> for Op

fn substitute( &self, normal_form: &mut NormalForm, defs: &mut Defs<Term> ) -> Result<Term, Error>

impl StructuralPartialEq for Op