Operators are very slow

[arnfaldur]

I'm using SignalOperators.jl in a jupyter notebook to experiment with music composition and noticed that it tends to be unusably slow.
I suspect that the lazy evaluation is the culprit but am not sure.

play(signal) = sink(signal |> ToFramerate(44.1kHz) |> Amplify(-10dB), SampleBuf)
note(freq, dur, vol=-10dB) = Signal(sin, ω=freq) |> Until(dur) |> Ramp(dur/16)

sequence(freqs, dur::Number=(1/8)s) = Append([note(freq, dur) for freq in freqs]...)
melodify(root,ratios) = [root*ratio for ratio in ratios]

root = 220Hz
@time play(sequence(melodify(root, repeat([1, 3/2, 15/16, 1, 1, 3/2, 15/16, 255/256], 4)), 500ms))

which gives

29.265411 seconds (27.10 M allocations: 135.088 GiB, 25.30% gc time, 15.93% compilation time)

and a simple melody.

There is clearly a preposterous number of allocations happening behind this relatively simple sequence.
When executing the command without playing it, it's evident that a huge signal path structure is built to execute it.

I would like to keep using this toolkit because the syntax is nice but need to make it faster for it to be usable. I might just be using it wrong or expecting too much of the wrong features, do you have any advice?

[haberdashPI]

First of all: Hi! I'm flattered you are considering SignalOperators.jl. I have also run into situations where SignalOperators is quite slow.

If you check out issue #63, you will see that I am thinking through an alternative implementation using LazyArrays.jl, which is an efficient library that already solves many of the problems this package has run into. It seems to occur when you compose certain operators, but I haven't figured out what minimal interactions are required for the issue to crop up. I think newer versions of Julia have also exacerbated the problem.

While that's my plan, I don't yet have the space in my life to dedicate to making those improvements in a timely fashion, because I haven't actively required its features for my recent work. You can see my progress towards a faster implementation on this branch. I have been chipping away at it here and there, but it has not been a priority.

Sorry I can't give you a more reassuring answer.

[arnfaldur]

I noticed that issue, feel free to close this one as #63 is already essentially tracking what I'm proposing, I was just wandering if I was doing something wrong.

As an example of the signal path I mentioned:

this command, in the context from above:

print(sequence(melodify(root, [1,2])))

prints this monstrosity

SignalOperators.AppendSignals{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Tuple{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits

{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}}, Float64, Missing}((SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp)

, Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}(SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}

, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 220, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators

.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 

s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, typeof(one), true}(SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:off, SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.MapSignal{SignalOperators.FnBr{typeof(*)}, 2, 1, Float64, Missing, Tuple{Float64}, Tuple{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}}, typeof(one), Tuple{SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}, SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}}}(SignalOperators.FnBr{typeof(*)}(*), (0.0,), (SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.

CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp)), missing, one, (SignalOperators.PaddedSignal{SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, typeof(one), true}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), one), SignalOperators.PaddedSignal{SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}, typeof(one), true}(SignalOperators.RampSignal{:on, SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, typeof(sinramp), Float64}(SignalOperators.CutApply{SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}, Quantity{Float64, 𝐓, Unitful.FreeUnits{(s,), 𝐓, nothing}}, Val{:Until}, Float64}(SignalOperators.SignalFunction{typeof(sin), Int64, Tuple{Float64}, Float64, Missing}(sin, (0.0,), 440, 0.0, missing), 0.125 s), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true), 0.0078125 s, SignalOperators.sinramp), one)), 4096, true)), missing)

I don't really know the internals well enough to be able to tell if this is to be expected but this structure seems rather large for what it's doing.

Good luck with the project.

[haberdashPI]

That does seem huge!! I don't see anything greatly amis though, I think that is a consequence of the lazy representation.

You don't have to keep everything lazy. It is possible, for your problem, that you can solve it by using sink in the right places, as the resulting value will still be operable as a signal, but will no longer be lazy. For example, the following modifications may help you.

play(signal) = sink(signal |> ToFramerate(44.1kHz) |> Amplify(-10dB), SampleBuf)
note(freq, dur, vol=-10dB) = Signal(sin, ω=freq) |> Until(dur) |> Ramp(dur/16) |> sink

sequence(freqs, dur::Number=(1/8)s) = Append([note(freq, dur) for freq in freqs]...) |> sink
melodify(root,ratios) = [root*ratio for ratio in ratios]

[arnfaldur]

Oh wow, that makes a lot of difference. Although the note can't be piped into a sink like that, I added ToFramerate to it and that works. Most of my tests take around 2 seconds now which is acceptable.

Are there any particular spots where adding a sink is inadvisable?

I noticed in particular that front loading a lot of the processing helped a lot.

note(freq, dur, vol=-10dB) = Signal(sin, ω=freq) |> ToFramerate(44.1kHz) |> 
    Until(dur) |> sink |> Amplify(vol) |> sink |> Ramp(dur/16) |> sink
play(signal) = sink(signal, SampleBuf)

These two replacement functions do exactly the same (for my needs) and take most times down to less than half a second. Totally usable. Let's see if I manage to create a complex enough composition to make it slow again.