[GenExpr] Param in a function?

So, the example you give here...

a=biz(0,blam=4); // returns 4
b=biz(0); //returns 0 even after calling above line

...catches one of the subtle things about genexpr, which is that operations are 'lexically instanced'.

I think it might be easier to consider from the perspective of cycle. Roughly speaking cycle could be implemented like this:

mycycle(freq) {
History phase;
phase = wrap(phase + freq/samplerate, 0, 1);
return cos(twopi * phase);
}

Now, if you want to make a chord of sinewaves, you can write this:

out1 = mycycle(100) + mycycle(150);

Both of these phasors have internal state (the History phase), each of which is independent of each other. Behind the scenes, each time you write `mycycle()` you are creating a `History phase` for that instance, which is retained over time -- it is "stateful" in a way that e.g. `add()` isn't.

Your `biz()` function is also stateful in this way, because of the `Param blam`. So each time you write `biz()` in the code, you create a new instance of the `Param blam` associated with it. This `Param blam` remembers its value for each invocation of its particular `biz()` over time. But if you write `biz()` twice, you get two `Param blams`, one each.

If we didn't do it that way, then `mycycle(100) + mycycle(150)` would not create a chord, instead it would create one oscillator with a frequency of 250Hz.

So, the state *inside* a function is "lexically instanced": there's a new indepenent instance of that internal state for each time you *write* a call to the function.

If you want to share state between separate function calls, you will have to pass that state in to the function from outside. E.g.:

biz(poop, blam) {
return poop + blam;
}
History blam(7);
out1 = biz(30, blam) + biz(30, blam);

Or, this:

biz(poop, blam) {
return poop + blam;
}
superbiz(poop) {
Param blam; // this param shared by both biz's:
return biz(poop, blam) + biz(poop, blam);
}
// we only write `superbiz` once,
// so there's only one instance of its internal state `Param blam`:
out1 = superbiz(30, blam=7);

Note that you can also pass buffers etc. into functions in this way.

Hope that makes it clear!