@startuml "bliplib class diagram"

left to right direction
skinparam linetype ortho

package std {
    interface From<T> {
        from(value: T): Self
    }
}

package nom {
    interface Parser<I>
}

package fasteval {
    enum Instruction
}

package parser {
    interface TokenParser<I>
    struct ParserParametters<'n, 's, 'v, I: Input + Clone + nom::Compare<I>, C: Into<char>> {
        +notes: &'n [I]
        +slopes: &'s HashMap<I, VariableChange>
        +variables: &'v [C]
    }
    struct Parser<'i, 'n, 's, 'v, I: Input + Clone, C: Into<char>> {
        -input: &'i I
        -parametters: ParserParametters<'n, 's, 'v, I, C>
        +parse_all(): Result<Vec<Box<dyn Token>>, nom::Error<nom_locate::LocatedSpan<&'i I>>>
    }
    struct ParserBuilder<'i, 'n, 's, 'v, I: Input + Clone, C: Into<char>> {
        -input: Option<&'i I>
        -notes: Option<&'n [I]>
        -slopes: Option<&'s HashMap<I, VariableChange>>
        -variables: Option<&'v [C]>
        +input(self, input: &'i I): Self
        +notes(self, notes: &'n [I]): Self
        +slopes(self, slopes: &'s HashMap<I, VariableChange>): Self
        +variables(self, variables: &'v [C]): Self
    }
}

package compiler {
    interface Token {
        -apply(&self, context: Context): Context
    }
    struct Silence {
        -parser<I>(): impl TokenParser<I>
    }
    struct Marker {
        -parser<I>(): impl TokenParser<I>
    }
    struct Note {
        +n: u8
        -parser<'a, I: nom::Input + nom::Compare<I> + Clone>(notes: &'a [I]): impl TokenParser<I>
    }
    struct VariableChange {
        +name: char,
        +change: Instruction
        -parser<'a, I, C: Into<char> + Clone>(variables: &'a [C]): impl TokenParser<I>
    }
    struct Loop {
        +times: usize
        +inner: Vec<Box<dyn Token>>
        -parser<'n, 's, 'v, I: Input + Clone + nom::Compare<I>, C: Into<char>>(parametters: ParserParametters<'n, 's, 'v, I, C>): impl TokenParser<I>
    }
    struct Tuplet {
        +inner: Vec<Box<dyn Token>>
        -parser<'n, 's, 'v, I: Input + Clone + nom::Compare<I>, C: Into<char>>(parametters: ParserParametters<'n, 's, 'v, I, C>): impl TokenParser<I>
    }
    struct Slope {
        +inner: Vec<Box<dyn Token>>
        +each_frame: VariableChange
        -parser<'n, 's, 'v, I: Input + Clone + nom::Compare<I>, C: Into<char>>(parametters: ParserParametters<'n, 's, 'v, I, C>): impl TokenParser<I>
    }
    struct Context {
        +result: Vec<f64>
        +variables: HashMap<char, f64>
        +instrument: Instruction
        +slopes: HashMap<char, Instruction>
        +current_length(&self): f64
        +render(&self, n: Option<u8>): Vec<f64>
    }
}

compiler.Silence ..|> Token
compiler.Marker ..|> Token
compiler.Note ..|> Token
compiler.VariableChange ..|> Token
compiler.Loop ..|> Token
compiler.Tuplet ..|> Token
compiler.Slope ..|> Token
compiler.Token --> parser.Parser
parser.Parser --> VariableChange
parser.ParserBuilder --> VariableChange

compiler.Loop --> ParserParametters
compiler.Tuplet --> ParserParametters
compiler.Slope --> ParserParametters

compiler.Silence --> TokenParser
compiler.Marker --> TokenParser
compiler.Note --> TokenParser
compiler.VariableChange --> TokenParser
compiler.Loop --> TokenParser
compiler.Tuplet --> TokenParser
compiler.Slope --> TokenParser

interface "From<ParserBuilder>" as from_parserbuilder
interface "nom::Parser<nom_locate::LocatedSpan<&'i I>>" as nomparser_locatedspan

from_parserbuilder --> parser.ParserBuilder
from_parserbuilder --> parser.ParserParametters
from_parserbuilder --|> std.From
nomparser_locatedspan --|> nom.Parser
parser.Parser --> nomparser_locatedspan
parser.Parser ..|> from_parserbuilder
parser.TokenParser --|> nomparser_locatedspan: Output = Self, Error = nom::Err<nom::Error<nom_locate::LocatedSpan<&'i I>
nomparser_locatedspan ..|> parser.TokenParser: for any T
compiler.Slope --> compiler.VariableChange
compiler.Token --> compiler.Context
compiler.VariableChange --> Instruction
Context --> Instruction

@enduml