I definitely appreciate the the Scheme drive to create abstractions that are as simple as possible while providing as much power as possible (call/cc is popularized by Scheme). call/cc certainly does this. But these tools hide a very complex underlying implementation to the point that it's pretty hard to understand all the layers. Generators, for example, can be done with a strategy pattern in object-oriented programming in a way that at first glance seems more complicated because there's more code, but actually has a very straightforward translation to the underlying machine code.
Having a very mathematical bent, most of the time Scheme's functional abstractions "just work". But work with Scheme enough and you'll eventually hit a problem where they don't (usually a performance issue) and then it becomes difficult: you end up having to read very deep into implementation details of the language.
I dunno how this is going to work out. Maybe at some point all the situations where this stuff doesn't "just work" will be weeded out. But until then, it's tough to justify my interest in these topics as anything but fun.