How I would like to define audio plugins

audio_dsl.swift

// first, let's define some types.
// many of these would be built into a framework 
// and the user can just use them

type PoleType : EnumDefinition {
    LowPass = 0
    LowShelf = 1
    HighPass = 2
    HighShelf = 3
    Peak = 4
}

// the extern keyword signifies that 
// the C++ side may define more properties or functions on these types
// which can be called by the C++ implementation of other types.
// they have to be defined in the script so the compiler knows about their interface
extern type NumberProvider
extern type ValueStringConverter
extern type DefaultValueStringConverter : ValueStringConverter

type Parameter {
    min: number | NumberProvider
    max: number | NumberProvider
    default: number | NumberProvider
    unit?: string
    converter: ValueStringConverter = DefaultValueStringConverter // default impl which appends unit
}

// these are all implemented in C++
extern type EnumMinProvider : NumberProvider {
    def: EnumDefinition
}
extern type EnumMaxProvider : NumberProvider {
    def: EnumDefinition
}
extern type EnumDefaultProvider : NumberProvider {
    def: EnumDefinition
}
extern type EnumStringConverter : ValueStringConverter {
    def: EnumDefinition
}

type EnumParameter = Parameter {
    enum: EnumDefinition

    min = EnumMinProvider { def = enum } 
    max = EnumMaxProvider { def = enum } 
    default = EnumDefaultProvider { def = enum }
    converter = EnumStringConverter { def = enum }
}

extern type SlopeStringConverter : ValueStringConverter
type SlopeParameter = Parameter {
    min = 1
    max = 4
    default = 1
    converter = SlopeStringConverter
}

extern type Eq : Effect {
    type: NumberProvider
    cutoff: NumberProvider
    slope: NumberProvider
}

params = Parameters {
    type = EnumParameter {
        id = 1
        enum = PoleType
        default = Peak
    }

    cutoff = Parameter {
        id = 2
        min = 20
        max = 20000
        default = 1000
        unit = "hz"
    }

    slope = SlopeParameter {
        id = 3

        // default values inherited by type can be overridden
        max = 6
        default = 2
    }
}

extern type LockFreeQueueProvider // defined as an interface in C++

// builtin type.
// every type has lifecycle hooks that can be implemented in C++,
// therefore a LockFreeQueue will create a queue object internally
// when its constructed 
extern type LockFreeQueue : LockFreeQueueProvider{
    capacity: number = 1024
}

extern type LockFreeQueue : LockFreeQueueProvider

extern type ParamsToUiSender {
    queue: LockFreeQueueProvider
}

extern type ParamsToUiReceiver {
    queue: LockFreeQueueProvider
}

// instantiation of a type with default arguments
parameterQueue = LockFreeQueue

extern type BiasCutoffProvider : NumberProvider

// now we can define our processor and UI

Processor {
    // in C++, it is defined that Eq type hooks 
    // into the parent processor's events
    Eq {
        type = params.type
        cutoff = params.cutoff
        slope = params.slope
    }

    // add some fixed bias
    Eq {
        type = Peak
        cutoff = BiasCutoffProvider { parameter = params.cutoff } // defined and implemented in C++
    }

    // sync params with UI
    ParamsToUiSender {
        queue = parameterQueue
    }
}

extern type MyProjectWebUiSource : WebPageSource

WebUi {
    pageSource = MyProjectWebUiSource

    // additional objects that are added as children 
    // receive the parent UI's callbacks (such as main loop timer etc)
    ParamsToUiReceiver {
        queue = parameterQueue
    }
}