Show HN: Tacopy – Tail Call Optimization for Python

by raaid-rt • 8 months ago

95 54 8 months ago

anilakar• 8 months ago

This eliminates the risk of stack overflow errors

When you get stack overflows anywhere from a thousand down to fifty(!) frames in the stack it's not a risk, it's an inevitability in anything more complex than a programming tutorial.

Yeah, I've been bitten by this in production. Writing the functionality in a clean iterative style was just too much of a hassle.

phplovesong• 8 months ago

TCO can be implemented easily in non TC optimized langauges with a trampoline wrapper.

Why do i need a fully fledged library for something that is basically a few lines of code?

srean3• 8 months ago

There's quite a bit of overhead.

I believe Clojure does it with trampoline as JVM does not (as far as I know) does not support tail call optimization. Ironic, given Guy Steele.

ndr3• 8 months ago

Yes, Clojure doesn't have TCO either.

You get `(loop ... (recur ...))` or `trampoline`.

Naive recursion will consume the stack.

https://clojuredocs.org/clojure.core/loop

https://clojuredocs.org/clojure.core/recur

https://clojuredocs.org/clojure.core/trampoline

srean3• 8 months ago

Tacopy is a Python library that provides a decorator to optimize tail-recursive functions by transforming them into iterative loops.

Can this handle mutually recursive calls ? Because those are mostly the only place I use tail calls, rest I translate to iterative loops, list comprehension, maps and reduces.

pansa2• 8 months ago

Limitations […] No mutual recursion: Only direct self-recursion is optimized

srean3• 8 months ago

Oh! slapping head. How did I miss that. Thanks

javierbg95• 8 months ago

Really cool project, fairly succinct and to the point :)

I would love to see support for arbitrarily nested functions, as it is common to wrap these into a public API function without the iteration parameters.

ndr3• 8 months ago

Yes, it is quite surprised they're not allowed. I wonder what's the likely limitation, any ideas?

ndr3• 8 months ago

Found out

Nested function definitions with @tacopy decorators are not supported. Functions decorated with @tacopy must be defined at module level. This constraint exists because inspect.getsource() on nested functions returns the source of the entire enclosing function, making it impossible to reliably extract and transform just the nested function's code. The decorator detects nested functions by checking for '<locals>' in the function's __qualname__ attribute and raises a clear error message instructing users to extract the function to module level.

https://github.com/raaidrt/tacopy/blob/8f5db70da2b7bbfafc41b...

dkersten• 8 months ago

Once upon a time I tried to write such a decorator too in python 2.x and the byteplay bytecode disassembler library. I was trying to do the conversion at the bytecode level instead of transforming the AST. I believe I got as far as detecting simple self recursive functions, but never actually managed to implement the actual transformation.

lioeters• 8 months ago

That is an ambitious idea, and I applaud anyone who attempts such heights even if it turned out to be impractical.

OP's approach is surprisingly straight forward, only a few hundred lines.

https://github.com/raaidrt/tacopy/blob/main/src/tacopy/trans...

jagged-chisel• 8 months ago

Taco Py. No Ta Copy. Took my brain a minute or so …

upghost2• 8 months ago

Really impressive! For anyone who's not a pythonista, trying to implement TCO is something akin to solving the Collatz conjecture but for Python. It's often just an exercise in madness. So seeing an elegant solution to this is really cool, I myself was a victim of this madness and was unable to do it so very cool to see someone nail it! This will be a goto tool for sure.

busfahrer• 8 months ago

Fun fact: In Scheme, TCO is required by the spec

debugnik• 8 months ago

EcmaScript too, but most browser JS runtimes don't (didn't?) support it. It's also part of .NET CIL but only F# uses it so support for it has historically been flakey outside the CLR's main JIT mode.

monster_truck• 8 months ago

Safari's JSC (and much more recently, WebAssembly) are the only ones that actually implement it. In practice I don't think it actually ends up being any better than V8, which I believe has some amount of logic to replace them with iterators or trampolines when it can.

IIRC ES6 introduced PTC (Proper Tail Calls), Chrome had an experimental flag for a while but it introduced more issues than it solved (stack traces became a mess and the stack inspection changes came with realistic security concerns). Microsoft and Firefox refused to implement it. Safari refused to un-implement it, and also refused to adopt an opt-in per function flag.

It's crazy how fast javascript has gotten. Ported a classic game earlier this year using all of the new stuff in ES5/6/onwards, the benchmarks are within a couple of percent of what the perf would be were it a standalone game. Runs with 250x monsters at 30x the original tick rate, or >1000x as many monsters at the original tick rate.

artemonster5• 8 months ago

Can someone give some real world examples for TCO? Every time I see this I only see fibonacci and gcd and I really want to encounter this one in the wild on something real and applicable

threeducks• 8 months ago

Tail calls can be used for parsing very efficiently: https://news.ycombinator.com/item?id=41289114

spapas82• 8 months ago

For tco to be really useful you need to think in a non procedural way. Imagine that you don't have loops in your language so you need recursion to do stuff multiple times.

Also even in procedural languages there are some problems that are easier to understand and model if you use recursion, for example tree or graph like structures.

artemonster5• 8 months ago

traversing graph or a tree is not a TCO case because it would involve a stack/queue for DFS/BFS, whatever. I dont want to think in non procedural way, I reserve this nonsense to haskellers, please provide me a valid python use case for TCO :)

upghost2• 8 months ago

A really simple one is traversing a linked list (or any naturally recursive data structure, such as a dictionary or tree). It is very natural to traverse a recursive data structure recursively.

jhgb3• 8 months ago

It gives you arbitrarily complex control flow even in presence of modularity. A tail call is a state transition. Without them, you'd have to resort to a big loop (which breaks modularity), or some sort of trampoline (which works but it's a bit clumsy).

artemonster5• 8 months ago

this whole thing is equivalent to a goto at the beginning of a function.

tpoacher2• 8 months ago

I don't know about real world "examples", but the beauty of tail-call recursion specifically is the theoretical insight that they have a one-to-one mapping with an loop-based equivalent formulation, and vice versa (which is generally not necessarily true of all recursion).

But, for languages that don't have loop constructs and you need to rely on recursion, all you need to do is write your recipe in standard loop form, and then map back to a tail-call syntax. This is often a LOT easier than trying to think of the problem in a recursive mindset from scratch. (though occasionally, the reverse is also true.)

So the only constraint for re-implementing such looped logic onto tailcalls is that this relies on the stack, which may overflow. By providing TCO you are effectively removing that restriction, so it's a very useful thing for a language to support (especially if they don't provide low-level loops).

The title "tail call optimisation" in the package above is a bit of a misnomer, since this is more of a "transformation" than an "optimisation", but effectively the whole loop-tailcall equivalence is exactly what the package mentioned above relies on to work; it uses decorators to transform tail-call recursive functions to their equivalent loop-based formulations, and thus passing the need to create multiple stacks for the recursion (and risk stack overflow), since the translated loop will now take place in a single stack frame.

artemonster5• 8 months ago

I know what TCO is. Screw the "beauty", honestly. I want to see at least one real world use case

chuckadams• 8 months ago

State machines come to mind: a transition is just a function call. Unfortunately that's a general tail call, not always a recursive one, so no love from this library, and that's where "proper" TCO wins (or trampolines if $your_language lacks TCO)

Also it wouldn't help with Fibonacci, since while it's recursive, it's not tail-recursive (yes, it can be written that way, but I'm talking about the idiomatic naive definition).

mwkaufma• 8 months ago

Lua has mandatory TCO and several games I've been on which use it for a scripting use TCO for a state machine. Easy to debug - just look at the stack!

lukasnxyz• 8 months ago

what is this, why is 95% of the file useless comments: https://github.com/raaidrt/tacopy/blob/main/src/tacopy/unpar...

you're calling a built in function, why make obfuscate this in an "llm way"

stingraycharles• 8 months ago

I also don’t think it’s actually tail call optimization, but rather an “unrecurser”.

I’m also not convinced that this actually is worth the effort, considering it’s doing runtime rewriting of Python using Python.

throwaway81523• 8 months ago

It's a suboptimal implementation but it's interesting for the purpose of transpiling something like Scheme or ML or maybe Purescript to Python.

Historically, suggestions to make Python tail recursive were rejected on the theory that the added stack frames helped debugging, and that Python was supposed to be an imperative language. But it has been dragged into supporting some FP idioms over the years and that has seemed like a good thing.

raaid-rt4• 8 months ago

Certain function calls that were unable to be run in Python can now be run. From that perspective, my thinking was that this was a net good since one can preserve the "clean syntax" from recursion while still being able to access the performance benefits of an iterative solution.

jasonjmcghee• 8 months ago

It's very llm-y. But, kudos to them for preserving the commit history / being honest about it.

raaid-rt4• 8 months ago

Haha this is my first attempt at making an open-source tool - I don't really know what kind of comment hygiene we want here.

denys_potapov2• 8 months ago

Cool. Recursion in python is common bottleneck in competitive programming. Will give it a try. I created a similar tool for recursion [1]. But ended with rewriting AST and emulating stack. Pros - no need for accumulator, cons - almost unusable in real world.

[1] https://dev.to/denyspotapov/callonce-python-macro-for-unlimi...

qsort• 8 months ago

Do you frequently use Python for competitive programming puzzles? I've done it a bit in the past, and everyone always used C++.

denys_potapov2• 8 months ago

Always. Probably you can't get in top 100 with python[1]. But I like dicts with tuple keys, bigints, all the list things.

[1] My best is around 1300 place in HackerCup.

simonw• 8 months ago

OK this is fun. I knocked up a quick browser-based playground to try it out: https://tools.simonwillison.net/tacopy-playground

raaid-rt4• 8 months ago

thanks for making this! - curious to hear if you had any suggestions for what else you'd want supported by this tool

hencq• 8 months ago

From the description, it doesn't really seem to be full Tail Call Optimization, but only optimizes tail recursion. At least all the examples are about tail recursion, where the function calls itself in tail position, which can indeed easily be changed to a loop. Tail Call Optimization would mean it optimizes any function call in tail position. Typically you'd implement that with a trampoline, but it doesn't seem like this does that.

Edit: It's actually called out under limitations "No mutual recursion: Only direct self-recursion is optimized"

nonameiguess• 8 months ago

It's always amusing to see what Python has become thanks to NumPy and Django and how widely deployed it became when its intended purpose was always to be easy to understand, not performant. But just like JavaScript, people are going to hack it to death to make it fast anyway.

Guido on tail calls 16 years ago: https://neopythonic.blogspot.com/2009/04/final-words-on-tail...

skylurk• 8 months ago

It was not exactly the final word:

https://blog.reverberate.org/2025/02/10/tail-call-updates.ht...

spyc• 7 months ago

The current implementation breaks semantics of functions with tail recursion from within loops: https://github.com/raaidrt/tacopy/issues/1

Show HN: Tacopy – Tail Call Optimization for Python

Related Stories