tco | Tail Call Optimization for Python

You can use the --stack-size V8 option (see also here).

To see the default size, you can check --v8-options:

Here's some sample code that shows how the "Commands out of sync" error can occur:

Use np.where with the required condition, value when the condition is True and the default value.

Memoize returns function, so you have to use def:

the result of the recursive call should be returned immediately. But why?

That's because in order to optimize a tail call you need to convert the final recursive call into a simple "jump" instruction. When you do this, you are merely "replacing" function arguments and then re-starting the function.

This is only possible if you can "throw away" the current stack frame and re-use it for the same function again, possibly overwriting it. If you need to remember a value to do more calculations and then return, you cannot use the same stack frame for the recursive call (i.e. cannot turn the "call" into a "jump"), as it could possibly erase/modify the value you wanted to remember before returning.

Furthermore, if your function is very simple (like yours) chances are that it could be written without using the stack at all (except for the return address maybe), and only store data in registers. Even in this case, you don't want to make a jump to the same function (that uses the same registers) if you need to remember one of the values before returning.

Here is a valid example for TCO:

This is for sure not possible, as scheme specification imposes tail recursive calls to become iterative processes.

In the implementation, there is an APPLY return code that drops the stack frames of the iterative processes made via tail recursion -- the interpreter does SCODE check for "NULL == CDR(SCODE)" as a special condition for returning code of type APPLY.

If you want to happen as you with, you can modify this condition in the eval and recompile the scheme -- which will not be scheme any more.

If you want to debug, other methods can be applied.

Dart does not support tail-call optimization. There are no current plans to add it.

The primary reason is that it's a feature that you need to rely on in order to use, otherwise you get hugely inefficient code that might overflow the stack, and since JavaScript currently does not support tail call optimization, the feature cannot be efficiently compiled to JavaScript.

This solution is about 50% faster and also works with more than one css property

The problem is that the typehead doesn't know how to retrieve the value from the field name 4. region since it is invalid according to its internal implementation! A proper solution is to declare your interface like follow: