Method annotation used to transform methods with tail recursive calls into iterative methods automagically since the JVM cannot do this itself. This works for both static and non-static methods.

It allows you to write a method like this:

 import groovy.transform.TailRecursive
 class Target {
      @TailRecursive
      long sumUp(long number, long sum = 0) {
          if (number == 0)
              return sum;
          sumUp(number - 1, sum + number)
      }
 }
 def target = new Target()
 assert target.sumUp(100) == 5050
 assert target.sumUp(1000000) == 500000500000 //will blow the stack on most machines when used without @TailRecursive
 

• Only non-void methods are currently being handled. Void methods will fail compilation.
• Only direct recursion (calling the exact same method again) is supported.
• Mixing of tail calls and non-tail calls is not possible. The compiler will complain if some recursive calls cannot be handled.
• Checking if a recursive call is really tail-recursive is not very strict. You might run into cases where non-tail calls will be considered tail calls.
• In the presence of method overloading and method overriding you might run into situations where a call is considered recursive although it really is not.
• Catching Throwable around a recursive might lead to problems
• Non trivial continuation passing style examples do not work.
• Probably many unrecognized edge cases.

More examples:

 import groovy.transform.TailRecursive

 @TailRecursive
 long sizeOfList(list, counter = 0) {
     if (list.size() == 0) {
         counter
     } else {
        sizeOfList(list.tail(), counter + 1) 
     }
 }

 // Without @TailRecursive a StackOverFlowError
 // is thrown.
 assert sizeOfList(1..10000) == 10000
 

Authors:

Johannes Link

Since:

2.3