> You must carefully not leaving any recursive functions not annotated with #[recursive]
Isn’t the same true of forgetting #[stacksafe]?
This reminds me of certain Haskell patterns where you selectively make some operations strict instead of lazy for similar reasons. I’m glad this library exists, but I’m sad the Rust compiler itself doesn’t have better support for recursion.
lionkor 2 hours ago [-]
Why would I use a bandaid fix like this that has horrible memory usage, when there are crates[1] that allow tail call recursion?
This works on functions that can't be tail-recursive, like depth-first search.
CyberDildonics 20 minutes ago [-]
Why not just use a stack data structure instead of using the call stack as a stack data structure? Each stack frame is going to take up a lot more space than a straight array used as a stack.
Jtsummers 16 minutes ago [-]
You may disagree with their take on it, but they do address that in the write-up.
> This approach works for simple cases but becomes extremely complex or impossible when any of these conditions apply:
> 1. The algorithm transforms data structures rather than just evaluating them (e.g., optimizing an AST)
> 2. Multiple recursive calls need to be coordinated (e.g., tree balancing algorithms)
> 3. The algorithm doesn’t fit the tail-recursion pattern
I would disagree with "impossible" (pretty sure it's never actually impossible, but some type systems and language features may work together to make it so, I suppose), but definitely agree with "extremely complex".
Isn’t the same true of forgetting #[stacksafe]?
This reminds me of certain Haskell patterns where you selectively make some operations strict instead of lazy for similar reasons. I’m glad this library exists, but I’m sad the Rust compiler itself doesn’t have better support for recursion.
[1] https://docs.rs/tailcall/latest/tailcall/
> This approach works for simple cases but becomes extremely complex or impossible when any of these conditions apply:
> 1. The algorithm transforms data structures rather than just evaluating them (e.g., optimizing an AST)
> 2. Multiple recursive calls need to be coordinated (e.g., tree balancing algorithms)
> 3. The algorithm doesn’t fit the tail-recursion pattern
I would disagree with "impossible" (pretty sure it's never actually impossible, but some type systems and language features may work together to make it so, I suppose), but definitely agree with "extremely complex".